@inferencesh/sdk 0.6.30 → 0.6.47

package/dist/api/tasks.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
 import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, CursorListRequest, CursorListResponse } from '../types';
 export interface RunOptions {
     /** Callback for real-time status updates */
@@ -13,6 +14,8 @@ export interface RunOptions {
     stream?: boolean;
     /** Polling interval in ms when stream is false. Overrides client default. */
     pollIntervalMs?: number;
+    /** Callback for streaming delta events (token-by-token updates) */
+    onDelta?: (delta: Record<string, any>, seq: number) => void;
 }
 /**
  * Tasks API
@@ -23,27 +26,27 @@ export declare class TasksAPI {
     /**
      * List tasks with cursor-based pagination
      */
-    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Task>>;
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<Task>>>;
     /**
      * List featured tasks with cursor-based pagination
      */
-    listFeatured(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Task>>;
+    listFeatured(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<Task>>>;
     /**
      * Get a task by ID
      */
-    get(taskId: string): Promise<Task>;
+    get(taskId: string): Promise<Response<Task>>;
     /**
      * Create and run a task
      */
-    create(data: ApiAppRunRequest): Promise<Task>;
+    create(data: ApiAppRunRequest): Promise<Response<Task>>;
     /**
      * Delete a task
      */
-    delete(taskId: string): Promise<void>;
+    delete(taskId: string): Promise<Response<void>>;
     /**
      * Cancel a running task
      */
-    cancel(taskId: string): Promise<void>;
+    cancel(taskId: string): Promise<Response<void>>;
     /**
      * Create an EventSource for streaming task updates
      */
@@ -57,22 +60,22 @@ export declare class TasksAPI {
     /**
      * Update task visibility
      */
-    updateVisibility(taskId: string, visibility: string): Promise<Task>;
+    updateVisibility(taskId: string, visibility: string): Promise<Response<Task>>;
     /**
      * Feature/unfeature a task
      */
-    feature(taskId: string, featured: boolean): Promise<Task>;
+    feature(taskId: string, featured: boolean): Promise<Response<Task>>;
     /**
      * Get task logs
      */
-    getLogs(taskId: string): Promise<TaskLogsDTO>;
+    getLogs(taskId: string): Promise<Response<TaskLogsDTO>>;
     /**
      * Get task timings
      */
-    getTimings(taskId: string): Promise<TaskTimingsDTO>;
+    getTimings(taskId: string): Promise<Response<TaskTimingsDTO>>;
     /**
      * Get task telemetry
      */
-    getTelemetry(taskId: string): Promise<Record<string, unknown>[]>;
+    getTelemetry(taskId: string): Promise<Response<Record<string, unknown>[]>>;
 }
 export declare function createTasksAPI(http: HttpClient): TasksAPI;

package/dist/api/tasks.js

@@ -69,13 +69,14 @@ export class TasksAPI {
      * Run a task and optionally wait for completion
      */
     async run(params, processedInput, options = {}) {
-        const { onUpdate, onPartialUpdate, wait = true, } = options;
-        const task = await this.http.request('post', '/apps/run', {
+        const { onUpdate, onPartialUpdate, onDelta, wait = true, } = options;
+        const resp = await this.http.request('post', '/apps/run', {
             data: {
                 ...params,
                 input: processedInput,
             },
         });
+        const task = resp.data;
         // Return immediately if not waiting
         if (!wait) {
             return stripTask(task);
@@ -93,6 +94,7 @@ export class TasksAPI {
                 url,
                 headers,
                 credentials,
+                onDelta,
                 onData: (data) => {
                     // Merge new data, preserving existing fields if not in update
                     accumulatedTask = { ...accumulatedTask, ...data };
@@ -144,7 +146,10 @@ export class TasksAPI {
         let prevStatus = task.status;
         return new Promise((resolve, reject) => {
             const poller = new PollManager({
-                pollFunction: () => this.http.request('get', `/tasks/${task.id}/status`),
+                pollFunction: async () => {
+                    const resp = await this.http.request('get', `/tasks/${task.id}/status`);
+                    return resp.data;
+                },
                 intervalMs,
                 maxRetries: maxReconnects,
                 onData: async (statusData) => {
@@ -153,7 +158,8 @@ export class TasksAPI {
                     prevStatus = statusData.status;
                     // Status changed — fetch full task
                     try {
-                        const fullTask = await this.http.request('get', `/tasks/${task.id}`);
+                        const fullResp = await this.http.request('get', `/tasks/${task.id}`);
+                        const fullTask = fullResp.data;
                         const stripped = stripTask(fullTask);
                         onUpdate?.(stripped);
                         if (parseStatus(fullTask.status) === TaskStatusCompleted) {

package/dist/api/teams.d.ts

@@ -1,5 +1,6 @@
 import { HttpClient } from '../http/client';
-import { UserDTO, TeamRelationDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest } from '../types';
+import type { Response } from '../http/response';
+import { UserDTO, TeamRelationDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types';
 export interface MeResponse {
     user: UserDTO;
     team?: TeamRelationDTO;
@@ -13,59 +14,57 @@ export declare class TeamsAPI {
     /**
      * Get current user and team context
      */
-    me(): Promise<MeResponse>;
+    me(): Promise<Response<MeResponse>>;
     /**
      * List user's teams
      */
-    list(): Promise<TeamRelationDTO[]>;
+    list(): Promise<Response<TeamRelationDTO[]>>;
     /**
      * Get a team by ID
      */
-    get(teamId: string): Promise<TeamRelationDTO>;
+    get(teamId: string): Promise<Response<TeamRelationDTO>>;
     /**
      * Create a new team
      */
-    create(data: TeamCreateRequest): Promise<TeamRelationDTO>;
+    create(data: TeamCreateRequest): Promise<Response<TeamRelationDTO>>;
     /**
      * Update a team
      */
-    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<TeamRelationDTO>;
+    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<Response<TeamRelationDTO>>;
     /**
      * Delete a team
      */
-    delete(teamId: string): Promise<void>;
+    delete(teamId: string): Promise<Response<void>>;
     /**
      * Check username availability
      */
-    checkUsername(username: string): Promise<{
-        available: boolean;
-    }>;
+    checkUsername(username: string): Promise<Response<AvailabilityResponse>>;
     /**
      * Get team members
      */
-    getMembers(teamId: string): Promise<TeamMemberDTO[]>;
+    getMembers(teamId: string): Promise<Response<TeamMemberDTO[]>>;
     /**
      * Add a team member
      */
-    addMember(teamId: string, data: TeamMemberAddRequest): Promise<TeamMemberDTO>;
+    addMember(teamId: string, data: TeamMemberAddRequest): Promise<Response<TeamMemberDTO>>;
     /**
      * Remove a team member
      */
-    removeMember(teamId: string, userId: string): Promise<void>;
+    removeMember(teamId: string, userId: string): Promise<Response<void>>;
     /**
      * Update a member's role
      */
-    updateMemberRole(teamId: string, userId: string, role: string): Promise<TeamMemberDTO>;
+    updateMemberRole(teamId: string, userId: string, role: string): Promise<Response<TeamMemberDTO>>;
     /**
      * List team invites
      */
-    listInvites(teamId: string): Promise<TeamInviteDTO[]>;
+    listInvites(teamId: string): Promise<Response<TeamInviteDTO[]>>;
     /**
      * Create an invite
      */
-    createInvite(teamId: string, data: TeamInviteCreateRequest): Promise<TeamInviteDTO>;
+    createInvite(teamId: string, data: TeamInviteCreateRequest): Promise<Response<TeamInviteDTO>>;
     /**
      * Revoke an invite
      */
-    revokeInvite(teamId: string, inviteId: string): Promise<void>;
+    revokeInvite(teamId: string, inviteId: string): Promise<Response<void>>;
 }

package/dist/delta.d.ts

@@ -0,0 +1,15 @@
+export type { DeltaEvent } from './types';
+export type FieldTags = Record<string, {
+    merge: string;
+}>;
+export type FieldTagsRegistry = Map<FieldTags, FieldTags>;
+export declare class DeltaAccumulator {
+    private state;
+    private tags;
+    private registry;
+    constructor(tags: FieldTags, registry?: FieldTagsRegistry);
+    seed(output: Record<string, any>): void;
+    apply(delta: Record<string, any>): void;
+    toOutput(): Record<string, any>;
+}
+export declare function createLLMDeltaAccumulator(): DeltaAccumulator;

package/dist/delta.js

@@ -0,0 +1,84 @@
+import { LLMDelta_fieldTags, ToolCallDelta_fieldTags, ToolCallFunctionDelta_fieldTags, MergeStrategyConcat, MergeStrategyIndexed, MergeStrategyNested, MergeStrategyReplace, } from './types';
+function mergeField(current, incoming, strategy, childTags, registry) {
+    if (incoming == null)
+        return current;
+    switch (strategy) {
+        case MergeStrategyConcat:
+            return (current ?? '') + incoming;
+        case MergeStrategyReplace:
+            return incoming;
+        case MergeStrategyIndexed:
+            return mergeIndexed(current, incoming, childTags, registry);
+        case MergeStrategyNested:
+            return mergeNested(current, incoming, childTags, registry);
+        default:
+            return incoming;
+    }
+}
+function mergeIndexed(current, incoming, itemTags, registry) {
+    const byIndex = new Map();
+    if (current) {
+        for (const item of current)
+            byIndex.set(item.index ?? 0, item);
+    }
+    for (const item of incoming) {
+        const idx = item.index ?? 0;
+        const existing = byIndex.get(idx);
+        if (!existing) {
+            byIndex.set(idx, { ...item });
+        }
+        else {
+            byIndex.set(idx, mergeObject(existing, item, itemTags, registry));
+        }
+    }
+    return Array.from(byIndex.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([_, v]) => v);
+}
+function mergeNested(current, incoming, nestedTags, registry) {
+    if (current == null)
+        return { ...incoming };
+    return mergeObject(current, incoming, nestedTags, registry);
+}
+function mergeObject(current, incoming, tags, registry) {
+    const result = { ...current };
+    for (const [key, value] of Object.entries(incoming)) {
+        if (value == null)
+            continue;
+        const strategy = tags[key]?.merge ?? MergeStrategyReplace;
+        const childTags = registry?.get(tags) ?? {};
+        result[key] = mergeField(result[key], value, strategy, childTags, registry);
+    }
+    return result;
+}
+export class DeltaAccumulator {
+    constructor(tags, registry) {
+        this.state = {};
+        this.tags = tags;
+        this.registry = registry;
+    }
+    seed(output) {
+        for (const [key, value] of Object.entries(output)) {
+            if (value != null)
+                this.state[key] = value;
+        }
+    }
+    apply(delta) {
+        for (const [key, value] of Object.entries(delta)) {
+            if (value == null)
+                continue;
+            const strategy = this.tags[key]?.merge ?? MergeStrategyReplace;
+            const childTags = this.registry?.get(this.tags) ?? {};
+            this.state[key] = mergeField(this.state[key], value, strategy, childTags, this.registry);
+        }
+    }
+    toOutput() {
+        return { ...this.state };
+    }
+}
+export function createLLMDeltaAccumulator() {
+    const registry = new Map();
+    registry.set(LLMDelta_fieldTags, ToolCallDelta_fieldTags);
+    registry.set(ToolCallDelta_fieldTags, ToolCallFunctionDelta_fieldTags);
+    return new DeltaAccumulator(LLMDelta_fieldTags, registry);
+}

package/dist/hook-builder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hook Builder - Fluent API for defining lifecycle hooks
+ */
+import { LifecycleHookConfig, HookEvent } from './types';
+export declare class LifecycleHookBuilder {
+    private event;
+    private handlerType;
+    private handlerRef;
+    private isAsync?;
+    private timeoutSeconds?;
+    constructor(event: HookEvent);
+    /** Set handler to a webhook URL */
+    webhook(url: string): this;
+    /** Set handler to a task (agent ref) */
+    task(agentRef: string): this;
+    /** Set async execution */
+    async(enabled: boolean): this;
+    /** Set handler timeout in seconds */
+    timeout(seconds: number): this;
+    build(): LifecycleHookConfig;
+}
+/** Create a lifecycle hook for an agent event */
+export declare const lifecycleHook: (event: HookEvent) => LifecycleHookBuilder;

package/dist/hook-builder.js

@@ -0,0 +1,50 @@
+/**
+ * Hook Builder - Fluent API for defining lifecycle hooks
+ */
+import { HookHandlerWebhook, HookHandlerTask } from './types';
+// =============================================================================
+// Hook Builder
+// =============================================================================
+export class LifecycleHookBuilder {
+    constructor(event) {
+        this.handlerType = HookHandlerWebhook;
+        this.handlerRef = '';
+        this.event = event;
+    }
+    /** Set handler to a webhook URL */
+    webhook(url) {
+        this.handlerType = HookHandlerWebhook;
+        this.handlerRef = url;
+        return this;
+    }
+    /** Set handler to a task (agent ref) */
+    task(agentRef) {
+        this.handlerType = HookHandlerTask;
+        this.handlerRef = agentRef;
+        return this;
+    }
+    /** Set async execution */
+    async(enabled) {
+        this.isAsync = enabled;
+        return this;
+    }
+    /** Set handler timeout in seconds */
+    timeout(seconds) {
+        this.timeoutSeconds = seconds;
+        return this;
+    }
+    build() {
+        return {
+            event: this.event,
+            type: this.handlerType,
+            handler: this.handlerRef,
+            async: this.isAsync,
+            timeout: this.timeoutSeconds,
+        };
+    }
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/** Create a lifecycle hook for an agent event */
+export const lifecycleHook = (event) => new LifecycleHookBuilder(event);

package/dist/http/client.d.ts

@@ -1,9 +1,11 @@
+import type { Response } from './response';
 import { EventSource } from 'eventsource';
 /**
  * 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.
  */
 export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>) => Promise<unknown>;
+export type MessageHandler = (messages: import('../types').ResponseMessage[]) => void;
 export interface HttpClientConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
     apiKey?: string;
@@ -25,6 +27,11 @@ export interface HttpClientConfig {
      * Can be used for retry logic, auth refresh, OTP handling, etc.
      */
     onError?: ErrorHandler;
+    /**
+     * Callback fired when a successful response includes messages (warnings, info).
+     * Use for surfacing concurrency limits, upgrade prompts, deprecation notices, etc.
+     */
+    onMessage?: MessageHandler;
     /**
      * Use polling instead of SSE for real-time updates (default: true = SSE).
      * Set to false for environments that can't maintain long-lived connections
@@ -50,6 +57,7 @@ export declare class HttpClient {
     private readonly customHeaders;
     private readonly credentials;
     private readonly onError;
+    private readonly onMessage;
     private readonly streamDefault;
     private readonly pollInterval;
     constructor(config: HttpClientConfig);
@@ -71,7 +79,7 @@ export declare class HttpClient {
     request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {
         params?: P;
         data?: unknown;
-    }): Promise<T>;
+    }): Promise<Response<T>>;
     /**
      * Execute the actual HTTP request (internal)
      */

package/dist/http/client.js

@@ -16,9 +16,10 @@ 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', 'X-API-Version': '2', ...config.headers };
+        this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', ...config.headers };
         this.credentials = config.credentials || 'include';
         this.onError = config.onError;
+        this.onMessage = config.onMessage;
         this.streamDefault = config.stream ?? true;
         this.pollInterval = config.pollIntervalMs ?? 2000;
     }
@@ -136,9 +137,17 @@ export class HttpClient {
             throw new InferenceError(response.status, errorDetail || 'Request failed', responseText);
         }
         if (response.status === 204 || !responseText) {
-            return undefined;
+            return { data: undefined, messages: [] };
+        }
+        // Unwrap V3 envelope: {"data": <dto>, "messages": [...]}
+        if (data && typeof data === 'object' && 'data' in data && !Array.isArray(data)) {
+            const messages = data.messages ?? [];
+            if (this.onMessage && messages.length) {
+                this.onMessage(messages);
+            }
+            return { data: data.data, messages };
         }
-        return data;
+        return { data: data, messages: [] };
     }
     /**
      * Get URL and headers for NDJSON streaming.

package/dist/http/response.d.ts

@@ -0,0 +1,9 @@
+import type { ResponseMessage } from '../types';
+/**
+ * Response wraps the V3 API envelope — every API call returns this.
+ * Access .data for the DTO and .messages for any warnings the server surfaced.
+ */
+export interface Response<T> {
+    data: T;
+    messages: ResponseMessage[];
+}

package/dist/http/response.js

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

package/dist/http/stream.d.ts

@@ -22,6 +22,7 @@ export declare class StreamManager<T> {
     private reconnectTimeout;
     private stopTimeout;
     private initialConnectionAttempts;
+    private consecutiveErrors;
     private isConnected;
     private isStopped;
     private eventListeners;

package/dist/http/stream.js

@@ -15,6 +15,7 @@ export class StreamManager {
         this.reconnectTimeout = null;
         this.stopTimeout = null;
         this.initialConnectionAttempts = 0;
+        this.consecutiveErrors = 0;
         this.isConnected = false;
         this.isStopped = false;
         this.eventListeners = new Map();
@@ -112,9 +113,11 @@ export class StreamManager {
     scheduleReconnect() {
         if (!this.options.autoReconnect || this.isStopped)
             return false;
-        // If we had a successful connection before, always reconnect
-        // Otherwise, check if we've exceeded initial connection attempts
-        if (!this.isConnected && this.initialConnectionAttempts >= (this.options.maxReconnects ?? 5)) {
+        const maxReconnects = this.options.maxReconnects ?? 5;
+        if (!this.isConnected && this.initialConnectionAttempts >= maxReconnects) {
+            return false;
+        }
+        if (this.isConnected && this.consecutiveErrors >= maxReconnects) {
             return false;
         }
         this.reconnectTimeout = setTimeout(() => {
@@ -122,6 +125,7 @@ export class StreamManager {
                 if (!this.isConnected) {
                     this.initialConnectionAttempts++;
                 }
+                this.consecutiveErrors++;
                 this.connect();
             }
         }, this.options.reconnectDelayMs);
@@ -144,6 +148,7 @@ export class StreamManager {
             source.onmessage = (e) => {
                 if (this.isStopped)
                     return;
+                this.consecutiveErrors = 0;
                 try {
                     const parsed = JSON.parse(e.data);
                     // Check if this is a partial data wrapper from the server

package/dist/http/streamable.d.ts

@@ -55,6 +55,8 @@ export interface StreamableManagerOptions<T> {
     onStart?: () => void;
     /** Called when stream ends */
     onEnd?: () => void;
+    /** Called for delta events (streaming token deltas) */
+    onDelta?: (delta: Record<string, any>, seq: number) => void;
 }
 export declare class StreamableManager<T> {
     private options;
@@ -66,7 +68,7 @@ export declare class StreamableManager<T> {
      * Add a listener for typed events (e.g., 'chats', 'chat_messages').
      * Used when server sends events with {"event": "eventName", "data": ...} format.
      */
-    addEventListener<E = unknown>(eventName: string, callback: (data: E) => void): () => void;
+    addEventListener<E = unknown>(eventName: string, callback: (data: E, fields?: string[]) => void): () => void;
     start(): Promise<void>;
     stop(): void;
 }

package/dist/http/streamable.js

@@ -118,11 +118,20 @@ export class StreamableManager {
                 if (!this.isRunning)
                     break;
                 const wrapper = message;
+                // Handle delta events
+                if (wrapper.event === 'delta' && this.options.onDelta) {
+                    const payload = wrapper.data;
+                    if (payload && payload.delta) {
+                        this.options.onDelta(payload.delta, payload.seq);
+                    }
+                    continue;
+                }
                 // Handle typed events ({"event": "...", "data": ...})
                 if (wrapper.event && this.eventListeners.has(wrapper.event)) {
                     const listeners = this.eventListeners.get(wrapper.event);
                     const eventData = wrapper.data !== undefined ? wrapper.data : message;
-                    listeners.forEach(callback => callback(eventData));
+                    const fields = wrapper.fields;
+                    listeners.forEach(callback => callback(eventData, fields));
                     continue;
                 }
                 // Check if it's a partial update

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export { HttpClient, type HttpClientConfig, type ErrorHandler, createHttpClient } from './http/client';
+export { HttpClient, type HttpClientConfig, type ErrorHandler, type MessageHandler, createHttpClient } from './http/client';
+export type { Response } from './http/response';
+import type { Response } from './http/response';
 export { StreamManager, type StreamManagerOptions, type PartialDataWrapper } from './http/stream';
 export { StreamableManager, type StreamableManagerOptions, type StreamableMessage, streamable, streamableRaw } from './http/streamable';
 export { PollManager, type PollManagerOptions } from './http/poll';
@@ -22,7 +24,11 @@ export { ProjectsAPI } from './api/projects';
 export { MCPServersAPI } from './api/mcp-servers';
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
 export type { ClientTool, ClientToolHandler } from './tool-builder';
-export { parseStatus, isTerminalStatus, isChatBusy } from './utils';
+export { lifecycleHook } from './hook-builder';
+export type { LifecycleHookBuilder } from './hook-builder';
+export { DeltaAccumulator, createLLMDeltaAccumulator, type DeltaEvent, type FieldTags, type FieldTagsRegistry } from './delta';
+export { parseStatus, isTerminalStatus, isChatBusy, pendingApprovals } from './utils';
+export type { PendingApproval } from './utils';
 export * from './types';
 export type { TaskDTO as Task } from './types';
 import { HttpClient, type HttpClientConfig } from './http/client';
@@ -98,7 +104,7 @@ export declare class Inference {
     _request<T>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {
         params?: Record<string, unknown>;
         data?: Record<string, unknown>;
-    }): Promise<T>;
+    }): Promise<Response<T>>;
     /** @internal */
     _createEventSource(endpoint: string): Promise<import("eventsource").EventSource | null>;
     /**
@@ -112,11 +118,11 @@ export declare class Inference {
     /**
      * Cancel a running task
      */
-    cancel(taskId: string): Promise<void>;
+    cancel(taskId: string): Promise<Response<void>>;
     /**
      * Get a task by ID
      */
-    getTask(taskId: string): Promise<Task>;
+    getTask(taskId: string): Promise<Response<Task>>;
     /**
      * Create an EventSource for streaming task updates
      */

package/dist/index.js

@@ -26,8 +26,12 @@ export { ProjectsAPI } from './api/projects';
 export { MCPServersAPI } from './api/mcp-servers';
 // Tool Builder (fluent API)
 export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
+// Hook Builder (fluent API)
+export { lifecycleHook } from './hook-builder';
+// Delta accumulator for streaming responses
+export { DeltaAccumulator, createLLMDeltaAccumulator } from './delta';
 // Status utilities (handle both int and string status values)
-export { parseStatus, isTerminalStatus, isChatBusy } from './utils';
+export { parseStatus, isTerminalStatus, isChatBusy, pendingApprovals } from './utils';
 // Types - includes TaskStatus constants and all DTOs
 export * from './types';
 // =============================================================================
@@ -71,6 +75,7 @@ export class Inference {
             headers: 'headers' in config ? config.headers : undefined,
             credentials: 'credentials' in config ? config.credentials : undefined,
             onError: 'onError' in config ? config.onError : undefined,
+            onMessage: 'onMessage' in config ? config.onMessage : undefined,
             stream: 'stream' in config ? config.stream : undefined,
             pollIntervalMs: 'pollIntervalMs' in config ? config.pollIntervalMs : undefined,
         });

package/dist/proxy/index.d.ts

@@ -51,6 +51,8 @@ export interface ProxyAdapter<T> {
 export interface ProxyOptions {
     /** Custom API key (defaults to INFERENCE_API_KEY env var) */
     apiKey?: string;
+    /** Override API base URL (defaults to INFERENCE_API_BASE_URL env var) */
+    apiBaseUrl?: string;
     /** Allow requests to additional domains (besides *.inference.sh) */
     allowedDomains?: RegExp[];
 }

package/dist/proxy/index.js

@@ -73,6 +73,15 @@ export async function processProxyRequest(adapter, options) {
             error: `Missing ${INF_TARGET_HEADER} header or ${INF_TARGET_PARAM} query param`,
         });
     }
+    // 1b. Rewrite base URL if INFERENCE_API_BASE_URL is set
+    const overrideBase = options?.apiBaseUrl || process.env.INFERENCE_API_BASE_URL;
+    if (overrideBase) {
+        const parsed = new URL(targetUrl);
+        const override = new URL(overrideBase);
+        parsed.protocol = override.protocol;
+        parsed.host = override.host;
+        targetUrl = parsed.toString();
+    }
     // 2. Validate target domain
     let host;
     try {

package/dist/tool-builder.d.ts

@@ -126,6 +126,8 @@ declare class InternalToolsBuilder {
     widget(enabled?: boolean): this;
     /** Enable finish tool - sub-agents only */
     finish(enabled?: boolean): this;
+    /** Enable meta tools */
+    meta(enabled?: boolean): this;
     /** Enable all internal tools */
     all(): this;
     /** Disable all internal tools */