@inferencesh/sdk 0.29.1 → 0.31.0

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.30.0] - 2026-10-18
+
+### Removed
+- `credentialId` on `httpTool().auth()` and `mcpTool()`, and the positional `mcpTool(name, credentialId, toolName)`: a tool no longer pins a connection. Credential-auth HTTP tools and MCP tools always sign in with the caller's own login to the provider at run time; `mcpTool(name, { server, toolName })` requires `server` (INF-1012). Generated types: `ToolAuthConfig`, `MCPToolConfig` and `MCPToolConfigDTO` lose `credential_id`.
+
 ## [0.29.0] - 2026-10-17
 
 ### Removed

package/README.md

@@ -377,7 +377,7 @@ Use the fluent builders to define `AgentTool` schemas. Client tools (`tool`) run
 | `agentTool(name, agentRef)` | Server | Delegate to a sub-agent |
 | `httpTool(name, url)` / `callTool(name, url)` | Server | HTTP request with credential injection (preferred over `webhookTool`) |
 | `webhookTool(name, url)` | Server | Unsigned webhook (legacy; use `httpTool` for new tools) |
-| `mcpTool(name, { server, toolName, credentialId? })` | Server | Call a tool on an MCP server (by slug), signed in through the server's provider; `credentialId` pins one connection. `mcpTool(name, credentialId, toolName)` still works and is saved with the connection's server |
+| `mcpTool(name, { server, toolName })` | Server | Call a tool on an MCP server (by slug), signed in with the runner's own connection to the server's provider |
 | `internalTools()` | Server | Built-in tools: plan, memory, widget, finish, skills, meta, remote, knowledge, artifact, agent |
 
 ```typescript
@@ -401,7 +401,7 @@ const clientTool = tool('get_weather')
 const gmailSend = httpTool('gmail_send', 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send')
   .describe('Send an email via Gmail')
   .method('POST')
-  .auth({ credential: CredentialProviderGoogle, credentialId: 'your-credential-id' })
+  .auth({ credential: CredentialProviderGoogle })
   .build();
 
 // API key or bearer auth

package/dist/index.d.ts

@@ -36,8 +36,8 @@ export type { ClientTool, ClientToolHandler, ClientToolResult } from './tool-bui
 export { lifecycleHook, learningHooks } from './hook-builder.js';
 export type { LifecycleHookBuilder } from './hook-builder.js';
 export { DeltaAccumulator, createLLMDeltaAccumulator, type DeltaEvent, type FieldTags, type FieldTagsRegistry } from './delta.js';
-export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, heldTurn, } from './utils.js';
-export type { PendingApproval, HeldTurn } from './utils.js';
+export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, heldTurn, pendingWait, } from './utils.js';
+export type { PendingApproval, HeldTurn, PendingWait } from './utils.js';
 export * from './types.js';
 export type { TaskDTO as Task } from './types.js';
 import { HttpClient, type HttpClientConfig } from './http/client.js';

package/dist/index.js

@@ -38,7 +38,7 @@ export { lifecycleHook, learningHooks } from './hook-builder.js';
 // Delta accumulator for streaming responses
 export { DeltaAccumulator, createLLMDeltaAccumulator } from './delta.js';
 // Status utilities (handle both int and string status values)
-export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, heldTurn, } from './utils.js';
+export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, heldTurn, pendingWait, } from './utils.js';
 // Types - includes TaskStatus constants and all DTOs
 export * from './types.js';
 // =============================================================================

package/dist/tool-builder.d.ts

@@ -100,13 +100,12 @@ declare class HTTPToolBuilder extends ToolBuilder {
     constructor(name: string, url: string);
     method(m: string): this;
     /**
-     * How the tool authenticates: `credential` sends a connected account's
-     * access token (pick the account with `credentialId`), `apiKey` / `bearer`
-     * send a vault secret.
+     * How the tool authenticates: `credential` sends the access token of the
+     * runner's own connection to that provider, `apiKey` / `bearer` send a
+     * vault secret.
      */
     auth(config: {
         credential?: string;
-        credentialId?: string;
         apiKey?: string;
         bearer?: string;
         header?: string;
@@ -131,24 +130,15 @@ export interface MCPToolTarget {
     /** The MCP server's slug (a workspace registration or a directory entry). */
     server: string;
     toolName: string;
-    /** Pins one connection to the server's provider; by default the runner's own is used. */
-    credentialId?: string;
 }
 /**
  * Create an MCP tool: `toolName` on the MCP server `target.server` (its slug).
- * The call signs in with the runner's connection to the server's provider;
- * `credentialId` pins one connection instead.
- *
- * The older form `mcpTool(name, credentialId, toolName)` (a string second
- * argument) still works: a tool naming only a connection is saved with the
- * server that connection's provider is declared by.
+ * The call signs in with the runner's own connection to the server's provider.
  */
-export declare function mcpTool(name: string, target: MCPToolTarget | string, toolName?: string): MCPToolBuilder;
+export declare function mcpTool(name: string, target: MCPToolTarget): MCPToolBuilder;
 declare class MCPToolBuilder extends ToolBuilder {
     private target;
-    constructor(name: string, target: Partial<MCPToolTarget> & {
-        toolName: string;
-    });
+    constructor(name: string, target: MCPToolTarget);
     build(): AgentTool;
 }
 declare class InternalToolsBuilder {

package/dist/tool-builder.js

@@ -184,13 +184,13 @@ class HTTPToolBuilder extends ToolBuilder {
         return this;
     }
     /**
-     * How the tool authenticates: `credential` sends a connected account's
-     * access token (pick the account with `credentialId`), `apiKey` / `bearer`
-     * send a vault secret.
+     * How the tool authenticates: `credential` sends the access token of the
+     * runner's own connection to that provider, `apiKey` / `bearer` send a
+     * vault secret.
      */
     auth(config) {
         if (config.credential) {
-            this.authConfig = { type: ToolAuthTypeCredential, provider: config.credential, credential_id: config.credentialId };
+            this.authConfig = { type: ToolAuthTypeCredential, provider: config.credential };
         }
         else if (config.apiKey) {
             this.authConfig = { type: ToolAuthTypeAPIKey, secret: config.apiKey, header: config.header || 'X-API-Key' };
@@ -238,17 +238,9 @@ export const httpTool = (name, url) => new HTTPToolBuilder(name, url);
 export const callTool = (name, url) => new HTTPToolBuilder(name, url);
 /**
  * Create an MCP tool: `toolName` on the MCP server `target.server` (its slug).
- * The call signs in with the runner's connection to the server's provider;
- * `credentialId` pins one connection instead.
- *
- * The older form `mcpTool(name, credentialId, toolName)` (a string second
- * argument) still works: a tool naming only a connection is saved with the
- * server that connection's provider is declared by.
+ * The call signs in with the runner's own connection to the server's provider.
  */
-export function mcpTool(name, target, toolName) {
-    if (typeof target === 'string') {
-        return new MCPToolBuilder(name, { toolName: toolName ?? '', credentialId: target });
-    }
+export function mcpTool(name, target) {
     return new MCPToolBuilder(name, target);
 }
 class MCPToolBuilder extends ToolBuilder {
@@ -264,9 +256,8 @@ class MCPToolBuilder extends ToolBuilder {
             type: ToolTypeMCP,
             require_approval: this.approval || undefined,
             mcp: {
+                server: this.target.server,
                 tool_name: this.target.toolName,
-                ...(this.target.server ? { server: this.target.server } : {}),
-                ...(this.target.credentialId ? { credential_id: this.target.credentialId } : {}),
             },
         };
     }

package/dist/types.d.ts

@@ -17,6 +17,7 @@ export interface InternalToolsConfig {
     agent?: boolean;
     remote?: boolean;
     knowledge?: boolean;
+    wait?: boolean;
 }
 /**
  * AgentPermissions is what an agent's new chats in its own workspace may do
@@ -43,6 +44,11 @@ export interface AgentTool {
     description: string;
     type: ToolType;
     require_approval?: boolean;
+    /**
+     * ApprovalTimeout is how many seconds a call of this tool waits for its
+     * approval before it is refused. 0 waits until someone answers.
+     */
+    approval_timeout?: number;
     app?: AppToolConfig;
     agent?: AgentToolConfig;
     hook?: HookToolConfig;
@@ -97,6 +103,7 @@ export interface AgentToolDTO {
     description: string;
     type: ToolType;
     require_approval?: boolean;
+    approval_timeout?: number;
     app?: AppToolConfigDTO;
     agent?: AgentToolConfigDTO;
     hook?: HookToolConfigDTO;
@@ -172,7 +179,6 @@ export declare const ToolAuthTypeBearer: ToolAuthType;
 export interface ToolAuthConfig {
     type: ToolAuthType;
     provider?: string;
-    credential_id?: string;
     secret?: string;
     header?: string;
 }
@@ -203,15 +209,12 @@ export interface HTTPToolConfig {
 /**
  * MCPToolConfig is a tool of an MCP server: the server by its slug (the
  * agent's team's registration, its org's or the directory's) and the tool
- * to call. CredentialID pins the connection the call signs in with; without
- * it the runner's connection to the server's provider is used. A tool
- * written with only a connection is saved with the server that
- * connection's provider is declared by.
+ * to call. Each call signs in with the runner's connection to the
+ * server's provider (Credential.ToolConnection).
  */
 export interface MCPToolConfig {
     server?: string;
     tool_name: string;
-    credential_id?: string;
 }
 export interface AppToolConfigDTO {
     ref: string;
@@ -264,7 +267,6 @@ export interface HTTPToolConfigDTO {
 export interface MCPToolConfigDTO {
     server: string;
     tool_name: string;
-    credential_id?: string;
 }
 /**
  * CoreAppConfigDTO references an app used as the agent's core
@@ -6716,6 +6718,13 @@ export declare const GraphEdgeTypeOutput: GraphEdgeType;
  * allow starts the turn, a deny ends the run.
  */
 export declare const InterruptResourceTurn: InterruptResourceType;
+/**
+ * InterruptReasonWait is a tool call the agent made to wait: the run is
+ * paused until the interrupt's deadline, when its own expiry trigger settles
+ * it (allow), or until a person ends the wait sooner. Its resource is the
+ * wait call (InterruptResourceToolInvocation).
+ */
+export declare const InterruptReasonWait: InterruptReason;
 /**
  * MergeStrategy defines how a delta field should be merged by consumers.
  */
@@ -7846,7 +7855,7 @@ export declare const AgentRunStateRejected: AgentRunState;
  * InterruptReason describes why an agent run is in an interrupted state.
  * Aligns with AG-UI interrupt outcome reasons.
  */
-export type InterruptReason = "tool_approval" | "client_tool" | "widget" | "auth" | "confirmation" | "hook_gate";
+export type InterruptReason = "wait" | "tool_approval" | "client_tool" | "widget" | "auth" | "confirmation" | "hook_gate";
 export declare const InterruptReasonToolApproval: InterruptReason;
 export declare const InterruptReasonClientTool: InterruptReason;
 export declare const InterruptReasonWidget: InterruptReason;

package/dist/types.js

@@ -992,6 +992,13 @@ export const GraphEdgeTypeOutput = "output";
  * allow starts the turn, a deny ends the run.
  */
 export const InterruptResourceTurn = "turn";
+/**
+ * InterruptReasonWait is a tool call the agent made to wait: the run is
+ * paused until the interrupt's deadline, when its own expiry trigger settles
+ * it (allow), or until a person ends the wait sooner. Its resource is the
+ * wait call (InterruptResourceToolInvocation).
+ */
+export const InterruptReasonWait = "wait";
 export const MergeStrategyConcat = "concat";
 export const MergeStrategyReplace = "replace";
 export const MergeStrategyIndexed = "indexed";

package/dist/utils.d.ts

@@ -49,3 +49,14 @@ export type HeldTurn = {
 };
 /** The held turn among a run's pending interrupts, if one is held. */
 export declare function heldTurn(interrupts: InterruptDTO[] | null | undefined): HeldTurn | null;
+/** A run paused by its agent's wait tool (InterruptReasonWait): it continues at `until`, or sooner when the person ends the wait ("continue now", allow) or cancels it (deny). */
+export type PendingWait = {
+    interruptId: string;
+    runId: string;
+    /** When the wait ends, RFC3339; null when the api gives no deadline. */
+    until: string | null;
+    /** What the agent said it will do when the wait ends. */
+    note: string;
+};
+/** The wait among a run's pending interrupts, if the run is waiting. */
+export declare function pendingWait(interrupts: InterruptDTO[] | null | undefined): PendingWait | null;

package/dist/utils.js

@@ -2,7 +2,7 @@
  * Status utilities for handling both int and string-based status values.
  * Provides future compatibility when API migrates from int to string status.
  */
-import { InterruptReasonToolApproval, InterruptResourceTurn, InterruptStatusPending } from './types.js';
+import { InterruptReasonToolApproval, InterruptReasonWait, InterruptResourceTurn, InterruptStatusPending } from './types.js';
 import { TaskStatusUnknown, TaskStatusReceived, TaskStatusQueued, TaskStatusDispatched, TaskStatusPreparing, TaskStatusServing, TaskStatusSettingUp, TaskStatusRunning, TaskStatusCancelling, TaskStatusUploading, TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, TaskStatusRejected, AgentRunStateWorking, AgentRunStateSubmitted, AgentRunStateInputRequired, AgentRunStateAuthRequired, AgentRunStateCompleted, AgentRunStateFailed, AgentRunStateCanceled, AgentRunStateRejected, ChatMessageStatusReady, ChatMessageStatusFailed, ChatMessageStatusCancelled, ChatStatusBusy, ChatStatusAwaitingInput, } from './types.js';
 /** Map string status names to TaskStatus values (for future string-based API) */
 const STATUS_STRING_MAP = {
@@ -117,11 +117,23 @@ export function pendingApprovals(chat) {
     }
     return out;
 }
+/** The first pending interrupt among a run's that matches. */
+function pendingInterrupt(interrupts, match) {
+    return interrupts?.find(i => i.status === InterruptStatusPending && match(i));
+}
 /** The held turn among a run's pending interrupts, if one is held. */
 export function heldTurn(interrupts) {
-    const interrupt = interrupts?.find(i => i.resource_type === InterruptResourceTurn && i.status === InterruptStatusPending);
+    const interrupt = pendingInterrupt(interrupts, i => i.resource_type === InterruptResourceTurn);
     if (!interrupt)
         return null;
     const { steps } = parseMeta(interrupt);
     return { interruptId: interrupt.id, runId: interrupt.run_id, steps: typeof steps === 'number' ? steps : null };
 }
+/** The wait among a run's pending interrupts, if the run is waiting. */
+export function pendingWait(interrupts) {
+    const interrupt = pendingInterrupt(interrupts, i => i.reason === InterruptReasonWait);
+    if (!interrupt)
+        return null;
+    const { note } = parseMeta(interrupt);
+    return { interruptId: interrupt.id, runId: interrupt.run_id, until: interrupt.expires_at ?? null, note: typeof note === 'string' ? note : '' };
+}

package/package.json

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