Session Options

const session = client.createSession({
  // Model
  model: 'claude-sonnet-4-5-20250929',
  fallbackModel: 'claude-3-5-haiku-20241022',

  // Limits
  maxTurns: 10,
  maxBudgetUsd: 1.00,
  maxThinkingTokens: 10000,

  // Prompts
  systemPrompt: 'You are a helpful assistant.',

  // Tools
  tools: [myTool],
  mcpServers: [myServer],
  allowedTools: ['tool1', 'tool2'],
  disallowedTools: ['dangerous_tool'],

  // Session management
  sessionId: 'existing-session-id',
  forkSession: false,
  continue: true,

  // Output
  outputFormat: { type: 'json_schema', schema: mySchema },

  // Environment
  env: { API_KEY: 'value' },
  permissionMode: 'default',
});

model: 'claude-sonnet-4-5-20250929'

model: 'sonnet'  // claude-sonnet-4-5-20250929
model: 'opus'    // claude-opus-4-5-20251101
model: 'haiku'   // claude-3-5-haiku-20241022

fallbackModel: 'claude-3-5-haiku-20241022'

maxTurns: 10

maxBudgetUsd: 1.00  // $1.00 limit

maxThinkingTokens: 10000

systemPrompt: 'You are a helpful coding assistant.'

systemPrompt: {
  type: 'preset',
  preset: 'claude_code',
}

systemPrompt: {
  type: 'preset',
  preset: 'claude_code',
  append: `
## Additional Context
Working directory: ${process.cwd()}
User preferences: ${userPrefs}
`,
}

import { tool, textResult } from '@chucky.cloud/sdk';

const myTool = tool(
  'get_weather',
  'Get weather for a city',
  { type: 'object', properties: { city: { type: 'string' } } },
  async ({ city }) => textResult(`Sunny in ${city}`)
);

const session = client.createSession({
  tools: [myTool],
});

import { McpServerBuilder, textResult } from '@chucky.cloud/sdk';

const server = new McpServerBuilder('my-tools', '1.0.0')
  .addTool({
    name: 'tool1',
    description: 'First tool',
    inputSchema: { type: 'object', properties: {} },
    handler: async () => textResult('Done'),
  })
  .addTool({
    name: 'tool2',
    description: 'Second tool',
    inputSchema: { type: 'object', properties: {} },
    handler: async () => textResult('Done'),
  })
  .build();

const session = client.createSession({
  mcpServers: [server],
});

allowedTools: ['Read', 'Write', 'Bash']

disallowedTools: ['Bash', 'Write']  // Read-only mode

const session = client.createSession({
  sessionId: 'sess_abc123...',
});

const session = client.createSession({
  sessionId: 'sess_abc123...',
  forkSession: true,  // Creates a new branch
});

const session = client.createSession({
  sessionId: 'sess_abc123...',
  continue: true,
});

const session = client.createSession({
  sessionId: 'sess_abc123...',
  resumeSessionAt: 'conv_xyz789...',  // Conversation ID
});

settingSources: ['user', 'project', 'local']

const session = client.createSession({
  jobId: 'job_abc123...',
});

const session = client.createSession({
  outputFormat: {
    type: 'json_schema',
    schema: {
      type: 'object',
      properties: {
        summary: { type: 'string' },
        items: {
          type: 'array',
          items: { type: 'string' },
        },
      },
      required: ['summary', 'items'],
    },
  },
});

includePartialMessages: true

env: {
  API_KEY: 'sk-...',
  DATABASE_URL: 'postgres://...',
  DEBUG: 'true',
}

permissionMode: 'default'

allowDangerouslySkipPermissions: true

betas: ['extended_thinking', 'vision']

agents: {
  researcher: {
    name: 'Researcher',
    description: 'Searches and summarizes information',
    tools: ['WebSearch', 'Read'],
    model: 'claude-3-5-haiku-20241022',
  },
  coder: {
    name: 'Coder',
    description: 'Writes and edits code',
    tools: ['Read', 'Write', 'Bash'],
    model: 'claude-sonnet-4-5-20250929',
  },
}

const client = new ChuckyClient({
  // Required
  token: 'your-jwt-token',

  // Optional
  baseUrl: 'wss://conjure.chucky.cloud/ws',
  debug: false,
  timeout: 60000,
  keepAliveInterval: 300000,
  autoReconnect: false,
  maxReconnectAttempts: 5,
});

baseUrl: 'wss://staging.chucky.cloud/ws'

debug: true

timeout: 60000  // 60 seconds

keepAliveInterval: 300000  // 5 minutes

autoReconnect: true

maxReconnectAttempts: 5

interface SessionOptions {
  // Model
  model?: Model;
  fallbackModel?: Model;

  // Limits
  maxTurns?: number;
  maxBudgetUsd?: number;
  maxThinkingTokens?: number;

  // Prompts
  systemPrompt?: string | SystemPromptConfig;

  // Tools
  tools?: ToolDefinition[];
  mcpServers?: McpServerDefinition[];
  allowedTools?: string[];
  disallowedTools?: string[];

  // Session
  sessionId?: string;
  forkSession?: boolean;
  continue?: boolean;
  resumeSessionAt?: string;
  settingSources?: Array<'user' | 'project' | 'local'>;
  jobId?: string;

  // Output
  outputFormat?: OutputFormat;
  includePartialMessages?: boolean;

  // Environment
  env?: Record<string, string>;
  permissionMode?: PermissionMode;
  allowDangerouslySkipPermissions?: boolean;
  betas?: string[];

  // Agents
  agents?: Record<string, AgentConfig>;
}

type Model =
  | 'claude-sonnet-4-5-20250929'
  | 'claude-opus-4-5-20251101'
  | 'claude-3-5-sonnet-20241022'
  | 'claude-3-5-haiku-20241022'
  | 'claude-3-opus-20240229'
  | 'sonnet'
  | 'opus'
  | 'haiku'
  | string;

type PermissionMode = 'default' | 'plan' | 'bypassPermissions';

interface OutputFormat {
  type: 'json_schema';
  schema: object;
}

interface SystemPromptConfig {
  type: 'preset';
  preset: 'claude_code' | 'assistant' | 'coder';
  append?: string;
}

const session = client.createSession();
await session.send('Hello');

const session = client.createSession({
  model: 'claude-sonnet-4-5-20250929',
  mcpServers: [myToolServer],
  maxTurns: 10,
});

const session = client.createSession({
  outputFormat: {
    type: 'json_schema',
    schema: {
      type: 'object',
      properties: {
        answer: { type: 'string' },
        confidence: { type: 'number' },
      },
    },
  },
});

const session = client.createSession({
  sessionId: previousSessionId,
  continue: true,
});

const session = client.createSession({
  model: 'haiku',  // Faster, cheaper
  debug: true,
  maxBudgetUsd: 0.10,
});