@inferencesh/sdk 0.27.0 → 0.29.0

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.29.0] - 2026-10-17
+
+### Removed
+- `CredentialConfigDTO.provider_info` is gone: read `company` (INF-1079). The API stopped sending it in api-v1313.
+
+### Changed
+- `CredentialConfigDTO.auth_scheme_id` is `auth_provider_id`, matching the API (INF-1079).
+- Generated types follow the API: engine release targets (`client.engines.updateBinary` takes a release target, `releases()` lists channel heads), `EngineDTO.capabilities` (`EngineCapability`, `EngineCapabilities`), `ChatMessageDTO.compaction_meta`.
+
+### Fixed
+- Partial chat and run stream updates merge instead of replacing, and streamed text never blinks back to an older copy.
+- A read that got no response is sent again, twice.
+
+## [0.28.0] - 2026-10-15
+
+### Changed
+- Types regenerated for the credentials vocabulary (INF-1079): `AuthSchemeDTO`, `AuthSchemeCreateRequest`, `AuthSchemeUpdateRequest`, `AuthSchemeHooksDTO`, `AuthSchemeSeedResult` are now `AuthProviderDTO`, `AuthProviderCreateRequest`, `AuthProviderUpdateRequest`, `AuthProviderHooksDTO`, `AuthProviderSeedResult`; `AuthSchemeSpec` and its `AuthScheme*` enums are `AuthMethod` and `AuthMethod*`; `ProviderDTO`, `ProviderSeed`, `ProviderSummary`, `ProviderTreeDTO`, `ProviderUpsertRequest`, `ProviderCategory`, `ProviderStatus` are `Company*`. `CredentialConfigDTO.company` is the company (`provider_info` still carries the same value, deprecated). Wire formats are unchanged.
+- `pollUntilIdle` rejects once and stops polling when the run fails; `sendMessage({ stream: false })` no longer hangs forever (99075b7).
+- Test mocks tidied (70cce44); dependabot overrides and `allowBuilds` in the pnpm workspace (75be627, 54b7ce1).
+
 ## [0.27.0] - 2026-10-13
 
 ### Changed

package/dist/agent/actions.js

@@ -12,6 +12,7 @@ import { createLLMDeltaAccumulator } from '../delta.js';
 import { isAdHocConfig, extractClientToolHandlers } from './types.js';
 import * as api from './api.js';
 import { buildMCPInputResult } from './mcp-input.js';
+import { applyChatUpdate } from './reducer.js';
 import { isInferenceError } from '../http/errors.js';
 // =============================================================================
 // Action Creators
@@ -226,11 +227,16 @@ export function createActions(ctx) {
             },
         });
         // Listen for Chat object updates (status changes only — don't replace messages)
