@jangts/agent-core 0.3.6 → 0.5.0

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 }),
+            });
+        },
+    });
+}

package/dist/cjs/support/model/stage-transport.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStageModelTransport = createStageModelTransport;
 /**
- * Stage-scoped model transport: expose only the capabilities declared for each stage.
+ * Stage-scoped model transport: expose only the tools declared for each stage.
  *
  * Static capability sources are projected once at construction; dynamic sources are re-projected
  * at the model boundary. Either way, an undeclared stage or capability is rejected rather than
@@ -19,14 +19,14 @@ const transports_js_1 = require("./transports.js");
  *
  * @param registration Transport declaration: unique ID, stage-to-capability references, interaction
  *   adapter, options and a static or per-stage capability source.
- * @returns A Core model transport with `capabilities(stage)`.
+ * @returns A Core model transport with `tools(stage)`.
  * @throws {Error} When a stage ID repeats, has no capability IDs, the declaration has no stages, a
  *   stage or capability is not registered, or a dynamic capability source is asynchronous.
  */
 function createStageModelTransport(registration) {
     const stages = new Map();
     for (const stage of registration.stages) {
-        const ids = stage.capabilityIds;
+        const ids = stage.toolIds;
         (0, rules_js_1.breakWhile)(!stage.id?.trim() ||
             stages.has(stage.id) ||
             !Array.isArray(ids) ||
@@ -35,15 +35,15 @@ function createStageModelTransport(registration) {
         stages.set(stage.id, Object.freeze([...ids]));
     }
     (0, rules_js_1.breakWhile)(!stages.size, 'Model transport requires declared stages');
-    const { id, adapter, options, requireStrictArguments, capabilities: source } = registration;
-    const project = (stage, capabilities) => {
+    const { id, adapter, options, requireStrictArguments, tools: source } = registration;
+    const project = (stage, tools) => {
         const ids = stages.get(stage);
         (0, rules_js_1.breakWhile)(!ids, `Unregistered model stage: ${id} -> ${stage}`);
-        const catalog = new model_js_1.ModelCapabilityRegistry(capabilities.values());
+        const catalog = new model_js_1.ModelToolRegistry(tools.values());
         for (const id of ids)
             (0, rules_js_1.breakWhile)(!catalog.has(id), `Unregistered model capability: ${stage} -> ${id}`);
         const selected = catalog.select(ids);
-        const resolve = capabilities.resolve.bind(capabilities);
+        const resolve = tools.resolve.bind(tools);
         return Object.freeze({
             values: () => selected.values(),
             resolve(selection, context) {
@@ -61,7 +61,7 @@ function createStageModelTransport(registration) {
         adapter,
         options,
         requireStrictArguments,
-        capabilities(stage) {
+        tools(stage) {
             (0, rules_js_1.breakWhile)(!stages.has(stage), `Unregistered model stage: ${id} -> ${stage}`);
             return fixed
                 ? fixed.get(stage)

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModelTransport = void 0;
+exports.prepareSessionFunctions = exports.createSessionModelTransport = exports.createModelTransport = void 0;
 exports.createTextTransport = createTextTransport;
 exports.createJsonTransport = createJsonTransport;
 /**
@@ -18,6 +18,9 @@ const model_protocol_js_1 = require("../../utils/model-protocol.js");
 const transports_js_1 = require("../../model/transports.js");
 var selection_transport_js_1 = require("../../model/selection-transport.js");
 Object.defineProperty(exports, "createModelTransport", { enumerable: true, get: function () { return selection_transport_js_1.createModelTransport; } });
+var session_js_1 = require("./session.js");
+Object.defineProperty(exports, "createSessionModelTransport", { enumerable: true, get: function () { return session_js_1.createSessionModelTransport; } });
+Object.defineProperty(exports, "prepareSessionFunctions", { enumerable: true, get: function () { return session_js_1.prepareSessionFunctions; } });
 /**
  * Create a plain-text transport that trims the assembled response.
  *
@@ -25,7 +28,7 @@ Object.defineProperty(exports, "createModelTransport", { enumerable: true, get:
  * @returns A frozen Core transport definition typed as string output.
  */
 function createTextTransport(definition) {
-    return (0, transports_js_1.createPlainTextTransport)(definition.id, definition.options);
+    return (0, transports_js_1.createPlainTextTransport)(definition.id, definition.options, definition.trim);
 }
 /**
  * Create a typed JSON transport without a capability-selection envelope.