@inferencesh/sdk 0.10.1 → 0.12.0

package/dist/agent/actions.js

@@ -4,13 +4,15 @@
  * Action creators that handle side effects (API calls, streaming).
  * These are created once per provider instance with access to dispatch.
  */
-import { AgentRunStateWorking, AgentRunStateSubmitted, AgentRunStateInputRequired, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, ChatMessageStatusReady, ChatMessageStatusFailed, ChatMessageStatusCancelled, } from '../types';
-import { isChatBusy } from '../utils';
+import { ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, } from '../types';
+import { isChatBusy, isMessageTerminal, isRunInterrupted, isRunWorking } from '../utils';
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { createLLMDeltaAccumulator } from '../delta';
 import { isAdHocConfig, extractClientToolHandlers } from './types';
 import * as api from './api';
+import { buildMCPInputResult } from './mcp-input';
+import { isInferenceError } from '../http/errors';
 // =============================================================================
 // Action Creators
 // =============================================================================
@@ -148,9 +150,7 @@ export function createActions(ctx) {
             // A message that has reached a terminal state will receive no further
             // deltas, so its accumulator is done. This bounds the map by the number
             // of messages streaming at once rather than by chat length.
-            if (message.status === ChatMessageStatusReady
-                || message.status === ChatMessageStatusFailed
-                || message.status === ChatMessageStatusCancelled) {
+            if (isMessageTerminal(message.status)) {
                 deltaAccums.delete(message.id);
             }
             updateMessage(message, fields);
@@ -158,8 +158,7 @@ export function createActions(ctx) {
         // Listen for AgentRun updates (state transitions, output)
         manager.addEventListener('agent_runs', (run) => {
             dispatch({ type: 'UPDATE_ACTIVE_RUN', payload: run });
-            const isRunActive = run.state === AgentRunStateWorking || run.state === AgentRunStateSubmitted || run.state === AgentRunStateInputRequired;
-            callbacks.onStatusChange?.(isRunActive ? 'streaming' : 'idle');
+            callbacks.onStatusChange?.(isRunWorking(run.state) || isRunInterrupted(run.state) ? 'streaming' : 'idle');
             const currentChat = getState().chat;
             if (currentChat)
                 checkTurnEnd({ ...currentChat, active_run: run });
@@ -326,6 +325,23 @@ export function createActions(ctx) {
                 throw error;
             }
         },
+        submitMCPInput: async (toolInvocationId, responses) => {
+            try {
+                await api.submitToolResult(client, toolInvocationId, buildMCPInputResult(responses));
+            }
+            catch (error) {
+                // A 400 means the answers were rejected and the call is still waiting:
+                // the caller shows it next to the form, the connection is fine.
+                if (isInferenceError(error) && error.statusCode === 400)
+                    throw error;
+                console.error('[AgentSDK] Failed to submit MCP input:', error);
+                const err = error instanceof Error ? error : new Error('Failed to submit MCP input');
+                dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
+                dispatch({ type: 'SET_ERROR', payload: err.message });
+                callbacks.onError?.(err);
+                throw error;
+            }
+        },
         approveTool: async (toolInvocationId) => {
             try {
                 await api.approveTool(client, toolInvocationId);

package/dist/agent/index.d.ts

@@ -48,3 +48,4 @@ export { useAgentChat, useAgentActions, useAgentClient, useAgentChatContext, use
 export { AgentChatContext, type AgentChatContextValue } from './context';
 export type { AgentClient, FileRef, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';
+export { MCPMethodElicitationCreate, parseMCPInputState, elicitParams, isURLElicitation, buildMCPInputResult, type MCPInputState, type ElicitRequestParams, type ElicitRequestedSchema, type ElicitPropertySchema, } from './mcp-input';

package/dist/agent/index.js

@@ -51,3 +51,5 @@ export { useAgentChat, useAgentActions, useAgentClient, useAgentChatContext, use
 export { AgentChatContext } from './context';
 // Type guards and helpers
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';
+// MCP input requests
+export { MCPMethodElicitationCreate, parseMCPInputState, elicitParams, isURLElicitation, buildMCPInputResult, } from './mcp-input';

package/dist/agent/mcp-input.d.ts

@@ -0,0 +1,57 @@
+/**
+ * MCP input requests on agent tool invocations.
+ *
+ * When a remote MCP server answers a tool call with `input_required`, the agent
+ * runtime parks the invocation in `awaiting_input` and stores an MCPInputState in
+ * its `data`. The UI renders each input request, collects an ElicitResult per
+ * key, and submits them with `submitMCPInput`; the runtime then re-sends the
+ * tool call with those responses.
+ */
+import type { ElicitResult, InputRequest } from '../types';
+export declare const MCPMethodElicitationCreate = "elicitation/create";
+/** Stored in ToolInvocationDTO.data while an MCP tool call waits for the user. */
+export interface MCPInputState {
+    input_required: true;
+    input_requests: Record<string, InputRequest>;
+    request_state?: string;
+    /** 1 for the first request; goes up each time the server asks again. */
+    round: number;
+}
+/** One property of a form-mode requestedSchema (MCP restricts these to flat primitives). */
+export interface ElicitPropertySchema {
+    type?: 'string' | 'number' | 'integer' | 'boolean';
+    title?: string;
+    description?: string;
+    default?: unknown;
+    format?: 'email' | 'uri' | 'date' | 'date-time' | string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    enum?: string[];
+    enumNames?: string[];
+    oneOf?: {
+        const: string;
+        title?: string;
+    }[];
+}
+export interface ElicitRequestedSchema {
+    type?: 'object';
+    properties?: Record<string, ElicitPropertySchema>;
+    required?: string[];
+}
+/** params of an elicitation/create request. */
+export interface ElicitRequestParams {
+    mode?: 'form' | 'url';
+    message: string;
+    requestedSchema?: ElicitRequestedSchema;
+    url?: string;
+}
+/** Parses an invocation's data into MCPInputState, or null when it isn't one. */
+export declare function parseMCPInputState(data: unknown): MCPInputState | null;
+/** Returns the elicitation params of an input request, or null for other methods. */
+export declare function elicitParams(request: InputRequest): ElicitRequestParams | null;
+/** URL mode sends the user to a page; form mode asks for fields. Mode defaults to form. */
+export declare function isURLElicitation(params: ElicitRequestParams): boolean;
+/** Builds the tool result string the runtime expects: {<key>: {action, content?}}. */
+export declare function buildMCPInputResult(responses: Record<string, ElicitResult>): string;

package/dist/agent/mcp-input.js

@@ -0,0 +1,58 @@
+/**
+ * MCP input requests on agent tool invocations.
+ *
+ * When a remote MCP server answers a tool call with `input_required`, the agent
+ * runtime parks the invocation in `awaiting_input` and stores an MCPInputState in
+ * its `data`. The UI renders each input request, collects an ElicitResult per
+ * key, and submits them with `submitMCPInput`; the runtime then re-sends the
+ * tool call with those responses.
+ */
+export const MCPMethodElicitationCreate = 'elicitation/create';
+/** Parses an invocation's data into MCPInputState, or null when it isn't one. */
+export function parseMCPInputState(data) {
+    let value = data;
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!value || typeof value !== 'object')
+        return null;
+    const state = value;
+    if (state.input_required !== true)
+        return null;
+    if (!state.input_requests || typeof state.input_requests !== 'object')
+        return null;
+    if (Object.keys(state.input_requests).length === 0)
+        return null;
+    return {
+        input_required: true,
+        input_requests: state.input_requests,
+        request_state: state.request_state,
+        round: typeof state.round === 'number' ? state.round : 1,
+    };
+}
+/** Returns the elicitation params of an input request, or null for other methods. */
+export function elicitParams(request) {
+    if (request.method !== MCPMethodElicitationCreate || !request.params)
+        return null;
+    const params = request.params;
+    return { ...params, message: params.message ?? '' };
+}
+/** URL mode sends the user to a page; form mode asks for fields. Mode defaults to form. */
+export function isURLElicitation(params) {
+    return params.mode === 'url' || (!params.mode && !!params.url);
+}
+/** Builds the tool result string the runtime expects: {<key>: {action, content?}}. */
+export function buildMCPInputResult(responses) {
+    const out = {};
+    for (const [key, response] of Object.entries(responses)) {
+        out[key] = response.action === 'accept' && response.content
+            ? { action: response.action, content: response.content }
+            : { action: response.action };
+    }
+    return JSON.stringify(out);
+}

package/dist/agent/reducer.js

@@ -3,13 +3,14 @@
  *
  * Pure reducer for managing agent chat state.
  */
-import { ChatStatusBusy, ChatStatusAwaitingInput, ChatStatusIdle, AgentRunStateWorking, AgentRunStateSubmitted } from '../types';
+import { ChatStatusBusy, ChatStatusAwaitingInput, ChatStatusIdle } from '../types';
+import { isRunInterrupted, isRunWorking } from '../utils';
 function deriveChatStatus(run) {
     if (!run)
         return ChatStatusIdle;
-    if (run.state === AgentRunStateWorking || run.state === AgentRunStateSubmitted)
+    if (isRunWorking(run.state))
         return ChatStatusBusy;
-    if (run.state === 'input_required' || run.state === 'auth_required')
+    if (isRunInterrupted(run.state))
         return ChatStatusAwaitingInput;
     return ChatStatusIdle;
 }

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { AgentRunDTO, AgentVersionDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef } from '../types';
+import type { AgentRunDTO, AgentVersionDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef, ElicitResult } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
@@ -126,6 +126,8 @@ export interface AgentChatActions {
     clearError: () => void;
     /** Submit a tool result (for widgets/awaiting input) - usually called automatically by SDK */
     submitToolResult: (toolInvocationId: string, result: string) => Promise<void>;
+    /** Answer an MCP tool call's input requests (AwaitingInput status with MCPInputState data) */
+    submitMCPInput: (toolInvocationId: string, responses: Record<string, ElicitResult>) => Promise<void>;
     /** Approve a tool (for HIL approval - AwaitingApproval status) */
     approveTool: (toolInvocationId: string) => Promise<void>;
     /** Reject a tool (for HIL approval - AwaitingApproval status) */

package/dist/api/agents.js

@@ -1,9 +1,8 @@
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
 import { createLLMDeltaAccumulator } from '../delta';
-import { ChatMessageStatusCancelled, ChatMessageStatusFailed, ChatMessageStatusReady, ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
-import { isChatBusy } from '../utils';
-const terminalMessageStatuses = new Set([ChatMessageStatusReady, ChatMessageStatusFailed, ChatMessageStatusCancelled]);
+import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
+import { isChatBusy, isMessageTerminal } from '../utils';
 /**
  * Decides when one sendMessage() turn is over.
  *
@@ -25,7 +24,7 @@ class TurnGate {
             this.sawBusy = true;
     }
     observeMessage(message) {
-        if (message.id === this.assistantMessageId && terminalMessageStatuses.has(message.status)) {
+        if (message.id === this.assistantMessageId && isMessageTerminal(message.status)) {
             this.assistantDone = true;
         }
     }
@@ -86,23 +85,19 @@ export class Agent {
             if (others.length > 0)
                 fileUris = others.map((f) => f.uri);
         }
-        const body = isTemplate
-            ? {
-                chat_id: this.chatId,
-                agent: this.config,
-                context: this.context,
-                input: { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
-            }
-            : {
-                chat_id: this.chatId,
-                agent_config: this.config,
-                agent_name: this.agentName ?? this.config.name,
-                context: this.context,
-                input: { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
-            };
-        if (options.channel_context !== undefined) {
-            body.channel_context = options.channel_context;
-        }
+        const input = { text, images: imageUris, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 };
+        const body = {
+            chat_id: this.chatId ?? undefined,
+            context: this.context,
+            input,
+            channel_context: options.channel_context,
+            ...(isTemplate
+                ? { agent: this.config }
+                : {
+                    agent_config: this.config,
+                    agent_name: this.agentName ?? this.config.name,
+                }),
+        };
         const useStream = options.stream ?? this.http.getStreamDefault();
         const shouldWait = useStream === false || hasCallbacks;
         const gate = new TurnGate(!!this.chatId);
@@ -270,7 +265,7 @@ export class Agent {
             });
             this.stream.addEventListener('chat_messages', (message) => {
                 // A terminal message receives no further deltas.
-                if (terminalMessageStatuses.has(message.status))
+                if (isMessageTerminal(message.status))
                     deltaAccums.delete(message.id);
                 gate.observeMessage(message);
                 options.onMessage?.(message);

package/dist/index.d.ts

@@ -26,14 +26,15 @@ export { ProjectsAPI } from './api/projects';
 export { MCPServersAPI } from './api/mcp-servers';
 export { LiveSession, accessUrl } from './live/session';
 export type { LiveState, LiveEnd, LiveHandlers, LiveSessionOptions, LiveUpdate, WebSocketLike, WebSocketConstructor } from './live/session';
-export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema';
+export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, REDIAL_CODES } from './live/protocol';
+export { isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema';
 export type { JsonSchema, MediaType, PCMFormat, LiveField } from './live/schema';
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
 export type { ClientTool, ClientToolHandler } from './tool-builder';
 export { lifecycleHook } from './hook-builder';
 export type { LifecycleHookBuilder } from './hook-builder';
 export { DeltaAccumulator, createLLMDeltaAccumulator, type DeltaEvent, type FieldTags, type FieldTagsRegistry } from './delta';
-export { parseStatus, isTerminalStatus, isChatBusy, pendingApprovals } from './utils';
+export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, } from './utils';
 export type { PendingApproval } from './utils';
 export * from './types';
 export type { TaskDTO as Task } from './types';

package/dist/index.js

@@ -28,7 +28,8 @@ export { ProjectsAPI } from './api/projects';
 export { MCPServersAPI } from './api/mcp-servers';
 // Live: the socket of a stream task and the live fields of its schemas
 export { LiveSession, accessUrl } from './live/session';
-export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema';
+export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, REDIAL_CODES } from './live/protocol';
+export { isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema';
 // Tool Builder (fluent API)
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
 // Hook Builder (fluent API)
@@ -36,7 +37,7 @@ export { lifecycleHook } from './hook-builder';
 // Delta accumulator for streaming responses
 export { DeltaAccumulator, createLLMDeltaAccumulator } from './delta';
 // Status utilities (handle both int and string status values)
-export { parseStatus, isTerminalStatus, isChatBusy, pendingApprovals } from './utils';
+export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, } from './utils';
 // Types - includes TaskStatus constants and all DTOs
 export * from './types';
 // =============================================================================

package/dist/live/protocol.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The live socket's wire protocol. sdk-py (inferencesh/models/stream.py)
+ * mirrors all of it and sdk-js-app (src/stream.ts) mirrors CLEAR_KEY and
+ * ERROR_KEY; change the copies together.
+ */
+export declare const STREAM_FORMAT = "stream";
+/** `{"$clear": "audio"}`: drop what has been buffered of a live output field. */
+export declare const CLEAR_KEY = "$clear";
+/**
+ * `{"$error": {"field": ..., "message": ...}}`: a refused frame, or anything
+ * else the caller should be told went wrong. The stream goes on.
+ */
+export declare const ERROR_KEY = "$error";
+/**
+ * Relay close codes that mean "dial again". 1012: the relay is restarting and
+ * closed an end that still waited for its peer. 1013: the peer did not come in
+ * time. Neither means anything once frames have flowed.
+ */
+export declare const REDIAL_CODES: ReadonlySet<number>;

package/dist/live/protocol.js

@@ -0,0 +1,21 @@
+/**
+ * The live socket's wire protocol. sdk-py (inferencesh/models/stream.py)
+ * mirrors all of it and sdk-js-app (src/stream.ts) mirrors CLEAR_KEY and
+ * ERROR_KEY; change the copies together.
+ */
+export const STREAM_FORMAT = 'stream';
+// Control frames. Reserved keys start with `$`, which no field name can, so a
+// control frame is never mistaken for an output field.
+/** `{"$clear": "audio"}`: drop what has been buffered of a live output field. */
+export const CLEAR_KEY = '$clear';
+/**
+ * `{"$error": {"field": ..., "message": ...}}`: a refused frame, or anything
+ * else the caller should be told went wrong. The stream goes on.
+ */
+export const ERROR_KEY = '$error';
+/**
+ * Relay close codes that mean "dial again". 1012: the relay is restarting and
+ * closed an end that still waited for its peer. 1013: the peer did not come in
+ * time. Neither means anything once frames have flowed.
+ */
+export const REDIAL_CODES = new Set([1012, 1013]);

package/dist/live/schema.d.ts

@@ -16,14 +16,6 @@
  * The helpers are generic over the schema type so a caller with a richer
  * JSON Schema type keeps it.
  */
-export declare const STREAM_FORMAT = "stream";
-/** `{"$clear": "audio"}`: drop what has been buffered of a live output field. */
-export declare const CLEAR_KEY = "$clear";
-/**
- * `{"$error": {"field": ..., "message": ...}}`: a refused frame, or anything
- * else the caller should be told went wrong. The stream goes on.
- */
-export declare const ERROR_KEY = "$error";
 /** The part of JSON Schema these helpers read. */
 export interface JsonSchema {
     $ref?: string;

package/dist/live/schema.js

@@ -16,16 +16,7 @@
  * The helpers are generic over the schema type so a caller with a richer
  * JSON Schema type keeps it.
  */
-export const STREAM_FORMAT = 'stream';
-// Control frames. Reserved keys start with `$`, which no field name can, so a
-// control frame is never mistaken for an output field.
-/** `{"$clear": "audio"}`: drop what has been buffered of a live output field. */
-export const CLEAR_KEY = '$clear';
-/**
- * `{"$error": {"field": ..., "message": ...}}`: a refused frame, or anything
- * else the caller should be told went wrong. The stream goes on.
- */
-export const ERROR_KEY = '$error';
+import { STREAM_FORMAT } from './protocol';
 export function isLiveField(schema) {
     return !!schema && schema.format === STREAM_FORMAT;
 }

package/dist/live/session.js

@@ -1,9 +1,6 @@
-import { binaryLiveField, CLEAR_KEY, ERROR_KEY, splitLiveSchema } from './schema';
+import { CLEAR_KEY, ERROR_KEY, REDIAL_CODES } from './protocol';
+import { binaryLiveField, splitLiveSchema } from './schema';
 const WS_OPEN = 1;
-// 1012: the relay is restarting and closed an end that still waited for its
-// peer. 1013: the peer did not come in time. Both mean "dial again" while the
-// task is alive, and neither means anything once frames have flowed.
-const REDIAL_CODES = new Set([1012, 1013]);
 const MAX_REDIALS = 5;
 function globalWebSocket() {
     const ctor = globalThis.WebSocket;