@octavus/server-sdk 2.19.0 → 2.20.0

package/dist/index.d.cts

@@ -0,0 +1,552 @@
+import { ZodType, z } from 'zod';
+import { ToolHandlers, ToolSchema, ToolResult, StreamEvent, ChatMessage, UIMessage, ToolProvider } from '@octavus/core';
+export * from '@octavus/core';
+export { AppError, ConflictError, ForbiddenError, MAIN_THREAD, NotFoundError, OCTAVUS_SKILL_TOOLS, OctavusError, ValidationError, createApiErrorEvent, createErrorEvent, createInternalErrorEvent, errorToStreamEvent, generateId, getSkillSlugFromToolCall, isAbortError, isAuthenticationError, isFileReference, isFileReferenceArray, isMainThread, isOctavusSkillTool, isOtherThread, isProviderError, isRateLimitError, isRetryableError, isToolError, isValidationError, resolveThread, safeParseStreamEvent, safeParseUIMessage, safeParseUIMessages, threadForPart } from '@octavus/core';
+
+/**
+ * Error thrown when API request fails
+ */
+declare class ApiError extends Error {
+    status: number;
+    code?: string | undefined;
+    constructor(message: string, status: number, code?: string | undefined);
+}
+
+interface ApiClientConfig {
+    baseUrl: string;
+    getHeaders: () => Record<string, string>;
+}
+/** Base class for API clients with shared HTTP utilities */
+declare abstract class BaseApiClient {
+    protected readonly config: ApiClientConfig;
+    constructor(config: ApiClientConfig);
+    protected httpGet<T>(path: string, schema: ZodType<T>): Promise<T>;
+    protected httpPost<T>(path: string, body: unknown, schema: ZodType<T>): Promise<T>;
+    protected httpPatch<T>(path: string, body: unknown, schema: ZodType<T>): Promise<T>;
+    protected httpDelete<T>(path: string, schema: ZodType<T>): Promise<T>;
+}
+
+/** Agent format - interactive (chat) or worker (background task) */
+type AgentFormat = 'interactive' | 'worker';
+/** Agent settings */
+interface AgentSettings {
+    slug: string;
+    name: string;
+    description?: string;
+    format: AgentFormat;
+}
+/** Agent prompt */
+interface AgentPrompt {
+    name: string;
+    content: string;
+}
+/**
+ * Agent summary returned from list endpoint
+ */
+interface Agent {
+    /** Agent slug (human-readable identifier within project) */
+    slug: string;
+    /** Agent ID - use this for API calls */
+    id: string;
+    name: string;
+    description: string | null;
+    format: AgentFormat;
+    createdAt: string;
+    updatedAt: string;
+    projectId: string;
+}
+/**
+ * Full agent definition returned from get endpoint
+ */
+interface AgentDefinition {
+    settings: AgentSettings;
+    protocol: string;
+    prompts: AgentPrompt[];
+    /** Agent ID - use this for API calls like createSession */
+    id: string;
+}
+
+/**
+ * API for listing and retrieving agent definitions.
+ *
+ * Note: Agent management (create, update, sync) should be done via the @octavus/cli package.
+ * This API uses agent IDs only - use CLI for slug-based operations.
+ */
+declare class AgentsApi extends BaseApiClient {
+    /** List all agents in the project */
+    list(): Promise<Agent[]>;
+    /** Get a single agent by ID */
+    get(agentId: string): Promise<AgentDefinition>;
+}
+
+/**
+ * Base class for agent-managed resources.
+ * Extend this class to define how each resource should be persisted when the agent updates it.
+ */
+declare abstract class Resource {
+    /** The resource name as defined in the agent protocol */
+    abstract readonly name: string;
+    /** Called when the agent updates this resource */
+    abstract onUpdate(value: unknown): Promise<void> | void;
+}
+
+/** Start a new trigger execution */
+interface TriggerRequest {
+    type: 'trigger';
+    triggerName: string;
+    input?: Record<string, unknown>;
+    /** ID of the last message to keep. Messages after this are removed before execution. `null` = truncate all. */
+    rollbackAfterMessageId?: string | null;
+}
+/** Continue execution after client-side tool handling */
+interface ContinueRequest {
+    type: 'continue';
+    executionId: string;
+    toolResults: ToolResult[];
+}
+/** All request types supported by the session */
+type SessionRequest = TriggerRequest | ContinueRequest;
+/** Stop message to abort in-flight requests */
+interface StopMessage {
+    type: 'stop';
+}
+/** All socket protocol messages (trigger, continue, stop) */
+type SocketMessage = TriggerRequest | ContinueRequest | StopMessage;
+/** Handlers for socket message streaming */
+interface SocketMessageHandlers {
+    /** Called for each stream event */
+    onEvent: (event: StreamEvent) => void;
+    /** Called after streaming completes (not called if aborted) */
+    onFinish?: () => void | Promise<void>;
+}
+/**
+ * Converts an async iterable of stream events to an SSE-formatted ReadableStream.
+ * Use this when you need to return an SSE response (e.g., HTTP endpoints).
+ *
+ * @example
+ * ```typescript
+ * const events = session.trigger('user-message', input);
+ * return new Response(toSSEStream(events), {
+ *   headers: { 'Content-Type': 'text/event-stream' },
+ * });
+ * ```
+ */
+declare function toSSEStream(events: AsyncIterable<StreamEvent>): ReadableStream<Uint8Array>;
+interface SessionConfig {
+    sessionId: string;
+    config: ApiClientConfig;
+    tools?: ToolHandlers;
+    resources?: Resource[];
+    /** Tool schemas to send to the platform on the first trigger (device MCP tools, etc.) */
+    additionalToolSchemas?: ToolSchema[];
+    /** Called after server-side tools execute, before yielding events or continuing. Use to normalize tool results (e.g., upload base64 images). */
+    onToolResults?: (results: ToolResult[]) => Promise<void>;
+    /** When true, unhandled tool calls return errors instead of being emitted as client-tool-request events. */
+    rejectClientToolCalls?: boolean;
+}
+/**
+ * Options for trigger execution.
+ */
+interface TriggerOptions {
+    /** Abort signal to cancel the trigger execution */
+    signal?: AbortSignal;
+}
+/** Handles streaming and tool continuation for agent sessions */
+declare class AgentSession {
+    private sessionId;
+    private config;
+    private toolHandlers;
+    private resourceMap;
+    private additionalToolSchemas;
+    private additionalToolSchemasSent;
+    private socketAbortController;
+    private onToolResults?;
+    private rejectClientToolCalls;
+    constructor(sessionConfig: SessionConfig);
+    /**
+     * Execute a session request and stream the response.
+     *
+     * This is the unified method that handles both triggers and continuations.
+     * Use this when you want to pass through requests from the client directly.
+     *
+     * @param request - The request (check `request.type` for the kind)
+     * @param options - Optional configuration including abort signal
+     *
+     * @example HTTP route (simple passthrough)
+     * ```typescript
+     * const events = session.execute(body, { signal: request.signal });
+     * return new Response(toSSEStream(events));
+     * ```
+     *
+     * @example WebSocket handler
+     * ```typescript
+     * socket.on('message', (data) => {
+     *   const events = session.execute(data);
+     *   for await (const event of events) {
+     *     socket.send(JSON.stringify(event));
+     *   }
+     * });
+     * ```
+     */
+    execute(request: SessionRequest, options?: TriggerOptions): AsyncGenerator<StreamEvent>;
+    getSessionId(): string;
+    /**
+     * Handle a WebSocket protocol message (trigger, continue, or stop).
+     * Manages abort controller lifecycle internally.
+     *
+     * @example
+     * ```typescript
+     * conn.on('data', (raw) => {
+     *   session.handleSocketMessage(JSON.parse(raw), {
+     *     onEvent: (event) => conn.write(JSON.stringify(event)),
+     *     onFinish: async () => {
+     *       // Fetch messages and persist to your database for restoration
+     *     },
+     *   });
+     * });
+     * ```
+     */
+    handleSocketMessage(message: SocketMessage, handlers: SocketMessageHandlers): Promise<void>;
+    private executeStream;
+    private handleResourceUpdate;
+}
+
+/** Session status indicating whether it's active or expired */
+type SessionStatus = 'active' | 'expired';
+interface SessionState {
+    id: string;
+    agentId: string;
+    input: Record<string, unknown>;
+    variables: Record<string, unknown>;
+    resources: Record<string, unknown>;
+    messages: ChatMessage[];
+    status?: 'active';
+    createdAt: string;
+    updatedAt: string;
+}
+interface UISessionState {
+    sessionId: string;
+    agentId: string;
+    messages: UIMessage[];
+    status?: 'active';
+}
+interface ExpiredSessionState {
+    sessionId: string;
+    agentId: string;
+    status: 'expired';
+    createdAt: string;
+}
+interface RestoreSessionResult {
+    sessionId: string;
+    /** True if session was restored from messages, false if already active */
+    restored: boolean;
+}
+interface ClearSessionResult {
+    sessionId: string;
+    cleared: boolean;
+}
+interface SessionAttachOptions {
+    tools?: ToolHandlers;
+    resources?: Resource[];
+    /** Computer capability provider (browser, filesystem, shell via MCP). */
+    computer?: ToolProvider;
+    /** Called after server-side tools execute, before yielding events or continuing. Use to normalize tool results (e.g., upload base64 images). */
+    onToolResults?: (results: ToolResult[]) => Promise<void>;
+    /** When true, unhandled tool calls return errors instead of being emitted as client-tool-request events. */
+    rejectClientToolCalls?: boolean;
+}
+/** API for managing agent sessions */
+declare class AgentSessionsApi extends BaseApiClient {
+    /** Create a new session for an agent */
+    create(agentId: string, input?: Record<string, unknown>): Promise<string>;
+    /**
+     * Get full session state (for internal/debug use)
+     * Note: Contains all messages including hidden content
+     *
+     * Returns SessionState for active sessions, ExpiredSessionState for expired sessions.
+     * Check `status` field to determine which type was returned.
+     */
+    get(sessionId: string): Promise<SessionState | ExpiredSessionState>;
+    /**
+     * Get UI-ready session messages (for client display)
+     * Returns only visible messages with hidden content filtered out.
+     *
+     * For expired sessions, returns status: 'expired' without messages.
+     * Use restore() to restore from stored messages before continuing.
+     */
+    getMessages(sessionId: string): Promise<UISessionState | ExpiredSessionState>;
+    /**
+     * Restore an expired session from stored messages.
+     *
+     * Use this to restore a session after its state has expired.
+     * The consumer should have stored the UIMessage[] array from previous interactions.
+     *
+     * @param sessionId - The session ID to restore
+     * @param messages - Previously stored UIMessage[] array
+     * @param input - Optional session input for system prompt interpolation (same as create)
+     * @returns { sessionId, restored: true } if restored, { sessionId, restored: false } if already active
+     */
+    restore(sessionId: string, messages: UIMessage[], input?: Record<string, unknown>): Promise<RestoreSessionResult>;
+    /**
+     * Clear session state from the server.
+     * The session will transition to 'expired' status and can be restored with restore().
+     * Idempotent: succeeds even if state was already cleared/expired.
+     */
+    clear(sessionId: string): Promise<ClearSessionResult>;
+    /** Attach to an existing session for triggering events */
+    attach(sessionId: string, options?: SessionAttachOptions): AgentSession;
+}
+
+/**
+ * Schema for a single file upload request
+ */
+declare const fileUploadRequestSchema: z.ZodObject<{
+    filename: z.ZodString;
+    mediaType: z.ZodString;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Schema for a single file upload response
+ */
+declare const fileUploadInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    uploadUrl: z.ZodURL;
+    downloadUrl: z.ZodURL;
+}, z.core.$strip>;
+/**
+ * Schema for the upload URLs response
+ */
+declare const uploadUrlsResponseSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        uploadUrl: z.ZodURL;
+        downloadUrl: z.ZodURL;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type FileUploadRequest = z.infer<typeof fileUploadRequestSchema>;
+type FileUploadInfo = z.infer<typeof fileUploadInfoSchema>;
+type UploadUrlsResponse = z.infer<typeof uploadUrlsResponseSchema>;
+/**
+ * API for file operations.
+ *
+ * Provides methods to generate presigned URLs for file uploads.
+ * Files are uploaded directly to S3, not through the platform.
+ *
+ * @example
+ * ```typescript
+ * // Get upload URLs
+ * const { files } = await client.files.getUploadUrls(sessionId, [
+ *   { filename: 'image.png', mediaType: 'image/png', size: 12345 }
+ * ]);
+ *
+ * // Upload directly to S3
+ * await fetch(files[0].uploadUrl, {
+ *   method: 'PUT',
+ *   body: imageFile,
+ *   headers: { 'Content-Type': 'image/png' }
+ * });
+ *
+ * // Use downloadUrl as FileReference in trigger input
+ * ```
+ */
+declare class FilesApi extends BaseApiClient {
+    /**
+     * Get presigned URLs for uploading files to a session.
+     *
+     * Returns upload URLs (PUT) and download URLs (GET) for each file.
+     * Upload URLs expire in 15 minutes, download URLs match session TTL (24 hours).
+     *
+     * @param sessionId - The session ID to associate files with
+     * @param files - Array of file metadata (filename, mediaType, size)
+     * @returns Upload info with presigned URLs for each file
+     *
+     * @throws ApiError if session doesn't exist or validation fails
+     *
+     * @example
+     * ```typescript
+     * const { files } = await client.files.getUploadUrls(sessionId, [
+     *   { filename: 'photo.jpg', mediaType: 'image/jpeg', size: 102400 },
+     *   { filename: 'doc.pdf', mediaType: 'application/pdf', size: 204800 },
+     * ]);
+     *
+     * // files[0].id - Use in FileReference
+     * // files[0].uploadUrl - PUT to this URL
+     * // files[0].downloadUrl - Use as FileReference.url
+     * ```
+     */
+    getUploadUrls(sessionId: string, files: FileUploadRequest[]): Promise<UploadUrlsResponse>;
+}
+
+/** Start a new worker execution */
+interface WorkerStartRequest {
+    type: 'start';
+    input: Record<string, unknown>;
+}
+/** Continue execution after client-side tool handling */
+interface WorkerContinueRequest {
+    type: 'continue';
+    executionId: string;
+    toolResults: ToolResult[];
+}
+/** All request types supported by workers */
+type WorkerRequest = WorkerStartRequest | WorkerContinueRequest;
+/** Options for worker execution */
+interface WorkerExecuteOptions {
+    /** Tool handlers for server-side tool execution */
+    tools?: ToolHandlers;
+    /** Abort signal to cancel the execution */
+    signal?: AbortSignal;
+}
+/** Result from a non-streaming worker execution via `generate()` */
+interface WorkerGenerateResult {
+    /** The worker's output value */
+    output: unknown;
+    /** Session ID for the worker execution (usable for debugging/session URLs) */
+    sessionId: string;
+}
+/** API for executing worker agents */
+declare class WorkersApi extends BaseApiClient {
+    /**
+     * Execute a worker agent and stream the response.
+     *
+     * Worker agents execute steps sequentially and return an output value.
+     * Unlike interactive sessions, workers don't maintain persistent state.
+     *
+     * The execution handles the tool continuation pattern automatically:
+     * - Server tools (with handlers provided) are executed automatically
+     * - Client tools (without handlers) emit a client-tool-request event
+     *
+     * @param agentId - The worker agent ID
+     * @param input - Input values for the worker
+     * @param options - Optional configuration including tools and abort signal
+     * @returns An async generator of stream events
+     *
+     * @example Basic execution
+     * ```typescript
+     * const events = client.workers.execute(agentId, { TOPIC: 'AI safety' });
+     * for await (const event of events) {
+     *   if (event.type === 'worker-start') {
+     *     console.log(`Worker ${event.workerSlug} started (${event.workerId})`);
+     *   }
+     *   if (event.type === 'worker-result') {
+     *     if (event.error) {
+     *       console.error('Worker failed:', event.error);
+     *     } else {
+     *       console.log('Output:', event.output);
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @example With tool handlers
+     * ```typescript
+     * const events = client.workers.execute(agentId, { TOPIC: 'AI safety' }, {
+     *   tools: {
+     *     'web-search': async (args) => {
+     *       return await searchWeb(args.query);
+     *     },
+     *   },
+     * });
+     * ```
+     */
+    execute(agentId: string, input: Record<string, unknown>, options?: WorkerExecuteOptions): AsyncGenerator<StreamEvent>;
+    /**
+     * Execute a worker agent and return the final output.
+     *
+     * Non-streaming equivalent of `execute()` — runs the worker to completion
+     * and returns the output value directly. Use this when you don't need to
+     * observe intermediate streaming events.
+     *
+     * @param agentId - The worker agent ID
+     * @param input - Input values for the worker
+     * @param options - Optional configuration including tools and abort signal
+     * @returns The worker output and session ID
+     * @throws {WorkerError} If the worker fails or completes without output
+     *
+     * @example Basic usage
+     * ```typescript
+     * const { output, sessionId } = await client.workers.generate(agentId, {
+     *   TOPIC: 'AI safety',
+     * });
+     * console.log(output);
+     * console.log(`Debug: ${client.baseUrl}/platform/sessions/${sessionId}`);
+     * ```
+     *
+     * @example With timeout
+     * ```typescript
+     * const { output } = await client.workers.generate(agentId, input, {
+     *   signal: AbortSignal.timeout(120_000),
+     * });
+     * ```
+     */
+    generate(agentId: string, input: Record<string, unknown>, options?: WorkerExecuteOptions): Promise<WorkerGenerateResult>;
+    /**
+     * Continue a worker execution after client-side tool handling.
+     *
+     * Use this when your worker has tools without server-side handlers.
+     * The execution returns a client-tool-request event with an executionId.
+     * Execute the tools client-side, then call this method to continue.
+     *
+     * @param agentId - The worker agent ID
+     * @param executionId - The execution ID from the client-tool-request event
+     * @param toolResults - Results from client-side tool execution
+     * @param options - Optional configuration including tools and abort signal
+     * @returns An async generator of stream events
+     *
+     * @example
+     * ```typescript
+     * // Start execution
+     * for await (const event of client.workers.execute(agentId, input)) {
+     *   if (event.type === 'client-tool-request') {
+     *     // Execute tools client-side
+     *     const results = await executeToolsClientSide(event.toolCalls);
+     *     // Continue execution
+     *     for await (const ev of client.workers.continue(agentId, event.executionId, results)) {
+     *       // Handle remaining events
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    continue(agentId: string, executionId: string, toolResults: ToolResult[], options?: WorkerExecuteOptions): AsyncGenerator<StreamEvent>;
+}
+
+interface OctavusClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    /** Enable model request tracing to capture full payloads sent to providers (default: false) */
+    traceModelRequests?: boolean;
+}
+/** Client for interacting with the Octavus platform API */
+declare class OctavusClient {
+    readonly agents: AgentsApi;
+    readonly agentSessions: AgentSessionsApi;
+    readonly files: FilesApi;
+    readonly workers: WorkersApi;
+    readonly baseUrl: string;
+    private readonly apiKey?;
+    private readonly traceModelRequests;
+    constructor(config: OctavusClientConfig);
+    getHeaders(): Record<string, string>;
+}
+
+/** Error thrown when a worker execution fails */
+declare class WorkerError extends Error {
+    /** Session ID if the worker started before failing (for debugging URLs) */
+    readonly sessionId?: string | undefined;
+    constructor(message: string, 
+    /** Session ID if the worker started before failing (for debugging URLs) */
+    sessionId?: string | undefined);
+}
+
+/**
+ * Extract base64 image blobs from tool results, upload them to S3 via
+ * presigned URLs, and replace inline data with compact metadata +
+ * FileReference entries.
+ *
+ * Runs at the server-sdk streaming layer so images are uploaded before
+ * tool results travel over the network (WebSocket, HTTP continuation).
+ */
+declare function normalizeToolResultImages(toolResults: ToolResult[], filesApi: FilesApi, sessionId: string): Promise<void>;
+
+export { type Agent, type AgentDefinition, type AgentFormat, type AgentPrompt, AgentSession, AgentSessionsApi, type AgentSettings, AgentsApi, ApiError, type ClearSessionResult, type ContinueRequest, type ExpiredSessionState, type FileUploadInfo, type FileUploadRequest, FilesApi, OctavusClient, type OctavusClientConfig, Resource, type RestoreSessionResult, type SessionAttachOptions, type SessionConfig, type SessionRequest, type SessionState, type SessionStatus, type SocketMessage, type SocketMessageHandlers, type StopMessage, type TriggerOptions, type TriggerRequest, type UISessionState, type UploadUrlsResponse, type WorkerContinueRequest, WorkerError, type WorkerExecuteOptions, type WorkerGenerateResult, type WorkerRequest, type WorkerStartRequest, WorkersApi, normalizeToolResultImages, toSSEStream };

