@jangts/agent-core 0.3.5 → 0.5.0

package/dist/cjs/support/context/nodes.js

@@ -14,6 +14,7 @@ exports.createContextReductionNode = createContextReductionNode;
  * Main exports: `createContextProcessingNode`, `createContextSelectionNode`,
  * `createContextReductionNode` and their result/definition types.
  */
+const native_sub_flow_js_1 = require("../../diagnostics/native-sub-flow.js");
 const processing_js_1 = require("./processing.js");
 const defaults_js_1 = require("../../model/defaults.js");
 const synchronous_js_1 = require("../../utils/synchronous.js");
@@ -129,53 +130,55 @@ function contextNode(definition, execute) {
         onErrorRouteId: definition.onErrorRouteId,
         routes: definition.routes,
         async run(state, context) {
-            // The node timeout is an additional bound; parent cancellation still wins.
-            const signal = (0, cancellation_js_1.combineSignals)(context.signal, AbortSignal.timeout(timeoutMs));
-            const prepared = selectPrepared
-                ? selectPrepared(state, context)
-                : context.model.prepare(typeof request === 'function' ? request(state, context) : request);
-            const input = (0, synchronous_js_1.synchronous)(plan(state, context), 'Context plans must be synchronous');
-            // An empty measurement reports the allowance left after transport, instruction and schema
-            // overhead, so processing must fit inside whichever limit is tighter.
-            const overhead = prepared.measure([]);
-            const fullLimit = Math.min(input.maxInputChars, overhead.maxInputChars);
-            const bodyLimit = fullLimit;
-            (0, rules_js_1.breakWhile)(bodyLimit < 1, 'No input capacity for context');
-            const work = (0, processing_js_1.beginContextProcessing)({
-                fragments: input.fragments,
-                additionalMessages: input.additionalMessages,
-                originalFragments: input.originalFragments,
-                mutableFragmentIds: input.mutableFragmentIds,
-                maxInputChars: bodyLimit,
-            }, policy, {
-                stageId: prepared.stageId,
-                signal,
-                diagnostics: context.diagnostics,
-                compressors,
-                selectors,
-                // Read lazily so handlers see the live budget rather than the value at preparation.
-                remainingCalls: () => prepared.remainingCalls,
-                callModel: (options) => context.model.invoke({
-                    ...options,
-                    modelId: options.modelId ?? prepared.modelId,
+            return (0, native_sub_flow_js_1.nativeSubFlowAsync)(context, 'context', definition.id, async () => {
+                // The node timeout is an additional bound; parent cancellation still wins.
+                const signal = (0, cancellation_js_1.combineSignals)(context.signal, AbortSignal.timeout(timeoutMs));
+                const prepared = selectPrepared
+                    ? selectPrepared(state, context)
+                    : context.model.prepare(typeof request === 'function' ? request(state, context) : request);
+                const input = (0, synchronous_js_1.synchronous)(plan(state, context), 'Context plans must be synchronous');
+                // An empty measurement reports the allowance left after transport, instruction and schema
+                // overhead, so processing must fit inside whichever limit is tighter.
+                const overhead = prepared.measure([]);
+                const fullLimit = Math.min(input.maxInputChars, overhead.maxInputChars);
+                const bodyLimit = fullLimit;
+                (0, rules_js_1.breakWhile)(bodyLimit < 1, 'No input capacity for context');
+                const work = (0, processing_js_1.beginContextProcessing)({
+                    fragments: input.fragments,
+                    additionalMessages: input.additionalMessages,
+                    originalFragments: input.originalFragments,
+                    mutableFragmentIds: input.mutableFragmentIds,
+                    maxInputChars: bodyLimit,
+                }, policy, {
+                    stageId: prepared.stageId,
                     signal,
-                }),
-                ...(overhead.counterId
-                    ? {
-                        tokenBudget: {
-                            counterId: overhead.counterId,
-                            inputLimit: overhead.inputTokenLimit,
-                            measure: (messages) => prepared.measure(messages).inputTokens,
-                        },
-                    }
-                    : {}),
+                    diagnostics: context.diagnostics,
+                    compressors,
+                    selectors,
+                    // Read lazily so handlers see the live budget rather than the value at preparation.
+                    remainingCalls: () => prepared.remainingCalls,
+                    callModel: (options) => context.model.invoke({
+                        ...options,
+                        modelId: options.modelId ?? prepared.modelId,
+                        signal,
+                    }),
+                    ...(overhead.counterId
+                        ? {
+                            tokenBudget: {
+                                counterId: overhead.counterId,
+                                inputLimit: overhead.inputTokenLimit,
+                                measure: (messages) => prepared.measure(messages).inputTokens,
+                            },
+                        }
+                        : {}),
+                });
+                context.report({ payload: { phase: 'processing', fragmentCount: input.fragments.length } });
+                const result = await execute(work, prepared, fullLimit, state, context);
+                // Never report or commit a result produced after cancellation.
+                signal.throwIfAborted();
+                context.report({ payload: { phase: 'processed', report: work.report } });
+                return (0, synchronous_js_1.synchronous)(update(result, state), 'Context node updates must be synchronous');
             });
-            context.report({ payload: { phase: 'processing', fragmentCount: input.fragments.length } });
-            const result = await execute(work, prepared, fullLimit, state, context);
-            // Never report or commit a result produced after cancellation.
-            signal.throwIfAborted();
-            context.report({ payload: { phase: 'processed', report: work.report } });
-            return (0, synchronous_js_1.synchronous)(update(result, state), 'Context node updates must be synchronous');
         },
     };
 }

package/dist/cjs/support/context/processing.js

@@ -26,6 +26,7 @@ exports.processContext = processContext;
  * `finishContextProcessing` (staged runs), the policy/reduction catalogs and the individual
  * validation, measurement and reduction helpers used by workflow nodes.
  */
+const native_sub_flow_js_1 = require("../../diagnostics/native-sub-flow.js");
 const snapshot_js_1 = require("./snapshot.js");
 const audit_js_1 = require("../../context/audit.js");
 const history_js_1 = require("./history.js");
@@ -610,7 +611,9 @@ function finishContextProcessing(state) {
  * @throws {BudgetError} When a handler exhausts its call allowance.
  */
 async function processContext(plan, policy, ports) {
-    const state = beginContextProcessing(plan, policy, ports);
-    await exports.contextPolicyCatalog[policy.mode].run(state);
-    return finishContextProcessing(state);
+    return (0, native_sub_flow_js_1.nativeSubFlowAsync)(ports, 'context', policy.mode, async () => {
+        const state = beginContextProcessing(plan, policy, ports);
+        await exports.contextPolicyCatalog[policy.mode].run(state);
+        return finishContextProcessing(state);
+    });
 }

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

@@ -21,7 +21,7 @@ function snapshotFragment(fragment) {
  *   unsupported `detail` value.
  */
 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 {
@@ -38,5 +38,15 @@ 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/cjs/support/decorators/index.js

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelPool = exports.agentPool = exports.workflowPool = exports.fragmentPool = exports.toolPool = exports.nodePool = void 0;
+exports.Intent = Intent;
 exports.node = node;
+exports.WorkflowNode = node;
 exports.tool = tool;
+exports.WorkflowTool = tool;
+exports.tool = tool;
+exports.WorkflowTool = tool;
+exports.node = node;
+exports.WorkflowNode = node;
 exports.fragment = fragment;
 exports.workflow = workflow;
 exports.agent = agent;
 exports.model = model;
 const tools_js_1 = require("../tools.js");
+const capabilities_js_1 = require("../model/capabilities.js");
+const tool_conditions_js_1 = require("../../capabilities/tool-conditions.js");
 const workflow_js_1 = require("../../execution/workflow.js");
 const assembly_js_1 = require("../context/assembly.js");
 const binding_js_1 = require("../../model/binding.js");
@@ -19,15 +28,43 @@ Object.defineProperty(exports, "fragmentPool", { enumerable: true, get: function
 Object.defineProperty(exports, "workflowPool", { enumerable: true, get: function () { return pool_js_1.workflowPool; } });
 Object.defineProperty(exports, "agentPool", { enumerable: true, get: function () { return pool_js_1.agentPool; } });
 Object.defineProperty(exports, "modelPool", { enumerable: true, get: function () { return pool_js_1.modelPool; } });
+/** 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. */
+function Intent(metadata = true) {
+    const normalized = (0, tool_conditions_js_1.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') {
-            (0, definition_js_1.classDecoration)(kind, id, options, compile)(value, context);
+            (0, definition_js_1.classDecoration)(kind, id, options, convert)(value, context);
         }
         else {
             const { ns, ...metadata } = options;
-            (0, definition_js_1.methodDecoration)(kind, id, metadata, key, { ns }, compile)(value, context);
+            (0, definition_js_1.methodDecoration)(kind, id, metadata, key, { ns }, convert)(value, context);
         }
     };
 }
@@ -35,7 +72,12 @@ function node(id, options = {}) {
     return decorate('node', id, options, 'run', (value) => value);
 }
 function tool(id, options = {}) {
-    return decorate('tool', id, options, 'execute', (value) => (0, tools_js_1.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
+        ? (0, tools_js_1.defineTool)(value)
+        : (0, capabilities_js_1.defineModelTools)([value]).require(value.id));
 }
 function fragment(id, options = {}) {
     return decorate('fragment', id, options, 'format', (value) => {

package/dist/cjs/support/index.js

@@ -42,3 +42,4 @@ Object.defineProperty(exports, "createReplyPreview", { enumerable: true, get: fu
 __exportStar(require("./capabilities.js"), exports);
 var decision_retry_js_1 = require("../model/decision-retry.js");
 Object.defineProperty(exports, "retryMultipleModelCalls", { enumerable: true, get: function () { return decision_retry_js_1.retryMultipleModelCalls; } });
+__exportStar(require("./associations.js"), exports);

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

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineModelCapabilities = defineModelCapabilities;
+exports.defineModelTools = defineModelTools;
 /**
  * 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`.
  */
 const catalog_js_1 = require("../../utils/catalog.js");
 const model_js_1 = require("../../capabilities/model.js");
@@ -22,10 +22,40 @@ const model_js_1 = require("../../capabilities/model.js");
  *   unknown ID.
  * @throws {Error} When a resolver is asynchronous.
  */
-function defineModelCapabilities(definitions) {
-    const registry = new model_js_1.ModelCapabilityRegistry(definitions).seal();
+function defineModelTools(definitions) {
+    const registry = new model_js_1.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({
         ...(0, catalog_js_1.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/cjs/support/model/chat-completions.js

@@ -19,10 +19,19 @@ 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/cjs/support/model/completion/calls.js

@@ -1,61 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createToolCallCollector = createToolCallCollector;
-const model_protocol_js_1 = require("../../../utils/model-protocol.js");
+exports.createToolCallCollector = void 0;
 /**
- * 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`.
  */
-function createToolCallCollector(fail = model_protocol_js_1.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;
-        },
-    };
-}
+var calls_js_1 = require("../../../model/interactions/calls.js");
+Object.defineProperty(exports, "createToolCallCollector", { enumerable: true, get: function () { return calls_js_1.createToolCallCollector; } });

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

@@ -83,29 +83,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.
  */
 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;
-        (0, rules_js_1.breakWhile)(!id || capabilities.has(id), 'Duplicate preview capability declaration');
+        (0, rules_js_1.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;
         (0, rules_js_1.breakWhile)(!stageId || stages.has(stageId), 'Duplicate preview stage declaration');
         stages.add(stageId);
-        const ids = capabilityIds === undefined ? [] : stringList(capabilityIds, 'capability IDs');
-        (0, rules_js_1.breakWhile)(new Set(ids).size !== ids.length || ids.some((id) => !capabilities.has(id)), 'Preview stage references an unknown capability');
-        (0, rules_js_1.breakWhile)(preview !== undefined && !['text', 'capabilities'].includes(preview), 'Unknown preview stage mode');
+        const ids = toolIds === undefined ? [] : stringList(toolIds, 'capability IDs');
+        (0, rules_js_1.breakWhile)(new Set(ids).size !== ids.length || ids.some((id) => !tools.has(id)), 'Preview stage references an unknown capability');
+        (0, rules_js_1.breakWhile)(preview !== undefined && !['text', 'tools'].includes(preview), 'Unknown preview stage mode');
         if (!preview)
             continue;
         if (preview === 'text') {
@@ -114,7 +114,7 @@ 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;
@@ -130,7 +130,7 @@ function createReplyPreviewRules(options) {
                 Object.freeze({ path: Object.freeze(when.path), values: Object.freeze(when.values) });
             rules.push(Object.freeze({
                 stageId,
-                capabilityId: (0, arguments_js_1.wireName)(id),
+                toolId: (0, arguments_js_1.wireName)(id),
                 paths: emittedPaths,
                 ...(emittedWhen ? { when: emittedWhen } : {}),
             }));

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

@@ -199,7 +199,7 @@ 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),
@@ -261,7 +261,7 @@ 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;
@@ -279,7 +279,7 @@ 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/cjs/support/model/session.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSessionFunctions = prepareSessionFunctions;
+exports.createSessionModelTransport = createSessionModelTransport;
+/**
+ * Session transport policy: one response may contain prose and several tool calls.
+ *
+ * Core owns the raw `ModelSessionResult`; this Support module adds the host-facing
+ * resolution fields (`toolId`, parsed `input`, non-fatal `problem`) and the transport
+ * that advertises the stage's tools. Keeping the resolution policy here prevents Core
+ * from depending on tool catalogs or business error categories.
+ *
+ * Exports: `ResolvedSessionCall`, `ResolvedSessionResult`, `PreparedSessionTransport`,
+ * `SessionFunctionOptions`, `SessionModelTransportRegistration`, `prepareSessionFunctions`
+ * and `createSessionModelTransport`.
+ */
+const arguments_js_1 = require("../../model/interactions/arguments.js");
+const calls_js_1 = require("../../model/interactions/calls.js");
+const options_js_1 = require("../../model/options.js");
+const model_protocol_js_1 = require("../../utils/model-protocol.js");
+/**
+ * Parse one call's raw arguments without failing the whole response.
+ *
+ * @param raw - Raw JSON text; an empty string means an empty argument object.
+ * @returns The parsed object, or undefined when the text is not a JSON object.
+ */
+function parseArguments(raw) {
+    try {
+        const value = JSON.parse(raw === '' ? '{}' : raw);
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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.
+ */
+function prepareSessionFunctions(tools, options = {}) {
+    if (!tools.length)
+        throw new TypeError('Session transport requires registered tools');
+    const names = new Map(tools.map((tool) => [(0, arguments_js_1.wireName)(tool.id), tool.id]));
+    if (names.size !== tools.length)
+        throw new TypeError('Model wire name collision');
+    const functions = tools.map((tool) => ({
+        name: (0, arguments_js_1.wireName)(tool.id),
+        description: tool.description,
+        parameters: tool.inputSchema.jsonSchema,
+        strict: false,
+    }));
+    const instruction = 'You may answer directly or call one or more registered tools. Prose and calls may appear together. A call is a proposal, not proof of execution.';
+    return {
+        options: {
+            json: false,
+            functions,
+            toolChoice: options.toolChoice ?? 'auto',
+            ...(options.parallelToolCalls === undefined
+                ? {}
+                : { parallelToolCalls: options.parallelToolCalls }),
+            ...(options.temperature === undefined ? {} : { temperature: options.temperature }),
+        },
+        schemaChars: JSON.stringify(functions).length + instruction.length,
+        instruction,
+        createResponse() {
+            const collector = (0, calls_js_1.createToolCallCollector)();
+            let text = '';
+            return {
+                get outputChars() {
+                    return (text.length +
+                        collector.calls.reduce((sum, call) => sum + call.id.length + call.name.length + call.arguments.length, 0));
+                },
+                get calls() {
+                    try {
+                        return collector.complete().map((call) => ({
+                            id: call.id,
+                            name: call.name,
+                            argumentChars: call.arguments.length,
+                            toolId: names.get(call.name),
+                        }));
+                    }
+                    catch {
+                        return undefined;
+                    }
+                },
+                push(part) {
+                    if (typeof part === 'string') {
+                        text += part;
+                        return;
+                    }
+                    collector.push(part);
+                },
+                finish() {
+                    const completed = collector.complete();
+                    if (text.trim() === '' && completed.length === 0)
+                        (0, model_protocol_js_1.modelProtocolError)('Model response is empty', 'MODEL_INCOMPLETE');
+                    const calls = completed.map((call) => {
+                        const toolId = names.get(call.name);
+                        const input = parseArguments(call.arguments);
+                        return {
+                            index: call.index,
+                            id: call.id,
+                            name: call.name,
+                            arguments: call.arguments,
+                            argumentChars: call.arguments.length,
+                            ...(toolId === undefined ? {} : { toolId }),
+                            ...(input === undefined ? {} : { input }),
+                            ...(toolId === undefined
+                                ? { problem: 'unknown-tool' }
+                                : input === undefined
+                                    ? { problem: 'invalid-arguments' }
+                                    : {}),
+                        };
+                    });
+                    return { text, calls };
+                },
+            };
+        },
+    };
+}
+/**
+ * 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.
+ */
+function createSessionModelTransport(registration) {
+    const id = registration.id;
+    if (typeof id !== 'string' || !id.trim())
+        throw new TypeError('Session transport requires an ID');
+    const source = registration.tools;
+    const options = (0, options_js_1.snapshotModelOptions)(registration.options ?? {});
+    return Object.freeze({
+        id,
+        prepare() {
+            return prepareSessionFunctions([...source.values()], {
+                ...(options.temperature === undefined ? {} : { temperature: options.temperature }),
+                ...(options.toolChoice === undefined ? {} : { toolChoice: options.toolChoice }),
+                ...(options.parallelToolCalls === undefined
+                    ? {}
+                    : { parallelToolCalls: options.parallelToolCalls }),
+            });
+        },
+    });
+}