@jangts/agent-core 0.3.6 → 0.5.0

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

@@ -0,0 +1,26 @@
+import type { AssociatedRegistration, AssociationOptions } from '../structs/support/associations.js';
+/** Compile independent and owner-derived Tool declarations, validating all references eagerly. */
+export declare function defineAssociatedCatalog<Entry extends AssociatedRegistration>(entries: readonly Entry[], options?: AssociationOptions<Entry>): Readonly<{
+    tools: import("../index.js").ModelToolCatalog<any>;
+    bindings: import("../index.js").ReadonlyCatalog<{
+        id: Entry["id"];
+        toolIds: readonly string[];
+    }>;
+    sources: import("../index.js").ReadonlyCatalog<{
+        id: string;
+        sources: readonly Readonly<{
+            toolIds: readonly string[];
+            kind: "standalone" | "registration";
+            id: string;
+            description: string;
+        }>[];
+    }>;
+    definitions: readonly Readonly<Entry>[];
+    ids(): readonly string[];
+    values(): IterableIterator<Readonly<Entry>>;
+    entries(): IterableIterator<readonly [string, Readonly<Entry>]>;
+    has(id: string): boolean;
+    get(id: string): Readonly<Entry> | undefined;
+    require(id: string): Readonly<Entry>;
+}>;
+export type * from '../structs/support/associations.js';

package/dist/esm/support/associations.js

@@ -0,0 +1,76 @@
+/** Compile owner-to-tool relations without parallel intent identities or execution side effects. */
+import { readonlyCatalog } from '../utils/catalog.js';
+import { synchronous } from '../utils/synchronous.js';
+import { defineModelTools } from './model/capabilities.js';
+/** Compile independent and owner-derived Tool declarations, validating all references eagerly. */
+export function defineAssociatedCatalog(entries, options = {}) {
+    const owners = readonlyCatalog(entries, (id) => new TypeError(`Unknown tool owner: ${id}`));
+    const definitions = new Map();
+    const sources = new Map();
+    const declare = (tool, source) => {
+        if (definitions.has(tool.id))
+            throw new TypeError(`Duplicate model tool: ${tool.id}`);
+        definitions.set(tool.id, tool);
+        sources.set(tool.id, [source]);
+    };
+    const independent = new Set();
+    for (const tool of options.tools ?? []) {
+        independent.add(tool.id);
+        declare(tool, {
+            kind: 'standalone',
+            id: tool.id,
+            description: tool.description,
+            toolIds: [tool.id],
+        });
+    }
+    const bindings = owners.definitions.map((owner) => {
+        const fallback = options.toolDefaults
+            ? synchronous(options.toolDefaults(owner), 'Tool defaults must be synchronous')
+            : undefined;
+        const declarations = owner.modelTools ?? (fallback ? [{}] : []);
+        const toolIds = [];
+        for (const declaration of declarations) {
+            if (typeof declaration === 'string') {
+                if (!independent.has(declaration))
+                    throw new TypeError(`Tool reference must name an independent tool: ${owner.id} -> ${declaration}`);
+                sources.get(declaration).push({
+                    kind: 'registration',
+                    id: owner.id,
+                    description: owner.description,
+                    toolIds: [declaration],
+                });
+                toolIds.push(declaration);
+            }
+            else {
+                if (!declaration || typeof declaration !== 'object' || Array.isArray(declaration))
+                    throw new TypeError('Invalid tool association');
+                const tool = {
+                    ...fallback,
+                    ...declaration,
+                    id: declaration.id ?? fallback?.id ?? owner.id,
+                    description: declaration.description ?? fallback?.description ?? owner.description,
+                    resolve: declaration.resolve?.bind(declaration) ?? fallback?.resolve?.bind(fallback),
+                };
+                declare(tool, {
+                    kind: 'registration',
+                    id: owner.id,
+                    description: owner.description,
+                    toolIds: [tool.id],
+                });
+                toolIds.push(tool.id);
+            }
+        }
+        if (new Set(toolIds).size !== toolIds.length)
+            throw new TypeError(`Duplicate tool reference: ${owner.id}`);
+        return Object.freeze({ id: owner.id, toolIds: Object.freeze(toolIds) });
+    });
+    return Object.freeze({
+        ...owners,
+        tools: defineModelTools([...definitions.values()]),
+        bindings: readonlyCatalog(bindings, (id) => new TypeError(`Unknown tool binding: ${id}`)),
+        sources: readonlyCatalog([...sources].map(([id, values]) => Object.freeze({
+            id,
+            sources: Object.freeze(values.map((source) => Object.freeze({ ...source, toolIds: Object.freeze([...source.toolIds]) }))),
+        })), (id) => new TypeError(`Unknown tool source: ${id}`)),
+    });
+}

