@inferencesh/sdk 0.20.1 → 0.22.0

package/dist/api/agents.js

@@ -1,4 +1,4 @@
-import { StreamableManager } from '../http/streamable';
+import { streamUntilTerminal } from '../http/stream-until-terminal';
 import { PollManager } from '../http/poll';
 import { createLLMDeltaAccumulator } from '../delta';
 import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
@@ -108,6 +108,10 @@ export class Agent {
         let waitPromise = null;
         if (this.chatId && shouldWait) {
             waitPromise = waitFn(options);
+            // The stream can fail while the POST is in flight, before anything
+            // awaits waitPromise; mark the rejection handled so Node does not treat
+            // it as unhandled. The await below still sees it.
+            waitPromise.catch(() => { });
         }
         // Make the POST request
         let response;
@@ -145,8 +149,11 @@ export class Agent {
                 this.disconnect();
                 reject(signal.reason);
             };
-            if (signal.aborted)
-                return onAbort();
+            if (signal.aborted) {
+                onAbort();
+                wait.catch(() => { });
+                return;
+            }
             signal.addEventListener('abort', onAbort, { once: true });
             wait.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
         });
@@ -203,91 +210,101 @@ export class Agent {
     startStreaming(options = {}) {
         if (!this.chatId)
             return;
-        this.streamUntilIdle(options, new TurnGate(false));
+        // Fire-and-forget: a stream failure must not become an unhandled rejection.
+        this.streamUntilIdle(options, new TurnGate(false)).catch((error) => {
+            console.warn('[Agent] Stream error:', error);
+        });
     }
     /** Stream events until chat becomes idle */
     streamUntilIdle(options, gate) {
         if (!this.chatId)
             return Promise.resolve();
-        const { url, headers, credentials } = this.http.getStreamableConfig(`/chats/${this.chatId}/stream`);
-        return new Promise((resolve) => {
-            this.stream?.stop();
-            this.stream = new StreamableManager({
-                url,
-                headers,
-                credentials,
-            });
+        const chatId = this.chatId;
+        this.stream?.stop();
+        const handle = streamUntilTerminal((settle) => {
             // Last chat/run observation was idle but the gate wasn't settled yet;
             // a terminal message for this turn can settle it.
             let idlePending = false;
             const onIdle = () => {
                 if (gate.settled)
-                    resolve();
+                    settle.resolve();
                 else
                     idlePending = true;
             };
-            this.stream.addEventListener('chats', (chat) => {
+            const observeChat = (chat) => {
                 options.onChat?.(chat);
                 gate.observeChat(chat);
                 if (!isChatBusy(chat))
                     onIdle();
                 else
                     idlePending = false;
-            });
-            this.stream.addEventListener('agent_runs', (run) => {
-                const asChat = { active_run: run };
-                options.onChat?.(asChat);
-                gate.observeChat(asChat);
-                if (!isChatBusy(asChat))
-                    onIdle();
-                else
-                    idlePending = false;
-            });
+            };
             // One accumulator per message being streamed, keyed by the message id
             // the delta names, so a tool-call-only turn never shows the previous
             // message's text. Same attribution rule as the React hooks.
             const deltaAccums = new Map();
-            this.stream.addEventListener('delta', (evt) => {
-                if (!options.onDelta || !evt?.delta || !evt.resource_id)
-                    return;
-                let accum = deltaAccums.get(evt.resource_id);
-                if (!accum) {
-                    accum = createLLMDeltaAccumulator();
-                    deltaAccums.set(evt.resource_id, accum);
-                }
-                accum.apply(evt.delta);
-                options.onDelta({
-                    messageId: evt.resource_id,
-                    delta: evt.delta,
-                    output: accum.toOutput(),
-                    seq: evt.seq,
-                });
-            });
-            this.stream.addEventListener('chat_messages', (message) => {
-                // A terminal message receives no further deltas.
-                if (isMessageTerminal(message.status))
-                    deltaAccums.delete(message.id);
-                gate.observeMessage(message);
-                options.onMessage?.(message);
-                if (idlePending && gate.settled)
-                    resolve();
-                if (message.tool_invocations && options.onToolCall) {
-                    for (const inv of message.tool_invocations) {
-                        if (this.dispatchedToolCalls.has(inv.id))
-                            continue;
-                        if (inv.type === ToolTypeClient && (inv.status === ToolInvocationStatusInProgress || inv.status === ToolInvocationStatusAwaitingInput)) {
-                            this.dispatchedToolCalls.add(inv.id);
-                            options.onToolCall({
-                                id: inv.id,
-                                name: inv.function?.name || '',
-                                args: inv.function?.arguments || {},
-                            });
+            return {
+                request: (init) => this.http.fetch(`/chats/${chatId}/stream`, init),
+                events: {
+                    chats: (chat) => observeChat(chat),
+                    agent_runs: (run) => observeChat({ active_run: run }),
+                    delta: (evt) => {
+                        if (!options.onDelta || !evt?.delta || !evt.resource_id)
+                            return;
+                        let accum = deltaAccums.get(evt.resource_id);
+                        if (!accum) {
+                            accum = createLLMDeltaAccumulator();
+                            deltaAccums.set(evt.resource_id, accum);
                         }
-                    }
-                }
-            });
-            this.stream.start();
+                        accum.apply(evt.delta);
+                        options.onDelta({
+                            messageId: evt.resource_id,
+                            delta: evt.delta,
+                            output: accum.toOutput(),
+                            seq: evt.seq,
+                        });
+                    },
+                    chat_messages: (message) => {
+                        // A terminal message receives no further deltas.
+                        if (isMessageTerminal(message.status))
+                            deltaAccums.delete(message.id);
+                        gate.observeMessage(message);
+                        options.onMessage?.(message);
+                        if (idlePending && gate.settled)
+                            settle.resolve();
+                        if (message.tool_invocations && options.onToolCall) {
+                            for (const inv of message.tool_invocations) {
+                                if (this.dispatchedToolCalls.has(inv.id))
+                                    continue;
+                                if (inv.type === ToolTypeClient && (inv.status === ToolInvocationStatusInProgress || inv.status === ToolInvocationStatusAwaitingInput)) {
+                                    this.dispatchedToolCalls.add(inv.id);
+                                    options.onToolCall({
+                                        id: inv.id,
+                                        name: inv.function?.name || '',
+                                        args: inv.function?.arguments || {},
+                                    });
+                                }
+                            }
+                        }
+                    },
+                },
+                // The stream closed before the chat was seen idle: the chat itself
+                // says whether the turn is over.
+                reconcile: async () => {
+                    const { data: chat } = await this.http.request('get', `/chats/${chatId}`);
+                    observeChat(chat);
+                },
+                closedMessage: 'Chat stream closed before the chat became idle',
+                // Stopped by disconnect()/abort or replaced by a newer stream: the
+                // caller stopped waiting on purpose.
+                onStopped: () => settle.resolve(),
+                // Once the turn is over the stream stays attached, so onChat/onMessage
+                // keep reporting until the next turn or disconnect() replaces it.
+                keepOpen: true,
+            };
         });
+        this.stream = handle;
+        return handle.done;
     }
     /** Poll until chat becomes idle, dispatching callbacks on changes */
     pollUntilIdle(options, gate) {
@@ -396,7 +413,8 @@ export class AgentsAPI {
         return this.http.request('post', '/agents', { data });
     }
     /**
-     * Update an agent template
+     * Update an agent template: its visibility and images, and a new version
+     * when `version` is set (see AgentUpdateBody).
      */
     async update(agentId, data) {
         return this.http.request('post', `/agents/${agentId}`, { data });
@@ -474,7 +492,11 @@ export class AgentsAPI {
         await this.http.request('post', `/tools/${toolInvocationId}`, { data: { result } });
     }
     /**
-     * Resolve an interrupt gate on an agent run
+     * Resolve an interrupt gate on an agent run.
+     *
+     * Needs approvals:write, which only the account holder's own sign-in holds:
+     * with an API key, an app's OAuth token or the server proxy it rejects with
+     * 403 `requires_sign_in` (ErrorCodeRequiresSignIn).
      */
     async resolveInterrupt(interruptId, decision) {
         return this.http.request('post', `/interrupts/${interruptId}/resolve`, {

package/dist/api/api-keys.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { ApiKeyDTO, CursorListRequest, CursorListResponse } from '../types';
+import { ApiKeyDTO, CreateApiKeyRequest, CursorListRequest, CursorListResponse } from '../types';
 /**
  * API Keys API
  */
@@ -14,10 +14,7 @@ export declare class ApiKeysAPI {
     /**
      * Create an API key
      */
-    create(data: {
-        name: string;
-        scopes?: string[];
-    }): Promise<Response<ApiKeyDTO>>;
+    create(data: CreateApiKeyRequest): Promise<Response<ApiKeyDTO>>;
     /**
      * Delete an API key
      */

package/dist/api/apps.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { AppPatchBody, AppUpdateBody } from './write-bodies';
 import { AppDTO as App, AppVersionDTO, CursorListRequest, CursorListResponse, LicenseRecordDTO } from '../types';
 /**
  * Apps API
@@ -24,9 +25,15 @@ export declare class AppsAPI {
      */
     create(data: Partial<App>): Promise<Response<App>>;
     /**
-     * Update an app
+     * Update an app's copy and edit its current version in place (see
+     * AppUpdateBody). Status and visibility have their own methods.
      */
-    update(appId: string, data: Partial<App>): Promise<Response<App>>;
+    update(appId: string, data: AppUpdateBody): Promise<Response<App>>;
+    /**
+     * Change some of an app's copy (PATCH): only the fields sent are written,
+     * the others keep their value. Editing the version in place: update.
+     */
+    patch(appId: string, data: AppPatchBody): Promise<Response<App>>;
     /**
      * Delete an app
      */

package/dist/api/apps.js

@@ -30,11 +30,19 @@ export class AppsAPI {
         return this.http.request('post', '/apps', { data });
     }
     /**
-     * Update an app
+     * Update an app's copy and edit its current version in place (see
+     * AppUpdateBody). Status and visibility have their own methods.
      */
     async update(appId, data) {
         return this.http.request('post', `/apps/${appId}`, { data });
     }
+    /**
+     * Change some of an app's copy (PATCH): only the fields sent are written,
+     * the others keep their value. Editing the version in place: update.
+     */
+    async patch(appId, data) {
+        return this.http.request('patch', `/apps/${appId}`, { data });
+    }
     /**
      * Delete an app
      */

package/dist/api/chats.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { ChatDTO as Chat, ChatMessageDTO, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
+import type { ChatUpdateBody } from './write-bodies';
+import { ChatDTO as Chat, ChatMessageDTO, ChatSettingsDTO, ChatSettingsRequest, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Chats API
  */
@@ -16,9 +17,18 @@ export declare class ChatsAPI {
      */
     get(chatId: string): Promise<Response<Chat>>;
     /**
-     * Update a chat
+     * Update a chat's name and description (PATCH): only the fields sent are
+     * written. Visibility and the other chat settings: updateSettings.
      */
-    update(chatId: string, data: Partial<Chat>): Promise<Response<Chat>>;
+    update(chatId: string, data: ChatUpdateBody): Promise<Response<Chat>>;
+    /**
+     * Change a chat's settings (name, visibility, tool approval, hooks,
+     * memory). Answers with the settings as they now are. Widening what runs
+     * without approval needs approvals:write, held only by the account
+     * holder's own sign-in: other credentials get 403 `requires_sign_in`
+     * (ErrorCodeRequiresSignIn).
+     */
+    updateSettings(chatId: string, settings: ChatSettingsRequest): Promise<Response<ChatSettingsDTO>>;
     /**
      * Delete a chat
      */

package/dist/api/chats.js

@@ -18,10 +18,21 @@ export class ChatsAPI {
         return this.http.request('get', `/chats/${chatId}`);
     }
     /**
-     * Update a chat
+     * Update a chat's name and description (PATCH): only the fields sent are
+     * written. Visibility and the other chat settings: updateSettings.
      */
     async update(chatId, data) {
-        return this.http.request('post', `/chats/${chatId}`, { data });
+        return this.http.request('patch', `/chats/${chatId}`, { data });
+    }
+    /**
+     * Change a chat's settings (name, visibility, tool approval, hooks,
+     * memory). Answers with the settings as they now are. Widening what runs
+     * without approval needs approvals:write, held only by the account
+     * holder's own sign-in: other credentials get 403 `requires_sign_in`
+     * (ErrorCodeRequiresSignIn).
+     */
+    async updateSettings(chatId, settings) {
+        return this.http.request('post', `/chats/${chatId}/settings`, { data: settings });
     }
     /**
      * Delete a chat

package/dist/api/engines.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { EngineUpdateBody } from './write-bodies';
 import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Engines API
@@ -27,9 +28,10 @@ export declare class EnginesAPI {
      */
     create(data: Partial<Engine>): Promise<Response<Engine>>;
     /**
-     * Update an engine
+     * Rename an engine (see EngineUpdateBody). PATCH: only the fields sent are
+     * written.
      */
-    update(engineId: string, data: Partial<Engine>): Promise<Response<Engine>>;
+    update(engineId: string, data: EngineUpdateBody): Promise<Response<Engine>>;
     /**
      * Delete an engine
      */

package/dist/api/engines.js

@@ -30,10 +30,11 @@ export class EnginesAPI {
         return this.http.request('post', '/engines', { data });
     }
     /**
-     * Update an engine
+     * Rename an engine (see EngineUpdateBody). PATCH: only the fields sent are
+     * written.
      */
     async update(engineId, data) {
-        return this.http.request('post', `/engines/${engineId}`, { data });
+        return this.http.request('patch', `/engines/${engineId}`, { data });
     }
     /**
      * Delete an engine

package/dist/api/flow-runs.d.ts

@@ -24,7 +24,11 @@ export declare class FlowRunsAPI {
      */
     clone(flowRunId: string): Promise<Response<FlowRun>>;
     /**
-     * Update a flow run
+     * Update a flow run.
+     *
+     * @deprecated A flow run has no caller-writable fields: the API refuses this
+     * request. To change who can see a run, use {@link FlowRunsAPI.updateVisibility}.
+     * Kept so existing code still compiles; it will be removed in a future major version.
      */
     update(flowRunId: string, data: Partial<FlowRun>): Promise<Response<FlowRun>>;
     /**
@@ -40,7 +44,8 @@ export declare class FlowRunsAPI {
      */
     streamTasks(flowRunId: string): Promise<import("eventsource").EventSource | null>;
     /**
-     * Update flow run visibility
+     * Set who can see a flow run: `private`, `team`, `unlisted` or `public`.
+     * This is the one change a caller can make to a run.
      */
     updateVisibility(flowRunId: string, visibility: string): Promise<Response<FlowRun>>;
 }

package/dist/api/flow-runs.js

@@ -30,7 +30,11 @@ export class FlowRunsAPI {
         return this.http.request('post', `/flowruns/${flowRunId}/clone`);
     }
     /**
-     * Update a flow run
+     * Update a flow run.
+     *
+     * @deprecated A flow run has no caller-writable fields: the API refuses this
+     * request. To change who can see a run, use {@link FlowRunsAPI.updateVisibility}.
+     * Kept so existing code still compiles; it will be removed in a future major version.
      */
     async update(flowRunId, data) {
         return this.http.request('post', `/flowruns/${flowRunId}`, { data });
@@ -54,7 +58,8 @@ export class FlowRunsAPI {
         return this.http.createEventSource(`/flowruns/${flowRunId}/tasks/stream`);
     }
     /**
-     * Update flow run visibility
+     * Set who can see a flow run: `private`, `team`, `unlisted` or `public`.
+     * This is the one change a caller can make to a run.
      */
     async updateVisibility(flowRunId, visibility) {
         return this.http.request('post', `/flowruns/${flowRunId}/visibility`, { data: { visibility } });

package/dist/api/flows.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { FlowPatchBody, FlowUpdateBody, FlowViewportBody } from './write-bodies';
 import { FlowDTO as Flow, FlowVersionDTO, AppDTO as App, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Flows API
@@ -20,9 +21,19 @@ export declare class FlowsAPI {
      */
     create(name: string): Promise<Response<Flow>>;
     /**
-     * Update a flow
+     * Update a flow's copy and images, and save its draft graph when the body
+     * names the draft (see FlowUpdateBody). A field left out is written
+     * empty: to change some fields only, use patch.
      */
-    update(flowId: string, data: Partial<Flow>): Promise<Response<Flow>>;
+    update(flowId: string, data: FlowUpdateBody): Promise<Response<Flow>>;
+    /**
+     * Change some of a flow's fields: only the fields sent are written.
+     */
+    patch(flowId: string, data: FlowPatchBody): Promise<Response<Flow>>;
+    /**
+     * Save where the editor's canvas looks on the flow's draft.
+     */
+    saveViewport(flowId: string, viewport: FlowViewportBody): Promise<Response<void>>;
     /**
      * Update flow visibility
      */

package/dist/api/flows.js

@@ -24,11 +24,25 @@ export class FlowsAPI {
         return this.http.request('post', '/flows', { data: { name } });
     }
     /**
-     * Update a flow
+     * Update a flow's copy and images, and save its draft graph when the body
+     * names the draft (see FlowUpdateBody). A field left out is written
+     * empty: to change some fields only, use patch.
      */
     async update(flowId, data) {
         return this.http.request('post', `/flows/${flowId}`, { data });
     }
+    /**
+     * Change some of a flow's fields: only the fields sent are written.
+     */
+    async patch(flowId, data) {
+        return this.http.request('patch', `/flows/${flowId}`, { data });
+    }
+    /**
+     * Save where the editor's canvas looks on the flow's draft.
+     */
+    async saveViewport(flowId, viewport) {
+        return this.http.request('post', `/flows/${flowId}/viewport`, { data: viewport });
+    }
     /**
      * Update flow visibility
      */

package/dist/api/knowledge.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { KnowledgeUpdateBody } from './write-bodies';
 import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types';
 /**
  * Knowledge API
@@ -24,9 +25,10 @@ export declare class KnowledgeAPI {
      */
     create(data: KnowledgeCreateRequest): Promise<Response<KnowledgeDTO>>;
     /**
-     * Update a knowledge entry
+     * Update a knowledge entry (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
-    update(id: string, data: Partial<KnowledgeDTO>): Promise<Response<KnowledgeDTO>>;
+    update(id: string, data: KnowledgeUpdateBody): Promise<Response<KnowledgeDTO>>;
     /**
      * Delete a knowledge entry
      */
@@ -75,9 +77,10 @@ export declare class SkillsAPI {
      */
     create(data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
     /**
-     * Update a skill
+     * Update a skill (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
-    update(id: string, data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
+    update(id: string, data: KnowledgeUpdateBody): Promise<Response<SkillDTO>>;
     /**
      * Delete a skill
      */

package/dist/api/knowledge.js

@@ -30,10 +30,11 @@ export class KnowledgeAPI {
         return this.http.request('post', '/knowledge', { data });
     }
     /**
-     * Update a knowledge entry
+     * Update a knowledge entry (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/knowledge/${id}`, { data });
+        return this.http.request('patch', `/knowledge/${id}`, { data });
     }
     /**
      * Delete a knowledge entry
@@ -107,10 +108,11 @@ export class SkillsAPI {
         return this.http.request('post', '/skills', { data });
     }
     /**
-     * Update a skill
+     * Update a skill (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/skills/${id}`, { data });
+        return this.http.request('patch', `/skills/${id}`, { data });
     }
     /**
      * Delete a skill

package/dist/api/mcp-servers.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { MCPServerUpdateBody } from './write-bodies';
 import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * MCP Servers API
@@ -38,7 +39,7 @@ export declare class MCPServersAPI {
     /**
      * Update an MCP server
      */
-    update(id: string, data: Partial<MCPServerDTO>): Promise<Response<MCPServerDTO>>;
+    update(id: string, data: MCPServerUpdateBody): Promise<Response<MCPServerDTO>>;
     /**
      * Delete an MCP server
      */

package/dist/api/projects.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { ProjectWriteBody } from './write-bodies';
 import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Projects API
@@ -18,11 +19,12 @@ export declare class ProjectsAPI {
     /**
      * Create a project
      */
-    create(data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
+    create(data: ProjectWriteBody): Promise<Response<ProjectDTO>>;
     /**
-     * Update a project
+     * Update a project (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
-    update(id: string, data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
+    update(id: string, data: ProjectWriteBody): Promise<Response<ProjectDTO>>;
     /**
      * Delete a project
      */

package/dist/api/projects.js

@@ -24,10 +24,11 @@ export class ProjectsAPI {
         return this.http.request('post', '/projects', { data });
     }
     /**
-     * Update a project
+     * Update a project (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/projects/${id}`, { data });
+        return this.http.request('patch', `/projects/${id}`, { data });
     }
     /**
      * Delete a project

package/dist/api/secrets.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { SecretDTO, SecretCreateRequest, CursorListRequest, CursorListResponse } from '../types';
+import { SecretDTO, SecretCreateRequest, SecretUpdateRequest, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Secrets API
  */
@@ -18,7 +18,7 @@ export declare class SecretsAPI {
     /**
      * Update a secret
      */
-    update(key: string, data: Partial<SecretCreateRequest>): Promise<Response<SecretDTO>>;
+    update(key: string, data: SecretUpdateRequest): Promise<Response<SecretDTO>>;
     /**
      * Delete a secret
      */