@jangts/agent-core 0.3.5 → 0.5.0

package/dist/esm/support/decorators/pool.d.ts

@@ -1,5 +1,6 @@
 import type { WorkflowNode, AgentWorkflowDefinition } from '../../structs/execution/workflow.js';
 import type { ToolDefinition } from '../../structs/capabilities/tools.js';
+import type { ModelTool } from '../../structs/capabilities/model.js';
 import type { ContextFragmentConfig } from '../../structs/support/context.js';
 /** Registration identity; ids are unique within one kind and namespace. */
 export interface IdentifiedDefinition {
@@ -19,7 +20,7 @@ export declare function registerDefinition(kind: DefinitionKind, definition: Ide
 /** Decorated nodes; ids are unique within each namespace. */
 export declare const nodePool: DefinitionReader<WorkflowNode<any, any, any>>;
 /** Decorated tools; namespaces isolate otherwise identical ids. */
-export declare const toolPool: DefinitionReader<ToolDefinition<any, any, any, string>>;
+export declare const toolPool: DefinitionReader<ModelTool<any, any, any> | ToolDefinition<any, any, any>>;
 /** Decorated fragment configurations; use the original builder to assemble them. */
 export declare const fragmentPool: DefinitionReader<ContextFragmentConfig<any>>;
 /** Decorated workflow definitions; execution still belongs to the original Engine. */
@@ -29,7 +30,7 @@ export declare const agentPool: DefinitionReader<(Omit<import("../../index.js").
     readonly branch?: import("../../index.js").AgentBranch;
     readonly tools?: {
         invoke: (request: import("../../index.js").ToolInvocationRequest) => Promise<import("../../index.js").ToolResult<unknown>>;
-    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ExecutableTool>, "invokeAsync">;
+    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ErasedTool>, "invokeAsync">;
 } & {
     model?: import("../../index.js").AgentModelBinding;
     models?: never;
@@ -42,7 +43,7 @@ export declare const agentPool: DefinitionReader<(Omit<import("../../index.js").
     readonly branch?: import("../../index.js").AgentBranch;
     readonly tools?: {
         invoke: (request: import("../../index.js").ToolInvocationRequest) => Promise<import("../../index.js").ToolResult<unknown>>;
-    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ExecutableTool>, "invokeAsync">;
+    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ErasedTool>, "invokeAsync">;
 } & {
     model?: string;
     models: Readonly<Record<string, import("../../index.js").AgentModelBinding>>;
@@ -56,7 +57,7 @@ export declare const agentPool: DefinitionReader<(Omit<import("../../index.js").
     readonly branch?: import("../../index.js").AgentBranch;
     readonly tools?: {
         invoke: (request: import("../../index.js").ToolInvocationRequest) => Promise<import("../../index.js").ToolResult<unknown>>;
-    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ExecutableTool>, "invokeAsync">;
+    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ErasedTool>, "invokeAsync">;
 } & {
     model?: import("../../index.js").AgentModelBinding;
     models?: never;
@@ -70,7 +71,7 @@ export declare const agentPool: DefinitionReader<(Omit<import("../../index.js").
     readonly branch?: import("../../index.js").AgentBranch;
     readonly tools?: {
         invoke: (request: import("../../index.js").ToolInvocationRequest) => Promise<import("../../index.js").ToolResult<unknown>>;
-    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ExecutableTool>, "invokeAsync">;
+    } | Pick<import("../../index.js").ToolRegistry<import("../../index.js").ErasedTool>, "invokeAsync">;
 } & {
     model?: string;
     models: Readonly<Record<string, import("../../index.js").AgentModelBinding>>;

package/dist/esm/support/decorators/types.d.ts

@@ -11,7 +11,9 @@ import type { DefinitionBody } from './definition.js';
 /** A node implementation; its public id is supplied by @node. */
 export type Node<State, Result, App = undefined> = DefinitionBody<WorkflowNode<State, Result, App>>;
 /** A tool implementation with the original schema, authorization and execution contracts. */
-export type Tool<Input = unknown, Output = unknown, App = unknown> = DefinitionBody<ToolDefinition<Input, Output, App>>;
+export type Tool<Input = unknown, Output = unknown, App = unknown> = DefinitionBody<Omit<ToolDefinition<Input, Output, App>, 'asIntent'>> & {
+    readonly asIntent?: never;
+};
 /** A formatter and its original provenance, trust and budget configuration. */
 export type Fragment<Input = unknown> = DefinitionBody<ContextFragmentConfig<Input>>;
 /** A complete graph definition whose workflow id is supplied by @workflow. */

package/dist/esm/support/index.d.ts

@@ -21,3 +21,4 @@ export type { ReplyPreviewRule, ReplyPreviewOptions } from './model/reply-previe
 export * from './capabilities.js';
 export { retryMultipleModelCalls } from '../model/decision-retry.js';
 export type { RegistrationDefinition } from '../structs/support/registration.js';
+export * from './associations.js';

package/dist/esm/support/index.js

@@ -18,3 +18,4 @@ export { streamEvents } from './stream-events.js';
 export { createReplyPreview } from './model/reply-preview.js';
 export * from './capabilities.js';
 export { retryMultipleModelCalls } from '../model/decision-retry.js';
+export * from './associations.js';

package/dist/esm/support/model/capabilities.d.ts

@@ -1,8 +1,13 @@
-import type { ModelCapabilityRegistration, ModelCapabilityCatalog } from '../../structs/capabilities/model.js';
+import type { ModelToolRegistration, ModelToolCatalog } from '../../structs/capabilities/model.js';
+import type { ToolProposal } from '../../structs/capabilities/model.js';
 /** A sealed typed snapshot. Mutating the original list cannot widen its result contract. */
 type CapabilityOutput<Definition> = Definition extends {
+    execute(...args: any[]): unknown;
+} ? ToolProposal : Definition extends {
     resolve(...args: any[]): infer Output;
-} ? Output : never;
+} ? Output : Definition extends {
+    inputSchema: import('../../structs/common.js').SchemaAdapter<infer Input>;
+} ? Input : never;
 /**
  * Build a sealed capability catalog from typed declarations.
  *
@@ -13,5 +18,5 @@ type CapabilityOutput<Definition> = Definition extends {
  *   unknown ID.
  * @throws {Error} When a resolver is asynchronous.
  */
-export declare function defineModelCapabilities<const Definitions extends readonly ModelCapabilityRegistration[]>(definitions: Definitions): ModelCapabilityCatalog<CapabilityOutput<Definitions[number]>>;
+export declare function defineModelTools<const Definitions extends readonly ModelToolRegistration[]>(definitions: Definitions): ModelToolCatalog<CapabilityOutput<Definitions[number]>>;
 export {};

package/dist/esm/support/model/capabilities.js

@@ -2,13 +2,13 @@
  * Model capability catalog: seal a typed declaration list into a reusable catalog.
  *
  * The catalog is a frozen snapshot, so mutating the original declaration list cannot widen the
- * result type or add capabilities at runtime. Resolution stays inside Core's registry; Support only
+ * result type or add tools at runtime. Resolution stays inside Core's registry; Support only
  * projects the declarations and their output type.
  *
- * Main export: `defineModelCapabilities`.
+ * Main export: `defineModelTools`.
  */
 import { readonlyCatalog } from '../../utils/catalog.js';
-import { ModelCapabilityRegistry } from '../../capabilities/model.js';
+import { ModelToolRegistry } from '../../capabilities/model.js';
 /**
  * Build a sealed capability catalog from typed declarations.
  *
@@ -19,10 +19,40 @@ import { ModelCapabilityRegistry } from '../../capabilities/model.js';
  *   unknown ID.
  * @throws {Error} When a resolver is asynchronous.
  */
-export function defineModelCapabilities(definitions) {
-    const registry = new ModelCapabilityRegistry(definitions).seal();
+export function defineModelTools(definitions) {
+    const registry = new ModelToolRegistry(definitions.map(modelDefinition)).seal();
+    return project(registry);
+}
+/** Executable tools propose raw arguments; business parsing occurs once at execution. */
+function modelDefinition(definition) {
+    const executable = definition;
+    if (typeof executable.execute !== 'function')
+        return definition;
+    if (typeof executable.authorize !== 'function' || typeof executable.parseOutput !== 'function')
+        throw new TypeError('Missing executable tool handler');
+    const id = definition.id;
+    return {
+        id,
+        description: definition.description,
+        active: typeof definition.active === 'function'
+            ? definition.active.bind(definition)
+            : definition.active,
+        asIntent: typeof definition.asIntent === 'function'
+            ? definition.asIntent.bind(definition)
+            : definition.asIntent,
+        inputSchema: {
+            jsonSchema: definition.inputSchema.jsonSchema,
+            parse: (input) => input,
+        },
+        resolve: (input) => ({ toolId: id, input }),
+    };
+}
+/** Project existing immutable entries without re-registering schemas or rebinding handlers. */
+function project(registry) {
     return Object.freeze({
         ...readonlyCatalog(registry.definitions, (id) => new TypeError(`Unknown model capability: ${id}`)),
         resolve: (selection, stage) => registry.resolve(selection, stage),
+        select: (ids, ...context) => project(context.length ? registry.select(ids, context[0]) : registry.select(ids)),
+        withIntent: (context) => project(registry.withIntent(context)),
     });
 }

package/dist/esm/support/model/chat-completions.js

@@ -14,10 +14,19 @@ export function chatCompletionFunctionOptions(options) {
         return {};
     if (!options.functions.length)
         throw new TypeError('Empty model function catalog');
+    if (options.toolChoice !== undefined &&
+        !['auto', 'required', 'none'].includes(options.toolChoice))
+        throw new TypeError('Invalid toolChoice');
+    if (options.parallelToolCalls !== undefined &&
+        options.parallelToolCalls !== 'omit' &&
+        typeof options.parallelToolCalls !== 'boolean')
+        throw new TypeError('Invalid parallelToolCalls');
     return {
         tools: options.functions.map((fn) => ({ type: 'function', function: fn })),
-        tool_choice: 'required',
-        parallel_tool_calls: false,
+        tool_choice: options.toolChoice ?? 'required',
+        ...(options.parallelToolCalls === 'omit'
+            ? {}
+            : { parallel_tool_calls: options.parallelToolCalls ?? false }),
     };
 }
 /**

package/dist/esm/support/model/completion/calls.d.ts

@@ -1,40 +1,12 @@
 /**
- * Tool-call delta aggregation.
+ * Tool-call delta aggregation, re-exported from Core.
  *
- * One algorithm is shared by completion policies and direct callers: fragments are keyed by their
- * provider index, IDs may not conflict, and a complete call requires both an ID and a name. A
- * complete call never hides another started but incomplete one.
+ * The algorithm lives in `model/interactions/calls.ts` so session transports and
+ * completion policies share one implementation. This module keeps the existing
+ * Support import path stable.
  *
  * Exports: `AggregatedToolCall`, `ToolCallCollector`, `ToolCallFailure` and
  * `createToolCallCollector`.
  */
-import type { ModelPart } from '../../../structs/model/messages.js';
-/** One completed native tool call in provider index order. */
-export interface AggregatedToolCall {
-    readonly index: number;
-    readonly id: string;
-    readonly name: string;
-    readonly arguments: string;
-}
-/** Report a protocol violation and stop; callers decide how the failure is classified. */
-export type ToolCallFailure = (message: string) => never;
-/** Aggregation entry point for streamed function-call deltas. */
-export interface ToolCallCollector {
-    /** Feed one part; text parts are ignored and cannot satisfy or break a call. */
-    push(part: ModelPart): void;
-    /** Calls started so far, including incomplete ones, in index order. */
-    readonly calls: readonly AggregatedToolCall[];
-    /**
-     * Finalize the calls.
-     *
-     * @throws When any started call is still missing its ID or name.
-     */
-    complete(): readonly AggregatedToolCall[];
-}
-/**
- * Create a collector for one response.
- *
- * @param fail - Protocol failure factory; defaults to the Core model protocol error.
- * @returns A collector that keeps its own state and never shares it with another response.
- */
-export declare function createToolCallCollector(fail?: ToolCallFailure): ToolCallCollector;
+export { createToolCallCollector } from '../../../model/interactions/calls.js';
+export type { AggregatedToolCall, ToolCallCollector, ToolCallFailure, } from '../../../model/interactions/calls.js';

package/dist/esm/support/model/completion/calls.js

@@ -1,58 +1,11 @@
-import { modelProtocolError } from '../../../utils/model-protocol.js';
 /**
- * Create a collector for one response.
+ * Tool-call delta aggregation, re-exported from Core.
  *
- * @param fail - Protocol failure factory; defaults to the Core model protocol error.
- * @returns A collector that keeps its own state and never shares it with another response.
+ * The algorithm lives in `model/interactions/calls.ts` so session transports and
+ * completion policies share one implementation. This module keeps the existing
+ * Support import path stable.
+ *
+ * Exports: `AggregatedToolCall`, `ToolCallCollector`, `ToolCallFailure` and
+ * `createToolCallCollector`.
  */
-export function createToolCallCollector(fail = modelProtocolError) {
-    const pending = new Map();
-    const ids = new Set();
-    const calls = () => [...pending.entries()]
-        .sort(([left], [right]) => left - right)
-        .map(([index, call]) => ({ index, ...call }));
-    return {
-        push(part) {
-            if (typeof part === 'string')
-                return;
-            if (!part || typeof part !== 'object' || Array.isArray(part))
-                fail('Expected a native model call');
-            const { type, index, id, name, arguments: args } = part;
-            if (type !== 'function-call-delta')
-                fail('Expected a native model call');
-            if (!Number.isInteger(index) || index < 0)
-                fail('Invalid model call index');
-            if ((id !== undefined && (typeof id !== 'string' || !id)) ||
-                (name !== undefined && typeof name !== 'string') ||
-                (args !== undefined && typeof args !== 'string'))
-                fail('Invalid model call fields');
-            let call = pending.get(index);
-            if (!call) {
-                call = { id: '', name: '', arguments: '' };
-                pending.set(index, call);
-            }
-            if (id !== undefined) {
-                if (call.id && call.id !== id)
-                    fail('Conflicting model call IDs');
-                if (!call.id) {
-                    if (ids.has(id))
-                        fail('Duplicate model call ID');
-                    ids.add(id);
-                    call.id = id;
-                }
-            }
-            call.name += name ?? '';
-            call.arguments += args ?? '';
-        },
-        get calls() {
-            return calls();
-        },
-        complete() {
-            const completed = calls();
-            for (const call of completed)
-                if (!call.id || !call.name)
-                    fail('Incomplete model call');
-            return completed;
-        },
-    };
-}
+export { createToolCallCollector } from '../../../model/interactions/calls.js';

package/dist/esm/support/model/index.d.ts

@@ -22,7 +22,7 @@ export * from './capabilities.js';
 export { createStageModelTransport } from './stage-transport.js';
 export { createProviderObservationScope } from './observer.js';
 export { createReplyPreviewRules } from './preview-rules.js';
-export type { ReplyPreviewCapability, ReplyPreviewStage } from './preview-rules.js';
+export type { PreviewTool, ReplyPreviewTool, ReplyPreviewStage } from './preview-rules.js';
 export { runChildren } from './children.js';
 export type { ModelChildTask, ModelChildrenOptions } from './children.js';
 export { createModelStrategy, modelBudgetStrategies } from './strategies.js';

package/dist/esm/support/model/preview-rules.d.ts

@@ -1,11 +1,16 @@
 import type { JsonSchema } from '../../structs/common.js';
 import type { ReplyPreviewRule } from './reply-preview.js';
+import type { ModelTool } from '../../structs/capabilities/model.js';
+/** A model tool with an explicit, presentation-only streaming preview contract. */
+export interface PreviewTool<Input = unknown, Selection = Input, Context = any> extends ModelTool<Input, Selection, Context> {
+    readonly preview?: true | Omit<ReplyPreviewRule, 'stageId' | 'toolId'>;
+}
 /**
  * Capability declaration used to derive preview rules.
  *
  * Omitted `preview` means the capability never previews, so previewing is an explicit opt-in.
  */
-export interface ReplyPreviewCapability {
+export interface ReplyPreviewTool {
     /** Capability ID, which must equal the native function wire name used for transport. */
     readonly id: string;
     /** Input schema used to prove that preview and eligibility paths really exist. */
@@ -14,16 +19,16 @@ export interface ReplyPreviewCapability {
      * Explicit preview opt-in: `true` uses the default text/bubble paths, an object narrows the
      * paths and eligibility, and omission means the capability never previews.
      */
-    readonly preview?: true | Omit<ReplyPreviewRule, 'stageId' | 'capabilityId'>;
+    readonly preview?: true | Omit<ReplyPreviewRule, 'stageId' | 'toolId'>;
 }
-/** Stage declaration: which capabilities it exposes and whether it previews text or arguments. */
+/** Stage declaration: which tools it exposes and whether it previews text or arguments. */
 export interface ReplyPreviewStage {
     /** Stage ID used by the workflow and transport projection. */
     readonly id: string;
     /** Capabilities exposed at this stage; must be unique and registered. */
-    readonly capabilityIds?: readonly string[];
-    /** `text` previews plain model text; `capabilities` previews opted-in capability arguments. */
-    readonly preview?: 'text' | 'capabilities';
+    readonly toolIds?: readonly string[];
+    /** `text` previews plain model text; `tools` previews opted-in capability arguments. */
+    readonly preview?: 'text' | 'tools';
 }
 /**
  * Generate frozen preview rules from capability and stage declarations.
@@ -31,12 +36,12 @@ export interface ReplyPreviewStage {
  * Capabilities without preview metadata are skipped even when their stage opts in. Default paths
  * are `text` and `bubbles[*]`, each kept only when the capability schema declares it.
  *
- * @param options Stage declarations and the capabilities they may reference.
+ * @param options Stage declarations and the tools they may reference.
  * @returns Frozen rules in stage order, each with deep-frozen paths and eligibility.
  * @throws {Error} When a capability or stage ID repeats, a stage references an unknown capability,
  *   a preview mode is unknown, or a preview path or eligibility field is absent from the schema.
  */
 export declare function createReplyPreviewRules(options: {
     readonly stages: readonly ReplyPreviewStage[];
-    readonly capabilities: readonly ReplyPreviewCapability[];
+    readonly tools: readonly ReplyPreviewTool[];
 }): readonly ReplyPreviewRule[];

package/dist/esm/support/model/preview-rules.js

@@ -80,29 +80,29 @@ function previewSnapshot(preview) {
  * Capabilities without preview metadata are skipped even when their stage opts in. Default paths
  * are `text` and `bubbles[*]`, each kept only when the capability schema declares it.
  *
- * @param options Stage declarations and the capabilities they may reference.
+ * @param options Stage declarations and the tools they may reference.
  * @returns Frozen rules in stage order, each with deep-frozen paths and eligibility.
  * @throws {Error} When a capability or stage ID repeats, a stage references an unknown capability,
  *   a preview mode is unknown, or a preview path or eligibility field is absent from the schema.
  */
 export function createReplyPreviewRules(options) {
-    const capabilities = new Map();
-    for (const capability of options.capabilities) {
+    const tools = new Map();
+    for (const capability of options.tools) {
         const id = capability.id;
-        breakWhile(!id || capabilities.has(id), 'Duplicate preview capability declaration');
+        breakWhile(!id || tools.has(id), 'Duplicate preview capability declaration');
         const preview = previewSnapshot(capability.preview);
         // Validate and emit the same canonical snapshot, never reread App getters.
         const jsonSchema = preview ? structuredClone(capability.jsonSchema) : {};
-        capabilities.set(id, { id, preview, jsonSchema });
+        tools.set(id, { id, preview, jsonSchema });
     }
     const stages = new Set(), rules = [];
     for (const stage of options.stages) {
-        const { id: stageId, preview, capabilityIds } = stage;
+        const { id: stageId, preview, toolIds } = stage;
         breakWhile(!stageId || stages.has(stageId), 'Duplicate preview stage declaration');
         stages.add(stageId);
-        const ids = capabilityIds === undefined ? [] : stringList(capabilityIds, 'capability IDs');
-        breakWhile(new Set(ids).size !== ids.length || ids.some((id) => !capabilities.has(id)), 'Preview stage references an unknown capability');
-        breakWhile(preview !== undefined && !['text', 'capabilities'].includes(preview), 'Unknown preview stage mode');
+        const ids = toolIds === undefined ? [] : stringList(toolIds, 'capability IDs');
+        breakWhile(new Set(ids).size !== ids.length || ids.some((id) => !tools.has(id)), 'Preview stage references an unknown capability');
+        breakWhile(preview !== undefined && !['text', 'tools'].includes(preview), 'Unknown preview stage mode');
         if (!preview)
             continue;
         if (preview === 'text') {
@@ -111,7 +111,7 @@ export function createReplyPreviewRules(options) {
             continue;
         }
         for (const id of ids) {
-            const capability = capabilities.get(id);
+            const capability = tools.get(id);
             if (!capability.preview)
                 continue;
             const source = capability.preview === true ? {} : capability.preview;
@@ -127,7 +127,7 @@ export function createReplyPreviewRules(options) {
                 Object.freeze({ path: Object.freeze(when.path), values: Object.freeze(when.values) });
             rules.push(Object.freeze({
                 stageId,
-                capabilityId: wireName(id),
+                toolId: wireName(id),
                 paths: emittedPaths,
                 ...(emittedWhen ? { when: emittedWhen } : {}),
             }));

package/dist/esm/support/model/reply-preview.d.ts

@@ -2,11 +2,11 @@ import type { ModelOutputEvent } from '../../structs/model/runtime.js';
 /**
  * One projection rule: which stage/capability it matches and which prose fields may be shown.
  *
- * A rule without `capabilityId` may only match a registered plain-text stage.
+ * A rule without `toolId` may only match a registered plain-text stage.
  */
 export interface ReplyPreviewRule {
     /** Native function wire name. Omit only for a registered plain-text stage. */
-    capabilityId?: string;
+    toolId?: string;
     /** Restrict the rule to one stage; omitted matches any stage producing this capability. */
     stageId?: string;
     /** JSON paths to project, where `*` matches any array index; defaults to text/bubble paths. */

package/dist/esm/support/model/reply-preview.js

@@ -196,7 +196,7 @@ export function createReplyPreview(options) {
     if (!Number.isSafeInteger(maxChars) || maxChars < 1)
         throw new TypeError('Invalid reply preview budget');
     const rules = options.rules.map((rule) => Object.freeze({
-        capabilityId: rule.capabilityId,
+        toolId: rule.toolId,
         stageId: rule.stageId,
         paths: rule.paths === undefined ? undefined : structuredClone(rule.paths),
         when: rule.when === undefined ? undefined : structuredClone(rule.when),
@@ -258,7 +258,7 @@ export function createReplyPreview(options) {
             return;
         }
         if (typeof part === 'string') {
-            const rule = rules.find((rule) => !rule.capabilityId && rule.stageId === event.payload.stageId);
+            const rule = rules.find((rule) => !rule.toolId && rule.stageId === event.payload.stageId);
             if (!rule) {
                 if (part.trim()) {
                     disabled = true;
@@ -276,7 +276,7 @@ export function createReplyPreview(options) {
             return;
         }
         name += part.name ?? '';
-        const rule = rules.find((rule) => rule.capabilityId === name && (!rule.stageId || rule.stageId === event.payload.stageId));
+        const rule = rules.find((rule) => rule.toolId === name && (!rule.stageId || rule.stageId === event.payload.stageId));
         if (!rule) {
             if (selected) {
                 disabled = true;

package/dist/esm/support/model/session.d.ts

@@ -0,0 +1,61 @@
+import type { ModelToolSource, RegisteredModelTool } from '../../structs/capabilities/model.js';
+import type { ModelResponseCollector } from '../../structs/model/interactions.js';
+import type { ModelOptions } from '../../structs/model/messages.js';
+import type { ModelTransportDefinition } from '../../structs/model/runtime.js';
+import type { ModelSessionCall, ModelSessionResult } from '../../structs/model/session.js';
+/** One completed call with host-facing resolution; unknown tools and bad JSON stay non-fatal. */
+export interface ResolvedSessionCall extends ModelSessionCall {
+    /** Registered tool id, absent when the name is unknown to this stage. */
+    readonly toolId?: string;
+    /** Parsed arguments, absent when parsing failed or the tool is unknown. */
+    readonly input?: Record<string, unknown>;
+    /** Non-fatal problem the workflow should turn into a tool error message. */
+    readonly problem?: 'unknown-tool' | 'invalid-arguments';
+}
+/** Complete result of one session response after host-facing resolution. */
+export interface ResolvedSessionResult extends Omit<ModelSessionResult, 'calls'> {
+    readonly calls: readonly ResolvedSessionCall[];
+}
+/** Prepared session transport handed to the runner. */
+export interface PreparedSessionTransport {
+    readonly options: Pick<ModelOptions, 'functions' | 'json' | 'temperature' | 'toolChoice' | 'parallelToolCalls'>;
+    readonly schemaChars: number;
+    readonly instruction: string;
+    createResponse(): ModelResponseCollector<ResolvedSessionResult>;
+}
+/** Options a session transport may pass through to provider options. */
+export interface SessionFunctionOptions {
+    readonly temperature?: number;
+    readonly toolChoice?: 'auto' | 'required' | 'none';
+    readonly parallelToolCalls?: boolean | 'omit';
+}
+/** Registration for one session transport. */
+export interface SessionModelTransportRegistration {
+    /** Transport id used by call requests and diagnostics. */
+    readonly id: string;
+    /** Tools advertised to the model for this stage. */
+    readonly tools: ModelToolSource;
+    /** Sampling and tool-selection settings. */
+    readonly options?: SessionFunctionOptions;
+}
+/**
+ * Build the session policy for one stage.
+ *
+ * @param tools - Registered tools available in this stage; must be non-empty.
+ * @param options - Sampling and tool-selection settings.
+ * @returns A prepared transport whose collector returns text and every completed call.
+ * @throws TypeError When the tool list is empty or two ids collide on the wire name.
+ */
+export declare function prepareSessionFunctions(tools: readonly RegisteredModelTool[], options?: SessionFunctionOptions): PreparedSessionTransport;
+/**
+ * Create a session transport.
+ *
+ * @param registration - Transport id, tool source and optional settings.
+ * @returns A frozen transport definition whose result contains text and every completed call.
+ * @throws TypeError When the id is blank.
+ */
+export declare function createSessionModelTransport<const Id extends string>(registration: SessionModelTransportRegistration & {
+    readonly id: Id;
+}): ModelTransportDefinition<ResolvedSessionResult> & {
+    readonly id: Id;
+};