@jangts/agent-core 0.1.1 → 0.2.0

package/dist/esm/support/model/compatible-provider.js

@@ -1,20 +1,55 @@
+/**
+ * OpenAI-compatible HTTP provider: streaming chat completions over SSE.
+ *
+ * The provider owns the request/response lifecycle and error classification; the application
+ * supplies endpoint, credentials, optional request-body extensions and user-visible error mapping.
+ * Configuration is snapshotted so getters cannot change between validation and I/O, and every
+ * failure is recorded with the same code that is returned to the caller.
+ *
+ * Main exports: `CompatibleModelProvider` and the provider configuration/error types.
+ */
 import { getErrorInfo, recordErrorContext } from '../../errors.js';
 import { modelRunnerDefaults } from '../../model/defaults.js';
 import { snapshotModelOptions } from '../../model/options.js';
 import { diagnosticError } from '../../diagnostics/index.js';
 import { ChatProvider } from '../../structs/model/chat-provider.js';
-import { chatCompletionFunctionOptions, chatCompletionParts, chatCompletionMessages } from './chat-completions.js';
+import { chatCompletionFunctionOptions, chatCompletionParts, chatCompletionMessages, } from './chat-completions.js';
+import { defaultCompletionPolicy } from './completion/default.js';
 import { readSse } from '../transport/sse.js';
 import { providerObservation } from './observer.js';
 import { synchronous } from '../../utils/synchronous.js';
 import { awaitWithSignal } from '../../utils/cancellation.js';
+/**
+ * HTTP status to provider error code.
+ *
+ * Unlisted statuses fall back to `MODEL_UPSTREAM`; 408, 429 and 5xx are additionally marked
+ * retryable when the error context is recorded.
+ */
 const httpFailures = Object.freeze({
-    400: 'MODEL_CONFIG', 401: 'MODEL_AUTH', 402: 'MODEL_BALANCE', 403: 'MODEL_AUTH',
-    404: 'MODEL_CONFIG', 429: 'MODEL_BUSY',
+    400: 'MODEL_CONFIG',
+    401: 'MODEL_AUTH',
+    402: 'MODEL_BALANCE',
+    403: 'MODEL_AUTH',
+    404: 'MODEL_CONFIG',
+    429: 'MODEL_BUSY',
 });