package/dist/index.d.ts

@@ -141,6 +141,8 @@ interface SessionConfig {
     additionalToolSchemas?: ToolSchema[];
     /** Called after server-side tools execute, before yielding events or continuing. Use to normalize tool results (e.g., upload base64 images). */
     onToolResults?: (results: ToolResult[]) => Promise<void>;
+    /** When true, unhandled tool calls return errors instead of being emitted as client-tool-request events. */
+    rejectClientToolCalls?: boolean;
 }
 /**
  * Options for trigger execution.
@@ -159,6 +161,7 @@ declare class AgentSession {
     private additionalToolSchemasSent;
     private socketAbortController;
     private onToolResults?;
+    private rejectClientToolCalls;
     constructor(sessionConfig: SessionConfig);
     /**
      * Execute a session request and stream the response.
@@ -249,6 +252,8 @@ interface SessionAttachOptions {
     computer?: ToolProvider;
     /** Called after server-side tools execute, before yielding events or continuing. Use to normalize tool results (e.g., upload base64 images). */
     onToolResults?: (results: ToolResult[]) => Promise<void>;
+    /** When true, unhandled tool calls return errors instead of being emitted as client-tool-request events. */
+    rejectClientToolCalls?: boolean;
 }
 /** API for managing agent sessions */
 declare class AgentSessionsApi extends BaseApiClient {

package/dist/index.js

@@ -294,18 +294,34 @@ async function* executeStream(config, payload, signal) {
         }
       }
       if (clientTools.length > 0) {
-        if (!executionId) {
-          yield createInternalErrorEvent("Missing executionId for client-tool-request");
-          return;
+        if (config.rejectClientToolCalls) {
+          const rejectedResults = clientTools.map((tc) => ({
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            error: `Tool "${tc.toolName}" is not available. No handler is registered for this tool.`,
+            outputVariable: tc.outputVariable,
+            blockIndex: tc.blockIndex,
+            thread: tc.thread,
+            workerId: tc.workerId
+          }));
+          for (const tr of rejectedResults) {
+            yield { type: "tool-output-error", toolCallId: tr.toolCallId, error: tr.error };
+          }
+          toolResults = [...serverResults, ...rejectedResults];
+        } else {
+          if (!executionId) {
+            yield createInternalErrorEvent("Missing executionId for client-tool-request");
+            return;
+          }
+          yield {
+            type: "client-tool-request",
+            executionId,
+            toolCalls: clientTools,
+            serverToolResults: serverResults.length > 0 ? serverResults : void 0
+          };
+          yield { type: "finish", finishReason: "client-tool-calls", executionId };
+          continueLoop = false;
         }
-        yield {
-          type: "client-tool-request",
-          executionId,
-          toolCalls: clientTools,
-          serverToolResults: serverResults.length > 0 ? serverResults : void 0
-        };
-        yield { type: "finish", finishReason: "client-tool-calls", executionId };
-        continueLoop = false;
       } else {
         toolResults = serverResults;
       }
@@ -360,12 +376,14 @@ var AgentSession = class {
   additionalToolSchemasSent = false;
   socketAbortController = null;
   onToolResults;
+  rejectClientToolCalls;
   constructor(sessionConfig) {
     this.sessionId = sessionConfig.sessionId;
     this.config = sessionConfig.config;
     this.toolHandlers = sessionConfig.tools ?? {};
     this.additionalToolSchemas = sessionConfig.additionalToolSchemas;
     this.onToolResults = sessionConfig.onToolResults;
+    this.rejectClientToolCalls = sessionConfig.rejectClientToolCalls ?? false;
     this.resourceMap = /* @__PURE__ */ new Map();
     for (const resource of sessionConfig.resources ?? []) {
       this.resourceMap.set(resource.name, resource);
@@ -480,6 +498,7 @@ var AgentSession = class {
         },
         onResourceUpdate: (name, value) => this.handleResourceUpdate(name, value),
         onToolResults: this.onToolResults,
+        rejectClientToolCalls: this.rejectClientToolCalls,
         errorContext: "Failed to trigger"
       },
       { executionId: payload.executionId, toolResults: payload.toolResults },
@@ -622,7 +641,8 @@ var AgentSessionsApi = class extends BaseApiClient {
       tools: mergedTools,
       resources: options.resources,
       additionalToolSchemas: options.computer?.toolSchemas(),
-      onToolResults: options.onToolResults
+      onToolResults: options.onToolResults,
+      rejectClientToolCalls: options.rejectClientToolCalls
     });
   }
 };