@jangts/agent-core 0.3.5 → 0.5.0

package/dist/cjs/model/decision-retry.js

@@ -10,6 +10,7 @@ exports.retryMultipleModelCalls = retryMultipleModelCalls;
  *
  * Exports: `retryMultipleModelCalls`.
  */
+const native_sub_flow_js_1 = require("../diagnostics/native-sub-flow.js");
 const errors_js_1 = require("../errors.js");
 /**
  * Retry once when the failure is a rejected multi-call proposal.
@@ -28,6 +29,6 @@ async function retryMultipleModelCalls(request) {
     catch (error) {
         if (!(0, errors_js_1.getErrorInfo)(error).codes.includes('MODEL_MULTIPLE_CALLS'))
             throw error;
-        return request.retry(error);
+        return (0, native_sub_flow_js_1.nativeSubFlowAsync)(request, 'retry', 'MODEL_MULTIPLE_CALLS', () => request.retry(error));
     }
 }

package/dist/cjs/model/index.js

@@ -18,14 +18,10 @@ exports.modelRunnerDefaults = void 0;
 /**
  * Public surface of the model protocol layer.
  *
- * Re-exports the runner, the provider and transport contracts, the interaction
- * adapters and the defaults. Everything that interprets model output passes through
- * this module, so consumers should not import the individual files.
+ * Re-exports the runner and the provider/transport contracts. Support implementations are
+ * exported from the package root or `/support`; this Core barrel stays free of Support code.
  */
 __exportStar(require("./runner.js"), exports);
 __exportStar(require("../structs/model/chat-provider.js"), exports);
-__exportStar(require("../support/model/compatible-provider.js"), exports);
-__exportStar(require("../support/model/transports.js"), exports);
-__exportStar(require("../support/model/interactions/index.js"), exports);
 var defaults_js_1 = require("./defaults.js");
 Object.defineProperty(exports, "modelRunnerDefaults", { enumerable: true, get: function () { return defaults_js_1.modelRunnerDefaults; } });

package/dist/cjs/model/interactions/calls.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createToolCallCollector = createToolCallCollector;
+const model_protocol_js_1 = require("../../utils/model-protocol.js");
+/**
+ * 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.
+ */
+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;
+        },
+    };
+}

package/dist/cjs/model/interactions/json-object.js

