@inferencesh/sdk 0.6.28 → 0.6.30

package/dist/agent/actions.js

@@ -142,6 +142,13 @@ export function createActions(ctx) {
         manager.addEventListener('chat_messages', (message) => {
             updateMessage(message);
         });
+        // Listen for AgentRun updates (state transitions, output)
+        manager.addEventListener('agent_runs', (run) => {
+            dispatch({ type: 'UPDATE_ACTIVE_RUN', payload: run });
+            const asChat = { active_run: run };
+            callbacks.onStatusChange?.(isChatBusy(asChat) ? 'streaming' : 'idle');
+            checkTurnEnd(asChat);
+        });
         setStreamManager(manager);
         manager.start();
     };

package/dist/agent/reducer.js

@@ -29,12 +29,17 @@ export function chatReducer(state, action) {
             return { ...state, chat, messages };
         }
         case 'UPDATE_CHAT': {
-            // Update chat metadata (e.g. status) without replacing messages
+            // Update chat metadata without replacing messages
             const chat = action.payload;
             if (!chat)
                 return state;
             return { ...state, chat };
         }
+        case 'UPDATE_ACTIVE_RUN': {
+            if (!state.chat)
+                return state;
+            return { ...state, chat: { ...state.chat, active_run: action.payload } };
+        }
         case 'SET_MESSAGES':
             return { ...state, messages: action.payload };
         case 'UPDATE_MESSAGE': {

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef } from '../types';
+import type { AgentRunDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
@@ -187,6 +187,9 @@ export type ChatAction = {
 } | {
     type: 'UPDATE_CHAT';
     payload: ChatDTO | null;
+} | {
+    type: 'UPDATE_ACTIVE_RUN';
+    payload: AgentRunDTO;
 } | {
     type: 'SET_MESSAGES';
     payload: ChatMessageDTO[];

package/dist/api/agents.js

@@ -163,6 +163,13 @@ export class Agent {
                     resolve();
                 }
             });
