@inferencesh/sdk 0.21.0 → 0.22.0

package/dist/api/chats.d.ts

@@ -1,6 +1,7 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { ChatDTO as Chat, ChatMessageDTO, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
+import type { ChatUpdateBody } from './write-bodies';
+import { ChatDTO as Chat, ChatMessageDTO, ChatSettingsDTO, ChatSettingsRequest, ChatTraceDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Chats API
  */
@@ -16,9 +17,18 @@ export declare class ChatsAPI {
      */
     get(chatId: string): Promise<Response<Chat>>;
     /**
-     * Update a chat
+     * Update a chat's name and description (PATCH): only the fields sent are
+     * written. Visibility and the other chat settings: updateSettings.
      */
-    update(chatId: string, data: Partial<Chat>): Promise<Response<Chat>>;
+    update(chatId: string, data: ChatUpdateBody): Promise<Response<Chat>>;
+    /**
+     * Change a chat's settings (name, visibility, tool approval, hooks,
+     * memory). Answers with the settings as they now are. Widening what runs
+     * without approval needs approvals:write, held only by the account
+     * holder's own sign-in: other credentials get 403 `requires_sign_in`
+     * (ErrorCodeRequiresSignIn).
+     */
+    updateSettings(chatId: string, settings: ChatSettingsRequest): Promise<Response<ChatSettingsDTO>>;
     /**
      * Delete a chat
      */

package/dist/api/chats.js

@@ -18,10 +18,21 @@ export class ChatsAPI {
         return this.http.request('get', `/chats/${chatId}`);
     }
     /**
-     * Update a chat
+     * Update a chat's name and description (PATCH): only the fields sent are
+     * written. Visibility and the other chat settings: updateSettings.
      */
     async update(chatId, data) {
-        return this.http.request('post', `/chats/${chatId}`, { data });
+        return this.http.request('patch', `/chats/${chatId}`, { data });
+    }
+    /**
+     * Change a chat's settings (name, visibility, tool approval, hooks,
+     * memory). Answers with the settings as they now are. Widening what runs
+     * without approval needs approvals:write, held only by the account
+     * holder's own sign-in: other credentials get 403 `requires_sign_in`
+     * (ErrorCodeRequiresSignIn).
+     */
+    async updateSettings(chatId, settings) {
+        return this.http.request('post', `/chats/${chatId}/settings`, { data: settings });
     }
     /**
      * Delete a chat

package/dist/api/engines.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { EngineUpdateBody } from './write-bodies';
 import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Engines API
@@ -27,9 +28,10 @@ export declare class EnginesAPI {
      */
     create(data: Partial<Engine>): Promise<Response<Engine>>;
     /**
-     * Update an engine
+     * Rename an engine (see EngineUpdateBody). PATCH: only the fields sent are
+     * written.
      */
-    update(engineId: string, data: Partial<Engine>): Promise<Response<Engine>>;
+    update(engineId: string, data: EngineUpdateBody): Promise<Response<Engine>>;
     /**
      * Delete an engine
      */

package/dist/api/engines.js

@@ -30,10 +30,11 @@ export class EnginesAPI {
         return this.http.request('post', '/engines', { data });
     }
     /**
-     * Update an engine
+     * Rename an engine (see EngineUpdateBody). PATCH: only the fields sent are
+     * written.
      */
     async update(engineId, data) {
-        return this.http.request('post', `/engines/${engineId}`, { data });
+        return this.http.request('patch', `/engines/${engineId}`, { data });
     }
     /**
      * Delete an engine

package/dist/api/flow-runs.d.ts

@@ -24,7 +24,11 @@ export declare class FlowRunsAPI {
      */
     clone(flowRunId: string): Promise<Response<FlowRun>>;
     /**
-     * Update a flow run
+     * Update a flow run.
+     *
+     * @deprecated A flow run has no caller-writable fields: the API refuses this
+     * request. To change who can see a run, use {@link FlowRunsAPI.updateVisibility}.
+     * Kept so existing code still compiles; it will be removed in a future major version.
      */
     update(flowRunId: string, data: Partial<FlowRun>): Promise<Response<FlowRun>>;
     /**
@@ -40,7 +44,8 @@ export declare class FlowRunsAPI {
      */
     streamTasks(flowRunId: string): Promise<import("eventsource").EventSource | null>;
     /**
-     * Update flow run visibility
+     * Set who can see a flow run: `private`, `team`, `unlisted` or `public`.
+     * This is the one change a caller can make to a run.
      */
     updateVisibility(flowRunId: string, visibility: string): Promise<Response<FlowRun>>;
 }

package/dist/api/flow-runs.js

@@ -30,7 +30,11 @@ export class FlowRunsAPI {
         return this.http.request('post', `/flowruns/${flowRunId}/clone`);
     }
     /**
-     * Update a flow run
+     * Update a flow run.
+     *
+     * @deprecated A flow run has no caller-writable fields: the API refuses this
+     * request. To change who can see a run, use {@link FlowRunsAPI.updateVisibility}.
+     * Kept so existing code still compiles; it will be removed in a future major version.
      */
     async update(flowRunId, data) {
         return this.http.request('post', `/flowruns/${flowRunId}`, { data });
@@ -54,7 +58,8 @@ export class FlowRunsAPI {
         return this.http.createEventSource(`/flowruns/${flowRunId}/tasks/stream`);
     }
     /**
-     * Update flow run visibility
+     * Set who can see a flow run: `private`, `team`, `unlisted` or `public`.
+     * This is the one change a caller can make to a run.
      */
     async updateVisibility(flowRunId, visibility) {
         return this.http.request('post', `/flowruns/${flowRunId}/visibility`, { data: { visibility } });

package/dist/api/flows.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { FlowPatchBody, FlowUpdateBody, FlowViewportBody } from './write-bodies';
 import { FlowDTO as Flow, FlowVersionDTO, AppDTO as App, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Flows API
@@ -20,9 +21,19 @@ export declare class FlowsAPI {
      */
     create(name: string): Promise<Response<Flow>>;
     /**
-     * Update a flow
+     * Update a flow's copy and images, and save its draft graph when the body
+     * names the draft (see FlowUpdateBody). A field left out is written
+     * empty: to change some fields only, use patch.
      */
-    update(flowId: string, data: Partial<Flow>): Promise<Response<Flow>>;
+    update(flowId: string, data: FlowUpdateBody): Promise<Response<Flow>>;
+    /**
+     * Change some of a flow's fields: only the fields sent are written.
+     */
+    patch(flowId: string, data: FlowPatchBody): Promise<Response<Flow>>;
+    /**
+     * Save where the editor's canvas looks on the flow's draft.
+     */
+    saveViewport(flowId: string, viewport: FlowViewportBody): Promise<Response<void>>;
     /**
      * Update flow visibility
      */

package/dist/api/flows.js

@@ -24,11 +24,25 @@ export class FlowsAPI {
         return this.http.request('post', '/flows', { data: { name } });
     }
     /**
-     * Update a flow
+     * Update a flow's copy and images, and save its draft graph when the body
+     * names the draft (see FlowUpdateBody). A field left out is written
+     * empty: to change some fields only, use patch.
      */
     async update(flowId, data) {
         return this.http.request('post', `/flows/${flowId}`, { data });
     }
+    /**
+     * Change some of a flow's fields: only the fields sent are written.
+     */
+    async patch(flowId, data) {
+        return this.http.request('patch', `/flows/${flowId}`, { data });
+    }
+    /**
+     * Save where the editor's canvas looks on the flow's draft.
+     */
+    async saveViewport(flowId, viewport) {
+        return this.http.request('post', `/flows/${flowId}/viewport`, { data: viewport });
+    }
     /**
      * Update flow visibility
      */

package/dist/api/knowledge.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { KnowledgeUpdateBody } from './write-bodies';
 import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types';
 /**
  * Knowledge API
@@ -24,9 +25,10 @@ export declare class KnowledgeAPI {
      */
     create(data: KnowledgeCreateRequest): Promise<Response<KnowledgeDTO>>;
     /**
-     * Update a knowledge entry
+     * Update a knowledge entry (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
-    update(id: string, data: Partial<KnowledgeDTO>): Promise<Response<KnowledgeDTO>>;
+    update(id: string, data: KnowledgeUpdateBody): Promise<Response<KnowledgeDTO>>;
     /**
      * Delete a knowledge entry
      */
@@ -75,9 +77,10 @@ export declare class SkillsAPI {
      */
     create(data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
     /**
-     * Update a skill
+     * Update a skill (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
-    update(id: string, data: Partial<SkillDTO>): Promise<Response<SkillDTO>>;
+    update(id: string, data: KnowledgeUpdateBody): Promise<Response<SkillDTO>>;
     /**
      * Delete a skill
      */

package/dist/api/knowledge.js

@@ -30,10 +30,11 @@ export class KnowledgeAPI {
         return this.http.request('post', '/knowledge', { data });
     }
     /**
-     * Update a knowledge entry
+     * Update a knowledge entry (PATCH): only the fields sent are written, the
+     * others keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/knowledge/${id}`, { data });
+        return this.http.request('patch', `/knowledge/${id}`, { data });
     }
     /**
      * Delete a knowledge entry
@@ -107,10 +108,11 @@ export class SkillsAPI {
         return this.http.request('post', '/skills', { data });
     }
     /**
-     * Update a skill
+     * Update a skill (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/skills/${id}`, { data });
+        return this.http.request('patch', `/skills/${id}`, { data });
     }
     /**
      * Delete a skill

package/dist/api/mcp-servers.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { MCPServerUpdateBody } from './write-bodies';
 import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * MCP Servers API
@@ -38,7 +39,7 @@ export declare class MCPServersAPI {
     /**
      * Update an MCP server
      */
-    update(id: string, data: Partial<MCPServerDTO>): Promise<Response<MCPServerDTO>>;
+    update(id: string, data: MCPServerUpdateBody): Promise<Response<MCPServerDTO>>;
     /**
      * Delete an MCP server
      */

package/dist/api/projects.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
+import type { ProjectWriteBody } from './write-bodies';
 import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Projects API
@@ -18,11 +19,12 @@ export declare class ProjectsAPI {
     /**
      * Create a project
      */
-    create(data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
+    create(data: ProjectWriteBody): Promise<Response<ProjectDTO>>;
     /**
-     * Update a project
+     * Update a project (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
-    update(id: string, data: Partial<ProjectDTO>): Promise<Response<ProjectDTO>>;
+    update(id: string, data: ProjectWriteBody): Promise<Response<ProjectDTO>>;
     /**
      * Delete a project
      */

package/dist/api/projects.js

@@ -24,10 +24,11 @@ export class ProjectsAPI {
         return this.http.request('post', '/projects', { data });
     }
     /**
-     * Update a project
+     * Update a project (PATCH): only the fields sent are written, the others
+     * keep their value.
      */
     async update(id, data) {
-        return this.http.request('post', `/projects/${id}`, { data });
+        return this.http.request('patch', `/projects/${id}`, { data });
     }
     /**
      * Delete a project

package/dist/api/secrets.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { SecretDTO, SecretCreateRequest, CursorListRequest, CursorListResponse } from '../types';
+import { SecretDTO, SecretCreateRequest, SecretUpdateRequest, CursorListRequest, CursorListResponse } from '../types';
 /**
  * Secrets API
  */
@@ -18,7 +18,7 @@ export declare class SecretsAPI {
     /**
      * Update a secret
      */
-    update(key: string, data: Partial<SecretCreateRequest>): Promise<Response<SecretDTO>>;
+    update(key: string, data: SecretUpdateRequest): Promise<Response<SecretDTO>>;
     /**
      * Delete a secret
      */

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,47 +124,26 @@ export class TasksAPI {
         const { onUpdate, onPartialUpdate, onDelta } = options;
         // Accumulate state across partial updates to preserve fields like session_id
         let accumulatedTask = { ...task };
-        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({
+            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) {
@@ -159,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`);
@@ -176,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

@@ -103,7 +103,7 @@ export declare class HttpClient {
     /**
      * Make an HTTP request to the API
      */
-    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, { handleErrors, ...options }?: {
+    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'patch' | 'delete', endpoint: string, { handleErrors, ...options }?: {
         params?: P;
         data?: unknown;
         /**

package/dist/http/client.js

@@ -1,5 +1,6 @@
 import { InferenceError, RequirementsNotMetException } from './errors';
 import { EventSource } from 'eventsource';
+import { SDK_VERSION } from '../version';
 /**
  * Low-level HTTP client for inference.sh API
  *
@@ -16,7 +17,7 @@ export class HttpClient {
         this.baseUrl = config.baseUrl || 'https://api.inference.sh';
         this.proxyUrl = config.proxyUrl;
         this.getToken = config.getToken;
-        this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', ...config.headers };
+        this.customHeaders = { 'X-Client-Source': `inference-sdk-js/${SDK_VERSION}`, ...config.headers };
         // 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

package/dist/http/loopback.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Loopback hosts, where plain http never leaves the machine (local dev):
+ * `localhost`, any `*.localhost`, `[::1]` and 127.0.0.0/8. This is the one
+ * copy of the rule; the proxy, the app and common-js all ask it.
+ */
+export declare function isLoopbackHost(hostname: string): boolean;
+/** Whether `url` is https, or plain http to a loopback host. */
+export declare function isHttpsOrLoopback(url: URL): boolean;