package/dist/esm/support/context/snapshot.js

@@ -17,7 +17,7 @@ export function snapshotFragment(fragment) {
  *   unsupported `detail` value.
  */
 export function snapshotMessage(message) {
-    const { role, content, images } = message;
+    const { role, content, images, toolCalls, toolCallId } = message;
     if (images !== undefined && !Array.isArray(images))
         throw new TypeError('Context images must be an array');
     return {
@@ -34,5 +34,15 @@ export function snapshotMessage(message) {
                     return { url, ...(detail === undefined ? {} : { detail }) };
                 }),
             }),
+        ...(toolCalls === undefined
+            ? {}
+            : {
+                toolCalls: toolCalls.map((call) => ({
+                    id: call.id,
+                    name: call.name,
+                    arguments: call.arguments,
+                })),
+            }),
+        ...(toolCallId === undefined ? {} : { toolCallId }),
     };
 }

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

@@ -7,6 +7,7 @@ import type { AgentCoreEngineSetup } from '../../execution/engine.js';
 import type { ToolDefinition } from '../../structs/capabilities/tools.js';
 import type { ContextFragmentConfig } from '../../structs/support/context.js';
 import type { ModelRunnerOptions } from '../../structs/model/runtime.js';
+import type { AsIntent, ModelTool } from '../../structs/capabilities/model.js';
 import { type ClassDecoration, type MethodDecoration, type DecorationOptions } from './definition.js';
 import type { IdentifiedDefinition } from './pool.js';
 export { nodePool, toolPool, fragmentPool, workflowPool, agentPool, modelPool } from './pool.js';
@@ -15,14 +16,24 @@ export type { ClassDecoration, MethodDecoration, DecorationOptions } from './def
 export type { Node, Tool, Fragment, Workflow, Agent, Model } from './types.js';
 /** Method metadata describes the adapted handler, with optional external namespaces. */
 type MethodOptions<Definition extends IdentifiedDefinition, Key extends keyof Definition> = Omit<Definition, 'id' | Key> & DecorationOptions;
+/** Intent composition belongs to its own decorator, including on definition classes. */
+type WithoutIntent<Definition> = Definition extends unknown ? Omit<Definition, 'asIntent'> & {
+    readonly asIntent?: never;
+} : never;
+/** Mark a WorkflowTool for demand discovery; alone this decorator registers nothing. */
+export declare function Intent<Context = any>(metadata?: AsIntent<Context>): (value: object, context: ClassDecoratorContext | ClassMethodDecoratorContext) => void;
 /** Instantiate a node definition class once, injecting its id; graph validation stays in Workflow. */
 export declare function node<State = any, Result = unknown, App = any>(id: string, options?: DecorationOptions): ClassDecoration<WorkflowNode<State, Result, App>>;
 /** Bind a named host method as run without renaming or manually binding the original object. */
 export declare function node<State = any, Result = unknown, App = any>(id: string, options: MethodOptions<WorkflowNode<State, Result, App>, 'run'>): MethodDecoration<NonNullable<WorkflowNode<State, Result, App>['run']>>;
 /** Instantiate a tool definition class; schema and authorization stay with existing defineTool. */
-export declare function tool<Input = unknown, Output = unknown, App = any>(id: string, options?: DecorationOptions): ClassDecoration<ToolDefinition<Input, Output, App>>;
+export declare function tool<Input = any, Output = any, App = any>(id: string, options?: DecorationOptions): ClassDecoration<WithoutIntent<ToolDefinition<Input, Output, App> | ModelTool<Input, Output, App>>>;
 /** Bind an existing host method as the tool's execute callback. */
