@inferencesh/sdk 0.6.50 → 0.6.52

package/README.md

@@ -363,7 +363,7 @@ import {
   mcpTool,
   internalTools,
   string,
-  IntegrationProviderGoogle,
+  CredentialProviderGoogle,
 } from '@inferencesh/sdk';
 
 const clientTool = tool('get_weather')
@@ -375,7 +375,7 @@ const clientTool = tool('get_weather')
 const gmailSend = httpTool('gmail_send', 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send')
   .describe('Send an email via Gmail')
   .method('POST')
-  .auth({ integration: IntegrationProviderGoogle, integrationId: 'your-integration-id' })
+  .auth({ integration: CredentialProviderGoogle, integrationId: 'your-integration-id' })
   .build();
 
 // API key or bearer auth
@@ -606,24 +606,24 @@ if (task.status === TaskStatusCompleted) {
 
 ## Integration Constants
 
-`IntegrationDTO` fields (`provider`, `type`, `auth`, `status`) use typed string unions exported as constants:
+`CredentialDTO` fields (`provider`, `type`, `auth`, `status`) use typed string unions exported as constants:
 
 ```typescript
-import type { IntegrationDTO } from '@inferencesh/sdk';
+import type { CredentialDTO } from '@inferencesh/sdk';
 import {
-  IntegrationProviderGoogle,
-  IntegrationAuthTypeOAuth,
-  IntegrationStatusConnected,
-  IntegrationStatusDisconnected,
-  IntegrationStatusExpired,
-  IntegrationStatusError,
+  CredentialProviderGoogle,
+  CredentialTypeOAuth,
+  CredentialStatusConnected,
+  CredentialStatusDisconnected,
+  CredentialStatusExpired,
+  CredentialStatusError,
   isRequirementsNotMetException,
 } from '@inferencesh/sdk';
 
-function isGoogleConnected(integration: IntegrationDTO): boolean {
+function isGoogleConnected(integration: CredentialDTO): boolean {
   return (
-    integration.provider === IntegrationProviderGoogle &&
-    integration.status === IntegrationStatusConnected
+    integration.provider === CredentialProviderGoogle &&
+    integration.status === CredentialStatusConnected
   );
 }
 
@@ -633,7 +633,7 @@ try {
 } catch (error) {
   if (isRequirementsNotMetException(error)) {
     for (const req of error.errors) {
-      if (req.type === 'integration' && req.action?.provider === IntegrationProviderGoogle) {
+      if (req.type === 'integration' && req.action?.provider === CredentialProviderGoogle) {
         // User must connect Google — see https://inference.sh/docs/extend/integrations
       }
     }
@@ -643,9 +643,9 @@ try {
 
 | Constant group | Values |
 |----------------|--------|
-| `IntegrationProvider*` | `google`, `slack`, `notion`, `github`, `x`, `microsoft`, `salesforce`, `discord`, `gcp`, `mcp`, `reddit` |
-| `IntegrationAuthType*` | `service_account`, `oauth`, `api_key`, `wif`, `mcp` |
-| `IntegrationStatus*` | `connected`, `disconnected`, `expired`, `error` |
+| `CredentialProvider*` | `google`, `slack`, `notion`, `github`, `x`, `microsoft`, `salesforce`, `discord`, `gcp`, `mcp`, `reddit` |
+| `CredentialType*` | `service_account`, `oauth`, `api_key`, `wif`, `mcp` |
+| `CredentialStatus*` | `connected`, `disconnected`, `expired`, `error` |
 
 ## Instance Status Constants
 
@@ -698,7 +698,7 @@ import type {
   Task,
   ApiAppRunRequest,
   RunOptions,
-  IntegrationDTO,
+  CredentialDTO,
   AgentTool,
 } from '@inferencesh/sdk';
 ```

package/dist/agent/actions.js

@@ -4,7 +4,7 @@
  * 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, } from '../types';
+import { AgentRunStateWorking, AgentRunStateSubmitted, AgentRunStateInputRequired, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, ToolTypeClient, ChatMessageStatusReady, ChatMessageStatusFailed, ChatMessageStatusCancelled, } from '../types';
 import { isChatBusy } from '../utils';
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
@@ -139,17 +139,19 @@ export function createActions(ctx) {
                 checkTurnEnd(chatData);
             }
         });
