@inferencesh/sdk 0.11.0 → 0.13.0

package/dist/agent/actions.js

@@ -11,6 +11,8 @@ 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
 // =============================================================================
@@ -323,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/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/types.d.ts

@@ -2692,9 +2692,14 @@ export interface ElicitationCapability {
 }
 /**
  * ClientCapabilities advertises what a client can do.
+ * Extensions carries the extensions the client supports, keyed by identifier
+ * (e.g. ExtensionTasks), each with its extension-defined settings object.
  */
 export interface ClientCapabilities {
     elicitation?: ElicitationCapability;
+    extensions?: {
+        [key: string]: any;
+    };
 }
 /**
  * InputRequest is a single server-to-client request inside an InputRequiredResult.
@@ -2723,7 +2728,7 @@ export interface ElicitResult {
  * ResultType is the kind of result a response carries, required on every result
  * from 2026-07-28 onward.
  */
-export type ResultType = "complete" | "input_required";
+export type ResultType = "complete" | "input_required" | "task";
 /**
  * ResultTypeComplete marks an ordinary, finished result.
  */
@@ -2733,6 +2738,11 @@ export declare const ResultTypeComplete: ResultType;
  * Recognised so the outbound client never mistakes one for tool output.
  */
 export declare const ResultTypeInputRequired: ResultType;
+/**
+ * ResultTypeTask marks a CreateTaskResult: the server accepted the request
+ * as a task under the tasks extension and the result arrives via tasks/get.
+ */
+export declare const ResultTypeTask: ResultType;
 /**
  * CacheScope says who may reuse a cached result, per MCP 2026-07-28 (SEP-2549).
  * Analogous to HTTP Cache-Control public/private; the spec defines exactly these.
@@ -5624,7 +5634,25 @@ export type ToolParameterProperties = {
     [key: string]: ToolParameterProperty;
 };
 export interface ToolParameterProperty {
-    type: ToolParamType;
+    /**
+     * Type is the JSON Schema type of the value. Empty when AnyOf is set: the
+     * value then has one of several shapes, and naming a single type would be
+     * telling the model something untrue about what it may send.
+     */
+    type?: ToolParamType;
+    /**
+     * AnyOf lists the shapes a value may take, each described as a property of
+     * its own. Anthropic and OpenAI both accept anyOf in tool schemas. Before
+     * this field existed the converter picked one branch and dropped the rest,
+     * so an app that accepted "401" or 401 could only tell the model about one.
+     */
+    anyOf?: ToolParameterProperty[];
+    /**
+     * Enum is the closed set of values a scalar may take, kept as data so a
+     * consumer choosing arguments does not have to parse it back out of the
+     * description.
+     */
+    enum?: any[];
     title: string;
     description: string;
     properties?: ToolParameterProperties;

package/dist/types.js

@@ -438,6 +438,11 @@ export const ResultTypeComplete = "complete";
  * Recognised so the outbound client never mistakes one for tool output.
  */
 export const ResultTypeInputRequired = "input_required";
+/**
+ * ResultTypeTask marks a CreateTaskResult: the server accepted the request
+ * as a task under the tasks extension and the result arrives via tasks/get.
+ */
+export const ResultTypeTask = "task";
 /**
  * CacheScopePublic marks a response as free of user-specific data, so any
  * client or shared intermediary may cache it across authorization contexts.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",