-const reservedRequestFields = ['model', 'messages', 'stream', 'max_tokens', 'max_completion_tokens', 'toJSON'];
+/**
+ * Request fields the adapter composes itself.
+ *
+ * Allowing `requestBody` to set them would let application configuration replace the model,
+ * prompt, streaming mode or output budget that Core already validated.
+ */
+const reservedRequestFields = [
+    'model',
+    'messages',
+    'stream',
+    'max_tokens',
+    'max_completion_tokens',
+    'toJSON',
+];
 function assertRequestExtensions(config) {
-    if (config.maxOutputTokens !== undefined && (!Number.isSafeInteger(config.maxOutputTokens) || config.maxOutputTokens < 1)) {
+    if (config.maxOutputTokens !== undefined &&
+        (!Number.isSafeInteger(config.maxOutputTokens) || config.maxOutputTokens < 1)) {
         throw new TypeError('Provider maxOutputTokens must be a positive safe integer');
     }
     for (const key of reservedRequestFields) {
@@ -67,12 +102,18 @@ function snapshotConfiguration(config, signal) {
                 generated = { enable_thinking: level !== 'off' };
             else if (format === 'thinking-budget') {
                 const configured = read(reasoning, 'budgets');
-                const budgets = { low: configured ? read(configured, 'low') ?? 1024 : 1024,
-                    medium: configured ? read(configured, 'medium') ?? 4096 : 4096,
-                    high: configured ? read(configured, 'high') ?? 8192 : 8192 };
-                if (Object.values(budgets).some(value => !Number.isSafeInteger(value) || value < 1))
+                const budgets = {
+                    low: configured ? (read(configured, 'low') ?? 1024) : 1024,
+                    medium: configured ? (read(configured, 'medium') ?? 4096) : 4096,
+                    high: configured ? (read(configured, 'high') ?? 8192) : 8192,
+                };
+                if (Object.values(budgets).some((value) => !Number.isSafeInteger(value) || value < 1))
                     throw new TypeError('Thinking budgets must be positive safe integers');
-                generated = { thinking: level === 'off' ? { type: 'disabled' } : { type: 'enabled', budget_tokens: budgets[level] } };
+                generated = {
+                    thinking: level === 'off'
+                        ? { type: 'disabled' }
+                        : { type: 'enabled', budget_tokens: budgets[level] },
+                };
             }
             else
                 throw new TypeError('Unknown provider reasoning format');
@@ -91,10 +132,22 @@ function snapshotConfiguration(config, signal) {
         throw error;
     }
 }
-/** HTTP/SSE lifecycle shared by hosts. Apps supply config and user-visible error mapping only. */
+/**
+ * HTTP/SSE lifecycle shared by hosts. Apps supply config and user-visible error mapping only.
+ *
+ * A static configuration is validated and frozen in the constructor. A configuration function is
+ * called once per request instead, so credentials and models may rotate between calls.
+ */
 export class CompatibleModelProvider extends ChatProvider {
     configuration;
     ports;
+    /**
+     * Create a provider.
+     *
+     * @param options Static or per-request configuration, optional ports and observation/error hooks.
+     * @throws {TypeError} When a static configuration is invalid (for example `maxTokens`,
+     *   reserved request-body fields, unsupported reasoning format or invalid budgets).
+     */
     constructor(options) {
         super();
         const { config: configuration, ports } = options;
@@ -102,6 +155,7 @@ export class CompatibleModelProvider extends ChatProvider {
             request: ports?.request?.bind(ports),
             ensureJsonInstruction: ports?.ensureJsonInstruction,
             allowEmptyJson: ports?.allowEmptyJson,
+            completionPolicy: ports?.completionPolicy,
             observer: options.observe?.provider,
             error: options.errors?.failure?.bind(options.errors),
         };
@@ -111,11 +165,33 @@ export class CompatibleModelProvider extends ChatProvider {
             this.configuration = snapshotConfiguration(configuration);
     }
     failure(code, status, reason) {
-        const error = this.ports.error?.({ code, ...(status !== undefined ? { status } : {}), ...(reason ? { reason } : {}) })
-            ?? Object.assign(new Error(code), { code, status, reason });
-        recordErrorContext(error, { codes: [code], ...(status === undefined ? {} : { isRetryable: status === 408 || status === 429 || status >= 500 }) });
+        const error = this.ports.error?.({
+            code,
+            ...(status !== undefined ? { status } : {}),
+            ...(reason ? { reason } : {}),
+        }) ?? Object.assign(new Error(code), { code, status, reason });
+        recordErrorContext(error, {
+            codes: [code],
+            // Transient HTTP conditions are retryable; protocol/format failures are not.
+            ...(status === undefined
+                ? {}
+                : { isRetryable: status === 408 || status === 429 || status >= 500 }),
+        });
         return error;
     }
+    /**
+     * Stream one chat-completions response as Core model parts.
+     *
+     * The method validates the effective request and yields parts as they arrive. Whether the
+     * finished stream is acceptable is decided by the configured completion policy, which defaults
+     * to the legacy rules. A stream that ends without the end-of-stream marker is incomplete, not a
+     * partial success.
+     *
+     * @param messages Prompt messages in order, including provider tool-thread messages.
+     * @param context Provider context with signal, call options and diagnostics/observer ports.
+     * @yields Text chunks and function-call deltas as they arrive.
+     * @throws The classified provider error (see `MODEL_*` codes) or the signal's abort reason.
+     */
     async *stream(messages, context) {
         const { signal } = context;
         signal.throwIfAborted();
@@ -128,11 +204,14 @@ export class CompatibleModelProvider extends ChatProvider {
                 throw new TypeError('Use maxOutputTokens');
             options = snapshotModelOptions(configured);
             signal.throwIfAborted();
-            if (options.maxOutputTokens !== undefined && (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens < 1)) {
+            if (options.maxOutputTokens !== undefined &&
+                (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens < 1)) {
                 throw new TypeError('maxOutputTokens must be a positive safe integer');
             }
-            config = typeof this.configuration === 'function'
-                ? snapshotConfiguration(this.configuration(), signal) : this.configuration;
+            config =
+                typeof this.configuration === 'function'
+                    ? snapshotConfiguration(this.configuration(), signal)
+                    : this.configuration;
             signal.throwIfAborted();
         }
         catch (error) {
@@ -141,9 +220,14 @@ export class CompatibleModelProvider extends ChatProvider {
         }
         const maxOutputTokens = Math.min(options.maxOutputTokens ?? config.maxOutputTokens ?? modelRunnerDefaults.maxOutputTokens, config.maxOutputTokens ?? Infinity);
         const thinking = config.requestBody?.thinking;
-        if (thinking !== null && typeof thinking === 'object' && Object.hasOwn(thinking, 'budget_tokens')) {
+        if (thinking !== null &&
+            typeof thinking === 'object' &&
+            Object.hasOwn(thinking, 'budget_tokens')) {
             const budget = thinking.budget_tokens;
-            if (typeof budget !== 'number' || !Number.isSafeInteger(budget) || budget < 1 || budget >= maxOutputTokens) {
+            if (typeof budget !== 'number' ||
+                !Number.isSafeInteger(budget) ||
+                budget < 1 ||
+                budget >= maxOutputTokens) {
                 throw new TypeError('Thinking budget_tokens must be positive and smaller than the effective output token limit');
             }
         }
@@ -153,61 +237,99 @@ export class CompatibleModelProvider extends ChatProvider {
         try {
             if (!config.apiKey)
                 throw this.failure('MODEL_NOT_CONFIGURED');
-            const needsJsonInstruction = this.ports.ensureJsonInstruction && !options.functions && options.json
-                && !messages.some(message => ['system', 'user'].includes(message.role) && /json/i.test(message.content));
+            // Some providers require the word "json" in the prompt before accepting a JSON response
+            // format; only add the instruction when the prompt does not already mention it.
+            const needsJsonInstruction = this.ports.ensureJsonInstruction &&
+                !options.functions &&
+                options.json &&
+                !messages.some((message) => ['system', 'user'].includes(message.role) && /json/i.test(message.content));
             const requestMessages = needsJsonInstruction
-                ? [{ role: 'system', content: '只输出合法 JSON 对象，遵循给定字段和示例。' }, ...messages] : messages;
+                ? [{ role: 'system', content: '只输出合法 JSON 对象，遵循给定字段和示例。' }, ...messages]
+                : messages;
             const request = this.ports.request ?? fetch;
+            // Build the body once: the completion policy must judge the same fields the upstream reads.
+            const body = {
+                model: config.model,
+                messages: chatCompletionMessages(requestMessages),
+                stream: true,
+                max_tokens: maxOutputTokens,
+                ...((options.temperature ?? config.temperature) !== undefined
+                    ? { temperature: options.temperature ?? config.temperature }
+                    : {}),
+                ...(!options.functions && options.json ? { response_format: { type: 'json_object' } } : {}),
+                ...chatCompletionFunctionOptions(options),
+                ...config.requestBody,
+                ...(options.includeUsage ? { stream_options: { include_usage: true } } : {}),
+            };
+            const policy = this.ports.completionPolicy ?? defaultCompletionPolicy;
+            const session = policy.begin({
+                functions: !!options.functions,
+                toolChoice: body.tool_choice,
+                allowEmptyText: !options.functions && !!options.json && !!this.ports.allowEmptyJson,
+            }, (code) => this.failure(code));
             const observedRequest = (url, init) => {
                 observation.emit('provider.request', () => {
-                    const body = JSON.parse(String(init?.body));
-                    body.messages = body.messages.map((message) => ({ ...message, content: Array.isArray(message.content)
-                            ? message.content.map(part => part.type === 'image_url' ? { ...part, image_url: { url: '[image omitted]' } } : part) : message.content }));
-                    return { url: String(url), body };
+                    const observed = JSON.parse(String(init?.body));
+                    observed.messages = observed.messages.map((message) => ({
+                        ...message,
+                        content: Array.isArray(message.content)
+                            ? message.content.map((part) => part.type === 'image_url'
+                                ? { ...part, image_url: { url: '[image omitted]' } }
+                                : part)
+                            : message.content,
+                    }));
+                    return { url: String(url), body: observed };
                 });
                 signal.throwIfAborted();
                 return request(url, init);
             };
             signal.throwIfAborted();
             const pendingResponse = Promise.resolve(observedRequest(`${config.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
-                method: 'POST', redirect: 'error', signal,
-                headers: { Authorization: `Bearer ${config.apiKey}`, 'Content-Type': 'application/json', Accept: 'text/event-stream' },
-                body: JSON.stringify({ model: config.model, messages: chatCompletionMessages(requestMessages), stream: true,
-                    max_tokens: maxOutputTokens,
-                    ...((options.temperature ?? config.temperature) !== undefined ? { temperature: options.temperature ?? config.temperature } : {}),
-                    ...(!options.functions && options.json ? { response_format: { type: 'json_object' } } : {}),
-                    ...chatCompletionFunctionOptions(options), ...config.requestBody,
-                    ...(options.includeUsage ? { stream_options: { include_usage: true } } : {}),
-                }),
-            })).then(response => activeResponse(response, signal));
+                method: 'POST',
+                redirect: 'error',
+                signal,
+                headers: {
+                    Authorization: `Bearer ${config.apiKey}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify(body),
+            })).then((response) => activeResponse(response, signal));
             const response = await awaitWithSignal(pendingResponse, signal);
-            observation.emit('provider.response', () => ({ status: response.status, requestId: response.headers.get('x-request-id'), contentType: response.headers.get('content-type') }));
+            observation.emit('provider.response', () => ({
+                status: response.status,
+                requestId: response.headers.get('x-request-id'),
+                contentType: response.headers.get('content-type'),
+            }));
             activeResponse(response, signal);
             if (!response.ok) {
                 if (observation.enabled('provider.error-body')) {
                     try {
                         const capture = await captureErrorBody(response);
-                        observation.emit('provider.error-body', () => ({ status: response.status, ...capture }));
+                        observation.emit('provider.error-body', () => ({
+                            status: response.status,
+                            ...capture,
+                        }));
+                    }
+                    catch {
+                        /* Error capture cannot replace the HTTP failure. */
                     }
-                    catch { /* Error capture cannot replace the HTTP failure. */ }
                 }
                 else
                     discardResponse(response);
                 throw this.failure(httpFailures[response.status] ?? 'MODEL_UPSTREAM', response.status);
             }
-            if (!response.body || !response.headers.get('content-type')?.toLowerCase().startsWith('text/event-stream')) {
+            if (!response.body ||
+                !response.headers.get('content-type')?.toLowerCase().startsWith('text/event-stream')) {
                 discardResponse(response);
                 throw this.failure('MODEL_FORMAT');
             }
             let finished = false;
-            let hasFunction = false;
-            let hasText = false;
             for await (const event of readSse(response.body, { signal, waitForCancel: false })) {
                 observation.emit('provider.frame', () => ({ data: event.data }));
                 signal.throwIfAborted();
                 if (event.data === '[DONE]') {
-                    if (!finished || (options.functions ? !hasFunction : (!hasText && !(options.json && this.ports.allowEmptyJson))))
-                        throw this.failure('MODEL_INCOMPLETE');
+                    session.end();
                     complete = true;
                     return;
                 }
@@ -223,11 +345,17 @@ export class CompatibleModelProvider extends ChatProvider {
                 if (chunk.error)
                     throw this.failure('MODEL_UPSTREAM');
                 const usage = chunk.usage;
-                if (usage && [usage.prompt_tokens, usage.completion_tokens, usage.total_tokens].every(value => Number.isInteger(value) && value >= 0))
-                    options.onUsage?.({ promptTokens: usage.prompt_tokens, completionTokens: usage.completion_tokens, totalTokens: usage.total_tokens });
+                if (usage &&
+                    [usage.prompt_tokens, usage.completion_tokens, usage.total_tokens].every((value) => Number.isInteger(value) && value >= 0))
+                    options.onUsage?.({
+                        promptTokens: usage.prompt_tokens,
+                        completionTokens: usage.completion_tokens,
+                        totalTokens: usage.total_tokens,
+                    });
                 signal.throwIfAborted();
                 if (chunk.choices !== undefined && !Array.isArray(chunk.choices))
                     throw this.failure('MODEL_FORMAT');
+                // One request produces one choice; extra choices are ignored rather than merged.
                 const choice = chunk.choices?.find((item) => item?.index === 0);
                 if (!choice)
                     continue;
@@ -236,20 +364,13 @@ export class CompatibleModelProvider extends ChatProvider {
                 const parts = chatCompletionParts(choice.delta);
                 for (const part of parts) {
                     signal.throwIfAborted();
-                    if (typeof part === 'string')
-                        hasText = true;
-                    else {
-                        if (!options.functions)
-                            throw this.failure('MODEL_PROTOCOL');
-                        hasFunction = true;
-                    }
+                    session.part(part);
                     yield part;
                 }
                 if (choice.finish_reason != null) {
                     if (finished)
                         throw this.failure('MODEL_PROTOCOL');
-                    if (choice.finish_reason !== (options.functions ? 'tool_calls' : 'stop'))
-                        throw this.failure(choice.finish_reason === 'length' ? 'MODEL_OUTPUT_LIMIT' : 'MODEL_INCOMPLETE');
+                    session.finish(choice.finish_reason);
                     finished = true;
                 }
             }
@@ -257,11 +378,14 @@ export class CompatibleModelProvider extends ChatProvider {
         }
         catch (error) {
             failure = { error };
-            if (!signal.aborted && getErrorInfo(error).codes.every(code => code === 'UNKNOWN_ERROR'))
+            if (!signal.aborted && getErrorInfo(error).codes.every((code) => code === 'UNKNOWN_ERROR'))
                 recordErrorContext(error, { codes: ['MODEL_UPSTREAM'] });
         }
         finally {
-            observation.emit('provider.end', () => ({ complete, ...(failure ? { error: diagnosticError(failure.error) } : {}) }));
+            observation.emit('provider.end', () => ({
+                complete,
+                ...(failure ? { error: diagnosticError(failure.error) } : {}),
+            }));
         }
         throw failure.error;
     }
@@ -271,7 +395,9 @@ function discardResponse(response) {
     try {
         void Promise.resolve(response.body?.cancel()).catch(() => { });
     }
-    catch { /* Preserve the classified failure. */ }
+    catch {
+        /* Preserve the classified failure. */
+    }
 }
 function activeResponse(response, signal) {
     if (signal.aborted) {
@@ -290,7 +416,9 @@ async function captureErrorBody(response) {
     let bytes = 0;
     let truncated = true;
     let timer;
-    const deadline = new Promise(resolve => { timer = setTimeout(() => resolve(undefined), 250); });
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(undefined), 250);
+    });
     try {
         while (bytes < 65536) {
             const item = await Promise.race([reader.read(), deadline]);
@@ -314,6 +442,8 @@ async function captureErrorBody(response) {
         try {
             reader.releaseLock();
         }
-        catch { /* A pending read is cancelled independently. */ }
+        catch {
+            /* A pending read is cancelled independently. */
+        }
     }
 }

package/dist/esm/support/model/completion/calls.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Tool-call delta aggregation.
+ *
+ * One algorithm is shared by completion policies and direct callers: fragments are keyed by their
+ * provider index, IDs may not conflict, and a complete call requires both an ID and a name. A
+ * complete call never hides another started but incomplete one.
+ *
+ * Exports: `AggregatedToolCall`, `ToolCallCollector`, `ToolCallFailure` and
+ * `createToolCallCollector`.
+ */
+import type { ModelPart } from '../../../structs/model/messages.js';
+/** One completed native tool call in provider index order. */
+export interface AggregatedToolCall {
+    readonly index: number;
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+}
+/** Report a protocol violation and stop; callers decide how the failure is classified. */
+export type ToolCallFailure = (message: string) => never;
+/** Aggregation entry point for streamed function-call deltas. */
+export interface ToolCallCollector {
+    /** Feed one part; text parts are ignored and cannot satisfy or break a call. */
+    push(part: ModelPart): void;
+    /** Calls started so far, including incomplete ones, in index order. */
+    readonly calls: readonly AggregatedToolCall[];
+    /**
+     * Finalize the calls.
+     *
+     * @throws When any started call is still missing its ID or name.
+     */
+    complete(): readonly AggregatedToolCall[];
+}
+/**
+ * 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.
+ */
+export declare function createToolCallCollector(fail?: ToolCallFailure): ToolCallCollector;

package/dist/esm/support/model/completion/calls.js

@@ -0,0 +1,58 @@
+import { modelProtocolError } from '../../../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.
+ */
+export function createToolCallCollector(fail = 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/esm/support/model/completion/default.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default completion policy: the behavior the provider had before policies were configurable.
+ *
+ * Strictness is driven by whether the call declared functions, not by `tool_choice`: that one fact
+ * decides both whether function parts are acceptable and which `finish_reason` is expected.
+ *
+ * Exports: `defaultCompletionPolicy`.
+ */
+import type { CompletionPolicy } from '../../../structs/support/model/completion.js';
+export declare const defaultCompletionPolicy: CompletionPolicy;

package/dist/esm/support/model/completion/default.js

@@ -0,0 +1,29 @@
+const policy = {
+    id: 'default',
+    begin(facts, fail) {
+        let finished = false;
+        let hasText = false;
+        let hasCall = false;
+        return {
+            part(part) {
+                if (typeof part === 'string') {
+                    hasText = true;
+                    return;
+                }
+                if (!facts.functions)
+                    throw fail('MODEL_PROTOCOL');
+                hasCall = true;
+            },
+            finish(reason) {
+                if (reason !== (facts.functions ? 'tool_calls' : 'stop'))
+                    throw fail(reason === 'length' ? 'MODEL_OUTPUT_LIMIT' : 'MODEL_INCOMPLETE');
+                finished = true;
+            },
+            end() {
+                if (!finished || (facts.functions ? !hasCall : !hasText && !facts.allowEmptyText))
+                    throw fail('MODEL_INCOMPLETE');
+            },
+        };
+    },
+};
+export const defaultCompletionPolicy = Object.freeze(policy);

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

@@ -0,0 +1,10 @@
+export { createToolCallCollector } from './calls.js';
+export type { AggregatedToolCall, ToolCallCollector, ToolCallFailure } from './calls.js';
+export { defaultCompletionPolicy } from './default.js';
+export { sessionCompletionPolicy } from './session.js';
+export type * from '../../../structs/support/model/completion.js';
+/** Preset policies selected by an explicit port; the default is used when none is given. */
+export declare const completionPolicyCatalog: Readonly<{
+    default: import("./index.js").CompletionPolicy;
+    session: import("./index.js").CompletionPolicy;
+}>;

package/dist/esm/support/model/completion/index.js

@@ -0,0 +1,22 @@
+/**
+ * Completion policy catalog: policies a compatible provider may be configured with.
+ *
+ * Registration is explicit and frozen. The module refuses to load when a key and the policy's own
+ * identifier disagree, so a lookup can never return a policy under a false name.
+ *
+ * Main exports: `completionPolicyCatalog`, the two preset re-exports, the shared call collector
+ * and their contract types.
+ */
+import { breakWhile } from '../../../utils/rules.js';
+import { defaultCompletionPolicy } from './default.js';
+import { sessionCompletionPolicy } from './session.js';
+export { createToolCallCollector } from './calls.js';
+export { defaultCompletionPolicy } from './default.js';
+export { sessionCompletionPolicy } from './session.js';
+/** Preset policies selected by an explicit port; the default is used when none is given. */
+export const completionPolicyCatalog = Object.freeze({
+    default: defaultCompletionPolicy,
+    session: sessionCompletionPolicy,
+});
+for (const [id, policy] of Object.entries(completionPolicyCatalog))
+    breakWhile(id !== policy.id, 'Completion policy ID does not match its registered policy');

package/dist/esm/support/model/completion/session.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Standard session completion policy: one policy covering the documented `tool_choice` modes.
+ *
+ * Selection is explicit; consumers that do not opt in keep the default policy. Rules follow the
+ * effective `tool_choice` of the request body, so a host override is judged as the upstream saw it.
+ * An omitted field keeps the pre-policy rules instead of being read as `required`.
+ *
+ * Exports: `sessionCompletionPolicy`.
+ */
+import type { CompletionPolicy } from '../../../structs/support/model/completion.js';
+export declare const sessionCompletionPolicy: CompletionPolicy;