-        manager.addEventListener('chats', (chatData) => {
-            dispatch({ type: 'UPDATE_CHAT', payload: chatData });
-            if (chatData) {
-                callbacks.onStatusChange?.(isChatBusy(chatData) ? 'streaming' : 'idle');
-                checkTurnEnd(chatData);
+        manager.addEventListener('chats', (chatData, fields) => {
+            if (!chatData)
+                return;
+            dispatch({ type: 'UPDATE_CHAT', payload: chatData, fields });
+            // A partial update (a plan step writing agent_data) says nothing about
+            // the turn on its own: judge the chat it merges into.
+            const chat = applyChatUpdate(getState().chat, chatData, fields);
+            if (chat) {
+                callbacks.onStatusChange?.(isChatBusy(chat) ? 'streaming' : 'idle');
+                checkTurnEnd(chat);
             }
         });
         // Listen for ChatMessage updates
@@ -244,8 +250,11 @@ export function createActions(ctx) {
             updateMessage(message, fields);
         });
         // Listen for AgentRun updates (state transitions, output)
-        manager.addEventListener('agent_runs', (run) => {
-            dispatch({ type: 'UPDATE_ACTIVE_RUN', payload: run });
+        manager.addEventListener('agent_runs', (run, fields) => {
+            dispatch({ type: 'UPDATE_ACTIVE_RUN', payload: run, fields });
+            // A partial update (the run's output) carries no state.
+            if (fields)
+                return;
             callbacks.onStatusChange?.(isRunWorking(run.state) || isRunInterrupted(run.state) ? 'streaming' : 'idle');
             const currentChat = getState().chat;
             if (currentChat)

package/dist/agent/reducer.d.ts

@@ -3,6 +3,12 @@
  *
  * Pure reducer for managing agent chat state.
  */
+import type { ChatDTO } from '../types.js';
 import type { AgentChatState, ChatAction } from './types.js';
+/**
+ * The chat after a chats event: replaced by a full one, merged with a partial
+ * one. A partial update to another chat (or before any chat) is dropped.
+ */
+export declare function applyChatUpdate(existing: ChatDTO | null, update: ChatDTO, fields?: string[]): ChatDTO | null;
 export declare const initialState: AgentChatState;
 export declare function chatReducer(state: AgentChatState, action: ChatAction): AgentChatState;

package/dist/agent/reducer.js

@@ -4,7 +4,7 @@
  * Pure reducer for managing agent chat state.
  */
 import { ChatStatusBusy, ChatStatusAwaitingInput, ChatStatusIdle } from '../types.js';
-import { isRunInterrupted, isRunWorking } from '../utils.js';
+import { isMessageTerminal, isRunInterrupted, isRunWorking } from '../utils.js';
 function deriveChatStatus(run) {
     if (!run)
         return ChatStatusIdle;
@@ -14,6 +14,38 @@ function deriveChatStatus(run) {
         return ChatStatusAwaitingInput;
     return ChatStatusIdle;
 }
+/**
+ * A partial stream update (`fields` set) carries only the fields it names, so
+ * it merges into the object it updates instead of replacing it: a chat update
+ * naming only agent_data (a plan step) keeps the chat's status and active run.
+ * A named field missing from the payload was cleared (omitempty).
+ */
+function mergeFields(existing, update, fields) {
+    const merged = { ...existing };
+    for (const field of fields)
+        merged[field] = update[field];
+    return merged;
+}
+/**
+ * The chat after a chats event: replaced by a full one, merged with a partial
+ * one. A partial update to another chat (or before any chat) is dropped.
+ */
+export function applyChatUpdate(existing, update, fields) {
+    if (!fields)
+        return update;
+    if (!existing || existing.id !== update.id)
+        return existing;
+    const merged = mergeFields(existing, update, fields);
+    // The projector's update names active_run_id, which ChatDTO does not
+    // declare. The run object belongs to that id: a new or cleared active run
+    // drops it until the run's own event arrives.
+    if (fields.includes('active_run_id')) {
+        const runId = update.active_run_id;
+        if (merged.active_run && merged.active_run.id !== runId)
+            merged.active_run = undefined;
+    }
+    return merged;
+}
 /**
  * Every message enters state through here. The API serializes a message with
  * no content as `content: null` (a nil Go slice), and a partial stream update
@@ -27,6 +59,28 @@ function normalizeMessage(message, existing) {
         return message;
     return { ...message, content: existing?.content ?? [] };
 }
+/**
+ * Streamed text only grows until the message is done. Deltas build the text
+ * locally, while a message update carries the server's saved copy, which can
+ * lag behind them (often still empty). Taking that copy as-is blanks the text
+ * until the next delta, so while the message is still generating, a text
+ * that is an earlier version of what is shown keeps what is shown. Once the
+ * message is terminal the server's copy is final and wins.
+ */
+function keepStreamedText(updated, existing) {
+    if (isMessageTerminal(updated.status))
+        return updated;
+    const shown = existing.content.find((c) => c.type === 'text')?.text;
+    if (!shown)
+        return updated;
+    const incoming = updated.content.find((c) => c.type === 'text');
+    if (incoming?.text && !shown.startsWith(incoming.text))
+        return updated;
+    const content = incoming
+        ? updated.content.map((c) => (c === incoming ? { ...c, text: shown } : c))
+        : [{ type: 'text', text: shown }, ...updated.content];
+    return { ...updated, content };
+}
 const normalizeMessages = (messages) => messages.map((m) => normalizeMessage(m));
 // =============================================================================
 // Initial State
@@ -59,10 +113,10 @@ export function chatReducer(state, action) {
         }
         case 'UPDATE_CHAT': {
             // Update chat metadata without replacing messages
-            const chat = action.payload;
-            if (!chat)
+            if (!action.payload)
                 return state;
-            return { ...state, chat };
+            const chat = applyChatUpdate(state.chat, action.payload, action.fields);
+            return chat === state.chat ? state : { ...state, chat };
         }
         // The settings and set-agent endpoints answer with only what they wrote.
         // Merge it into the chat it belongs to; a chat switched away from in the
@@ -104,7 +158,15 @@ export function chatReducer(state, action) {
         case 'UPDATE_ACTIVE_RUN': {
             if (!state.chat)
                 return state;
-            return { ...state, chat: { ...state.chat, active_run: action.payload, status: deriveChatStatus(action.payload) } };
+            let run = action.payload;
+            if (action.fields) {
+                // A partial update (the run's output) needs the run it belongs to.
+                const existing = state.chat.active_run;
+                if (!existing || existing.id !== run.id)
+                    return state;
+                run = mergeFields(existing, run, action.fields);
+            }
+            return { ...state, chat: { ...state.chat, active_run: run, status: deriveChatStatus(run) } };
         }
         case 'SET_MESSAGES':
             return { ...state, messages: normalizeMessages(action.payload) };
@@ -120,9 +182,7 @@ export function chatReducer(state, action) {
             const existingIndex = state.messages.findIndex((m) => m.id === message.id);
             if (existingIndex !== -1) {
                 const existing = state.messages[existingIndex];
-                const updated = action.partial
-                    ? normalizeMessage({ ...existing, ...message }, existing)
-                    : normalizeMessage(message);
+                const updated = keepStreamedText(action.partial ? normalizeMessage({ ...existing, ...message }, existing) : normalizeMessage(message), existing);
                 if (existing === updated)
                     return state;
                 const newMessages = [...state.messages];
@@ -148,6 +208,10 @@ export function chatReducer(state, action) {
             if (!target)
                 return state;
             const textBlock = target.content.find(c => c.type === 'text');
+            // Deltas from a stream joined mid-message start partway; the message
+            // update already showed more, so keep it until they catch up.
+            if (textBlock?.text && textBlock.text.startsWith(output.response ?? ''))
+                return state;
             const newContent = textBlock
                 ? target.content.map(c => c.type === 'text' ? { ...c, text: output.response } : c)
                 : [{ type: 'text', text: output.response }, ...target.content];

package/dist/agent/types.d.ts

@@ -261,6 +261,7 @@ export type ChatAction = {
 } | {
     type: 'UPDATE_CHAT';
     payload: ChatDTO | null;
+    fields?: string[];
 } | {
     type: 'MERGE_CHAT_SETTINGS';
     payload: ChatSettingsDTO;
@@ -270,6 +271,7 @@ export type ChatAction = {
 } | {
     type: 'UPDATE_ACTIVE_RUN';
     payload: AgentRunDTO;
+    fields?: string[];
 } | {
     type: 'SET_MESSAGES';
     payload: ChatMessageDTO[];

package/dist/api/agents.js

@@ -330,9 +330,9 @@ export class Agent {
         // fetched chat never carries chat_messages, so their absence cannot tell
         // the two apart.
         const unchanged = {};
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.poller?.stop();
-            this.poller = new PollManager({
+            const poller = new PollManager({
                 pollFunction: async () => {
                     // Lightweight status check first
                     const statusResp = await this.http.request('get', `/chats/${this.chatId}/status`);
@@ -391,8 +391,19 @@ export class Agent {
                 onError: (error) => {
                     console.warn('[Agent] Poll error:', error);
                 },
+                // PollManager gave up after maxRetries consecutive errors: it has
+                // already stopped polling, so fail the turn once. A caller stop
+                // (disconnect, abort, a newer turn) passes no error.
+                onStop: (error) => {
+                    if (!error)
+                        return;
+                    if (this.poller === poller)
+                        this.poller = null;
+                    reject(error);
+                },
             });
-            this.poller.start();
+            this.poller = poller;
+            poller.start();
         });
     }
 }

package/dist/api/engines.d.ts

@@ -1,7 +1,7 @@
 import { HttpClient } from '../http/client.js';
 import type { Response } from '../http/response.js';
 import type { EngineUpdateBody } from './write-bodies.js';
-import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types.js';
+import { EngineDTO as Engine, EngineReleasesResponse, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Engines API
  */
@@ -65,8 +65,16 @@ export declare class EnginesAPI {
      */
     drain(engineId: string): Promise<Response<void>>;
     /**
-     * Update an engine binary (drain + restart with new version)
+     * Update an engine binary: it drains, installs the release and restarts.
+     * `version` is "stable" (the default: newest stable, lifting any pin),
+     * "canary" (the current canary build, pinned), or a version such as
+     * v1.9.3 (pinned). A pinned engine stays on its version until sent
+     * "stable" again.
      */
-    updateBinary(engineId: string): Promise<Response<void>>;
+    updateBinary(engineId: string, version?: string): Promise<Response<void>>;
+    /**
+     * The head of each engine release channel (stable, canary) on dist.inference.sh.
+     */
+    releases(): Promise<Response<EngineReleasesResponse>>;
 }
 export declare function createEnginesAPI(http: HttpClient): EnginesAPI;

package/dist/api/engines.js

@@ -85,10 +85,21 @@ export class EnginesAPI {
         return this.http.request('post', `/engines/${engineId}/drain`);
     }
     /**
-     * Update an engine binary (drain + restart with new version)
+     * Update an engine binary: it drains, installs the release and restarts.
+     * `version` is "stable" (the default: newest stable, lifting any pin),
+     * "canary" (the current canary build, pinned), or a version such as
+     * v1.9.3 (pinned). A pinned engine stays on its version until sent
+     * "stable" again.
      */
-    async updateBinary(engineId) {
-        return this.http.request('post', `/engines/${engineId}/update`);
+    async updateBinary(engineId, version) {
+        const body = version ? { version } : {};
+        return this.http.request('post', `/engines/${engineId}/update`, { data: body });
+    }
+    /**
+     * The head of each engine release channel (stable, canary) on dist.inference.sh.
+     */
+    async releases() {
+        return this.http.request('get', '/engines/releases');
     }
 }
 export function createEnginesAPI(http) {

package/dist/api/write-bodies.d.ts

@@ -12,7 +12,7 @@
  * chats, engines and teams send PATCH; apps.patch and flows.patch are the
  * partial siblings of the POST updates that also edit a version.
  */
-import type { AgentConfigInput, AgentImages, AppDTO, ChatDTO, CredentialRequirements, EngineDTO, FlowDTO, FlowVersionDTO, KnowledgeDTO, ProjectDTO, TeamDTO, Visibility } from '../types.js';
+import type { AgentConfigInput, ResourceImages, AppDTO, ChatDTO, CredentialRequirements, EngineDTO, FlowDTO, FlowVersionDTO, KnowledgeDTO, ProjectDTO, TeamDTO, Visibility } from '../types.js';
 /**
  * POST /agents/{id}. Visibility and images, and a new version when
  * `version` is set. Name, title, harness, placement: set at creation.
@@ -20,7 +20,7 @@ import type { AgentConfigInput, AgentImages, AppDTO, ChatDTO, CredentialRequirem
  */
 export interface AgentUpdateBody {
     visibility?: Visibility;
-    images?: AgentImages;
+    images?: ResourceImages;
     version?: AgentConfigInput;
 }
 /**

package/dist/http/client.js

@@ -1,6 +1,40 @@
 import { InferenceError, RequirementsNotMetException } from './errors.js';
 import { EventSource } from 'eventsource';
 import { SDK_VERSION } from '../version.js';
+/** How long to wait before each new try of a read that got no response. */
+const NETWORK_RETRY_DELAYS_MS = [300, 1000];
+/**
+ * fetch, sending a GET or HEAD that got no response again after each of
+ * NETWORK_RETRY_DELAYS_MS: a dropped connection or a network change fails a
+ * read that would succeed a moment later, and a read changes nothing on the
+ * server, so sending it again is safe. fetch rejects with a TypeError only
+ * when no response came; a response of any status, an abort, or a request
+ * of another method is the caller's at once.
+ */
+function fetchRetryingReads(input, init, attempt = 0) {
+    const method = (init.method ?? 'GET').toUpperCase();
+    const read = method === 'GET' || method === 'HEAD';
+    const sent = fetch(input, init);
+    if (!read)
+        return sent;
+    return sent.catch(async (error) => {
+        const delay = NETWORK_RETRY_DELAYS_MS[attempt];
+        if (delay === undefined || !(error instanceof TypeError) || init.signal?.aborted)
+            throw error;
+        await wait(delay, init.signal);
+        return fetchRetryingReads(input, init, attempt + 1);
+    });
+}
+/** Resolves after ms, or rejects with the abort when signal aborts first. */
+function wait(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}
 /**
  * Low-level HTTP client for inference.sh API
  *
@@ -127,7 +161,7 @@ export class HttpClient {
      * (`refused: 'return'`), handed back with its body unread.
      */
     async fetchHandled(url, targetUrl, init, refused) {
-        const send = (token) => fetch(url, {
+        const send = (token) => fetchRetryingReads(url, {
             ...init,
             headers: { ...init.headers, ...this.requestHeaders(targetUrl, token) },
             credentials: this.credentials,
@@ -213,7 +247,7 @@ export class HttpClient {
         if (options.data) {
             fetchOptions.body = JSON.stringify(options.data);
         }
-        const response = await fetch(fetchUrl, fetchOptions);
+        const response = await fetchRetryingReads(fetchUrl, fetchOptions);
         const responseText = await response.text();
         let data = null;
         try {

package/dist/http/poll.d.ts

@@ -19,8 +19,12 @@ export interface PollManagerOptions<T> {
     onError?: (error: Error) => void;
     /** Called when polling starts */
     onStart?: () => void;
-    /** Called when polling stops (intentionally or after max retries) */
-    onStop?: () => void;
+    /**
+     * Called once when polling stops. `error` is the last poll error when the
+     * manager gave up after `maxRetries` consecutive errors; it is undefined
+     * when the caller stopped it.
+     */
+    onStop?: (error?: Error) => void;
 }
 export declare class PollManager<T> {
     private options;
@@ -34,6 +38,7 @@ export declare class PollManager<T> {
     start(): void;
     /** Stop polling and clean up. */
     stop(): void;
+    private halt;
     private cleanup;
     private poll;
 }

package/dist/http/poll.js

@@ -30,11 +30,14 @@ export class PollManager {
     }
     /** Stop polling and clean up. */
     stop() {
+        this.halt();
+    }
+    halt(error) {
         if (this.isStopped)
             return;
         this.isStopped = true;
         this.cleanup();
-        this.options.onStop?.();
+        this.options.onStop?.(error);
     }
     cleanup() {
         if (this.interval) {
@@ -66,7 +69,7 @@ export class PollManager {
             this.consecutiveErrors++;
             this.options.onError?.(error);
             if (this.consecutiveErrors >= this.options.maxRetries) {
-                this.stop();
+                this.halt(error);
             }
         }
     }