@inferencesh/sdk 0.14.2 → 0.16.0

package/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-02
+
+### Added
+
+- `useAgentActions().getAlwaysAllowOptions(toolInvocationId)`: what "always allow" can save for a call awaiting approval, narrowest first, computed by the api (`GET /chats/{id}/tools/{toolId}/always-allow/options`). Each option has a `key`, a `scope` (`exact`, `prefix`, `folder`, `remote`, `tool`), a `label` such as "npm run commands on laptop", and the chat `rules` it saves; `default` is the narrowest that answers the call again, and `unavailable` says why there are none.
+- `useAgentActions().explainTool(toolInvocationId)`: a plain-words explanation of a call awaiting approval, `{ risk_level: 'low' | 'medium' | 'high', explanation, reasoning, risk }` (`POST /chats/{id}/tools/{toolId}/explain`). A model writes it the first time it is asked for and the api keeps it for the call; call it only when the person asks.
+- Types: `ToolExplanationDTO`, `ToolRiskLevel`, `AlwaysAllowOptionsDTO`, `AlwaysAllowOptionDTO`, `AlwaysAllowScope`, `AlwaysAllowRequest`, `AlwaysAllowResultDTO`, `PolicyRuleDTO` (with `label`), `AlwaysAllowChoice`.
+
+### Changed
+
+- `useAgentActions().alwaysAllowTool(toolInvocationId, { option })` saves the chosen option and resolves to the saved rules. The second argument used to be the tool name; a string is still accepted and means the api's default. A 409 (stale option) or 400 rejects without putting the chat in the error state.
+
+### Security
+
+- `proxy-addr` 2.0.8 in the lockfile (CVE-2026-90711).
+
+## [0.15.0] - 2026-10-02
+
+### Added
+
+- `useAgentActions().updateChatSettings(settings)`: change a chat's name, visibility, `allow_all_tools` (run every tool without asking; switching it on approves the calls already waiting), `disable_hooks` and `forget_memory` (`POST /chats/{id}/settings`).
+- `useAgentActions().switchAgent(agentRef)`: hand the chat to another agent our loop runs; the next message goes to it. A harness agent is refused.
+- Types: `ChatSettingsRequest`; `ChatData.allow_all_tools` and `disable_hooks`; per-server MCP headers; API key scope and an optional `last_used_at`; engine-picker provider options.
+
+### Changed
+
+- The `inference-src` export condition is listed before `types`, so a bundler that sets it resolves the TypeScript source.
+
 ## [0.14.2] - 2026-10-01
 
 ### Added

package/dist/agent/actions.js

@@ -368,16 +368,37 @@ export function createActions(ctx) {
                 throw error;
             }
         },
