@jangts/agent-core 0.1.0 → 0.2.0

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

@@ -1,3 +1,10 @@
+/**
+ * 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.
+ */
 export * from './runner.js';
 export * from '../structs/model/chat-provider.js';
 export * from '../support/model/compatible-provider.js';

package/dist/esm/model/index.js

@@ -1,3 +1,10 @@
+/**
+ * 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.
+ */
 export * from './runner.js';
 export * from '../structs/model/chat-provider.js';
 export * from '../support/model/compatible-provider.js';

package/dist/esm/model/interactions/arguments.d.ts

@@ -1,3 +1,30 @@
+/**
+ * Require a plain argument object.
+ *
+ * @param value - Candidate value.
+ * @returns The value typed as a string-keyed record.
+ * @throws ValidationError When the value is not a non-array object.
+ */
 export declare function object(value: unknown): Record<string, unknown>;
+/**
+ * Parse a complete JSON argument payload.
+ *
+ * Incomplete JSON is rejected rather than repaired, because a truncated stream must not
+ * be executed as a plausible partial call.
+ *
+ * @param raw - Complete JSON text.
+ * @returns The parsed argument object.
+ * @throws ValidationError When the text is not complete JSON or not an object.
+ */
 export declare function parse(raw: string): Record<string, unknown>;
+/**
+ * Map a business capability id onto a wire-safe function name.
+ *
+ * Business ids are not constrained by the wire protocol's naming alphabet or length, so
+ * an already valid id is returned unchanged and any other id is sanitized and suffixed
+ * with an FNV-1a hash. The hash keeps distinct ids distinct after sanitizing.
+ *
+ * @param id - Registered capability id.
+ * @returns A name matching the protocol's expected pattern.
+ */
 export declare function wireName(id: string): string;

package/dist/esm/model/interactions/arguments.js

@@ -1,9 +1,35 @@
+/**
+ * Shared argument decoding for interaction adapters.
+ *
+ * Every adapter ultimately produces the same pair — capability id and argument
+ * object — so parsing, validation and wire naming live here instead of being repeated
+ * per wire format.
+ *
+ * Exports: `object`, `parse` and `wireName`.
+ */
 import { modelProtocolError } from '../../utils/model-protocol.js';
+/**
+ * Require a plain argument object.
+ *
+ * @param value - Candidate value.
+ * @returns The value typed as a string-keyed record.
+ * @throws ValidationError When the value is not a non-array object.
+ */
 export function object(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         modelProtocolError('Model arguments must be an object');
     return value;
 }
