@inferencesh/sdk 0.28.0 → 0.29.0

package/CHANGELOG.md

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

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/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/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/types.d.ts

@@ -1629,7 +1629,7 @@ export interface AppVersionDTO extends BaseModelDTO {
 export interface DeployWarning {
     /**
      * Code identifies the check: readonly_broad_credential,
-     * unused_credential, missing_annotations.
+     * unused_credential, missing_annotations, unapproved_platform_scope.
      */
     code: string;
     /**
@@ -1791,6 +1791,32 @@ export interface ArtifactVersionDTO extends BaseModelDTO {
         [key: string]: any;
     };
     created_by_user_id?: string;
+    /**
+     * Files are the pages and data served beside the index page.
+     */
+    files?: ArtifactVersionFileDTO[];
+}
+/**
+ * ArtifactVersionFileDTO is one file published beside a version's index.
+ */
+export interface ArtifactVersionFileDTO {
+    path: string;
+    size_bytes: number;
+    content_type: string;
+}
+/**
+ * ArtifactFileInput is one extra file in a publish, served at Path relative
+ * to the index page: another page (.html, .md), or css, js, json, svg, txt,
+ * xml, csv.
+ */
+export interface ArtifactFileInput {
+    path: string;
+    content: string;
+    /**
+     * ContentEncoding is "base64" when Content is base64-encoded, as for the
+     * main content.
+     */
+    content_encoding?: string;
 }
 /**
  * ArtifactCreateRequest is the body for POST /artifacts. Creates the entry
@@ -1816,6 +1842,11 @@ export interface ArtifactCreateRequest {
      * from browsers and CLIs: edge firewalls reject raw <script> in JSON bodies.
      */
     content_encoding?: string;
+    /**
+     * Files are published beside the index page. A publish is the whole
+     * site: files of the previous version are not carried over.
+     */
+    files?: ArtifactFileInput[];
     label?: string;
     notes?: string;
     origin?: string;
@@ -1862,6 +1893,11 @@ export interface ArtifactPublishRequest {
      * ContentEncoding is "base64" when Content is base64-encoded UTF-8.
      */
     content_encoding?: string;
+    /**
+     * Files are published beside the index page. A publish is the whole
+     * site: files of the previous version are not carried over.
+     */
+    files?: ArtifactFileInput[];
     label?: string;
     notes?: string;
     origin?: string;
@@ -1932,9 +1968,25 @@ export interface ArtifactDataRequest {
         [key: string]: any;
     };
     /**
-     * Limit caps a list; the server clamps it.
+     * Limit caps a list; the server clamps it to 200.
      */
     limit?: number;
+    /**
+     * Cursor continues a list from the next_cursor of the page before.
+     */
+    cursor?: string;
+    /**
+     * Order is the list order: -updated_at (the default), updated_at,
+     * -created_at or created_at.
+     */
+    order?: string;
+    /**
+     * Where keeps only documents whose top-level fields equal these values
+     * (string, number, boolean, or null for a missing field).
+     */
+    where?: {
+        [key: string]: any;
+    };
 }
 /**
  * ArtifactDataListResponse is a page of documents from one collection.
@@ -1943,6 +1995,10 @@ export interface ArtifactDataListResponse {
     collection: string;
     documents: ArtifactDataDTO[];
     count: number;
+    /**
+     * NextCursor fetches the page after this one; empty on the last page.
+     */
+    next_cursor?: string;
 }
 /**
  * ArtifactViewerDTO is what the user capability tells a page about whoever
@@ -2277,6 +2333,10 @@ export interface ChatMessageDTO extends BaseModelDTO, PermissionModelDTO {
     tools?: Tool[];
     tool_call_id?: string;
     tool_invocations?: ToolInvocationDTO[];
+    /**
+     * CompactionMeta is what a compaction (role compaction) retired.
+     */
+    compaction_meta?: CompactionMeta;
 }
 /**
  * PolicyRuleDTO is one rule, typed form Kind[selector](specifier).
@@ -2529,6 +2589,12 @@ export interface CredentialDTO extends BaseModelDTO, PermissionModelDTO {
     account_identifier?: string;
     account_name?: string;
     scopes: StringSlice;
+    /**
+     * AllowedScopes, on an OAuth app row (grant credentials), is every
+     * scope a login through it may request; absent when any scope may be
+     * (a team's own client by default). Never set on a login.
+     */
+    allowed_scopes?: StringSlice;
     expires_at?: string;
     vault_id?: string;
     metadata?: {
@@ -2572,17 +2638,12 @@ export interface CredentialConfigDTO {
     slug: string;
     /**
      * Provider is the credential slug (what Credential.Provider stores):
-     * one way to authenticate. The company it belongs to is ProviderInfo.
+     * one way to authenticate. The company it belongs to is Company.
      */
     provider: string;
     /**
-     * ProviderInfo is the company this slug belongs to, for grouping: the
-     * providers row its auth provider names, else the slug's own identity.
-     */
-    provider_info?: CompanySummary;
-    /**
-     * Company is ProviderInfo under its settled name (INF-1079); provider_info
-     * stays one release.
+     * Company is the company this slug belongs to, for grouping: the
+     * companies row its auth provider names, else the slug's own identity.
      */
     company?: CompanySummary;
     type: string;
@@ -2613,7 +2674,7 @@ export interface CredentialConfigDTO {
      * AuthProviderID is set when the provider is one the team defined
      * itself (models.AuthProvider), so the UI can offer edit and remove.
      */
-    auth_scheme_id?: string;
+    auth_provider_id?: string;
     /**
      * Credential is the login used where no account is named: the caller's
      * own, else the workspace's default account.
@@ -2750,9 +2811,38 @@ export interface EngineDTO extends BaseModelDTO, PermissionModelDTO {
     api_url: string;
     status: EngineStatus;
     engine_version: string;
+    /**
+     * EnginePin is the version the engine is held on; empty follows stable.
+     */
+    engine_pin?: string;
+    /**
+     * Capabilities are what the engine last reported it can do.
+     */
+    capabilities?: EngineCapabilities;
     system_info?: SystemInfo;
     workers: (WorkerDTO | undefined)[];
 }
+/**
+ * EngineUpdateRequest names the release an engine should install: "stable",
+ * "canary", or a version such as v1.9.3. Empty is stable.
+ */
+export interface EngineUpdateRequest {
+    version?: string;
+}
+/**
+ * EngineRelease is one published engine build.
+ */
+export interface EngineRelease {
+    version: string;
+    release_date?: string;
+}
+/**
+ * EngineReleasesResponse is the head of each engine release channel.
+ */
+export interface EngineReleasesResponse {
+    stable?: EngineRelease;
+    canary?: EngineRelease;
+}
 /**
  * EngineSummary is a lightweight engine response embedded in tasks.
  */
@@ -2831,6 +2921,19 @@ export interface WorkerRAM {
     worker_id: string;
     total: number;
 }
+/**
+ * EngineCapability is something an engine can do beyond the base contract
+ * every engine meets. An engine reports the ones it has (EngineTelemetry);
+ * a task lists the ones it needs (Task.Requires); the scheduler only sends
+ * a task to an engine that has every one it needs.
+ */
+export type EngineCapability = "egress_gateway";
+export declare const EngineCapabilityEgressGateway: EngineCapability;
+/**
+ * EngineCapabilities is a set of capabilities, kept as a list. Nil and
+ * empty are the same: nothing beyond the base contract.
+ */
+export type EngineCapabilities = EngineCapability[];
 /**
  * EntitlementDTO for API responses
  */
@@ -7835,6 +7938,16 @@ export interface ContextInjection {
      */
     items?: string[];
 }
+/**
+ * CompactionMeta is stored on ChatMessage for context compaction markers.
+ */
+export interface CompactionMeta {
+    compacted_up_to_order: number;
+    compacted_count: number;
+    estimated_tokens: number;
+    method?: string;
+    analysis?: string;
+}
 /**
  * ToolCallEventData is the typed payload for agent.tool_call events.
  */

package/dist/types.js

@@ -376,6 +376,7 @@ export const ToolRiskMedium = "medium";
  * ToolRiskHigh: dangerous or irreversible changes.
  */
 export const ToolRiskHigh = "high";
+export const EngineCapabilityEgressGateway = "egress_gateway";
 export const ErrorCodeInvalidRequest = "invalid_request";
 export const ErrorCodeValidationError = "validation_error";
 export const ErrorCodeUnauthorized = "unauthorized";

package/package.json

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