+            this.stream.addEventListener('agent_runs', (run) => {
+                const asChat = { active_run: run };
+                options.onChat?.(asChat);
+                if (!isChatBusy(asChat)) {
+                    resolve();
+                }
+            });
             this.stream.addEventListener('chat_messages', (message) => {
                 options.onMessage?.(message);
                 if (message.tool_invocations && options.onToolCall) {

package/dist/types.d.ts

@@ -249,6 +249,7 @@ export interface AgentRunDTO extends BaseModelDTO, PermissionModelDTO {
     user_message_id?: string;
     state: AgentRunState;
     error?: string;
+    output?: any;
     interrupt_reason?: InterruptReason;
     interrupt_tool_id?: string;
     interrupt_meta?: any;
@@ -1429,6 +1430,7 @@ export type FlowNodeDataMap = {
  * FlowDTO for API responses
  */
 export interface FlowDTO extends BaseModelDTO, PermissionModelDTO {
+    namespace: string;
     name: string;
     description: string;
     card_image: string;
@@ -1784,6 +1786,162 @@ export interface SkillStoreListingDTO {
     uses: number;
     tags?: string[];
 }
+/**
+ * ElicitationCapability advertises which elicitation modes the client handles.
+ * An empty struct is equivalent to form-only for backward compatibility.
+ */
+export interface ElicitationCapability {
+    form?: {};
+    url?: {};
+}
+/**
+ * ClientCapabilities advertises what a client can do.
+ */
+export interface ClientCapabilities {
+    elicitation?: ElicitationCapability;
+}
+/**
+ * InputRequest is a single server-to-client request inside an InputRequiredResult.
+ */
+export interface InputRequest {
+    method: string;
+    params: any;
+}
+/**
+ * ElicitAction is the user's response to an elicitation request.
+ */
+export type ElicitAction = string;
+export declare const ElicitActionAccept: ElicitAction;
+export declare const ElicitActionDecline: ElicitAction;
+export declare const ElicitActionCancel: ElicitAction;
+/**
+ * ElicitResult is the client's response to an elicitation/create request.
+ */
+export interface ElicitResult {
+    action: ElicitAction;
+    content?: {
+        [key: string]: any;
+    };
+}
+/**
+ * ResultType is the kind of result a response carries, required on every result
+ * from 2026-07-28 onward.
+ */
+export type ResultType = string;
+/**
+ * ResultTypeComplete marks an ordinary, finished result.
+ */
+export declare const ResultTypeComplete: ResultType;
+/**
+ * ResultTypeInputRequired marks a Multi Round-Trip Request interim result.
+ * Recognised so the outbound client never mistakes one for tool output.
+ */
+export declare const ResultTypeInputRequired: 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.
+ */
+export type CacheScope = string;
+/**
+ * CacheScopePublic marks a response as free of user-specific data, so any
+ * client or shared intermediary may cache it across authorization contexts.
+ */
+export declare const CacheScopePublic: CacheScope;
+/**
+ * CacheScopePrivate restricts reuse to the same authorization context.
+ */
+export declare const CacheScopePrivate: CacheScope;
+/**
+ * ServerInfo represents information about the server
+ */
+export interface ServerInfo {
+    name: string;
+    title: string;
+    version: string;
+}
+/**
+ * ResultMeta is the _meta object attached to results. Servers SHOULD identify
+ * themselves in every result from 2026-07-28 onward (SEP-2575).
+ * The struct tag is the single definition of the key — Go tags cannot reference
+ * a constant, so there is deliberately no MetaServerInfo const to drift from it.
+ */
+export interface ResultMeta {
+    'io.modelcontextprotocol/serverInfo'?: ServerInfo;
+    /**
+     * TTLMs and CacheScope are read-only legacy fields: servers older than
+     * 2026-07-28 nested the caching signals here instead of on the result. They
+     * live on this type rather than a separate one so a single decode of the
+     * _meta object yields both them and serverInfo.
+     */
+    ttlMs?: number;
+    cacheScope?: CacheScope;
+}
+/**
+ * ResourceContent represents resource content
+ */
+export interface ResourceContent {
+    uri: string;
+    name: string;
+    title?: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+/**
+ * ToolCallRequest represents a request to call a tool.
+ * InputResponses and RequestState are present on MRTR retries: the client is
+ * echoing back responses to the server's InputRequiredResult.
+ */
+export interface ToolCallRequest {
+    name: string;
+    arguments: {
+        [key: string]: any;
+    };
+    inputResponses?: {
+        [key: string]: any;
+    };
+    requestState?: string;
+}
+/**
+ * ToolCallResponse represents a response from a tool call.
+ * ResultType is read as well as written: an inbound response carrying
+ * ResultTypeInputRequired is a Multi Round-Trip Request asking for more input,
+ * not tool output, and callers must not treat it as a result. Servers older than
+ * 2026-07-28 omit the field, which clients MUST read as "complete".
+ */
+export interface ToolCallResponse {
+    resultType?: ResultType;
+    content: ToolContent[];
+    structuredContent?: any;
+    isError: boolean;
+    _meta?: ResultMeta;
+    /**
+     * MRTR fields — present when ResultType == ResultTypeInputRequired.
+     */
+    inputRequests?: {
+        [key: string]: InputRequest;
+    };
+    requestState?: string;
+}
+/**
+ * ToolContentType is the kind of a content block. The spec defines exactly these.
+ */
+export type ToolContentType = string;
+export declare const ToolContentTypeText: ToolContentType;
+export declare const ToolContentTypeImage: ToolContentType;
+export declare const ToolContentTypeAudio: ToolContentType;
+export declare const ToolContentTypeResourceLink: ToolContentType;
+export declare const ToolContentTypeResource: ToolContentType;
+/**
+ * ToolContent represents content in a tool response
+ */
+export interface ToolContent {
+    type: ToolContentType;
+    text?: string;
+    data?: string;
+    mimeType?: string;
+    resource?: ResourceContent;
+}
 /**
  * StringSlice is a custom type for storing string slices
  */

package/dist/types.js

@@ -246,6 +246,32 @@ export const ScopeGroupEngines = "engines";
 export const ScopeGroupApiKeys = "apikeys";
 export const ScopeGroupUser = "user";
 export const ScopeGroupSettings = "settings";
+export const ElicitActionAccept = "accept";
+export const ElicitActionDecline = "decline";
+export const ElicitActionCancel = "cancel";
+/**
+ * ResultTypeComplete marks an ordinary, finished result.
+ */
+export const ResultTypeComplete = "complete";
+/**
+ * ResultTypeInputRequired marks a Multi Round-Trip Request interim result.
+ * Recognised so the outbound client never mistakes one for tool output.
+ */
+export const ResultTypeInputRequired = "input_required";
+/**
+ * CacheScopePublic marks a response as free of user-specific data, so any
+ * client or shared intermediary may cache it across authorization contexts.
+ */
+export const CacheScopePublic = "public";
+/**
+ * CacheScopePrivate restricts reuse to the same authorization context.
+ */
+export const CacheScopePrivate = "private";
+export const ToolContentTypeText = "text";
+export const ToolContentTypeImage = "image";
+export const ToolContentTypeAudio = "audio";
+export const ToolContentTypeResourceLink = "resource_link";
+export const ToolContentTypeResource = "resource";
 /**
  * Requirement error types
  */

package/package.json

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