-export declare function tool<Input = unknown, Output = unknown, App = any>(id: string, options: MethodOptions<ToolDefinition<Input, Output, App>, 'execute'>): MethodDecoration<ToolDefinition<Input, Output, App>['execute']>;
+export declare function tool<Input = unknown, Output = unknown, App = any>(id: string, options: MethodOptions<Omit<ToolDefinition<Input, Output, App>, 'asIntent'>, 'execute'>): MethodDecoration<ToolDefinition<Input, Output, App>['execute']>;
+/** A model-only tool method provides its synchronous resolver. */
+export declare function tool<Input = unknown, Output = Input, App = any>(id: string, options: MethodOptions<Omit<ModelTool<Input, Output, App>, 'asIntent'>, 'resolve'>): MethodDecoration<ModelTool<Input, Output, App>['resolve']>;
+/** Explicit workflow names share the same implementation and pools. */
+export { tool as WorkflowTool, node as WorkflowNode };
 /** Instantiate a self-describing fragment class; the original builder owns formatting checks. */
 export declare function fragment<Input = unknown>(id: string, options?: DecorationOptions): ClassDecoration<ContextFragmentConfig<Input>>;
 /** Bind a host's formatter method into an original fragment configuration. */

package/dist/esm/support/decorators/index.js

@@ -1,18 +1,48 @@
 import { defineTool } from '../tools.js';
+import { defineModelTools } from '../model/capabilities.js';
+import { snapshotIntent } from '../../capabilities/tool-conditions.js';
 import { defineWorkflow } from '../../execution/workflow.js';
 import { defineContextFragments } from '../context/assembly.js';
 import { snapshotModelBinding } from '../../model/binding.js';
 import { classDecoration, methodDecoration, } from './definition.js';
 export { nodePool, toolPool, fragmentPool, workflowPool, agentPool, modelPool } from './pool.js';
+/** Metadata follows the actual decorated target, independently of decorator order. */
+const intentKey = Symbol.for('@jangts/agent-core/tool-intent-metadata/v1');
+const realm = globalThis;
+const intentMetadata = realm[intentKey] ?? new WeakMap();
+if (!realm[intentKey])
+    Object.defineProperty(globalThis, intentKey, { value: intentMetadata });
+/** Mark a WorkflowTool for demand discovery; alone this decorator registers nothing. */
+export function Intent(metadata = true) {
+    const normalized = snapshotIntent(metadata);
+    return (value, context) => {
+        if (context.kind !== 'class' && context.kind !== 'method')
+            throw new TypeError('Intent requires a class or method');
+        if (intentMetadata.has(value))
+            throw new TypeError('Duplicate Intent decoration');
+        intentMetadata.set(value, normalized);
+    };
+}
 /** Internal conversion shared by node/tool/fragment; never a public free-function adapter. */
 function decorate(kind, id, options, key, compile) {
     return (value, context) => {
+        const convert = (definition) => {
+            if (kind !== 'tool')
+                return compile(definition);
+            if ('asIntent' in definition)
+                throw new TypeError('Use @Intent instead of asIntent in @WorkflowTool');
+            const metadata = intentMetadata.get(value);
+            // Intent metadata is collected before class/method initializers compile definitions.
+            if (metadata !== undefined)
+                Object.defineProperty(definition, 'asIntent', { value: metadata, enumerable: true });
+            return compile(definition);
+        };
         if (context?.kind === 'class') {
-            classDecoration(kind, id, options, compile)(value, context);
+            classDecoration(kind, id, options, convert)(value, context);
         }
         else {
             const { ns, ...metadata } = options;
-            methodDecoration(kind, id, metadata, key, { ns }, compile)(value, context);
+            methodDecoration(kind, id, metadata, key, { ns }, convert)(value, context);
         }
     };
 }
@@ -20,8 +50,15 @@ export function node(id, options = {}) {
     return decorate('node', id, options, 'run', (value) => value);
 }
 export function tool(id, options = {}) {
-    return decorate('tool', id, options, 'execute', (value) => defineTool(value));
+    if ('asIntent' in options)
+        throw new TypeError('Use @Intent instead of asIntent in @WorkflowTool');
+    const handlerKey = 'inputSchema' in options && !('authorize' in options) ? 'resolve' : 'execute';
+    return decorate('tool', id, options, handlerKey, (value) => 'kind' in value || 'authorize' in value || 'execute' in value
+        ? defineTool(value)
+        : defineModelTools([value]).require(value.id));
 }
+/** Explicit workflow names share the same implementation and pools. */
+export { tool as WorkflowTool, node as WorkflowNode };
 export function fragment(id, options = {}) {
     return decorate('fragment', id, options, 'format', (value) => {
         defineContextFragments([value]);

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[];