@@ -25,24 +25,24 @@ exports.jsonObjectInteraction = Object.freeze({
     /**
      * Build the instruction and response collector for one stage.
      *
-     * @param capabilities - Capabilities registered for this stage; must be non-empty.
+     * @param tools - Capabilities registered for this stage; must be non-empty.
      * @returns JSON mode options, the measured instruction and the collector factory.
      */
-    prepare(capabilities) {
-        const declarations = capabilities.map(({ id, description, inputSchema }) => ({
+    prepare(tools) {
+        const declarations = tools.map(({ id, description, inputSchema }) => ({
             id,
             description,
             input: inputSchema.jsonSchema,
         }));
         // Keep the wire shape after potentially long schemas so it cannot be mistaken
         // for a schema definition or a bare capability argument object.
-        const instruction = 'Registered capabilities: ' +
+        const instruction = 'Registered tools: ' +
             JSON.stringify(declarations) +
-            '\nReturn exactly one JSON object with exactly these two fields: {"capability":"registered id","input":{...}}. ' +
-            'Choose capability from ' +
-            JSON.stringify(capabilities.map((capability) => capability.id)) +
-            "; input is the chosen capability's actual argument object matching its input schema. " +
-            'Do not return the schema, response_format, an array, multiple calls, prose or fences. The outer object must contain capability and input.';
+            '\nReturn exactly one JSON object with exactly these two fields: {"name":"registered id","input":{...}}. ' +
+            'Choose tool name from ' +
+            JSON.stringify(tools.map((capability) => capability.id)) +
+            "; input is the chosen tool's actual argument object matching its input schema. " +
+            'Do not return the schema, response_format, an array, multiple calls, prose or fences. The outer object must contain name and input.';
         return {
             options: { json: true },
             schemaChars: instruction.length,
@@ -61,10 +61,10 @@ exports.jsonObjectInteraction = Object.freeze({
                     finish() {
                         const value = (0, arguments_js_1.parse)(raw);
                         if (Object.keys(value).length !== 2 ||
-                            typeof value.capability !== 'string' ||
+                            typeof value.name !== 'string' ||
                             !Object.hasOwn(value, 'input'))
                             (0, model_protocol_js_1.modelProtocolError)('Invalid model selection envelope');
-                        return { capabilityId: value.capability, input: (0, arguments_js_1.object)(value.input) };
+                        return { toolId: value.name, input: (0, arguments_js_1.object)(value.input) };
                     },
                 };
             },

package/dist/cjs/model/interactions/native-functions.js

@@ -12,6 +12,7 @@ exports.nativeFunctionInteraction = void 0;
  */
 const model_protocol_js_1 = require("../../utils/model-protocol.js");
 const arguments_js_1 = require("./arguments.js");
+const calls_js_1 = require("./calls.js");
 /**
  * Adapter that decodes a streamed native function call.
  *
@@ -27,15 +28,15 @@ exports.nativeFunctionInteraction = Object.freeze({
      * Wire names are derived from capability ids and must stay unique after mapping;
      * a collision would make it impossible to resolve the proposed name back to an id.
      *
-     * @param capabilities - Capabilities registered for this stage; must be non-empty.
+     * @param tools - Capabilities registered for this stage; must be non-empty.
      * @returns Function declarations, the measured instruction and the collector factory.
      * @throws TypeError When two capability ids map to the same wire name.
      */
-    prepare(capabilities) {
-        const names = new Map(capabilities.map((capability) => [(0, arguments_js_1.wireName)(capability.id), capability.id]));
-        if (names.size !== capabilities.length)
+    prepare(tools) {
+        const names = new Map(tools.map((capability) => [(0, arguments_js_1.wireName)(capability.id), capability.id]));
+        if (names.size !== tools.length)
             throw new TypeError('Model wire name collision');
-        const functions = capabilities.map((capability) => ({
+        const functions = tools.map((capability) => ({
             name: (0, arguments_js_1.wireName)(capability.id),
             description: capability.description,
             parameters: capability.inputSchema.jsonSchema,
@@ -47,11 +48,12 @@ exports.nativeFunctionInteraction = Object.freeze({
             schemaChars: JSON.stringify(functions).length + instruction.length,
             instruction,
             createResponse() {
+                const collector = (0, calls_js_1.createToolCallCollector)();
                 let raw = '';
-                let call;
                 return {
                     get outputChars() {
-                        return (raw.length + (call ? call.id.length + call.name.length + call.arguments.length : 0));
+                        return (raw.length +
+                            collector.calls.reduce((sum, call) => sum + call.id.length + call.name.length + call.arguments.length, 0));
                     },
                     push(part) {
                         if (typeof part === 'string') {
@@ -60,32 +62,24 @@ exports.nativeFunctionInteraction = Object.freeze({
                         }
                         if (!part || typeof part !== 'object' || Array.isArray(part))
                             (0, model_protocol_js_1.modelProtocolError)('Expected a native model call');
-                        const { type, index, id, name, arguments: args } = part;
+                        const { type, index } = part;
                         if (type !== 'function-call-delta')
                             (0, model_protocol_js_1.modelProtocolError)('Expected a native model call');
                         if (index !== 0)
                             (0, model_protocol_js_1.modelProtocolError)('Expected exactly one model call', 'MODEL_MULTIPLE_CALLS');
-                        if ((id !== undefined && (typeof id !== 'string' || !id)) ||
-                            (name !== undefined && typeof name !== 'string') ||
-                            (args !== undefined && typeof args !== 'string'))
-                            (0, model_protocol_js_1.modelProtocolError)('Invalid native model call fields');
-                        call ??= { id: '', name: '', arguments: '' };
-                        if (id !== undefined) {
-                            if (call.id && call.id !== id)
-                                (0, model_protocol_js_1.modelProtocolError)('Conflicting model call IDs');
-                            call.id = id;
-                        }
-                        call.name += name ?? '';
-                        call.arguments += args ?? '';
+                        collector.push(part);
                     },
                     finish() {
-                        if (!call?.id || !call.name || raw.trim())
+                        const calls = collector.complete();
+                        if (calls.length !== 1)
+                            (0, model_protocol_js_1.modelProtocolError)('Expected exactly one model call', 'MODEL_MULTIPLE_CALLS');
+                        if (raw.trim())
                             (0, model_protocol_js_1.modelProtocolError)('Expected one complete model call without prose');
-                        const completed = call;
+                        const completed = calls[0];
                         const capability = names.get(completed.name) ??
                             (0, model_protocol_js_1.modelProtocolError)('Model call is not registered for this stage');
                         return {
-                            capabilityId: capability,
+                            toolId: capability,
                             input: (0, arguments_js_1.parse)(completed.arguments),
                             call: {
                                 id: completed.id,

package/dist/cjs/model/message-diagnostics.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelMessageDiagnostics = modelMessageDiagnostics;
 /**
- * Replace every image payload with a placeholder.
+ * Replace every image payload and raw tool argument with a placeholder.
  *
  * Only the `url` is substituted; the `detail` hint is kept because it is small and
- * explains how the image was interpreted. The input array is not mutated.
+ * explains how the image was interpreted. Tool call ids and names remain because they
+ * identify the proposal; raw arguments are redacted. The input array is not mutated.
  *
  * @param messages - Messages about to be reported.
- * @returns New message objects whose images carry a placeholder URL.
+ * @returns New message objects with redacted images and tool arguments.
  */
 function modelMessageDiagnostics(messages) {
     return messages.map((message) => ({
@@ -18,5 +19,14 @@ function modelMessageDiagnostics(messages) {
                 images: message.images.map((image) => ({ ...image, url: '[image omitted]' })),
             }
             : {}),
+        ...(message.toolCalls
+            ? {
+                toolCalls: message.toolCalls.map((call) => ({
+                    id: call.id,
+                    name: call.name,
+                    arguments: '[tool arguments omitted]',
+                })),
+            }
+            : {}),
     }));
 }

package/dist/cjs/model/options.js

@@ -18,6 +18,8 @@ function snapshotModelOptions(options = {}) {
         includeUsage: options.includeUsage,
         onUsage: options.onUsage?.bind(options),
         functions: options.functions,
+        toolChoice: options.toolChoice,
+        parallelToolCalls: options.parallelToolCalls,
     };
     for (const key of Object.keys(snapshot)) {
         if (!(key in options))

package/dist/cjs/model/preparation.js

@@ -39,6 +39,23 @@ function snapshotImage(image) {
         (detail !== undefined && !['auto', 'low', 'high', 'original'].includes(detail)), () => new TypeError('Invalid model image'));
     return Object.freeze({ url, ...(detail === undefined ? {} : { detail }) });
 }
+/**
+ * Validate and freeze one assistant tool declaration.
+ *
+ * @param call - Candidate tool call.
+ * @returns A frozen tool call with only the declared fields.
+ * @throws TypeError When the id, name or raw arguments are invalid.
+ */
+function snapshotToolCall(call) {
+    (0, rules_js_1.breakWhile)(!call || typeof call !== 'object' || Array.isArray(call), () => new TypeError('Invalid model tool call'));
+    const { id, name, arguments: args } = call;
+    (0, rules_js_1.breakWhile)(typeof id !== 'string' ||
+        !id ||
+        typeof name !== 'string' ||
+        !name ||
+        typeof args !== 'string', () => new TypeError('Invalid model tool call'));
+    return Object.freeze({ id, name, arguments: args });
+}
 /**
  * Snapshot a dynamic transport once, preserving its collector factory receiver.
  *
@@ -99,19 +116,35 @@ function preparedInputSize(base, prepared) {
     (0, rules_js_1.breakWhile)(!Array.isArray(base), () => new TypeError('Model messages must be an array'));
     const snapshot = Array.from(base, (message) => {
         (0, rules_js_1.breakWhile)(!message || typeof message !== 'object' || Array.isArray(message), () => new TypeError('Invalid model message'));
-        const { role, content, images } = message;
-        (0, rules_js_1.breakWhile)(!['system', 'user', 'assistant'].includes(role) ||
+        const { role, content, images, toolCalls, toolCallId } = message;
+        const assistant = role === 'assistant';
+        const tool = role === 'tool';
+        (0, rules_js_1.breakWhile)(!['system', 'user', 'assistant', 'tool'].includes(role) ||
             typeof content !== 'string' ||
-            (images !== undefined && !Array.isArray(images)), () => new TypeError('Invalid model message'));
+            (images !== undefined && (!Array.isArray(images) || role !== 'user')) ||
+            (toolCalls !== undefined && (!Array.isArray(toolCalls) || !assistant)) ||
+            (toolCallId !== undefined &&
+                (!tool || typeof toolCallId !== 'string' || toolCallId.length === 0)) ||
+            (tool && (typeof toolCallId !== 'string' || toolCallId.length === 0)), () => new TypeError('Invalid model message'));
         return Object.freeze({
             role,
             content,
-            ...(images === undefined ? {} : { images: Object.freeze(Array.from(images, snapshotImage)) }),
+            ...(images === undefined
+                ? {}
+                : { images: Object.freeze(Array.from(images, snapshotImage)) }),
+            ...(toolCalls === undefined
+                ? {}
+                : { toolCalls: Object.freeze(Array.from(toolCalls, snapshotToolCall)) }),
+            ...(toolCallId === undefined ? {} : { toolCallId }),
         });
     });
     const messages = Object.freeze((0, token_budget_js_1.modelInputMessages)(snapshot, prepared.instruction).map((message) => Object.freeze(message)));
-    const messageChars = snapshot.reduce((sum, message) => sum + message.content.length, 0);
-    const instructionChars = messages.reduce((sum, message) => sum + message.content.length, 0) - messageChars;
+    const contentChars = snapshot.reduce((sum, message) => sum + message.content.length, 0);
+    const messageChars = snapshot.reduce((sum, message) => sum +
+        message.content.length +
+        (message.toolCalls?.reduce((callSum, call) => callSum + call.id.length + call.name.length + call.arguments.length, 0) ?? 0) +
+        (message.toolCallId?.length ?? 0), 0);
+    const instructionChars = messages.reduce((sum, message) => sum + message.content.length, 0) - contentChars;
     const functions = prepared.options.functions;
     const schemaChars = functions
         ? (functionSizes.get(functions) ?? JSON.stringify(functions).length)

package/dist/cjs/model/runner.js

@@ -13,6 +13,8 @@ exports.ModelRunner = exports.BudgetError = void 0;
  * Exports: `ModelRunner`, the re-exported `BudgetError`, and the runtime/config type
  * re-exports at the bottom of the file.
  */
+const sub_flow_js_1 = require("../diagnostics/sub-flow.js");
+const native_sub_flow_js_1 = require("../diagnostics/native-sub-flow.js");
 const events_js_1 = require("../execution/events.js");
 const call_budget_js_1 = require("./call-budget.js");
 const synchronous_js_1 = require("../utils/synchronous.js");
@@ -321,6 +323,19 @@ class ModelRunner {
         return snapshot;
     }
     async invoke(request) {
+        const context = typeof request === 'string' ? { logger: undefined, signal: undefined } : request;
+        (0, sub_flow_js_1.requireSubFlowLogger)(context.logger);
+        const callId = (0, invocation_js_1.invocationId)();
+        return (0, native_sub_flow_js_1.nativeSubFlowAsync)({
+            logger: context.logger,
+            signal: (0, cancellation_js_1.combineSignals)(this.signal, context.signal),
+            invocationId: callId,
+        }, 'model', typeof request === 'string'
+            ? defaults_js_1.modelRunnerDefaults.stage
+            : (request.stageId ?? request.prepared?.stageId ?? defaults_js_1.modelRunnerDefaults.stage), () => this.invokeRequest(request, callId));
+    }
+    /** Validate and execute a single request; optional recording is owned by invoke. */
+    async invokeRequest(request, callId) {
         const call = typeof request === 'string' ? { input: request } : request;
         const state = call.prepared === undefined ? undefined : this.preparedCalls.get(call.prepared);
         if (call.prepared !== undefined && (!state || state.used))
@@ -384,7 +399,7 @@ class ModelRunner {
             throw invalid('Prepared model request settings cannot be replaced');
         if (state)
             state.used = true;
-        return this.invokePrepared(stage, input, tokens, transportId, call.diagnostics, prepared, call.signal);
+        return this.invokePrepared(stage, input, tokens, transportId, call.diagnostics, prepared, call.signal, callId);
     }
     /**
      * Acquire the per-runner call slot and execute one call.
@@ -403,7 +418,7 @@ class ModelRunner {
      * @returns The parsed result with invocation metadata.
      * @throws Error When a call is already in flight or the request capacity is exhausted.
      */
-    async invokePrepared(stage, input, tokens, transportId, diagnostics = this.ports.diagnostics, prepared, requestSignal) {
+    async invokePrepared(stage, input, tokens, transportId, diagnostics = this.ports.diagnostics, prepared, requestSignal, callId = (0, invocation_js_1.invocationId)()) {
         const configuredRun = this.ports.diagnostics?.identity?.runId, selectedRun = diagnostics?.identity?.runId;
         if (configuredRun && selectedRun && configuredRun !== selectedRun)
             throw (0, errors_js_1.recordErrorContext)(new TypeError('Model observation parent belongs to a different run'), { stageId: stage, codes: ['MODEL_CONFIG'], isRetryable: false });
@@ -413,7 +428,7 @@ class ModelRunner {
         this.requestGate.active++;
         let failure;
         try {
-            return await this.execute(stage, input, tokens, transportId, (0, cancellation_js_1.combineSignals)(this.signal, requestSignal), diagnostics, prepared);
+            return await this.execute(stage, input, tokens, transportId, (0, cancellation_js_1.combineSignals)(this.signal, requestSignal), diagnostics, prepared, callId);
         }
         catch (error) {
             failure = (0, errors_js_1.recordErrorContext)(error, { stageId: stage });
@@ -444,8 +459,8 @@ class ModelRunner {
      * @returns The parsed result with invocation metadata.
      * @throws Error or ValidationError from any phase, decorated with stage context.
      */
-    async execute(stage, input, tokens, transportId, signal, parentDiagnostics = this.ports.diagnostics, prepared) {
-        const id = (0, invocation_js_1.invocationId)(), startedAtMs = Date.now();
+    async execute(stage, input, tokens, transportId, signal, parentDiagnostics = this.ports.diagnostics, prepared, callId = (0, invocation_js_1.invocationId)()) {
+        const id = callId, startedAtMs = Date.now();
         this.activeCall = undefined;
         const invocationDiagnostics = parentDiagnostics?.child(id, {
             invocationId: id,
@@ -617,6 +632,20 @@ class ModelRunner {
             catch {
                 /* best-effort metadata */
             }
+            try {
+                const calls = response.calls;
+                if (calls?.length) {
+                    step.calls = calls.map((call) => ({
+                        id: call.id,
+                        name: call.name,
+                        argumentChars: call.argumentChars,
+                        ...(call.toolId === undefined ? {} : { toolId: call.toolId }),
+                    }));
+                }
+            }
+            catch {
+                /* best-effort metadata */
+            }
         };
         const accountOutput = () => {
             const outputChars = response.outputChars;

package/dist/cjs/model/selection-transport.js

@@ -33,7 +33,7 @@ function createModelTransport(registration) {
     const adapter = registration.adapter ?? native_functions_js_1.nativeFunctionInteraction;
     if (registration.requireStrictArguments && !adapter.features.strictArguments)
         throw new TypeError(`Model interaction does not support strict arguments: ${adapter.id}`);
-    const source = registration.capabilities, createSource = typeof source === 'function' ? source.bind(registration) : undefined;
+    const source = registration.tools, createSource = typeof source === 'function' ? source.bind(registration) : undefined;
     const prepare = adapter.prepare.bind(adapter), options = Object.freeze((0, options_js_1.snapshotModelOptions)(registration.options));
     return Object.freeze({
         id: registration.id,
@@ -43,8 +43,8 @@ function createModelTransport(registration) {
                 : source;
             const definitions = [...catalog.values()];
             if (!definitions.length)
-                throw new TypeError('Model stage requires registered capabilities');
-            const capabilityIds = new Set(definitions.map((capability) => capability.id));
+                throw new TypeError('Model stage requires registered tools');
+            const toolIds = new Set(definitions.map((capability) => capability.id));
             const prepared = (0, synchronous_js_1.synchronous)(prepare(definitions), 'Model interaction preparation must be synchronous');
             const createResponse = prepared.createResponse.bind(prepared), resolve = catalog.resolve.bind(catalog);
             return {
@@ -65,7 +65,7 @@ function createModelTransport(registration) {
                         finish() {
                             const selection = (0, synchronous_js_1.synchronous)(buffer.finish(), 'Model selection parsers must be synchronous');
                             call = selection.call;
-                            if (!capabilityIds.has(selection.capabilityId))
+                            if (!toolIds.has(selection.toolId))
                                 (0, model_protocol_js_1.modelProtocolError)('Model capability is unavailable in this prepared call');
                             return (0, synchronous_js_1.synchronous)(resolve(selection, { stageId }), 'Model result parsers must be synchronous');
                         },

package/dist/cjs/model/token-budget.js

@@ -56,6 +56,9 @@ function countModelInput(budget, messages, options) {
     const snapshot = messages.map((message) => ({
         ...message,
         ...(message.images ? { images: message.images.map((image) => ({ ...image })) } : {}),
+        ...(message.toolCalls
+            ? { toolCalls: message.toolCalls.map((call) => ({ ...call })) }
+            : {}),
     }));
     const count = budget.countTokens({
         messages: snapshot,

package/dist/cjs/model/transports.js

@@ -49,16 +49,17 @@ function textResponse(decode) {
  *
  * @param id - Unique transport id, also used as the typed handle in `ModelRunner`.
  * @param options - Optional request options; only `temperature` is honored.
+ * @param trim - Trim surrounding whitespace from the final text; defaults to true.
  * @returns A frozen transport definition.
  */
-function createPlainTextTransport(id, options = {}) {
+function createPlainTextTransport(id, options = {}, trim = true) {
     const settings = Object.freeze({ ...(0, options_js_1.snapshotModelOptions)(options), json: false });
     return Object.freeze({
         id,
         prepare: (_stageId) => ({
             options: settings,
             schemaChars: 0,
-            createResponse: () => textResponse((raw) => raw.trim()),
+            createResponse: () => textResponse((raw) => (trim ? raw.trim() : raw)),
         }),
     });
 }

package/dist/cjs/structs/index.js

@@ -18,9 +18,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * Public entry of the structs layer.
  *
  * Structs are the shape-only half of agent-core: declarations and frozen constant catalogs that the
- * runtime modules (`capabilities`, `context`, `execution`, `model`, `kits`, `support`) both
- * implement and consume. Runtime classes declared here only describe shape or initialize fields,
- * so importing this barrel never starts execution.
+ * runtime modules (`tools`, `context`, `execution`, `model`, `kits`, `support`) both implement and
+ * consume. Runtime classes declared here only describe shape or initialize fields, so importing this
+ * barrel never starts execution.
  *
  * Exports: a curated re-export of the shared vocabulary, error classes, diagnostics/event
  * envelopes, model and workflow contracts, and the optional Kit protocol definitions.
@@ -35,6 +35,7 @@ __exportStar(require("./model/interactions.js"), exports);
 __exportStar(require("./context/journal.js"), exports);
 __exportStar(require("./support/transport/json.js"), exports);
 __exportStar(require("./model/messages.js"), exports);
+__exportStar(require("./model/session.js"), exports);
 __exportStar(require("./model/runtime.js"), exports);
 __exportStar(require("./support/model/provider.js"), exports);
 __exportStar(require("./kits/interaction.js"), exports);
@@ -48,10 +49,10 @@ __exportStar(require("./kits/evidence.js"), exports);
 __exportStar(require("./kits/presentation/templates.js"), exports);
 __exportStar(require("./kits/retrieval.js"), exports);
 __exportStar(require("./kits/text-skills.js"), exports);
-__exportStar(require("./kits/intents/registry.js"), exports);
-__exportStar(require("./kits/intents/scopes.js"), exports);
+__exportStar(require("./kits/domains/registry.js"), exports);
+__exportStar(require("./kits/domains/scopes.js"), exports);
 __exportStar(require("./kits/tools.js"), exports);
-__exportStar(require("./kits/intents/catalog.js"), exports);
+__exportStar(require("./kits/domains/catalog.js"), exports);
 __exportStar(require("./support/registration.js"), exports);
 __exportStar(require("./diagnostics.js"), exports);
 __exportStar(require("./support/context.js"), exports);

package/dist/cjs/structs/kits/domains/scopes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structs/kits/presentation/formats.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structs/kits/text-blocks.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Text block contract for the Text Blocks Kit.
+ *
+ * Place in the package: an optional App-side helper for splitting long plain text into
+ * structure-aware blocks before paging or retrieval. File reading, paging, search, storage
+ * and prompt wording stay with the App.
+ *
+ * Exports: `TextBlock`, `TextBlockOptions`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structs/model/session.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Raw session response contracts: one response may carry text and several tool calls.
+ *
+ * These shapes are Core-only and deliberately contain no host tool resolution. Support's
+ * session transport adds `toolId`, parsed `input` and non-fatal `problem` fields in its own
+ * `ResolvedSessionResult` type.
+ *
+ * Exports: `ModelSessionCall`, `ModelSessionResult`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/structs/support/associations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/support/associations.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineAssociatedCatalog = defineAssociatedCatalog;
+/** Compile owner-to-tool relations without parallel intent identities or execution side effects. */
+const catalog_js_1 = require("../utils/catalog.js");
+const synchronous_js_1 = require("../utils/synchronous.js");
+const capabilities_js_1 = require("./model/capabilities.js");
+/** Compile independent and owner-derived Tool declarations, validating all references eagerly. */
+function defineAssociatedCatalog(entries, options = {}) {
+    const owners = (0, catalog_js_1.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
+            ? (0, synchronous_js_1.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: (0, capabilities_js_1.defineModelTools)([...definitions.values()]),
+        bindings: (0, catalog_js_1.readonlyCatalog)(bindings, (id) => new TypeError(`Unknown tool binding: ${id}`)),
+        sources: (0, catalog_js_1.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}`)),
+    });
+}