@inferencesh/sdk 0.20.1 → 0.22.0

package/dist/api/tasks.js

@@ -1,4 +1,4 @@
-import { StreamableManager } from '../http/streamable';
+import { streamUntilTerminal } from '../http/stream-until-terminal';
 import { PollManager } from '../http/poll';
 import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types';
 import { parseStatus } from '../utils';
@@ -16,6 +16,20 @@ function stripTask(task) {
         session_id: task.session_id,
     };
 }
+/** Settles a watch when `data` carries a terminal status; no-op otherwise. */
+function settleTerminal(data, stripped, settle) {
+    switch (parseStatus(data.status)) {
+        case TaskStatusCompleted:
+            settle.resolve(stripped);
+            break;
+        case TaskStatusFailed:
+            settle.reject(new Error(data.error || 'task failed'));
+            break;
+        case TaskStatusCancelled:
+            settle.reject(new Error('task cancelled'));
+            break;
+    }
+}
 /**
  * Tasks API
  */
@@ -110,50 +124,26 @@ export class TasksAPI {
         const { onUpdate, onPartialUpdate, onDelta } = options;
         // Accumulate state across partial updates to preserve fields like session_id
         let accumulatedTask = { ...task };
-        const { url, headers, credentials } = this.http.getStreamableConfig(`/tasks/${task.id}/stream`);
-        let streamManager;
-        const done = new Promise((resolve, reject) => {
-            const settle = (data, stripped) => {
-                if (parseStatus(data.status) === TaskStatusCompleted) {
-                    streamManager.stop();
-                    resolve(stripped);
-                }
-                else if (parseStatus(data.status) === TaskStatusFailed) {
-                    streamManager.stop();
-                    reject(new Error(data.error || 'task failed'));
-                }
-                else if (parseStatus(data.status) === TaskStatusCancelled) {
-                    streamManager.stop();
-                    reject(new Error('task cancelled'));
-                }
+        return streamUntilTerminal((settle) => {
+            const observe = (data, fields) => {
+                // Merge new data, preserving existing fields if not in update
+                accumulatedTask = { ...accumulatedTask, ...data };
+                const stripped = stripTask(accumulatedTask);
+                if (fields)
+                    onPartialUpdate?.(stripped, fields);
+                else
+                    onUpdate?.(stripped);
+                settleTerminal(data, stripped, settle);
             };
-            streamManager = new StreamableManager({
-                url,
-                headers,
-                credentials,
+            return {
+                request: (init) => this.http.fetch(`/tasks/${task.id}/stream`, init),
                 onDelta,
-                onData: (data) => {
-                    // Merge new data, preserving existing fields if not in update
-                    accumulatedTask = { ...accumulatedTask, ...data };
-                    const stripped = stripTask(accumulatedTask);
-                    onUpdate?.(stripped);
-                    settle(data, stripped);
-                },
-                onPartialData: (data, fields) => {
-                    // Merge partial update, preserving fields not in this update
-                    accumulatedTask = { ...accumulatedTask, ...data };
-                    const stripped = stripTask(accumulatedTask);
-                    onPartialUpdate?.(stripped, fields);
-                    settle(data, stripped);
-                },
-                onError: (error) => {
-                    reject(error);
-                    streamManager.stop();
-                },
-            });
-            streamManager.start();
+                onData: (data) => observe(data),
+                onPartialData: (data, fields) => observe(data, fields),
+                reconcile: async () => observe((await this.get(task.id)).data),
+                closedMessage: `Task stream closed before task ${task.id} finished`,
+            };
         });
-        return { done, stop: () => streamManager.stop() };
     }
     /** Poll GET /tasks/{id}/status until terminal, full-fetch on status change. */
     watchPoll(task, options) {
@@ -162,6 +152,10 @@ export class TasksAPI {
         let prevStatus = task.status;
         let poller;
         const done = new Promise((resolve, reject) => {
+            const settle = {
+                resolve: (value) => { poller.stop(); resolve(value); },
+                reject: (error) => { poller.stop(); reject(error); },
+            };
             poller = new PollManager({
                 pollFunction: async () => {
                     const resp = await this.http.request('get', `/tasks/${task.id}/status`);
@@ -179,28 +173,13 @@ export class TasksAPI {
                         const fullTask = fullResp.data;
                         const stripped = stripTask(fullTask);
                         onUpdate?.(stripped);
-                        if (parseStatus(fullTask.status) === TaskStatusCompleted) {
-                            poller.stop();
-                            resolve(stripped);
-                        }
-                        else if (parseStatus(fullTask.status) === TaskStatusFailed) {
-                            poller.stop();
-                            reject(new Error(fullTask.error || 'task failed'));
-                        }
-                        else if (parseStatus(fullTask.status) === TaskStatusCancelled) {
-                            poller.stop();
-                            reject(new Error('task cancelled'));
-                        }
+                        settleTerminal(fullTask, stripped, settle);
                     }
                     catch (err) {
-                        poller.stop();
-                        reject(err instanceof Error ? err : new Error(String(err)));
+                        settle.reject(err instanceof Error ? err : new Error(String(err)));
                     }
                 },
-                onError: (error) => {
-                    reject(error);
-                    poller.stop();
-                },
+                onError: (error) => settle.reject(error),
             });
             poller.start();
         });

package/dist/api/teams.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { TeamUpdateBody } from './write-bodies';
 import { MeResponse, TeamDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types';
 /**
  * Teams API
@@ -24,9 +25,10 @@ export declare class TeamsAPI {
      */
     create(data: TeamCreateRequest): Promise<Response<TeamDTO>>;
     /**
-     * Update a team
+     * Update a team's profile (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
-    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<Response<TeamDTO>>;
+    update(teamId: string, data: TeamUpdateBody): Promise<Response<TeamDTO>>;
     /**
      * Delete a team
      */

package/dist/api/teams.js

@@ -30,10 +30,11 @@ export class TeamsAPI {
         return this.http.request('post', '/teams', { data });
     }
     /**
-     * Update a team
+     * Update a team's profile (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
     async update(teamId, data) {
-        return this.http.request('post', `/teams/${teamId}`, { data });
+        return this.http.request('patch', `/teams/${teamId}`, { data });
     }
     /**
      * Delete a team

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

@@ -0,0 +1,110 @@
+/**
+ * Request bodies of the generic create/update routes.
+ *
+ * Each type names exactly the fields its route writes; the API leaves every
+ * other field of the body alone (a full DTO sent back is fine, its other
+ * fields are ignored). A field with its own endpoint is listed next to the
+ * type that cannot set it.
+ *
+ * A POST /{resource}/{id} update writes every field below that the route
+ * takes: a field left out of the body is written empty. A PATCH writes only
+ * the fields sent. The SDK's update methods for projects, knowledge, skills,
+ * 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, EngineDTO, FlowDTO, FlowVersionDTO, KnowledgeDTO, MCPServerAuthType, ProjectDTO, TeamDTO, Visibility } from '../types';
+/**
+ * POST /agents/{id}. Visibility and images, and a new version when
+ * `version` is set. Name, title, harness, placement: set at creation.
+ * Project: `agents.moveToProject`; owner: `agents.transferOwnership`.
+ */
+export interface AgentUpdateBody {
+    visibility?: Visibility;
+    images?: AgentImages;
+    version?: AgentConfigInput;
+}
+/**
+ * PATCH /apps/{id}: only the fields sent are written. The app's copy;
+ * the version is edited through POST (`apps.update`).
+ */
+export type AppPatchBody = Partial<Pick<AppDTO, 'title' | 'description' | 'agent_description' | 'category' | 'images' | 'tags'>>;
+/**
+ * POST /apps/{id}. The app's copy, plus an in-place edit of the version
+ * named by `version_id` (its metadata, required secrets and required
+ * credentials). Status: `apps.updateStatus`; visibility:
+ * `apps.updateVisibility`; name, namespace and version contents: a deploy.
+ */
+export type AppUpdateBody = AppPatchBody & Partial<Pick<AppDTO, 'version_id' | 'version'>>;
+/**
+ * PATCH /chats/{id}. Name and description. Visibility and the chat's
+ * settings: `chats.updateSettings`.
+ */
+export type ChatUpdateBody = Partial<Pick<ChatDTO, 'name' | 'description'>>;
+/** PATCH /engines/{id}. The engine's name; the rest is the engine's own report. */
+export type EngineUpdateBody = Partial<Pick<EngineDTO, 'name'>>;
+/** PATCH /flows/{id}: only the fields sent are written. */
+export type FlowPatchBody = Partial<Pick<FlowDTO, 'name' | 'title' | 'description' | 'card_image' | 'thumbnail' | 'banner_image'>>;
+/**
+ * POST /flows/{id}. The flow's copy and images (as PATCH), plus
+ * `draft_version`, naming the flow's own draft by id, which saves that
+ * draft's graph. Visibility: `flows.updateVisibility`; viewport:
+ * `flows.saveViewport`.
+ */
+export type FlowUpdateBody = FlowPatchBody & {
+    draft_version?: Partial<FlowVersionDTO> & {
+        id: string;
+    };
+};
+/** Where the flow editor's canvas looks (POST /flows/{id}/viewport). */
+export interface FlowViewportBody {
+    x: number;
+    y: number;
+    zoom: number;
+}
+/**
+ * POST /projects and PATCH /projects/{id}. Visibility is taken on create
+ * only; no route changes it afterwards. Parent: none.
+ */
+export type ProjectWriteBody = Partial<Pick<ProjectDTO, 'name' | 'description' | 'type' | 'color' | 'icon'>> & {
+    visibility?: Visibility;
+};
+/**
+ * PATCH /knowledge/{id} and PATCH /skills/{id}. Copy and lifecycle. Name and
+ * type: fixed at creation; content: a new version (`create` with the same
+ * name); visibility: `updateVisibility`.
+ */
+export interface KnowledgeUpdateBody {
+    title?: string;
+    description?: string;
+    repo_url?: string;
+    lifecycle?: KnowledgeDTO['lifecycle'];
+}
+/**
+ * PATCH /teams/{id}. A team admin changes the profile; status and
+ * concurrency are platform staff's. The username is the team's namespace
+ * and does not change here.
+ */
+export type TeamUpdateBody = Partial<Pick<TeamDTO, 'name' | 'email' | 'avatar_url'>>;
+/**
+ * PUT /mcp-servers/{id}. A field left out keeps its value. Title,
+ * description, icon URL and documentation URL take what is sent, and ""
+ * clears them; slug, name, server URL, auth type and the OAuth client
+ * change only to a non-empty value. Headers sent replace the set ({}
+ * clears it). Visibility: `POST /mcp-servers/{id}/visibility`.
+ */
+export interface MCPServerUpdateBody {
+    slug?: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    icon_url?: string;
+    server_url?: string;
+    auth_type?: MCPServerAuthType;
+    oauth_client_id?: string;
+    oauth_secret_key?: string;
+    default_scopes?: string[];
+    headers?: {
+        [key: string]: string;
+    };
+    documentation_url?: string;
+}

package/dist/api/write-bodies.js

@@ -0,0 +1 @@
+export {};

package/dist/http/client.d.ts

@@ -1,10 +1,26 @@
 import type { Response } from './response';
 import { EventSource } from 'eventsource';
+/** What a failed request was sent with, for an error handler that acts on it. */
+export interface FailedRequest {
+    /**
+     * The bearer token the request carried, or undefined when it carried none
+     * (proxy mode, or no apiKey and getToken returned nothing). A handler that
+     * refreshes credentials compares it with the token in hand: when they
+     * differ, the credentials were already replaced and a retry is enough.
+     */
+    token: string | undefined;
+}
 /**
  * Error handler that can intercept errors and optionally retry the request.
  * Return a promise to retry with a new result, or throw/rethrow to propagate the error.
+ * `retry` sends the request again with the token of that moment and does not
+ * come back through the handler. `request` describes the attempt that failed.
  */
-export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>) => Promise<unknown>;
+export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>, request: FailedRequest) => Promise<unknown>;
+/** Options of HttpClient.fetch: a fetch init whose credentials mode is the client's. */
+export type HttpFetchInit = Omit<RequestInit, 'headers' | 'credentials'> & {
+    headers?: Record<string, string>;
+};
 export type MessageHandler = (messages: import('../types').ResponseMessage[]) => void;
 export interface HttpClientConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
@@ -16,8 +32,11 @@ export interface HttpClientConfig {
      * When set, requests are routed through your proxy server to protect API keys.
      */
     proxyUrl?: string;
-    /** Dynamic token getter (alternative to apiKey) */
-    getToken?: () => string | null | undefined;
+    /**
+     * Dynamic token getter (alternative to apiKey), asked before every request.
+     * It may be async: the request waits for the token.
+     */
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
     /** Dynamic headers */
     headers?: Record<string, string | (() => string | undefined)>;
     /** Request credentials mode */
@@ -71,15 +90,53 @@ export declare class HttpClient {
     isProxyMode(): boolean;
     /** Resolve dynamic headers */
     private resolveHeaders;
-    /** Get authorization token */
-    private getAuthToken;
+    /** The bearer token a request sent now carries; none through a proxy, which adds its own. */
+    private bearerToken;
+    /** The configured headers plus what identifies the request: its bearer, or through a proxy its target. */
+    private requestHeaders;
+    /**
+     * Where a request whose caller cannot set headers (EventSource) or reads
+     * the URL (streams) goes: the API, or the proxy with the target as a query
+     * parameter.
+     */
+    private streamUrl;
     /**
      * Make an HTTP request to the API
      */
-    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {
+    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'patch' | 'delete', endpoint: string, { handleErrors, ...options }?: {
         params?: P;
         data?: unknown;
+        /**
+         * `false` when the caller handles this request's failure itself: the
+         * client's error handler (onError) is not consulted, so there is no
+         * prompt, no redirect and no retry, and the error is thrown as it is.
+         */
+        handleErrors?: boolean;
     }): Promise<Response<T>>;
+    /**
+     * Fetch an API endpoint with the client's auth, headers and credentials
+     * mode and resolve with the raw response, for bodies request() does not
+     * parse (streams, text). A failure goes through onError like one of
+     * request() does: a refused response, or a request that got no response.
+     * It resolves with the response onError's retry got; when onError resolves
+     * with anything else the failure stands and is thrown, the error request()
+     * would throw. A request aborted through `init.signal` rejects with the
+     * abort and is not an error for onError.
+     */
+    fetch(endpoint: string, init?: HttpFetchInit): Promise<globalThis.Response>;
+    /**
+     * One fetch of `url` on behalf of `targetUrl`. A refused response, or a
+     * request that got none, goes to onError; the result is the response its
+     * retry got. Without one the failure stands: the error of a request that
+     * got no response is thrown, and a refusal is thrown as the error its body
+     * was read into or, for a caller that passes the response on
+     * (`refused: 'return'`), handed back with its body unread.
+     */
+    private fetchHandled;
+    /** The error a refused response stands for, read from its body. */
+    private readError;
+    /** HTTP errors → RFC 9457 problem+json */
+    private responseError;
     /**
      * Execute the actual HTTP request (internal)
      */
@@ -87,6 +144,10 @@ export declare class HttpClient {
     /**
      * Get URL and headers for NDJSON streaming.
      * Returns the full URL and auth headers needed for streamable requests.
+     * It answers synchronously, so it throws when getToken is async.
+     * @deprecated Use fetch(), or a StreamRequest built on it
+     * (`(init) => http.fetch(endpoint, init)`): a request made from this config
+     * bypasses onError and carries the token of the moment the config was read.
      */
     getStreamableConfig(endpoint: string): {
         url: string;
@@ -100,7 +161,7 @@ export declare class HttpClient {
     private extractErrorDetail;
     /**
      * Create an EventSource for SSE streaming
-     * @deprecated Use getStreamableConfig() with StreamableManager instead
+     * @deprecated Use StreamableManager with a StreamRequest instead
      */
     createEventSource(endpoint: string): Promise<EventSource | null>;
 }