-        alwaysAllowTool: async (toolInvocationId, toolName) => {
+        getAlwaysAllowOptions: async (toolInvocationId) => {
+            const chatId = getChatId();
+            if (!chatId)
+                return null;
+            return api.getAlwaysAllowOptions(client, chatId, toolInvocationId);
+        },
+        explainTool: async (toolInvocationId) => {
+            const chatId = getChatId();
+            if (!chatId)
+                throw new Error('Cannot explain a tool call without a chat');
+            return api.explainTool(client, chatId, toolInvocationId);
+        },
+        alwaysAllowTool: async (toolInvocationId, choice) => {
             const chatId = getChatId();
             if (!chatId) {
                 console.error('[AgentSDK] Cannot always-allow tool without a chatId');
-                return;
+                return undefined;
             }
+            // A string is the tool name older callers passed; the api reads the
+            // tool from the call, so it only means "the default option".
+            const option = typeof choice === 'string' ? undefined : choice?.option;
             try {
-                await api.alwaysAllowTool(client, chatId, toolInvocationId, toolName);
+                return await api.alwaysAllowTool(client, chatId, toolInvocationId, option);
             }
             catch (error) {
+                // 409: the option is stale (the rules changed since it was read);
+                // 400: nothing can be always-allowed here. The call is still
+                // waiting and the connection is fine: the caller reads the options
+                // again or shows why.
+                if (isInferenceError(error) && (error.statusCode === 409 || error.statusCode === 400))
+                    throw error;
                 console.error('[AgentSDK] Failed to always-allow tool:', error);
                 const err = error instanceof Error ? error : new Error('Failed to always-allow tool');
                 dispatch({ type: 'SET_CONNECTION_STATUS', payload: 'error' });
@@ -386,6 +407,42 @@ export function createActions(ctx) {
                 throw error;
             }
         },
+        updateChatSettings: async (settings) => {
+            const chatId = getChatId();
+            if (!chatId) {
+                console.error('[AgentSDK] Cannot change chat settings without a chatId');
+                return;
+            }
+            try {
+                // The response carries the chat without its messages: update the
+                // chat and keep the conversation on screen.
+                dispatch({ type: 'UPDATE_CHAT', payload: await api.updateChatSettings(client, chatId, settings) });
+            }
+            catch (error) {
+                console.error('[AgentSDK] Failed to change chat settings:', error);
+                const err = error instanceof Error ? error : new Error('Failed to change chat settings');
+                dispatch({ type: 'SET_ERROR', payload: err.message });
+                callbacks.onError?.(err);
+                throw error;
+            }
+        },
+        switchAgent: async (agentRef) => {
+            const chatId = getChatId();
+            if (!chatId) {
+                console.error('[AgentSDK] Cannot switch the agent without a chatId');
+                return;
+            }
+            try {
+                dispatch({ type: 'UPDATE_CHAT', payload: await api.setAgent(client, chatId, agentRef) });
+            }
+            catch (error) {
+                console.error('[AgentSDK] Failed to switch the agent:', error);
+                const err = error instanceof Error ? error : new Error('Failed to switch the agent');
+                dispatch({ type: 'SET_ERROR', payload: err.message });
+                callbacks.onError?.(err);
+                throw error;
+            }
+        },
         cancelMessage: async (messageId) => {
             try {
                 await api.cancelMessage(client, messageId);

package/dist/agent/api.d.ts

@@ -7,7 +7,7 @@
  *
  * /agents/run stays for A2A/programmatic use.
  */
-import type { ChatDTO, ChatMessageDTO, InterruptDTO } from '../types';
+import type { AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ChatDTO, ChatMessageDTO, ChatSettingsRequest, InterruptDTO, ToolExplanationDTO } from '../types';
 import type { AgentOptions, AgentClient, AgentInfo, FileRef } from './types';
 export interface SendResult {
     chatId: string;
@@ -46,7 +46,24 @@ export declare function submitToolResult(client: AgentClient, toolInvocationId:
 }): Promise<void>;
 export declare function approveTool(client: AgentClient, toolInvocationId: string): Promise<void>;
 export declare function rejectTool(client: AgentClient, toolInvocationId: string, reason?: string): Promise<void>;
-export declare function alwaysAllowTool(client: AgentClient, chatId: string, toolInvocationId: string, toolName: string): Promise<void>;
+/**
+ * What "always allow" can save for a call awaiting approval, narrowest first.
+ * The api computes the options from the call; each one, saved, answers it again.
+ */
+export declare function getAlwaysAllowOptions(client: AgentClient, chatId: string, toolInvocationId: string): Promise<AlwaysAllowOptionsDTO>;
+/**
+ * Save an "always allow" option (a key from getAlwaysAllowOptions) as chat
+ * rules and approve the call once. Without an option the api saves its old
+ * default: the command exactly for remote_exec, the whole tool otherwise.
+ */
+export declare function alwaysAllowTool(client: AgentClient, chatId: string, toolInvocationId: string, option?: string): Promise<AlwaysAllowResultDTO>;
+/**
+ * Explain a call awaiting approval in plain words: what it does, why the agent
+ * appears to make it, and its risk. Generated by a model the first time and kept
+ * for the call, so asking again is free.
+ */
+export declare function explainTool(client: AgentClient, chatId: string, toolInvocationId: string): Promise<ToolExplanationDTO>;
+export declare function updateChatSettings(client: AgentClient, chatId: string, settings: ChatSettingsRequest): Promise<ChatDTO>;
 export declare function resolveInterrupt(client: AgentClient, interruptId: string, decision: 'allow' | 'deny'): Promise<InterruptDTO>;
 export declare function listRunInterrupts(client: AgentClient, runId: string): Promise<InterruptDTO[]>;
 export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<FileRef>;

package/dist/agent/api.js

@@ -151,10 +151,36 @@ export async function approveTool(client, toolInvocationId) {
 export async function rejectTool(client, toolInvocationId, reason) {
     await client.http.request('post', `/tools/${toolInvocationId}/reject`, { data: { reason } });
 }
-export async function alwaysAllowTool(client, chatId, toolInvocationId, toolName) {
-    await client.http.request('post', `/chats/${chatId}/tools/${toolInvocationId}/always-allow`, {
-        data: { tool_name: toolName }
-    });
+/**
+ * What "always allow" can save for a call awaiting approval, narrowest first.
+ * The api computes the options from the call; each one, saved, answers it again.
+ */
+export async function getAlwaysAllowOptions(client, chatId, toolInvocationId) {
+    const resp = await client.http.request('get', `/chats/${chatId}/tools/${toolInvocationId}/always-allow/options`);
+    return resp.data;
+}
+/**
+ * Save an "always allow" option (a key from getAlwaysAllowOptions) as chat
+ * rules and approve the call once. Without an option the api saves its old
+ * default: the command exactly for remote_exec, the whole tool otherwise.
+ */
+export async function alwaysAllowTool(client, chatId, toolInvocationId, option) {
+    const data = option ? { option } : {};
+    const resp = await client.http.request('post', `/chats/${chatId}/tools/${toolInvocationId}/always-allow`, { data });
+    return resp.data;
+}
+/**
+ * Explain a call awaiting approval in plain words: what it does, why the agent
+ * appears to make it, and its risk. Generated by a model the first time and kept
+ * for the call, so asking again is free.
+ */
+export async function explainTool(client, chatId, toolInvocationId) {
+    const resp = await client.http.request('post', `/chats/${chatId}/tools/${toolInvocationId}/explain`);
+    return resp.data;
+}
+export async function updateChatSettings(client, chatId, settings) {
+    const resp = await client.http.request('post', `/chats/${chatId}/settings`, { data: settings });
+    return resp.data;
 }
 // =========================================================================
 // Interrupt operations

package/dist/agent/index.d.ts

@@ -46,6 +46,6 @@
 export { AgentChatProvider } from './provider';
 export { useAgentChat, useAgentActions, useAgentClient, useAgentChatContext, useMessage, } from './hooks';
 export { AgentChatContext, type AgentChatContextValue } from './context';
-export type { AgentClient, FileRef, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
+export type { AgentClient, FileRef, AdHocAgentConfig, TemplateAgentConfig, AgentOptions, AgentChatState, AgentChatActions, AlwaysAllowChoice, ChatStatus, AgentChatProviderProps, ClientTool, ClientToolHandlerFn, } from './types';
 export { isAdHocConfig, isTemplateConfig, isClientTool, extractToolSchemas, extractClientToolHandlers, } from './types';
 export { MCPMethodElicitationCreate, parseMCPInputState, elicitParams, isURLElicitation, buildMCPInputResult, type MCPInputState, type ElicitRequestParams, type ElicitRequestedSchema, type ElicitPropertySchema, } from './mcp-input';

package/dist/agent/types.d.ts

@@ -4,11 +4,15 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { AgentRunDTO, AgentVersionDTO, ChatDTO, ChatMessageDTO, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef, ElicitResult } from '../types';
+import type { AgentRunDTO, AgentVersionDTO, AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ToolExplanationDTO, ChatDTO, ChatMessageDTO, ChatSettingsRequest, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef, ElicitResult } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
 export type { FileRef } from '../types';
+/** The "always allow" option to save: a key from getAlwaysAllowOptions. */
+export interface AlwaysAllowChoice {
+    option?: string;
+}
 /**
  * Minimal client interface required by the agent module.
  * This allows extended clients (like the app client) to be used.
@@ -132,8 +136,30 @@ export interface AgentChatActions {
     approveTool: (toolInvocationId: string) => Promise<void>;
     /** Reject a tool (for HIL approval - AwaitingApproval status) */
     rejectTool: (toolInvocationId: string, reason?: string) => Promise<void>;
-    /** Always allow a tool for this chat (approves + auto-approves future invocations) */
-    alwaysAllowTool: (toolInvocationId: string, toolName: string) => Promise<void>;
+    /**
+     * What "always allow" can save for a call awaiting approval, narrowest
+     * first, as computed by the api (null without a chat). Show the options'
+     * labels in order; `default` is the narrowest that answers the call again.
+     */
+    getAlwaysAllowOptions: (toolInvocationId: string) => Promise<AlwaysAllowOptionsDTO | null>;
+    /**
+     * Explain a call awaiting approval (risk level, what it does, why, what could
+     * go wrong). A model generates it the first time it is asked for; later calls
+     * return the kept answer. Call it only when the person asks.
+     */
+    explainTool: (toolInvocationId: string) => Promise<ToolExplanationDTO>;
+    /**
+     * Always allow a call: save the chosen option's chat rules (`{ option: key }`
+     * from getAlwaysAllowOptions) and approve the call once. Without an option the
+     * api saves its default. A string is accepted from older callers (it was the
+     * tool name) and means the default. Rejects with a 409 when the option is
+     * stale: read the options again.
+     */
+    alwaysAllowTool: (toolInvocationId: string, choice?: AlwaysAllowChoice | string) => Promise<AlwaysAllowResultDTO | undefined>;
+    /** Change this chat's settings, e.g. allow_all_tools (switching it on approves the calls waiting) */
+    updateChatSettings: (settings: ChatSettingsRequest) => Promise<void>;
+    /** Hand this chat to another agent (namespace/name); the next message goes to it. Agents our loop runs only. */
+    switchAgent: (agentRef: string) => Promise<void>;
     /** Cancel a queued message before the agent processes it */
     cancelMessage: (messageId: string) => Promise<void>;
     /** Resolve an interrupt gate (allow or deny) */

package/dist/types.d.ts

@@ -552,6 +552,18 @@ export interface MeResponse {
      */
     team_view?: TeamViewDTO;
     diagnostics?: DiagnosticsConfig;
+    /**
+     * PersonalTeamID is the caller's personal workspace, empty for a managed
+     * account, which has none.
+     */
+    personal_team_id?: string;
+    /**
+     * NeedsUsername: the caller has not chosen a username yet (their
+     * personal workspace's setup is incomplete). Every new account picks one
+     * before landing, whichever team it lands in (an invite's included), via
+     * POST /teams/{personal_team_id}/complete-setup.
+     */
+    needs_username: boolean;
 }
 export interface TeamCreateRequest {
     name: string;
@@ -666,6 +678,11 @@ export interface CreateApiKeyRequest {
     name: string;
     expires_at?: string;
     scopes?: string[];
+    /**
+     * Scope is who the key acts as. Empty means user (a personal key);
+     * workspace requires manage_keys.
+     */
+    scope?: ApiKeyScope;
 }
 /**
  * EstimateCostRequest is the request for POST /store/apps/{appId}/estimate.
@@ -1042,10 +1059,24 @@ export interface ScopePreset {
 export interface ApiKeyDTO extends BaseModelDTO, PermissionModelDTO {
     name: string;
     key: string;
-    last_used_at: string;
+    /**
+     * LastUsedAt is absent for a key that has never been used.
+     */
+    last_used_at?: string;
     expires_at?: string;
     scopes: Scope[];
     source?: string;
+    /**
+     * Scope is who the key acts as: its creator (user) or the workspace.
+     */
+    scope: ApiKeyScope;
+    /**
+     * CreatedBy is the person who created the key; Creator is that person,
+     * set on lists. On a workspace key user_id is the workspace's service
+     * account, so these are what show who made it.
+     */
+    created_by: string;
+    creator?: TeamMemberUserDTO;
 }
 /**
  * AppPricing configures all pricing using CEL expressions.
@@ -1716,6 +1747,36 @@ export interface SubmitBountyResponse {
     submission: BountySubmissionDTO;
     granted_amount?: number;
 }
+/**
+ * ChatSettingsRequest changes a chat's settings. A field left out is left as
+ * it is.
+ */
+export interface ChatSettingsRequest {
+    /**
+     * Name renames the chat. It cannot be empty.
+     */
+    name?: string;
+    /**
+     * Visibility is who can open the chat: private (only you), team (your
+     * workspace) or public (anyone with the link).
+     */
+    visibility?: Visibility;
+    /**
+     * AllowAllTools runs every tool call without asking. Switching it on also
+     * approves the calls already waiting.
+     */
+    allow_all_tools?: boolean;
+    /**
+     * DisableHooks stops the agent's lifecycle hooks (suggest, learn,
+     * webhooks, gates) firing in this chat.
+     */
+    disable_hooks?: boolean;
+    /**
+     * ForgetMemory removes these keys from the chat's memory, the notes the
+     * agent keeps for this conversation. A key that is not there is ignored.
+     */
+    forget_memory?: string[];
+}
 /**
  * ChatDTO for API responses
  */
@@ -1773,6 +1834,189 @@ export interface ChatMessageDTO extends BaseModelDTO, PermissionModelDTO {
     tool_call_id?: string;
     tool_invocations?: ToolInvocationDTO[];
 }
+/**
+ * PolicyEffect is a rule's outcome: allow, ask or deny.
+ */
+export type PolicyEffect = "allow" | "ask" | "deny";
+export declare const PolicyEffectAllow: PolicyEffect;
+export declare const PolicyEffectAsk: PolicyEffect;
+export declare const PolicyEffectDeny: PolicyEffect;
+/**
+ * PolicyRuleDTO is one rule, typed form Kind[selector](specifier).
+ */
+export interface PolicyRuleDTO {
+    id: string;
+    effect: PolicyEffect;
+    /**
+     * Kind: RemoteExec, Workspace, Harness, Tool (and, from phase 3, App,
+     * Agent, Knowledge, Mcp, Flow, WebFetch).
+     */
+    kind: string;
+    /**
+     * Selector narrows the rule to one remote (its id) or a tag (tag:<name>);
+     * empty applies everywhere.
+     */
+    selector: string;
+    /**
+     * Specifier is the kind's pattern: a command (`npm test`, `git push:*`),
+     * a folder (`~/proj/**`), a harness tool with its pattern
+     * (`Bash(git status:*)`, `Edit`), or a loop tool's name. Empty is the
+     * whole kind.
+     */
+    specifier: string;
+    /**
+     * Label is the rule in words, e.g. "git commit commands on Laptop", the
+     * same words an approval prompt's "always allow" options use.
+     */
+    label: string;
+    /**
+     * CreatedAt is null for a rule that is not a stored row yet: an entry of
+     * the chat's always-allow list from before rules existed, or the chat's
+     * "allow every tool" setting.
+     */
+    created_at?: string;
+    /**
+     * CreatedBy is the user who wrote the rule; empty for those above.
+     */
+    created_by: string;
+}
+/**
+ * AlwaysAllowScope is how far an "always allow" option reaches, narrowest
+ * first.
+ */
+export type AlwaysAllowScope = "exact" | "prefix" | "folder" | "remote" | "tool";
+/**
+ * AlwaysAllowScopeExact: this call exactly (each piece of the command,
+ * the file, the domain).
+ */
+export declare const AlwaysAllowScopeExact: AlwaysAllowScope;
+/**
+ * AlwaysAllowScopePrefix: commands that start the same way, per piece
+ * (git commit:*, npm run:*).
+ */
+export declare const AlwaysAllowScopePrefix: AlwaysAllowScope;
+/**
+ * AlwaysAllowScopeFolder: files in the same folder.
+ */
+export declare const AlwaysAllowScopeFolder: AlwaysAllowScope;
+/**
+ * AlwaysAllowScopeRemote: every command on the machine.
+ */
+export declare const AlwaysAllowScopeRemote: AlwaysAllowScope;
+/**
+ * AlwaysAllowScopeTool: every call of the tool.
+ */
+export declare const AlwaysAllowScopeTool: AlwaysAllowScope;
+/**
+ * AlwaysAllowOptionDTO is one "always allow" choice on an approval prompt:
+ * the chat rules it saves.
+ */
+export interface AlwaysAllowOptionDTO {
+    /**
+     * Key names the option in POST .../always-allow. It changes when the
+     * rules it stands for change.
+     */
+    key: string;
+    scope: AlwaysAllowScope;
+    /**
+     * Label is the option in words, e.g. "git clone commands on Laptop".
+     */
+    label: string;
+    /**
+     * Description adds why a broad option is the narrowest offered, e.g.
+     * the command uses shell syntax no narrower rule can match.
+     */
+    description?: string;
+    /**
+     * Rules are the chat rules the option saves (not stored yet: no id).
+     */
+    rules: PolicyRuleDTO[];
+}
+/**
+ * AlwaysAllowOptionsDTO is GET /chats/{id}/tools/{toolId}/always-allow/options:
+ * the options for a call awaiting approval, narrowest first. Each one,
+ * saved, answers this call again. Computed by the api from the call; the
+ * client never builds rules.
+ */
+export interface AlwaysAllowOptionsDTO {
+    options: AlwaysAllowOptionDTO[];
+    /**
+     * Default is the key of the narrowest option, "" when there is none.
+     */
+    default?: string;
+    /**
+     * Unavailable says why there are no options: a policy allows only its
+     * own rules, or no chat rule could allow this call.
+     */
+    unavailable?: string;
+}
+/**
+ * AlwaysAllowRequest is POST /chats/{id}/tools/{toolId}/always-allow. The
+ * api saves the option's rules to the chat and approves the call once.
+ */
+export interface AlwaysAllowRequest {
+    /**
+     * Option is an option key from the options endpoint. A key that no
+     * longer names a current option is refused (409). Without one, the
+     * call saves what "always allow" saved before options existed: the
+     * command's pieces exactly for remote_exec, the whole tool otherwise.
+     */
+    option?: string;
+    /**
+     * ToolName is accepted from older clients and ignored: the call names
+     * its own tool.
+     */
+    tool_name?: string;
+}
+/**
+ * AlwaysAllowResultDTO is what an always-allow saved.
+ */
+export interface AlwaysAllowResultDTO {
+    /**
+     * Option is the option chosen; null for a call without one.
+     */
+    option?: AlwaysAllowOptionDTO;
+    /**
+     * Rules are the chat rules now in place for it.
+     */
+    rules: PolicyRuleDTO[];
+}
+/**
+ * ToolRiskLevel is how risky an explained call is.
+ */
+export type ToolRiskLevel = "low" | "medium" | "high";
+/**
+ * ToolRiskLow: safe development workflows (reads, builds, tests).
+ */
+export declare const ToolRiskLow: ToolRiskLevel;
+/**
+ * ToolRiskMedium: changes that can be undone.
+ */
+export declare const ToolRiskMedium: ToolRiskLevel;
+/**
+ * ToolRiskHigh: dangerous or irreversible changes.
+ */
+export declare const ToolRiskHigh: ToolRiskLevel;
+/**
+ * ToolExplanationDTO is POST /chats/{id}/tools/{toolId}/explain: a model's
+ * plain-words reading of a call awaiting approval (Claude Code's permission
+ * explainer). Generated once, when the person asks, and kept for the call.
+ */
+export interface ToolExplanationDTO {
+    risk_level: ToolRiskLevel;
+    /**
+     * Explanation is what the call does, in one or two sentences.
+     */
+    explanation: string;
+    /**
+     * Reasoning is why the agent appears to be making it.
+     */
+    reasoning: string;
+    /**
+     * Risk is what could go wrong, in a few words.
+     */
+    risk: string;
+}
 /**
  * CredentialDTO is the API response for a credential (never exposes secrets).
  */
@@ -2069,7 +2313,7 @@ export interface EntitlementErrorMeta {
  * and APIError.Code on the legacy envelope. Clients branch on these, so a
  * code is a named const here, where it generates into models and the SDKs.
  */
-export type ErrorCode = "invalid_request" | "validation_error" | "unauthorized" | "forbidden" | "not_found" | "conflict" | "name_conflict" | "already_exists" | "not_configured" | "method_not_allowed" | "rate_limited" | "internal_error" | "team_role_required" | "blocked_by_usage_policy" | "otp_required" | "mcp_auth_expired" | "limit_exceeded" | "feature_not_available" | "entitlement_unavailable" | "payment_required" | "payment_method_required" | "agents_disabled" | "remote_offline" | "remote_timeout" | "harness_not_drivable" | "harness_too_old";
+export type ErrorCode = "invalid_request" | "validation_error" | "unauthorized" | "forbidden" | "not_found" | "conflict" | "name_conflict" | "already_exists" | "not_configured" | "method_not_allowed" | "rate_limited" | "internal_error" | "team_role_required" | "blocked_by_usage_policy" | "last_owner" | "account_deactivated" | "account_banned" | "person_required" | "otp_required" | "mcp_auth_expired" | "limit_exceeded" | "feature_not_available" | "entitlement_unavailable" | "payment_required" | "payment_method_required" | "agents_disabled" | "remote_offline" | "remote_timeout" | "harness_not_drivable" | "harness_too_old";
 export declare const ErrorCodeInvalidRequest: ErrorCode;
 export declare const ErrorCodeValidationError: ErrorCode;
 export declare const ErrorCodeUnauthorized: ErrorCode;
@@ -2093,6 +2337,25 @@ export declare const ErrorCodeTeamRoleRequired: ErrorCode;
  * usage policy. The message names who to ask.
  */
 export declare const ErrorCodeBlockedByUsagePolicy: ErrorCode;
+/**
+ * ErrorCodeLastOwner (400): the change would leave a team (or an org's
+ * workspace) without an owner.
+ */
+export declare const ErrorCodeLastOwner: ErrorCode;
+/**
+ * ErrorCodeAccountDeactivated (403): an org deactivated this managed
+ * account; sign-in and every request are refused until an org admin
+ * reactivates it. ErrorCodeAccountBanned (403): the platform suspended
+ * the account.
+ */
+export declare const ErrorCodeAccountDeactivated: ErrorCode;
+export declare const ErrorCodeAccountBanned: ErrorCode;
+/**
+ * ErrorCodePersonRequired (403): only a person may do this, and the
+ * caller is a workspace's service account (a workspace API key), or the
+ * account is one and cannot sign in.
+ */
+export declare const ErrorCodePersonRequired: ErrorCode;
 export declare const ErrorCodeOTPRequired: ErrorCode;
 export declare const ErrorCodeMCPAuthExpired: ErrorCode;
 /**
@@ -2529,6 +2792,11 @@ export interface InstanceTypeDTO extends BaseModelDTO, PermissionModelDTO {
      * for this rental type. Empty on the raw catalog.
      */
     rental_type?: InstanceRentalType;
+    /**
+     * Options lists every in-stock provider for an engine-picker offer,
+     * cheapest first; the offer itself is the first one. Empty on the raw catalog.
+     */
+    options?: InstanceTypeOptionDTO[];
     configuration?: InstanceTypeConfiguration;
     availability: InstanceTypeAvailability[];
     boot_time?: InstanceTypeBootTime;
@@ -2554,6 +2822,28 @@ export interface InstanceTypeAvailability {
      */
     hourly_price?: number;
 }
+/**
+ * InstanceTypeOptionDTO is one launchable provider behind an engine-picker
+ * offer. Launch with its cloud and shade_instance_type, one of its regions and
+ * the offer's rental_type.
+ */
+export interface InstanceTypeOptionDTO {
+    cloud: InstanceCloudProvider;
+    cloud_logo_url?: string;
+    shade_instance_type: string;
+    cloud_instance_type: string;
+    hourly_price: number;
+    configuration?: InstanceTypeConfiguration;
+    regions: InstanceTypeOptionRegion[];
+}
+/**
+ * InstanceTypeOptionRegion is an in-stock region and its hourly price in
+ * cents. Spot prices can differ by region.
+ */
+export interface InstanceTypeOptionRegion {
+    region: string;
+    hourly_price: number;
+}
 export interface InstanceTypeBootTime {
     average_seconds: number;
     updated_at: string;
@@ -2914,6 +3204,17 @@ export interface MCPServerDTO {
     auth_type: MCPServerAuthType;
     oauth_client_id?: string;
     default_scopes: StringSlice;
+    /**
+     * Headers are static HTTP headers sent on every request to the server,
+     * set by the team's admins (e.g. X-MCP-Toolsets, X-MCP-Readonly).
+     */
+    headers?: {
+        [key: string]: string;
+    };
+    /**
+     * Setup is what the server's directory entry knows about setting it up.
+     */
+    setup?: MCPServerSetup;
     documentation_url: string;
     connection_status?: string;
     /**
@@ -2922,6 +3223,27 @@ export interface MCPServerDTO {
      */
     connection_scope?: CredentialScope;
 }
+/**
+ * MCPServerSetup is what a server's directory entry knows about setting the
+ * server up, as data: shown to whoever connects a server on the same host,
+ * so no server's specifics live in code.
+ */
+export interface MCPServerSetup {
+    /**
+     * ResourceAppID is the id the server's API has at its authorization
+     * server, which an organization must know before it can approve access
+     * (for a Microsoft Entra resource: the application id a tenant needs a
+     * service principal for).
+     */
+    resource_app_id?: string;
+    /**
+     * RecommendedHeaders are the least-privilege static headers the server
+     * documents (e.g. X-MCP-Toolsets), offered by the headers editor.
+     */
+    recommended_headers?: {
+        [key: string]: string;
+    };
+}
 /**
  * NotificationDTO is the data transfer object
  */
@@ -3793,6 +4115,12 @@ export interface TeamDTO extends BaseModelDTO {
      * OrgID of the org this team belongs to ('' = standalone team).
      */
     org_id?: string;
+    /**
+     * OrgName is that org's display name (its workspace's name), set on the
+     * caller's team list (/teams) so a member of one of its teams sees whose
+     * org it is without belonging to the org workspace.
+     */
+    org_name?: string;
     /**
      * UsagePolicyID of the team's own usage policy ('' = inherit the org's,
      * or ungoverned when standalone, INF-808).
@@ -3987,6 +4315,11 @@ export interface UserDTO extends BaseModelDTO {
      * cannot create teams/orgs).
      */
     managed_by_org_id?: string;
+    /**
+     * ServiceTeamID: set on a workspace's service account, the principal its
+     * workspace API keys act as.
+     */
+    service_team_id?: string;
     email: string;
     name: string;
     full_name: string;
@@ -4197,6 +4530,23 @@ export interface A2UISurface {
     components: A2UIComponent[];
     dataModel?: any;
 }
+/**
+ * ApiKeyScope is who an API key acts as, chosen when it is created, the way a
+ * credential's scope says who owns it.
+ */
+export type ApiKeyScope = "user" | "workspace";
+/**
+ * ApiKeyScopeUser is a personal key: it acts as the person who created it,
+ * in the workspace it was created in, and ends when they can no longer
+ * act there. Device-auth, `belt auth token`, OAuth and engine keys are
+ * always personal.
+ */
+export declare const ApiKeyScopeUser: ApiKeyScope;
+/**
+ * ApiKeyScopeWorkspace is a workspace key: it acts as the workspace's
+ * service account, not a person, and outlives the admin who created it.
+ */
+export declare const ApiKeyScopeWorkspace: ApiKeyScope;
 export type AppCategory = "image" | "video" | "audio" | "text" | "chat" | "3d" | "other" | "flow";
 export declare const AppCategoryImage: AppCategory;
 export declare const AppCategoryVideo: AppCategory;
@@ -4330,6 +4680,17 @@ export interface ChatData {
     plan_steps: PlanStep[];
     memory: StringEncodedMap;
     always_allowed_tools: string[];
+    /**
+     * AllowAllTools runs every tool call in this chat without asking. The
+     * person switches it in the chat's settings, and off again at any time.
+     */
+    allow_all_tools: boolean;
+    /**
+     * DisableHooks stops the agent's lifecycle hooks firing in this chat. A
+     * review branch is opened with it set, so a review cannot fire the hook
+     * that reviews it.
+     */
+    disable_hooks?: boolean;
 }
 /**
  * PlanStep represents a step in an agent's execution plan
@@ -5326,11 +5687,24 @@ export declare const TeamKindOrg: TeamKind;
  * TeamCapability is one thing a caller may do to a team's settings. The set is
  * closed; team.Subject.Can is the only place that grants them.
  */
-export type TeamCapability = "edit_profile" | "manage_members" | "view_members" | "manage_keys" | "manage_vault" | "view_billing" | "manage_billing" | "view_policy" | "manage_policy" | "manage_org" | "manage_sso" | "archive" | "create_team" | "create_org" | "connect_org_credential" | "connect_platform_credential";
+export type TeamCapability = "edit_profile" | "manage_members" | "manage_admins" | "view_members" | "manage_keys" | "create_keys" | "manage_vault" | "view_billing" | "manage_billing" | "view_policy" | "manage_policy" | "manage_org" | "manage_sso" | "archive" | "create_team" | "create_org" | "connect_org_credential" | "connect_platform_credential";
 export declare const TeamCapabilityEditProfile: TeamCapability;
 export declare const TeamCapabilityManageMembers: TeamCapability;
+/**
+ * ManageAdmins: granting, changing and removing the admin and owner
+ * roles. Owners only; admins manage plain members.
+ */
+export declare const TeamCapabilityManageAdmins: TeamCapability;
 export declare const TeamCapabilityViewMembers: TeamCapability;
+/**
+ * ManageKeys: the workspace's keys. Creating workspace keys, and listing
+ * and revoking every key of the workspace, whoever created it.
+ */
 export declare const TeamCapabilityManageKeys: TeamCapability;
+/**
+ * CreateKeys: creating, listing and revoking your own personal keys.
+ */
+export declare const TeamCapabilityCreateKeys: TeamCapability;
 export declare const TeamCapabilityManageVault: TeamCapability;
 export declare const TeamCapabilityViewBilling: TeamCapability;
 export declare const TeamCapabilityManageBilling: TeamCapability;

package/dist/types.js

@@ -302,6 +302,43 @@ export const ScopeGroupKnowledge = "knowledge";
 export const ScopeGroupArtifacts = "artifacts";
 export const ScopeGroupUser = "user";
 export const ScopeGroupSettings = "settings";
+export const PolicyEffectAllow = "allow";
+export const PolicyEffectAsk = "ask";
+export const PolicyEffectDeny = "deny";
+/**
+ * AlwaysAllowScopeExact: this call exactly (each piece of the command,
+ * the file, the domain).
+ */
+export const AlwaysAllowScopeExact = "exact";
+/**
+ * AlwaysAllowScopePrefix: commands that start the same way, per piece
+ * (git commit:*, npm run:*).
+ */
+export const AlwaysAllowScopePrefix = "prefix";
+/**
+ * AlwaysAllowScopeFolder: files in the same folder.
+ */
+export const AlwaysAllowScopeFolder = "folder";
+/**
+ * AlwaysAllowScopeRemote: every command on the machine.
+ */
+export const AlwaysAllowScopeRemote = "remote";
+/**
+ * AlwaysAllowScopeTool: every call of the tool.
+ */
+export const AlwaysAllowScopeTool = "tool";
+/**
+ * ToolRiskLow: safe development workflows (reads, builds, tests).
+ */
+export const ToolRiskLow = "low";
+/**
+ * ToolRiskMedium: changes that can be undone.
+ */
+export const ToolRiskMedium = "medium";
+/**
+ * ToolRiskHigh: dangerous or irreversible changes.
+ */
+export const ToolRiskHigh = "high";
 export const ErrorCodeInvalidRequest = "invalid_request";
 export const ErrorCodeValidationError = "validation_error";
 export const ErrorCodeUnauthorized = "unauthorized";
@@ -325,6 +362,25 @@ export const ErrorCodeTeamRoleRequired = "team_role_required";
  * usage policy. The message names who to ask.
  */
 export const ErrorCodeBlockedByUsagePolicy = "blocked_by_usage_policy";
+/**
+ * ErrorCodeLastOwner (400): the change would leave a team (or an org's
+ * workspace) without an owner.
+ */
+export const ErrorCodeLastOwner = "last_owner";
+/**
+ * ErrorCodeAccountDeactivated (403): an org deactivated this managed
+ * account; sign-in and every request are refused until an org admin
+ * reactivates it. ErrorCodeAccountBanned (403): the platform suspended
+ * the account.
+ */
+export const ErrorCodeAccountDeactivated = "account_deactivated";
+export const ErrorCodeAccountBanned = "account_banned";
+/**
+ * ErrorCodePersonRequired (403): only a person may do this, and the
+ * caller is a workspace's service account (a workspace API key), or the
+ * account is one and cannot sign in.
+ */
+export const ErrorCodePersonRequired = "person_required";
 export const ErrorCodeOTPRequired = "otp_required";
 export const ErrorCodeMCPAuthExpired = "mcp_auth_expired";
 /**
@@ -500,6 +556,18 @@ export const A2UIForm = "Form";
  * the viewer. Rendered from the artifact's /render endpoint.
  */
 export const A2UIArtifact = "Artifact";
+/**
+ * ApiKeyScopeUser is a personal key: it acts as the person who created it,
+ * in the workspace it was created in, and ends when they can no longer
+ * act there. Device-auth, `belt auth token`, OAuth and engine keys are
+ * always personal.
+ */
+export const ApiKeyScopeUser = "user";
+/**
+ * ApiKeyScopeWorkspace is a workspace key: it acts as the workspace's
+ * service account, not a person, and outlives the admin who created it.
+ */
+export const ApiKeyScopeWorkspace = "workspace";
 export const AppCategoryImage = "image";
 export const AppCategoryVideo = "video";
 export const AppCategoryAudio = "audio";
@@ -1094,8 +1162,21 @@ export const TeamKindOrgMember = "org_member";
 export const TeamKindOrg = "org";
 export const TeamCapabilityEditProfile = "edit_profile";
 export const TeamCapabilityManageMembers = "manage_members";
+/**
+ * ManageAdmins: granting, changing and removing the admin and owner
+ * roles. Owners only; admins manage plain members.
+ */
+export const TeamCapabilityManageAdmins = "manage_admins";
 export const TeamCapabilityViewMembers = "view_members";
+/**
+ * ManageKeys: the workspace's keys. Creating workspace keys, and listing
+ * and revoking every key of the workspace, whoever created it.
+ */
 export const TeamCapabilityManageKeys = "manage_keys";
+/**
+ * CreateKeys: creating, listing and revoking your own personal keys.
+ */
+export const TeamCapabilityCreateKeys = "create_keys";
 export const TeamCapabilityManageVault = "manage_vault";
 export const TeamCapabilityViewBilling = "view_billing";
 export const TeamCapabilityManageBilling = "manage_billing";

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.14.2",
+  "version": "0.16.0",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "inference-src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./proxy": {
@@ -28,8 +28,8 @@
       "default": "./dist/proxy/hono.js"
     },
     "./proxy/remix": {
-      "types": "./dist/proxy/remix.d.ts",
       "inference-src": "./src/proxy/remix.ts",
+      "types": "./dist/proxy/remix.d.ts",
       "default": "./dist/proxy/remix.js"
     },
     "./proxy/svelte": {
@@ -37,13 +37,13 @@
       "default": "./dist/proxy/svelte.js"
     },
     "./agent": {
-      "types": "./dist/agent/index.d.ts",
       "inference-src": "./src/agent/index.ts",
+      "types": "./dist/agent/index.d.ts",
       "default": "./dist/agent/index.js"
     },
     "./internal/upload": {
-      "types": "./dist/api/files.d.ts",
       "inference-src": "./src/api/files.ts",
+      "types": "./dist/api/files.d.ts",
       "default": "./dist/api/files.js"
     }
   },