+/**
+ * Parse a complete JSON argument payload.
+ *
+ * Incomplete JSON is rejected rather than repaired, because a truncated stream must not
+ * be executed as a plausible partial call.
+ *
+ * @param raw - Complete JSON text.
+ * @returns The parsed argument object.
+ * @throws ValidationError When the text is not complete JSON or not an object.
+ */
 export function parse(raw) {
     let value;
     try {
@@ -14,7 +40,16 @@ export function parse(raw) {
     }
     return object(value);
 }
-// Business IDs are not constrained by the wire protocol's naming alphabet/length.
+/**
+ * Map a business capability id onto a wire-safe function name.
+ *
+ * Business ids are not constrained by the wire protocol's naming alphabet or length, so
+ * an already valid id is returned unchanged and any other id is sanitized and suffixed
+ * with an FNV-1a hash. The hash keeps distinct ids distinct after sanitizing.
+ *
+ * @param id - Registered capability id.
+ * @returns A name matching the protocol's expected pattern.
+ */
 export function wireName(id) {
     if (/^[a-zA-Z0-9_-]{1,64}$/.test(id))
         return id;

package/dist/esm/model/interactions/json-object.d.ts

@@ -1,3 +1,9 @@
 import type { ModelInteractionAdapter } from '../../structs/model/interactions.js';
-/** Explicit alternative for providers without native calling. Its envelope belongs to this adapter, not to application messages. */
+/**
+ * Adapter that reads a single capability call out of a JSON object response.
+ *
+ * `strictArguments` is false because the wire format carries no schema enforcement; the
+ * adapter validates the envelope shape itself and leaves argument validation to the
+ * capability's own schema.
+ */
 export declare const jsonObjectInteraction: ModelInteractionAdapter;

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

@@ -1,29 +1,65 @@
+/**
+ * Interaction adapter for providers without native tool calling.
+ *
+ * Instead of function declarations, the capability list is embedded in the instruction
+ * and the model must answer with one JSON envelope. The envelope belongs to this
+ * adapter, not to application messages, so switching adapters never changes App code.
+ *
+ * Exports: `jsonObjectInteraction`.
+ */
 import { modelProtocolError } from '../../utils/model-protocol.js';
 import { object, parse } from './arguments.js';
-/** Explicit alternative for providers without native calling. Its envelope belongs to this adapter, not to application messages. */
+/**
+ * Adapter that reads a single capability call out of a JSON object response.
+ *
+ * `strictArguments` is false because the wire format carries no schema enforcement; the
+ * adapter validates the envelope shape itself and leaves argument validation to the
+ * capability's own schema.
+ */
 export const jsonObjectInteraction = Object.freeze({
     id: 'json-object',
     features: Object.freeze({ strictArguments: false }),
+    /**
+     * Build the instruction and response collector for one stage.
+     *
+     * @param capabilities - 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 }) => ({ id, description, input: inputSchema.jsonSchema }));
+        const declarations = capabilities.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: ' + 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.';
+        const instruction = 'Registered capabilities: ' +
+            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.';
         return {
-            options: { json: true }, schemaChars: instruction.length, instruction,
+            options: { json: true },
+            schemaChars: instruction.length,
+            instruction,
             createResponse() {
                 let raw = '';
                 return {
-                    get outputChars() { return raw.length; },
-                    push(part) { if (typeof part !== 'string')
-                        modelProtocolError('JSON interaction does not accept native call events'); raw += part; },
+                    get outputChars() {
+                        return raw.length;
+                    },
+                    push(part) {
+                        if (typeof part !== 'string')
+                            modelProtocolError('JSON interaction does not accept native call events');
+                        raw += part;
+                    },
                     finish() {
                         const value = parse(raw);
-                        if (Object.keys(value).length !== 2 || typeof value.capability !== 'string' || !Object.hasOwn(value, 'input'))
+                        if (Object.keys(value).length !== 2 ||
+                            typeof value.capability !== 'string' ||
+                            !Object.hasOwn(value, 'input'))
                             modelProtocolError('Invalid model selection envelope');
                         return { capabilityId: value.capability, input: object(value.input) };
                     },

package/dist/esm/model/interactions/native-functions.d.ts

@@ -1,2 +1,8 @@
 import type { ModelInteractionAdapter } from '../../structs/model/interactions.js';
+/**
+ * Adapter that decodes a streamed native function call.
+ *
+ * `strictArguments` is false because declarations are sent with `strict: false`; the
+ * adapter therefore validates the argument payload itself via `parse`.
+ */
 export declare const nativeFunctionInteraction: ModelInteractionAdapter;

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

@@ -1,22 +1,55 @@
+/**
+ * Default interaction adapter: native function calling.
+ *
+ * Declarations are sent as provider functions and the streamed function-call delta is
+ * reassembled into exactly one proposal. A call is a proposal, never proof of execution:
+ * this adapter only decodes it, and the core decides what to run.
+ *
+ * Exports: `nativeFunctionInteraction`.
+ */
 import { modelProtocolError } from '../../utils/model-protocol.js';
 import { parse, wireName } from './arguments.js';
+/**
+ * Adapter that decodes a streamed native function call.
+ *
+ * `strictArguments` is false because declarations are sent with `strict: false`; the
+ * adapter therefore validates the argument payload itself via `parse`.
+ */
 export const nativeFunctionInteraction = Object.freeze({
     id: 'native-functions',
     features: Object.freeze({ strictArguments: false }),
+    /**
+     * Build native declarations, the instruction and the response collector.
+     *
+     * 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.
+     * @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 => [wireName(capability.id), capability.id]));
+        const names = new Map(capabilities.map((capability) => [wireName(capability.id), capability.id]));
         if (names.size !== capabilities.length)
             throw new TypeError('Model wire name collision');
-        const functions = capabilities.map(capability => ({ name: wireName(capability.id), description: capability.description,
-            parameters: capability.inputSchema.jsonSchema, strict: false }));
+        const functions = capabilities.map((capability) => ({
+            name: wireName(capability.id),
+            description: capability.description,
+            parameters: capability.inputSchema.jsonSchema,
+            strict: false,
+        }));
         const instruction = 'Submit exactly one registered capability through its tool call. Protocol examples describe call arguments, not assistant prose. A call is a proposal, not proof of execution.';
         return {
-            options: { json: false, functions }, schemaChars: JSON.stringify(functions).length + instruction.length, instruction,
+            options: { json: false, functions },
+            schemaChars: JSON.stringify(functions).length + instruction.length,
+            instruction,
             createResponse() {
                 let raw = '';
                 let call;
                 return {
-                    get outputChars() { return raw.length + (call ? call.id.length + call.name.length + call.arguments.length : 0); },
+                    get outputChars() {
+                        return (raw.length + (call ? call.id.length + call.name.length + call.arguments.length : 0));
+                    },
                     push(part) {
                         if (typeof part === 'string') {
                             raw += part;
@@ -29,9 +62,9 @@ export const nativeFunctionInteraction = Object.freeze({
                             modelProtocolError('Expected a native model call');
                         if (index !== 0)
                             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'))
+                        if ((id !== undefined && (typeof id !== 'string' || !id)) ||
+                            (name !== undefined && typeof name !== 'string') ||
+                            (args !== undefined && typeof args !== 'string'))
                             modelProtocolError('Invalid native model call fields');
                         call ??= { id: '', name: '', arguments: '' };
                         if (id !== undefined) {
@@ -46,8 +79,17 @@ export const nativeFunctionInteraction = Object.freeze({
                         if (!call?.id || !call.name || raw.trim())
                             modelProtocolError('Expected one complete model call without prose');
                         const completed = call;
-                        const capability = names.get(completed.name) ?? modelProtocolError('Model call is not registered for this stage');
-                        return { capabilityId: capability, input: parse(completed.arguments), call: { id: completed.id, name: completed.name, argumentChars: completed.arguments.length } };
+                        const capability = names.get(completed.name) ??
+                            modelProtocolError('Model call is not registered for this stage');
+                        return {
+                            capabilityId: capability,
+                            input: parse(completed.arguments),
+                            call: {
+                                id: completed.id,
+                                name: completed.name,
+                                argumentChars: completed.arguments.length,
+                            },
+                        };
                     },
                 };
             },

package/dist/esm/model/message-diagnostics.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Redaction of model messages before they are observed or persisted.
+ *
+ * Diagnostics may keep message text, but image bytes must never leave the process,
+ * even when full content logging is enabled.
+ *
+ * Exports: `modelMessageDiagnostics`.
+ */
 import type { ModelMessage } from '../structs/model/messages.js';
-/** Image bytes are never persisted in model diagnostics, even with full text logging. */
+/**
+ * Replace every image payload 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.
+ *
+ * @param messages - Messages about to be reported.
+ * @returns New message objects whose images carry a placeholder URL.
+ */
 export declare function modelMessageDiagnostics(messages: readonly ModelMessage[]): ModelMessage[];

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

@@ -1,6 +1,19 @@
-/** Image bytes are never persisted in model diagnostics, even with full text logging. */
+/**
+ * Replace every image payload 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.
+ *
+ * @param messages - Messages about to be reported.
+ * @returns New message objects whose images carry a placeholder URL.
+ */
 export function modelMessageDiagnostics(messages) {
-    return messages.map(message => ({ ...message, ...(message.images ? {
-            images: message.images.map(image => ({ ...image, url: '[image omitted]' })),
-        } : {}) }));
+    return messages.map((message) => ({
+        ...message,
+        ...(message.images
+            ? {
+                images: message.images.map((image) => ({ ...image, url: '[image omitted]' })),
+            }
+            : {}),
+    }));
 }

package/dist/esm/model/options.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Snapshot helper for per-call model options.
+ *
+ * Options may be class instances with getters, so every field is read explicitly
+ * instead of being spread; fields the caller did not supply are then removed so
+ * "absent" and "explicitly undefined" stay distinguishable downstream.
+ *
+ * Exports: `snapshotModelOptions`.
+ */
 import type { ModelOptions } from '../structs/model/messages.js';
-/** Read structural options, including prototype getters, while preserving explicit overrides. */
+/**
+ * Copy declared model options, preserving explicit overrides.
+ *
+ * `onUsage` is rebound to the original options object so a method keeps its receiver.
+ * The deletion pass restores absent keys that the explicit reads had materialized.
+ *
+ * @param options - Source options; defaults to an empty object.
+ * @returns A plain options object containing only the keys present on the source.
+ */
 export declare function snapshotModelOptions(options?: Readonly<ModelOptions>): ModelOptions;

package/dist/esm/model/options.js

@@ -1,4 +1,12 @@
-/** Read structural options, including prototype getters, while preserving explicit overrides. */
+/**
+ * Copy declared model options, preserving explicit overrides.
+ *
+ * `onUsage` is rebound to the original options object so a method keeps its receiver.
+ * The deletion pass restores absent keys that the explicit reads had materialized.
+ *
+ * @param options - Source options; defaults to an empty object.
+ * @returns A plain options object containing only the keys present on the source.
+ */
 export function snapshotModelOptions(options = {}) {
     const snapshot = {
         json: options.json,

package/dist/esm/model/preparation.d.ts

@@ -1,9 +1,37 @@
 import type { ModelTransportDefinition } from '../structs/model/runtime.js';
 import type { PreparedModelTransport } from '../structs/model/interactions.js';
 import type { ModelMessage } from '../structs/model/messages.js';
-/** Snapshot a dynamic transport once, preserving its collector factory receiver. */
+/**
+ * Snapshot a dynamic transport once, preserving its collector factory receiver.
+ *
+ * The transport gets the stage id so it can specialize its instruction. Its options
+ * are copied, its function declarations cloned, and the whole snapshot frozen before
+ * the response factory is bound to the prepared source.
+ *
+ * @param transport - Registered transport definition.
+ * @param stageId - Stage the call belongs to.
+ * @returns A frozen prepared transport reused for measurement and the provider call.
+ * @throws TypeError When preparation is asynchronous or produces an invalid shape.
+ */
 export declare function prepareModelTransport(transport: ModelTransportDefinition, stageId: string): PreparedModelTransport;
-/** Message text and declarations are measured once, irrespective of native or in-message schema. */
+/**
+ * Measure a prepared request into its character accounting.
+ *
+ * Each message is read once into a frozen snapshot before any sum is computed, so
+ * caller mutations and extra getters cannot change the request between accounting,
+ * output backpressure and provider I/O.
+ *
+ * The instruction is merged into the effective messages exactly once, mirroring what
+ * the provider receives; `instructionChars` is therefore derived from that merge rather
+ * than measured separately. `transportChars` is the larger of the transport's declared
+ * schema size and the instruction plus in-message schema size, because a transport may
+ * declare native declarations instead of embedding them.
+ *
+ * @param base - Caller messages; must be a message array.
+ * @param prepared - Result of `prepareModelTransport` for the same call.
+ * @returns Frozen effective messages plus per-part and total character counts.
+ * @throws TypeError When the message array or any message is invalid.
+ */
 export declare function preparedInputSize(base: readonly ModelMessage[], prepared: PreparedModelTransport): {
     messages: readonly Readonly<ModelMessage>[];
     messageChars: number;

package/dist/esm/model/preparation.js

@@ -1,50 +1,124 @@
+/**
+ * One-shot preparation and measurement of a model request.
+ *
+ * Preparation freezes the transport's options, instruction and response factory before
+ * any counting happens; measurement then derives every size from that same snapshot.
+ * Splitting the two phases is what guarantees that the numbers checked against the
+ * budget are the numbers actually sent to the provider.
+ *
+ * Exports: `prepareModelTransport` and `preparedInputSize`.
+ */
 import { modelInputMessages } from './token-budget.js';
 import { synchronous } from '../utils/synchronous.js';
 import { freezeSchema } from '../utils/object.js';
 import { snapshotModelOptions } from './options.js';
 import { breakWhile } from '../utils/rules.js';
 // Only snapshots owned and frozen by this module are reusable across measurements.
+// Keyed by the frozen options object so a repeated measure of the same prepared call
+// does not re-serialize a large function schema.
 const functionSizes = new WeakMap();
+/**
+ * Validate and freeze one image reference.
+ *
+ * `detail` is restricted to the values understood by every supported provider so the
+ * wire payload never carries an unvalidated hint.
+ *
+ * @param image - Candidate image reference.
+ * @returns A frozen image object without an undefined `detail`.
+ * @throws TypeError When the shape or `detail` value is invalid.
+ */
 function snapshotImage(image) {
     breakWhile(!image || typeof image !== 'object' || Array.isArray(image), () => new TypeError('Invalid model image'));
     const { url, detail } = image;
-    breakWhile(typeof url !== 'string' || !url || (detail !== undefined && !['auto', 'low', 'high', 'original'].includes(detail)), () => new TypeError('Invalid model image'));
+    breakWhile(typeof url !== 'string' ||
+        !url ||
+        (detail !== undefined && !['auto', 'low', 'high', 'original'].includes(detail)), () => new TypeError('Invalid model image'));
     return Object.freeze({ url, ...(detail === undefined ? {} : { detail }) });
 }
-/** Snapshot a dynamic transport once, preserving its collector factory receiver. */
+/**
+ * Snapshot a dynamic transport once, preserving its collector factory receiver.
+ *
+ * The transport gets the stage id so it can specialize its instruction. Its options
+ * are copied, its function declarations cloned, and the whole snapshot frozen before
+ * the response factory is bound to the prepared source.
+ *
+ * @param transport - Registered transport definition.
+ * @param stageId - Stage the call belongs to.
+ * @returns A frozen prepared transport reused for measurement and the provider call.
+ * @throws TypeError When preparation is asynchronous or produces an invalid shape.
+ */
 export function prepareModelTransport(transport, stageId) {
     const source = synchronous(transport.prepare(stageId), 'Model transport preparation must be synchronous');
     if (!source)
         throw new TypeError('Invalid prepared model transport');
     const { schemaChars, instruction, createResponse } = source;
-    if (!Number.isSafeInteger(schemaChars) || schemaChars < 0 || typeof createResponse !== 'function'
-        || (instruction !== undefined && typeof instruction !== 'string'))
+    if (!Number.isSafeInteger(schemaChars) ||
+        schemaChars < 0 ||
+        typeof createResponse !== 'function' ||
+        (instruction !== undefined && typeof instruction !== 'string'))
         throw new TypeError('Invalid prepared model transport');
     const options = snapshotModelOptions(source.options);
     if (options.functions)
         options.functions = structuredClone(options.functions);
     freezeSchema(options);
-    const prepared = Object.freeze({ options, schemaChars, instruction, createResponse: createResponse.bind(source) });
+    const prepared = Object.freeze({
+        options,
+        schemaChars,
+        instruction,
+        createResponse: createResponse.bind(source),
+    });
     if (options.functions)
         functionSizes.set(options.functions, JSON.stringify(options.functions).length);
     return prepared;
 }
-/** Message text and declarations are measured once, irrespective of native or in-message schema. */
+/**
+ * Measure a prepared request into its character accounting.
+ *
+ * Each message is read once into a frozen snapshot before any sum is computed, so
+ * caller mutations and extra getters cannot change the request between accounting,
+ * output backpressure and provider I/O.
+ *
+ * The instruction is merged into the effective messages exactly once, mirroring what
+ * the provider receives; `instructionChars` is therefore derived from that merge rather
+ * than measured separately. `transportChars` is the larger of the transport's declared
+ * schema size and the instruction plus in-message schema size, because a transport may
+ * declare native declarations instead of embedding them.
+ *
+ * @param base - Caller messages; must be a message array.
+ * @param prepared - Result of `prepareModelTransport` for the same call.
+ * @returns Frozen effective messages plus per-part and total character counts.
+ * @throws TypeError When the message array or any message is invalid.
+ */
 export function preparedInputSize(base, prepared) {
     // Read only protocol fields, once. Caller mutations and extra getters cannot
     // change the request between accounting, output backpressure and Provider I/O.
     breakWhile(!Array.isArray(base), () => new TypeError('Model messages must be an array'));
-    const snapshot = Array.from(base, message => {
+    const snapshot = Array.from(base, (message) => {
         breakWhile(!message || typeof message !== 'object' || Array.isArray(message), () => new TypeError('Invalid model message'));
         const { role, content, images } = message;
-        breakWhile(!['system', 'user', 'assistant'].includes(role) || typeof content !== 'string' || (images !== undefined && !Array.isArray(images)), () => new TypeError('Invalid model message'));
-        return Object.freeze({ role, content, ...(images === undefined ? {} : { images: Object.freeze(Array.from(images, snapshotImage)) }) });
+        breakWhile(!['system', 'user', 'assistant'].includes(role) ||
+            typeof content !== 'string' ||
+            (images !== undefined && !Array.isArray(images)), () => new TypeError('Invalid model message'));
+        return Object.freeze({
+            role,
+            content,
+            ...(images === undefined ? {} : { images: Object.freeze(Array.from(images, snapshotImage)) }),
+        });
     });
-    const messages = Object.freeze(modelInputMessages(snapshot, prepared.instruction).map(message => Object.freeze(message)));
+    const messages = Object.freeze(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 functions = prepared.options.functions;
-    const schemaChars = functions ? functionSizes.get(functions) ?? JSON.stringify(functions).length : 0;
+    const schemaChars = functions
+        ? (functionSizes.get(functions) ?? JSON.stringify(functions).length)
+        : 0;
     const transportChars = Math.max(prepared.schemaChars, instructionChars + schemaChars);
-    return { messages, messageChars, instructionChars, schemaChars, transportChars, inputChars: messageChars + instructionChars + schemaChars };
+    return {
+        messages,
+        messageChars,
+        instructionChars,
+        schemaChars,
+        transportChars,
+        inputChars: messageChars + instructionChars + schemaChars,
+    };
 }