@jangts/agent-core 0.1.1 → 0.2.1

package/dist/cjs/utils/invocation.js

@@ -3,14 +3,52 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.invocationId = invocationId;
 exports.invocationResult = invocationResult;
 exports.toolInvocation = toolInvocation;
-/** Call IDs are platform-neutral and independent of App/request identities. */
-function invocationId() { return globalThis.crypto.randomUUID(); }
+/**
+ * Generate an invocation id.
+ *
+ * @returns A random UUID from the platform crypto implementation.
+ */
+function invocationId() {
+    return globalThis.crypto.randomUUID();
+}
+/**
+ * Wrap a value and its metadata in a frozen result envelope.
+ *
+ * Both layers are frozen so downstream consumers cannot mutate an already reported
+ * invocation.
+ *
+ * @param value - The produced value.
+ * @param metadata - Invocation metadata describing the call.
+ * @returns A frozen `InvocationResult`.
+ */
 function invocationResult(value, metadata) {
     return Object.freeze({ value, invocation: Object.freeze(metadata) });
 }
+/**
+ * Normalize the positional tool-invocation shorthand used by App handlers.
+ *
+ * The shorthand only accepts exactly one request so a handler cannot silently drop
+ * additional tools; the request must carry a non-blank `toolId` and an explicit
+ * `input` property, which distinguishes "no input" from "input omitted".
+ *
+ * @param request - Candidate request supplied as a single argument.
+ * @param arity - Number of arguments the caller actually passed; must be 1.
+ * @returns A plain object with the four supported request fields.
+ * @throws TypeError When the arity or the request shape is invalid.
+ */
 function toolInvocation(request, arity) {
-    if (arity !== 1 || !request || typeof request !== 'object' || typeof request.toolId !== 'string' || !request.toolId.trim() || !('input' in request)) {
+    if (arity !== 1 ||
+        !request ||
+        typeof request !== 'object' ||
+        typeof request.toolId !== 'string' ||
+        !request.toolId.trim() ||
+        !('input' in request)) {
         throw new TypeError('Use one tool request with toolId and input');
     }
-    return { toolId: request.toolId, input: request.input, diagnostics: request.diagnostics, signal: request.signal };
+    return {
+        toolId: request.toolId,
+        input: request.input,
+        diagnostics: request.diagnostics,
+        signal: request.signal,
+    };
 }

package/dist/cjs/utils/model-protocol.js

@@ -1,7 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelProtocolError = modelProtocolError;
+/**
+ * Fail a model-facing protocol contract.
+ *
+ * Model output is untrusted input: violations are reported as `ValidationError`
+ * issues so callers can inspect every problem instead of catching a bare Error.
+ *
+ * Exports: `modelProtocolError`.
+ */
 const errors_js_1 = require("../structs/errors.js");
+/**
+ * Throw a model protocol validation error.
+ *
+ * @param message - Primary issue message, always reported with code `MODEL_PROTOCOL`.
+ * @param reason - Optional secondary code for the same message, used to distinguish variants.
+ * @returns Never returns; the declared `never` return lets callers use it in expressions.
+ * @throws ValidationError carrying one or two issues.
+ */
 function modelProtocolError(message, reason) {
-    throw new errors_js_1.ValidationError([{ code: 'MODEL_PROTOCOL', message }, ...(reason ? [{ code: reason, message }] : [])]);
+    throw new errors_js_1.ValidationError([
+        { code: 'MODEL_PROTOCOL', message },
+        ...(reason ? [{ code: reason, message }] : []),
+    ]);
 }

package/dist/cjs/utils/object.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.freezeSchema = freezeSchema;
+/**
+ * Structural object freezing for schema snapshots.
+ *
+ * JSON schemas are shared by definition, so a consumer that mutates a nested keyword
+ * would corrupt every other consumer. This deep freeze makes that attempt fail loudly.
+ *
+ * Exports: `freezeSchema`.
+ */
+/**
+ * Recursively freeze an object graph.
+ *
+ * Arrays are objects, so they are covered as well. Already frozen nodes are skipped,
+ * which makes the walk safe on cyclic or shared sub-graphs and idempotent.
+ *
+ * @param value - Candidate node; primitives and non-objects are ignored.
+ */
 function freezeSchema(value) {
     if (!value || typeof value !== 'object' || Object.isFrozen(value))
         return;

package/dist/cjs/utils/observer.js

@@ -1,7 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.observeSafely = observeSafely;
-/** Observers receive detached data; uncloneable observations are skipped, never exposed by reference. */
+/**
+ * Defensive delivery of observed values to App-supplied observers.
+ *
+ * Observation is optional and must never influence the observed operation, so the
+ * value is cloned, failures are swallowed and returned promises are consumed.
+ *
+ * Exports: `observeSafely`.
+ */
+/**
+ * Deliver a detached copy of a value to an observer.
+ *
+ * The clone prevents an observer from mutating execution state through a shared
+ * reference. A value that cannot be structured-cloned is skipped entirely rather
+ * than handed over by reference.
+ *
+ * @param observe - Observer callback, if one is installed.
+ * @param value - Value to clone and deliver.
+ * @returns Nothing; the observer may run asynchronously after this returns.
+ */
 function observeSafely(observe, value) {
     if (!observe)
         return;
@@ -10,5 +28,7 @@ function observeSafely(observe, value) {
         if (pending)
             void Promise.resolve(pending).catch(() => { });
     }
-    catch { /* Observation is independent of the operation. */ }
+    catch {
+        /* Observation is independent of the operation. */
+    }
 }

package/dist/cjs/utils/protocol-registry.js

@@ -1,16 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProtocolRegistry = void 0;
-/** Schema and terminal semantics come entirely from registration, with no built-in step names. */
+/**
+ * Strict id-keyed registry for model output protocols.
+ *
+ * Registration is the only source of schema and terminal semantics: the core never
+ * knows protocol names. Writes are checked eagerly so a duplicate or blank id fails at
+ * wiring time instead of at dispatch time.
+ *
+ * Exports: `ProtocolRegistry`.
+ */
+/**
+ * Append-only protocol registry.
+ *
+ * Extending `Map` keeps lookup semantics familiar while `set` rejects every invalid
+ * registration, which makes the instance effectively immutable after wiring.
+ */
 class ProtocolRegistry extends Map {
+    /**
+     * @param definitions - Initial id/protocol pairs, applied through the validating `set`.
+     * @throws TypeError When any initial entry is invalid or duplicated.
+     */
     constructor(definitions = []) {
         super();
         for (const [id, protocol] of definitions)
             this.set(id, protocol);
     }
-    ids() { return Object.freeze([...this.keys()]); }
-    require(id) { const value = this.get(id); if (value === undefined)
-        throw new TypeError(`Unknown protocol: ${id}`); return value; }
+    /**
+     * @returns A frozen array of registered ids in insertion order.
+     */
+    ids() {
+        return Object.freeze([...this.keys()]);
+    }
+    /**
+     * Look up a protocol that must exist.
+     *
+     * @param id - Protocol id.
+     * @returns The registered protocol.
+     * @throws TypeError When the id is unknown.
+     */
+    require(id) {
+        const value = this.get(id);
+        if (value === undefined)
+            throw new TypeError(`Unknown protocol: ${id}`);
+        return value;
+    }
+    /**
+     * Register a protocol.
+     *
+     * @param id - Non-blank protocol id.
+     * @param protocol - Protocol implementation.
+     * @returns This registry, for chaining.
+     * @throws TypeError When the id is blank or the protocol is nullish.
+     * @throws Error When the id is already registered.
+     */
     set(id, protocol) {
         if (!id.trim() || protocol === null || protocol === undefined)
             throw new TypeError('Invalid protocol registration');

package/dist/cjs/utils/query-key.js

@@ -1,8 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrievalQueryKey = retrievalQueryKey;
+/**
+ * Stable identity for retrieval queries.
+ *
+ * Retrieval caches need a key that is insensitive to property order but sensitive to
+ * array order, because a query's result list is order-dependent.
+ *
+ * Exports: `retrievalQueryKey`.
+ */
 const rules_js_1 = require("./rules.js");
-/** Stable structural equality for queries; array order remains meaningful. */
+/**
+ * Serialize a query into a stable structural key.
+ *
+ * Object keys are sorted recursively while array positions are preserved. Values that
+ * JSON cannot represent, such as functions or `undefined`, make `JSON.stringify`
+ * return undefined and therefore produce an error instead of a colliding key.
+ *
+ * @param value - Query value to canonicalize.
+ * @returns A JSON string usable as a map key.
+ * @throws TypeError When the value cannot be serialized.
+ */
 function retrievalQueryKey(value) {
     const serialized = JSON.stringify(canonical(value));
     (0, rules_js_1.breakWhile)(serialized === undefined, () => new TypeError('Query cannot be serialized'));
@@ -12,7 +30,8 @@ function canonical(value) {
     if (Array.isArray(value))
         return value.map(canonical);
     if (value && typeof value === 'object') {
-        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
             .map(([key, item]) => [key, canonical(item)]));
     }
     return value;

package/dist/cjs/utils/registration.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registrationData = registrationData;
-/** Snapshot inherited metadata with its real receiver, without retaining a mutable prototype. */
+/**
+ * Copy the inherited, non-function data of a definition.
+ *
+ * The walk starts at the source and moves up the prototype chain while reading every
+ * accessor with the source as receiver, so getters keep observing their own instance
+ * without the snapshot retaining the mutable prototype. `constructor` is skipped for
+ * inherited levels because it describes the class rather than the definition.
+ *
+ * @param source - Definition to snapshot.
+ * @param excluded - Keys that must not appear in the result.
+ * @returns A plain object containing enumerable, writable non-function data.
+ */
 function registrationData(source, excluded = []) {
     const result = {};
     const seen = new Set(excluded);
@@ -13,7 +24,12 @@ function registrationData(source, excluded = []) {
             const descriptor = Object.getOwnPropertyDescriptor(owner, key);
             const value = descriptor.get ? descriptor.get.call(source) : descriptor.value;
             if (typeof value !== 'function')
-                Object.defineProperty(result, key, { value, enumerable: true, configurable: true, writable: true });
+                Object.defineProperty(result, key, {
+                    value,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                });
         }
     }
     return result;

package/dist/cjs/utils/rules.js

@@ -8,14 +8,29 @@ const synchronous_js_1 = require("./synchronous.js");
 const break_observer_js_1 = require("./break-observer.js");
 var break_observer_js_2 = require("./break-observer.js");
 Object.defineProperty(exports, "configureBreakWhile", { enumerable: true, get: function () { return break_observer_js_2.configureBreakWhile; } });
-/** First match owns the result, even when its handler returns undefined. */
+/**
+ * Dispatch to the first matching rule.
+ *
+ * A rule without a pattern matches unconditionally, so the table's order decides
+ * precedence. The first match owns the result even when its handler returns undefined,
+ * and later rules are not consulted.
+ *
+ * @param rules - Ordered rules; only the first match is executed.
+ * @param input - Value passed to the pattern and handler.
+ * @returns The handler result, or undefined when nothing matched.
+ * @throws TypeError When a pattern returns a thenable or a non-boolean.
+ */
 function matchRule(rules, input) {
-    return rules.find(rule => rule.pattern === undefined || (0, synchronous_js_1.booleanResult)(rule.pattern(input), 'Rule patterns must return boolean synchronously'))?.handle(input);
+    return rules
+        .find((rule) => rule.pattern === undefined ||
+        (0, synchronous_js_1.booleanResult)(rule.pattern(input), 'Rule patterns must return boolean synchronously'))
+        ?.handle(input);
 }
 function walkRules(rules, input = undefined) {
     for (const rule of rules) {
         (0, synchronous_js_1.synchronous)(rule.before?.(input), 'Rule traversal hooks must be synchronous');
-        if (rule.pattern === undefined || (0, synchronous_js_1.booleanResult)(rule.pattern(input), 'Rule patterns must return boolean synchronously'))
+        if (rule.pattern === undefined ||
+            (0, synchronous_js_1.booleanResult)(rule.pattern(input), 'Rule patterns must return boolean synchronously'))
             (0, synchronous_js_1.synchronous)(rule.handle(input), 'Rule traversal handlers must be synchronous');
     }
 }
@@ -24,24 +39,37 @@ function breakWhile(occur, errorOrTags, tags = []) {
     const callTags = Array.isArray(errorOrTags) ? errorOrTags : tags;
     // A single value keeps ordinary JS truthiness, including a function used as a value.
     const checks = Array.isArray(occur)
-        ? typeof occur[0] === 'function' && occur.every(item => typeof item === 'function')
+        ? typeof occur[0] === 'function' && occur.every((item) => typeof item === 'function')
             ? [{ occur, error }]
             : occur
         : [{ occur: () => occur, error }];
     for (const check of checks) {
         try {
-            if (!check || typeof check !== 'object' || Array.isArray(check) || !Object.hasOwn(check, 'occur')
-                || 'condition' in check || 'conditions' in check)
+            if (!check ||
+                typeof check !== 'object' ||
+                Array.isArray(check) ||
+                !Object.hasOwn(check, 'occur') ||
+                'condition' in check ||
+                'conditions' in check)
                 throw new TypeError('A break check requires occur; condition and conditions were renamed to occur');
             const occur = check.occur;
-            if (Array.isArray(occur) && occur.some(predicate => typeof predicate !== 'function'))
+            if (Array.isArray(occur) && occur.some((predicate) => typeof predicate !== 'function'))
                 throw new TypeError('An occur array requires predicates');
-            const matched = Array.isArray(occur) ? occur.some(predicate => (0, synchronous_js_1.synchronous)(predicate(), 'Occur predicates must be synchronous'))
-                : typeof occur === 'function' ? (0, synchronous_js_1.synchronous)(occur(), 'Occur predicates must be synchronous') : occur;
+            const matched = Array.isArray(occur)
+                ? occur.some((predicate) => (0, synchronous_js_1.synchronous)(predicate(), 'Occur predicates must be synchronous'))
+                : typeof occur === 'function'
+                    ? (0, synchronous_js_1.synchronous)(occur(), 'Occur predicates must be synchronous')
+                    : occur;
             if (!matched)
                 continue;
-            const reason = typeof check.error === 'function' ? (0, synchronous_js_1.synchronous)(check.error(), 'Break reasons must be synchronous') : check.error;
-            throw reason === undefined ? new Error() : typeof reason === 'string' ? new Error(reason) : reason;
+            const reason = typeof check.error === 'function'
+                ? (0, synchronous_js_1.synchronous)(check.error(), 'Break reasons must be synchronous')
+                : check.error;
+            throw reason === undefined
+                ? new Error()
+                : typeof reason === 'string'
+                    ? new Error(reason)
+                    : reason;
         }
         catch (failure) {
             (0, break_observer_js_1.observeBreak)(failure, callTags, check);

package/dist/cjs/utils/schema-adapter.js

@@ -1,9 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.snapshotSchemaAdapter = snapshotSchemaAdapter;
+/**
+ * Snapshot helper for registered schema adapters.
+ *
+ * An adapter owns a JSON schema and a parser. Both must be detached from the App object
+ * that supplied them, both must be immutable afterwards, and the parser must stay
+ * synchronous, because schema snapshots are reused across requests and diagnostics.
+ *
+ * Exports: `snapshotSchemaAdapter`.
+ */
 const object_js_1 = require("./object.js");
 const synchronous_js_1 = require("./synchronous.js");
-/** Pin the parser and its receiver independently of the schema snapshot. */
+/**
+ * Detach a schema adapter into a frozen, synchronous definition.
+ *
+ * The JSON schema is cloned and deep-frozen; the parser is bound to the original
+ * definition so a method keeps its receiver, then wrapped so a thenable result is
+ * rejected rather than awaited.
+ *
+ * @param definition - Adapter to snapshot.
+ * @param asyncError - Message used when the parser returns a thenable.
+ * @returns A frozen adapter with a cloned schema and a synchronous parser.
+ * @throws TypeError When `jsonSchema` is missing or not a plain object.
+ */
 function snapshotSchemaAdapter(definition, asyncError = 'Schema parsers must be synchronous') {
     const { jsonSchema } = definition;
     if (!jsonSchema || typeof jsonSchema !== 'object' || Array.isArray(jsonSchema)) {
@@ -12,5 +32,8 @@ function snapshotSchemaAdapter(definition, asyncError = 'Schema parsers must be
     const snapshot = structuredClone(jsonSchema);
     (0, object_js_1.freezeSchema)(snapshot);
     const parse = definition.parse.bind(definition);
-    return Object.freeze({ jsonSchema: snapshot, parse: (input) => (0, synchronous_js_1.synchronous)(parse(input), asyncError) });
+    return Object.freeze({
+        jsonSchema: snapshot,
+        parse: (input) => (0, synchronous_js_1.synchronous)(parse(input), asyncError),
+    });
 }

package/dist/cjs/utils/synchronous.js

@@ -5,12 +5,38 @@ exports.synchronous = synchronous;
 exports.assertion = assertion;
 exports.maybeAssertion = maybeAssertion;
 exports.booleanResult = booleanResult;
-/** Shared thenable test for contracts that either reject or explicitly await one. */
+/**
+ * Guards for contracts that require synchronous participants.
+ *
+ * Handlers, predicates and parsers are declared synchronous by contract. Detecting an
+ * accidental async implementation early is cheaper than debugging an interleaved
+ * execution, so every such call site passes its result through these helpers.
+ *
+ * Exports: `isPromiseLike`, `synchronous`, `assertion`, `maybeAssertion` and
+ * `booleanResult`.
+ */
+/**
+ * Test for a thenable without invoking it.
+ *
+ * @param value - Candidate value.
+ * @returns True when the value carries a callable `then`.
+ */
 function isPromiseLike(value) {
-    return value !== null && (typeof value === 'object' || typeof value === 'function')
-        && typeof value.then === 'function';
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
 }
-/** Reject an accidental async callback and consume its eventual rejection. This cannot undo its side effects. */
+/**
+ * Reject an accidentally asynchronous callback.
+ *
+ * A thenable is consumed before throwing so its eventual rejection cannot surface as an
+ * unhandled rejection. Any side effects the callback already started cannot be undone.
+ *
+ * @param value - Result of the callback.
+ * @param message - Message for the TypeError raised when the result is thenable.
+ * @returns The same value, narrowed to a non-thenable.
+ * @throws TypeError When the value is a thenable.
+ */
 function synchronous(value, message) {
     if (isPromiseLike(value)) {
         void Promise.resolve(value).catch(() => { });
@@ -18,17 +44,48 @@ function synchronous(value, message) {
     }
     return value;
 }
-/** Assertions and authorization must finish with undefined, never a discarded boolean. */
+/**
+ * Require an assertion hook to finish with `undefined`.
+ *
+ * Returning a boolean is a common mistake that would silently pass; requiring `void`
+ * makes a discarded decision fail loudly.
+ *
+ * @param value - Result of the assertion hook.
+ * @param message - Message for the TypeError.
+ * @throws TypeError When the result is thenable or not `undefined`.
+ */
 function assertion(value, message) {
     if (synchronous(value, message) !== undefined)
         throw new TypeError(message);
 }
-/** Retain a synchronous assertion when allowed; await only actual thenables. */
+/**
+ * Accept a synchronous assertion or await an actually asynchronous one.
+ *
+ * Only a thenable is awaited; synchronous results are validated immediately so callers
+ * that rely on ordering do not yield to the event loop unnecessarily.
+ *
+ * @param value - Result of the assertion hook.
+ * @param message - Message for the TypeError.
+ * @returns Nothing, or a promise resolved once the awaited assertion passed.
+ * @throws TypeError When the hook does not finish with `undefined`.
+ */
 function maybeAssertion(value, message) {
     if (isPromiseLike(value))
-        return Promise.resolve(value).then(result => assertion(result, message));
+        return Promise.resolve(value).then((result) => assertion(result, message));
     assertion(value, message);
 }
+/**
+ * Require a synchronous boolean decision.
+ *
+ * Truthiness is not accepted: routing must receive an explicit `true` or `false` so a
+ * predicate that forgets to return a value is reported instead of silently skipping.
+ *
+ * @param value - Result of the predicate.
+ * @param message - Message for the thenable TypeError.
+ * @param invalidMessage - Message for the non-boolean TypeError; defaults to `message`.
+ * @returns The validated boolean.
+ * @throws TypeError When the result is thenable or not boolean.
+ */
 function booleanResult(value, message, invalidMessage = message) {
     const result = synchronous(value, message);
     if (typeof result !== 'boolean')

package/dist/cjs/utils/text.js

@@ -1,7 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.commonPrefixLength = commonPrefixLength;
-/** Native prefix comparisons avoid a JavaScript character loop on long prompts. */
+/**
+ * Small string helpers used for prompt accounting.
+ *
+ * Exports: `commonPrefixLength`.
+ */
+/**
+ * Length of the longest common prefix of two strings.
+ *
+ * Implemented as a binary search over slice comparisons so long prompts stay on the
+ * native string comparison path instead of running a JavaScript character loop.
+ *
+ * @param left - First string.
+ * @param right - Second string.
+ * @returns Number of leading characters both strings share, bounded by the shorter length.
+ */
 function commonPrefixLength(left, right) {
     let low = 0;
     let high = Math.min(left.length, right.length);

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

@@ -1,3 +1,16 @@
+/**
+ * Capability registration surface: model capabilities, executable tools and host-selected
+ * invocations.
+ *
+ * These registries hold declarations only. Which capabilities a stage may use, whether a
+ * call is authorized, and what a payload means remain App decisions; this barrel provides
+ * the mechanisms that validate, seal and execute those declarations.
+ *
+ * Exports: the model capability registry (`model`), the executable tool registry and its
+ * sync/async invocation entry points (`tools`), host-selected invocation execution
+ * (`invocation`), and the Interaction Kit's protocol, command and handler definitions that
+ * shape and validate model-produced interactions.
+ */
 export * from './model.js';
 export * from './tools.js';
 export * from './invocation.js';

package/dist/esm/capabilities/index.js

@@ -1,3 +1,16 @@
+/**
+ * Capability registration surface: model capabilities, executable tools and host-selected
+ * invocations.
+ *
+ * These registries hold declarations only. Which capabilities a stage may use, whether a
+ * call is authorized, and what a payload means remain App decisions; this barrel provides
+ * the mechanisms that validate, seal and execute those declarations.
+ *
+ * Exports: the model capability registry (`model`), the executable tool registry and its
+ * sync/async invocation entry points (`tools`), host-selected invocation execution
+ * (`invocation`), and the Interaction Kit's protocol, command and handler definitions that
+ * shape and validate model-produced interactions.
+ */
 export * from './model.js';
 export * from './tools.js';
 export * from './invocation.js';

package/dist/esm/capabilities/invocation.d.ts

@@ -1,4 +1,18 @@
 import type { InvocationHandler, ToolInvocationPorts } from '../structs/capabilities/invocation.js';
-/** Execute a host-selected synchronous call. Selection, authorization facts and payload shape stay outside. */
+/**
+ * Run one synchronous invocation and record its effects.
+ *
+ * @param invocation Handler whose `call` performs the work; its `id` becomes the tool id in
+ *   diagnostics and journal records.
+ * @param input Payload handed to the handler unchanged.
+ * @param context App context passed to the ports below; it is never inspected here.
+ * @param ports Per-context callbacks for diagnostics, cancellation, journalling and receipt
+ *   capture. All are optional: without them the handler still runs, just unrecorded.
+ * @returns Nothing. The outcome is conveyed through the journal receipt, when one is bound.
+ * @throws TypeError when the handler identity is missing, or when the handler returns a
+ *   promise despite the synchronous contract.
+ * @throws Whatever the handler throws, unchanged, including the abort error raised by the
+ *   signal checks.
+ */
 export declare function executeInvocation<Input, Context>(invocation: InvocationHandler<Input, Context>, input: Input, context: Context, ports?: ToolInvocationPorts<Context>): void;
-export type { InvocationHandler, ToolInvocationPorts, ToolJournal } from '../structs/capabilities/invocation.js';
+export type { InvocationHandler, ToolInvocationPorts, ToolJournal, } from '../structs/capabilities/invocation.js';