-        // Token-by-token streaming state, reset at every assistant-message boundary.
-        const deltaAccum = createLLMDeltaAccumulator();
+        // Token-by-token streaming state, one accumulator per message being
+        // streamed. Deltas name their message (DeltaEvent.resource_id), so state
+        // never leaks between messages the way a single shared accumulator allowed.
+        const deltaAccums = new Map();
         // Listen for ChatMessage updates
         manager.addEventListener('chat_messages', (message, fields) => {
-            // A new assistant message starts a new accumulation. The accumulator is
-            // cumulative and shared across the whole connection, so without this the
-            // next message's deltas merge into the previous message's state — and
-            // because concat with "" is a no-op, a turn that is only tool calls
-            // would render the previous message's text as its own.
-            if (message.role === 'assistant' && !getState().messages.some(m => m.id === message.id)) {
-                deltaAccum.reset();
+            // 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) {
+                deltaAccums.delete(message.id);
             }
             updateMessage(message, fields);
         });
@@ -163,10 +165,23 @@ export function createActions(ctx) {
                 checkTurnEnd({ ...currentChat, active_run: run });
         });
         manager.addEventListener('delta', (evt) => {
-            if (evt && evt.delta) {
-                deltaAccum.apply(evt.delta);
-                dispatch({ type: 'DELTA_TOKEN', payload: deltaAccum.toOutput() });
+            if (!evt || !evt.delta)
+                return;
+            // On a chat stream every task is created with an execution edge, so a
+            // delta with no resource id means something is wrong upstream — a missing
+            // or ambiguous edge, or a failed lookup. Guessing a target there would
+            // reintroduce exactly the misattribution this field exists to end, so
+            // drop it: the text still lands when the message itself arrives.
+            const messageId = evt.resource_id;
+            if (!messageId)
+                return;
+            let accum = deltaAccums.get(messageId);
+            if (!accum) {
+                accum = createLLMDeltaAccumulator();
+                deltaAccums.set(messageId, accum);
             }
+            accum.apply(evt.delta);
+            dispatch({ type: 'DELTA_TOKEN', payload: { messageId, output: accum.toOutput() } });
         });
         setStreamManager(manager);
         manager.start();

package/dist/agent/reducer.js

@@ -85,16 +85,19 @@ export function chatReducer(state, action) {
                 messages: [...state.messages, action.payload].sort((a, b) => a.order - b.order),
             };
         case 'DELTA_TOKEN': {
-            const output = action.payload;
+            const { messageId, output } = action.payload;
             const msgs = state.messages;
-            const lastAssistant = [...msgs].reverse().find(m => m.role === 'assistant');
-            if (!lastAssistant)
+            // Apply to the message the delta names — never to a guessed one. A
+            // message we have not received yet (or an unnamed delta) is dropped
+            // rather than misattributed; the text still arrives with the message.
+            const target = msgs.find(m => m.id === messageId);
+            if (!target)
                 return state;
-            const textBlock = lastAssistant.content?.find(c => c.type === 'text');
+            const textBlock = target.content?.find(c => c.type === 'text');
             const newContent = textBlock
-                ? lastAssistant.content.map(c => c.type === 'text' ? { ...c, text: output.response } : c)
-                : [{ type: 'text', text: output.response }, ...lastAssistant.content];
-            const newMessages = msgs.map(m => m.id === lastAssistant.id ? { ...lastAssistant, content: newContent } : m);
+                ? target.content.map(c => c.type === 'text' ? { ...c, text: output.response } : c)
+                : [{ type: 'text', text: output.response }, ...target.content];
+            const newMessages = msgs.map(m => m.id === target.id ? { ...target, content: newContent } : m);
             return { ...state, messages: newMessages };
         }
         case 'SET_CONNECTION_STATUS':

package/dist/agent/types.d.ts

@@ -220,7 +220,10 @@ export type ChatAction = {
     payload: ChatMessageDTO;
 } | {
     type: 'DELTA_TOKEN';
-    payload: Record<string, any>;
+    payload: {
+        messageId: string;
+        output: Record<string, any>;
+    };
 } | {
     type: 'SET_CONNECTION_STATUS';
     payload: ChatStatus;

package/dist/api/agents.d.ts

@@ -1,7 +1,7 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
 import { FilesAPI } from './files';
-import { ChatDTO, ChatMessageDTO, AgentConfigInput as AgentConfig, AgentDTO, AgentVersionDTO, CreateAgentRequest, FileDTO as File, InterruptDTO, CursorListRequest, CursorListResponse } from '../types';
+import { ChatDTO, ChatMessageDTO, LLMDelta, LLMOutput, AgentConfigInput as AgentConfig, AgentDTO, AgentVersionDTO, CreateAgentRequest, FileDTO as File, InterruptDTO, CursorListRequest, CursorListResponse } from '../types';
 /** Internal tool definition returned by getInternalTools */
 export interface InternalToolDefinition {
     id: string;
@@ -20,6 +20,20 @@ export interface AgentOptions {
     /** Per-chat context variables — resolved in call tool URL templates ({{context.X}}) */
     context?: Record<string, string>;
 }
+/**
+ * One streamed token batch for a message, with everything received for that
+ * message so far. `output.response` is the assistant text as it grows.
+ */
+export interface AgentDelta {
+    /** The chat message the tokens belong to (normally this turn's assistant message) */
+    messageId: string;
+    /** This batch alone */
+    delta: LLMDelta;
+    /** All batches for the message merged, in the shape of the message's final output */
+    output: LLMOutput;
+    /** Producer sequence number, monotonically increasing per message */
+    seq: number;
+}
 export interface SendMessageOptions {
     /** File attachments - Blob (will be uploaded) or FileDTO (already uploaded, has uri) */
     files?: (Blob | File)[];
@@ -27,6 +41,12 @@ export interface SendMessageOptions {
     onMessage?: (message: ChatMessageDTO) => void;
     /** Callback for chat updates */
     onChat?: (chat: ChatDTO) => void;
+    /**
+     * Callback for token-by-token output while the assistant message is being
+     * generated. Streaming mode only: with `stream: false` there are no deltas
+     * and the message arrives whole through onMessage.
+     */
+    onDelta?: (delta: AgentDelta) => void;
     /** Callback when a client tool needs execution */
     onToolCall?: (invocation: {
         id: string;

package/dist/api/agents.js

@@ -1,7 +1,39 @@
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
-import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
+import { createLLMDeltaAccumulator } from '../delta';
+import { ChatMessageStatusCancelled, ChatMessageStatusFailed, ChatMessageStatusReady, ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
 import { isChatBusy } from '../utils';
+const terminalMessageStatuses = new Set([ChatMessageStatusReady, ChatMessageStatusFailed, ChatMessageStatusCancelled]);
+/**
+ * Decides when one sendMessage() turn is over.
+ *
+ * For an existing chat the stream/poll is opened before the POST so nothing is
+ * missed, but its first snapshot is the previous turn's idle state. Resolving on
+ * that made sendMessage return before the new run had started. An idle snapshot
+ * only counts once the chat was seen busy, or once this turn's assistant message
+ * reached a terminal status (runs that finish between two observations).
+ */
+class TurnGate {
+    constructor(existingChat) {
+        this.existingChat = existingChat;
+        this.assistantMessageId = null;
+        this.sawBusy = false;
+        this.assistantDone = false;
+    }
+    observeChat(chat) {
+        if (isChatBusy(chat))
+            this.sawBusy = true;
+    }
+    observeMessage(message) {
+        if (message.id === this.assistantMessageId && terminalMessageStatuses.has(message.status)) {
+            this.assistantDone = true;
+        }
+    }
+    /** Whether an idle observation may end the turn. */
+    get settled() {
+        return !this.existingChat || this.sawBusy || this.assistantDone;
+    }
+}
 /**
  * Agent for chat interactions
  *
@@ -28,7 +60,7 @@ export class Agent {
     async sendMessage(text, options = {}) {
         this.dispatchedToolCalls.clear();
         const isTemplate = typeof this.config === 'string';
-        const hasCallbacks = !!(options.onMessage || options.onChat || options.onToolCall);
+        const hasCallbacks = !!(options.onMessage || options.onChat || options.onToolCall || options.onDelta);
         // Process files - either already uploaded (FileDTO with uri) or needs upload (Blob)
         let imageUris;
         let fileUris;
@@ -68,17 +100,28 @@ export class Agent {
             };
         const useStream = options.stream ?? this.http.getStreamDefault();
         const shouldWait = useStream === false || hasCallbacks;
+        const gate = new TurnGate(!!this.chatId);
         const waitFn = useStream === false
-            ? (opts) => this.pollUntilIdle(opts)
-            : (opts) => this.streamUntilIdle(opts);
+            ? (opts) => this.pollUntilIdle(opts, gate)
+            : (opts) => this.streamUntilIdle(opts, gate);
         // For existing chats: Start waiting BEFORE POST so we don't miss updates
         let waitPromise = null;
         if (this.chatId && shouldWait) {
             waitPromise = waitFn(options);
         }
         // Make the POST request
-        const resp = await this.http.request('post', '/agents/run', { data: body });
-        const response = resp.data;
+        let response;
+        try {
+            const resp = await this.http.request('post', '/agents/run', { data: body });
+            response = resp.data;
+        }
+        catch (err) {
+            // Nothing to wait for; don't leave the pre-opened stream/poller running.
+            if (waitPromise)
+                this.disconnect();
+            throw err;
+        }
+        gate.assistantMessageId = response.assistant_message?.id ?? null;
         // For new chats: Set chatId and start waiting immediately after POST
         const isNewChat = !this.chatId && response.assistant_message.chat_id;
         if (isNewChat) {
@@ -145,10 +188,10 @@ export class Agent {
     startStreaming(options = {}) {
         if (!this.chatId)
             return;
-        this.streamUntilIdle(options);
+        this.streamUntilIdle(options, new TurnGate(false));
     }
     /** Stream events until chat becomes idle */
-    streamUntilIdle(options) {
+    streamUntilIdle(options, gate) {
         if (!this.chatId)
             return Promise.resolve();
         const { url, headers, credentials } = this.http.getStreamableConfig(`/chats/${this.chatId}/stream`);
@@ -159,21 +202,60 @@ export class Agent {
                 headers,
                 credentials,
             });
+            // 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();
+                else
+                    idlePending = true;
+            };
             this.stream.addEventListener('chats', (chat) => {
                 options.onChat?.(chat);
-                if (!isChatBusy(chat)) {
-                    resolve();
-                }
+                gate.observeChat(chat);
+                if (!isChatBusy(chat))
+                    onIdle();
+                else
+                    idlePending = false;
             });
             this.stream.addEventListener('agent_runs', (run) => {
                 const asChat = { active_run: run };
                 options.onChat?.(asChat);
-                if (!isChatBusy(asChat)) {
-                    resolve();
+                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 (terminalMessageStatuses.has(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))
@@ -193,7 +275,7 @@ export class Agent {
         });
     }
     /** Poll until chat becomes idle, dispatching callbacks on changes */
-    pollUntilIdle(options) {
+    pollUntilIdle(options, gate) {
         if (!this.chatId)
             return Promise.resolve();
         const intervalMs = options.pollIntervalMs ?? this.http.getPollIntervalMs();
@@ -206,7 +288,9 @@ export class Agent {
                     // Lightweight status check first
                     const statusResp = await this.http.request('get', `/chats/${this.chatId}/status`);
                     const status = statusResp.data;
-                    if (status.status === prevStatus) {
+                    // Unchanged status is skipped — unless the turn is still ungated: a run
+                    // that started and finished between two polls only shows in the messages.
+                    if (status.status === prevStatus && gate.settled) {
                         // No change — return a stub to skip processing
                         return { status: status.status };
                     }
@@ -220,6 +304,9 @@ export class Agent {
                         return;
                     prevStatus = chat.status;
                     options.onChat?.(chat);
+                    gate.observeChat(chat);
+                    for (const message of chat.chat_messages ?? [])
+                        gate.observeMessage(message);
                     // Dispatch new/updated messages
                     if (chat.chat_messages && options.onMessage) {
                         for (const message of chat.chat_messages) {
@@ -248,7 +335,7 @@ export class Agent {
                             }
                         }
                     }
-                    if (!isChatBusy(chat)) {
+                    if (!isChatBusy(chat) && gate.settled) {
                         this.poller?.stop();
                         this.poller = null;
                         resolve();

package/dist/api/integrations.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { IntegrationDTO, IntegrationConfigDTO, IntegrationConnectRequest, IntegrationConnectResponse, CursorListRequest, CursorListResponse } from '../types';
+import { CredentialDTO, CredentialConfigDTO, CredentialConnectRequest, CredentialConnectResponse, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Integrations API
  */
@@ -10,15 +10,15 @@ export declare class IntegrationsAPI {
     /**
      * List integrations with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<IntegrationDTO>>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<CredentialDTO>>>;
     /**
      * Get available integrations
      */
-    listAvailable(): Promise<Response<IntegrationConfigDTO[]>>;
+    listAvailable(): Promise<Response<CredentialConfigDTO[]>>;
     /**
      * Get integration configs
      */
-    getConfigs(): Promise<Response<IntegrationConfigDTO[]>>;
+    getConfigs(): Promise<Response<CredentialConfigDTO[]>>;
     /**
      * Get capabilities
      */
@@ -30,11 +30,11 @@ export declare class IntegrationsAPI {
     /**
      * Connect an integration
      */
-    connect(data: IntegrationConnectRequest): Promise<Response<IntegrationConnectResponse>>;
+    connect(data: CredentialConnectRequest): Promise<Response<CredentialConnectResponse>>;
     /**
      * Get an integration by provider key
      */
-    get(provider: string): Promise<Response<IntegrationDTO>>;
+    get(provider: string): Promise<Response<CredentialDTO>>;
     /**
      * Disconnect an integration
      */

package/dist/http/client.js

@@ -17,7 +17,11 @@ export class HttpClient {
         this.proxyUrl = config.proxyUrl;
         this.getToken = config.getToken;
         this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', ...config.headers };
-        this.credentials = config.credentials || 'include';
+        // Bearer auth needs no cookies, and 'include' makes browsers reject the
+        // response unless the API answers with Allow-Credentials — which it does not
+        // for third-party origins (WebKit reports that as "Load failed"). Cookies
+        // matter only for the proxy / getToken flows, which keep 'include'.
+        this.credentials = config.credentials || (config.apiKey ? 'omit' : 'include');
         this.onError = config.onError;
         this.onMessage = config.onMessage;
         this.streamDefault = config.stream ?? true;

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export { PollManager, type PollManagerOptions } from './http/poll';
 export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, isRequirementsNotMetException, isInferenceError, isSessionError, } from './http/errors';
 export { TasksAPI, type RunOptions } from './api/tasks';
 export { FilesAPI, type UploadFileOptions } from './api/files';
-export { AgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions } from './api/agents';
+export { AgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions, type AgentDelta } from './api/agents';
 export { SessionsAPI } from './api/sessions';
 export { AppsAPI } from './api/apps';
 export { ChatsAPI } from './api/chats';
@@ -32,6 +32,7 @@ export { parseStatus, isTerminalStatus, isChatBusy, pendingApprovals } from './u
 export type { PendingApproval } from './utils';
 export * from './types';
 export type { TaskDTO as Task } from './types';
+export type { CredentialDTO as IntegrationDTO, CredentialConfigDTO as IntegrationConfigDTO, CredentialConnectRequest as IntegrationConnectRequest, CredentialConnectResponse as IntegrationConnectResponse, CredentialCompleteOAuthRequest as IntegrationCompleteOAuthRequest, CredentialRequirement as IntegrationRequirement, CredentialStatus as IntegrationStatus, CredentialScope as IntegrationScope, CredentialGrant as IntegrationGrant, CredentialType as IntegrationAuthType, CredentialProvider as IntegrationProvider, } from './types';
 import { HttpClient, type HttpClientConfig } from './http/client';
 import { TasksAPI, RunOptions } from './api/tasks';
 import { FilesAPI, UploadFileOptions } from './api/files';
@@ -71,6 +72,11 @@ export interface InferenceConfig {
      * Polling interval in milliseconds when stream is false (default: 2000).
      */
     pollIntervalMs?: number;
+    /**
+     * fetch() credentials mode. Defaults to 'omit' with an apiKey and 'include'
+     * for proxyUrl / getToken flows that rely on cookies.
+     */
+    credentials?: RequestCredentials;
 }
 /**
  * Inference.sh SDK Client