@inferencesh/sdk 0.6.49 → 0.6.51

package/dist/agent/actions.js

@@ -139,8 +139,18 @@ export function createActions(ctx) {
                 checkTurnEnd(chatData);
             }
         });
+        // Token-by-token streaming state, reset at every assistant-message boundary.
+        const deltaAccum = createLLMDeltaAccumulator();
         // 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();
+            }
             updateMessage(message, fields);
         });
         // Listen for AgentRun updates (state transitions, output)
@@ -152,8 +162,6 @@ export function createActions(ctx) {
             if (currentChat)
                 checkTurnEnd({ ...currentChat, active_run: run });
         });
-        // Listen for LLM delta events (token-by-token streaming)
-        const deltaAccum = createLLMDeltaAccumulator();
         manager.addEventListener('delta', (evt) => {
             if (evt && evt.delta) {
                 deltaAccum.apply(evt.delta);

package/dist/api/agents.js

@@ -1,7 +1,38 @@
 import { StreamableManager } from '../http/streamable';
 import { PollManager } from '../http/poll';
-import { ToolTypeClient, ToolInvocationStatusAwaitingInput, ToolInvocationStatusInProgress, } from '../types';
+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
  *
@@ -68,17 +99,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 +187,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 +201,37 @@ 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;
             });
             this.stream.addEventListener('chat_messages', (message) => {
+                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 +251,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 +264,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 +280,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 +311,7 @@ export class Agent {
                             }
                         }
                     }
-                    if (!isChatBusy(chat)) {
+                    if (!isChatBusy(chat) && gate.settled) {
                         this.poller?.stop();
                         this.poller = null;
                         resolve();

package/dist/delta.d.ts

@@ -8,6 +8,14 @@ export declare class DeltaAccumulator {
     private tags;
     private registry;
     constructor(tags: FieldTags, registry?: FieldTagsRegistry);
+    /**
+     * Discard everything accumulated so far. Required at a message boundary: the
+     * accumulator is cumulative, so without a reset the next message's deltas
+     * merge into the previous message's state. Concat makes that invisible for
+     * text — appending "" leaves the old text in place, so a tool-call-only turn
+     * serves the previous message's answer as its own.
+     */
+    reset(): void;
     seed(output: Record<string, any>): void;
     apply(delta: Record<string, any>): void;
     toOutput(): Record<string, any>;

package/dist/delta.js

@@ -57,6 +57,16 @@ export class DeltaAccumulator {
         this.tags = tags;
         this.registry = registry;
     }
+    /**
+     * Discard everything accumulated so far. Required at a message boundary: the
+     * accumulator is cumulative, so without a reset the next message's deltas
+     * merge into the previous message's state. Concat makes that invisible for
+     * text — appending "" leaves the old text in place, so a tool-call-only turn
+     * serves the previous message's answer as its own.
+     */
+    reset() {
+        this.state = {};
+    }
     seed(output) {
         for (const [key, value] of Object.entries(output)) {
             if (value != null)

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

@@ -71,6 +71,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

package/dist/types.d.ts

@@ -2709,6 +2709,11 @@ export interface MenuItem {
     id: string;
     label: string;
     slug?: string;
+    /**
+     * Path is the linked page's path, filled in when a menu is read so a client
+     * can build the link without fetching each page. Never stored.
+     */
+    path?: string;
     page_id?: string;
     url?: string;
     icon?: string;
@@ -2729,6 +2734,7 @@ export interface PageDTO extends BaseModelDTO, PermissionModelDTO {
     type: PageType;
     metadata: PageMetadata;
     slug: string;
+    path: string;
     /**
      * PublishAt mirrors Metadata.PublishAt, which remains the field clients write.
      * Surfaced here so a reader does not have to reach into the metadata blob.
@@ -4381,6 +4387,11 @@ export type RefRouteType = string;
 export declare const RefRouteTypeApp: RefRouteType;
 export declare const RefRouteTypeAgent: RefRouteType;
 export declare const RefRouteTypeSkill: RefRouteType;
+/**
+ * RefRouteTypeURL routes a site path to another (/docs/api-files →
+ * /docs/api/sdk/files). Alias and target are literal paths, not refs.
+ */
+export declare const RefRouteTypeURL: RefRouteType;
 export type RefRouteMode = string;
 export declare const RefRouteModeRewrite: RefRouteMode;
 export declare const RefRouteModeRedirect: RefRouteMode;

package/dist/types.js

@@ -678,6 +678,11 @@ export const TeamInviteStatusRevoked = "revoked";
 export const RefRouteTypeApp = "app";
 export const RefRouteTypeAgent = "agent";
 export const RefRouteTypeSkill = "skill";
+/**
+ * RefRouteTypeURL routes a site path to another (/docs/api-files →
+ * /docs/api/sdk/files). Alias and target are literal paths, not refs.
+ */
+export const RefRouteTypeURL = "url";
 export const RefRouteModeRewrite = "rewrite";
 export const RefRouteModeRedirect = "redirect";
 export const KnowledgeTypeConcept = "concept";

package/package.json

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