@jangts/agent-core 0.1.1 → 0.2.0

package/dist/cjs/support/model/chat-completions.js

@@ -4,19 +4,43 @@ exports.chatCompletionFunctionOptions = chatCompletionFunctionOptions;
 exports.chatCompletionParts = chatCompletionParts;
 exports.chatCompletionMessages = chatCompletionMessages;
 const errors_js_1 = require("../../structs/errors.js");
-/** OpenAI-compatible wire adapter only; credentials, HTTP and business policy belong to hosts. */
+/**
+ * Build the tool-selection request fields for a function-calling stage.
+ *
+ * The adapter expects exactly one function call per response, so tool use is required and parallel
+ * calls are disabled.
+ *
+ * @param options Model options; absent `functions` means the stage has no tools.
+ * @returns Tool fields to merge into the request body, or an empty object.
+ * @throws {TypeError} When `functions` is present but empty.
+ */
 function chatCompletionFunctionOptions(options) {
     if (!options.functions)
         return {};
     if (!options.functions.length)
         throw new TypeError('Empty model function catalog');
     return {
-        tools: options.functions.map(fn => ({ type: 'function', function: fn })),
-        tool_choice: 'required', parallel_tool_calls: false,
+        tools: options.functions.map((fn) => ({ type: 'function', function: fn })),
+        tool_choice: 'required',
+        parallel_tool_calls: false,
     };
 }
+/**
+ * Convert one streamed `choice.delta` into Core model parts.
+ *
+ * Text is emitted only when non-empty; each tool-call fragment carries its index so Core can
+ * reassemble arguments that arrive across chunks.
+ *
+ * @param delta Raw `delta` value from a chat-completions chunk.
+ * @returns Text and function-call-delta parts; an unrelated shape yields an empty array.
+ * @throws {ValidationError} When `tool_calls` or one of its entries has an invalid shape.
+ */
 function chatCompletionParts(delta) {
-    const fail = () => { throw new errors_js_1.ValidationError([{ code: 'MODEL_PROTOCOL', message: 'Invalid function call stream' }]); };
+    const fail = () => {
+        throw new errors_js_1.ValidationError([
+            { code: 'MODEL_PROTOCOL', message: 'Invalid function call stream' },
+        ]);
+    };
     if (!delta || typeof delta !== 'object' || Array.isArray(delta))
         return [];
     const value = delta;
@@ -30,16 +54,21 @@ function chatCompletionParts(delta) {
             if (!item || typeof item !== 'object' || Array.isArray(item))
                 fail();
             const call = item;
-            if (!Number.isInteger(call.index) || call.index < 0
-                || (call.id !== undefined && (typeof call.id !== 'string' || !call.id))
-                || (call.type !== undefined && call.type !== 'function'))
+            if (!Number.isInteger(call.index) ||
+                call.index < 0 ||
+                (call.id !== undefined && (typeof call.id !== 'string' || !call.id)) ||
+                (call.type !== undefined && call.type !== 'function'))
                 fail();
-            if (call.function !== undefined && (!call.function || typeof call.function !== 'object' || Array.isArray(call.function)))
+            if (call.function !== undefined &&
+                (!call.function || typeof call.function !== 'object' || Array.isArray(call.function)))
                 fail();
             const fn = (call.function ?? {});
-            if ((fn.name !== undefined && typeof fn.name !== 'string') || (fn.arguments !== undefined && typeof fn.arguments !== 'string'))
+            if ((fn.name !== undefined && typeof fn.name !== 'string') ||
+                (fn.arguments !== undefined && typeof fn.arguments !== 'string'))
                 fail();
-            parts.push({ type: 'function-call-delta', index: call.index,
+            parts.push({
+                type: 'function-call-delta',
+                index: call.index,
                 ...(call.id !== undefined ? { id: call.id } : {}),
                 ...(fn.name !== undefined ? { name: fn.name } : {}),
                 ...(fn.arguments !== undefined ? { arguments: fn.arguments } : {}),
@@ -48,21 +77,64 @@ function chatCompletionParts(delta) {
     }
     return parts;
 }
-/** Preserve plain text requests; visual blocks are valid only on user messages. */
+/**
+ * Map Core and provider messages to chat-completions message payloads.
+ *
+ * Only declared message fields are sent. Assistant tool declarations become nested
+ * `tool_calls`, and tool results become `tool_call_id`; both are rewritten explicitly rather than
+ * forwarded as-is. Messages with images become a content-block array; images are accepted only on
+ * user messages and only as `http(s)` or `data:image` URLs.
+ *
+ * @param messages Messages in prompt order, either Core messages or provider tool-thread messages.
+ * @returns Wire messages with `images` removed and content blocks where needed.
+ * @throws {TypeError} When a role and field do not belong together, or an image URL or detail level
+ *   is invalid.
+ */
 function chatCompletionMessages(messages) {
-    return messages.map(({ images, ...message }) => {
+    return messages.map((message) => {
+        const { role, content, images, toolCalls, toolCallId } = message;
+        if (!['system', 'user', 'assistant', 'tool'].includes(role) || typeof content !== 'string')
+            throw new TypeError('Invalid provider message role or content');
+        if (toolCallId !== undefined && role !== 'tool')
+            throw new TypeError('Tool results require the tool role');
+        if (role === 'tool' && (typeof toolCallId !== 'string' || !toolCallId))
+            throw new TypeError('Tool results require a tool call id');
+        if (toolCalls !== undefined && role !== 'assistant')
+            throw new TypeError('Tool calls require an assistant message');
+        const wire = { role, content };
+        if (toolCallId !== undefined)
+            wire.tool_call_id = toolCallId;
+        if (toolCalls !== undefined)
+            wire.tool_calls = toolCalls.map((call) => {
+                if (!call ||
+                    typeof call.id !== 'string' ||
+                    !call.id ||
+                    typeof call.name !== 'string' ||
+                    !call.name ||
+                    typeof call.arguments !== 'string')
+                    throw new TypeError('Invalid tool call');
+                return {
+                    id: call.id,
+                    type: 'function',
+                    function: { name: call.name, arguments: call.arguments },
+                };
+            });
         if (!images?.length)
-            return message;
-        if (message.role !== 'user')
+            return wire;
+        if (role !== 'user')
             throw new TypeError('Images require a user message');
         for (const image of images) {
-            if (!image.url || !/^(https?:\/\/|data:image\/)/i.test(image.url)
-                || (image.detail !== undefined && !['auto', 'low', 'high', 'original'].includes(image.detail)))
+            if (!image.url ||
+                !/^(https?:\/\/|data:image\/)/i.test(image.url) ||
+                (image.detail !== undefined && !['auto', 'low', 'high', 'original'].includes(image.detail)))
                 throw new TypeError('Invalid model image');
         }
-        return { ...message, content: [
-                { type: 'text', text: message.content },
-                ...images.map(image => ({ type: 'image_url', image_url: image })),
-            ] };
+        return {
+            ...wire,
+            content: [
+                { type: 'text', text: content },
+                ...images.map((image) => ({ type: 'image_url', image_url: image })),
+            ],
+        };
     });
 }

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

@@ -4,17 +4,41 @@ exports.runChildren = runChildren;
 const cancellation_js_1 = require("../../utils/cancellation.js");
 const synchronous_js_1 = require("../../utils/synchronous.js");
 const rules_js_1 = require("../../utils/rules.js");
-/** Optional App-side composition of the existing child contract, not another scheduler protocol. */
+/**
+ * Run child tasks concurrently and return their values in declaration order.
+ *
+ * The first failure aborts the remaining group, but an already in-flight commit is still awaited
+ * because cancellation does not mean the write was rolled back.
+ *
+ * @param parent Parent runner supplying child creation, limits and cancellation.
+ * @param tasks Tasks to run; IDs must be unique and non-blank.
+ * @param options Concurrency, extra cancellation and accept/commit hooks.
+ * @returns Frozen values in declaration order.
+ * @throws {Error} When the concurrency, a task declaration or a duplicate ID is invalid.
+ * @throws The first task's error, or the combined signal's abort reason.
+ */
 async function runChildren(parent, tasks, options = {}) {
     const concurrency = options.concurrency ?? parent.childLimits.maxConcurrentCalls;
-    (0, rules_js_1.breakWhile)(!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > parent.childLimits.maxConcurrentCalls, 'Child group concurrency exceeds the parent policy');
+    (0, rules_js_1.breakWhile)(!Number.isSafeInteger(concurrency) ||
+        concurrency < 1 ||
+        concurrency > parent.childLimits.maxConcurrentCalls, 'Child group concurrency exceeds the parent policy');
     const accept = options.accept?.bind(options), commit = options.commit?.bind(options);
-    const definitions = tasks.map(task => {
+    const definitions = tasks.map((task) => {
         const { id, maxCalls, reserveCalls, timeoutMs, transports, diagnostics, signal, run } = task;
         (0, rules_js_1.breakWhile)(typeof id !== 'string' || !id.trim() || typeof run !== 'function', 'Invalid child task');
-        return { id, maxCalls, reserveCalls, timeoutMs, transports: transports === undefined ? undefined : [...transports], diagnostics, signal, run: run.bind(task) };
+        return {
+            id,
+            maxCalls,
+            reserveCalls,
+            timeoutMs,
+            transports: transports === undefined ? undefined : [...transports],
+            diagnostics,
+            signal,
+            run: run.bind(task),
+        };
     });
-    (0, rules_js_1.breakWhile)(new Set(definitions.map(task => task.id)).size !== definitions.length, 'Duplicate child task id');
+    (0, rules_js_1.breakWhile)(new Set(definitions.map((task) => task.id)).size !== definitions.length, 'Duplicate child task id');
+    // One group controller so the first failure cancels every sibling worker at once.
     const cancellation = new AbortController();
     const signal = (0, cancellation_js_1.combineSignals)(parent.signal, cancellation.signal, options.signal);
     signal.throwIfAborted();
@@ -25,12 +49,16 @@ async function runChildren(parent, tasks, options = {}) {
             const index = next++, definition = definitions[index];
             try {
                 signal.throwIfAborted();
-                const child = parent.createChild({ ...definition, signal: (0, cancellation_js_1.combineSignals)(signal, definition.signal) });
+                const child = parent.createChild({
+                    ...definition,
+                    signal: (0, cancellation_js_1.combineSignals)(signal, definition.signal),
+                });
                 const value = await (0, cancellation_js_1.awaitWithSignal)(definition.run(child, child.signal), child.signal);
                 child.signal.throwIfAborted();
                 if (accept)
                     await (0, cancellation_js_1.awaitAssertion)(() => accept(value, definition.id), child.signal, 'Child acceptance must return void');
                 child.signal.throwIfAborted();
+                // Index by declaration position so completion order never changes the result order.
                 values[index] = value;
             }
             catch (error) {

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

@@ -1,23 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompatibleModelProvider = void 0;
+/**
+ * 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.
+ */
 const errors_js_1 = require("../../errors.js");
 const defaults_js_1 = require("../../model/defaults.js");
 const options_js_1 = require("../../model/options.js");
 const index_js_1 = require("../../diagnostics/index.js");
 const chat_provider_js_1 = require("../../structs/model/chat-provider.js");
 const chat_completions_js_1 = require("./chat-completions.js");
+const default_js_1 = require("./completion/default.js");
 const sse_js_1 = require("../transport/sse.js");
 const observer_js_1 = require("./observer.js");
 const synchronous_js_1 = require("../../utils/synchronous.js");
 const cancellation_js_1 = require("../../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) {
@@ -70,12 +105,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');
@@ -94,10 +135,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.
+ */
 class CompatibleModelProvider extends chat_provider_js_1.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;
@@ -105,6 +158,7 @@ class CompatibleModelProvider extends chat_provider_js_1.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),
         };
@@ -114,11 +168,33 @@ class CompatibleModelProvider extends chat_provider_js_1.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 });
-        (0, errors_js_1.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 });
+        (0, errors_js_1.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();
@@ -131,11 +207,14 @@ class CompatibleModelProvider extends chat_provider_js_1.ChatProvider {
                 throw new TypeError('Use maxOutputTokens');
             options = (0, options_js_1.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) {
@@ -144,9 +223,14 @@ class CompatibleModelProvider extends chat_provider_js_1.ChatProvider {
         }
         const maxOutputTokens = Math.min(options.maxOutputTokens ?? config.maxOutputTokens ?? defaults_js_1.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');
             }
         }
@@ -156,61 +240,99 @@ class CompatibleModelProvider extends chat_provider_js_1.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: (0, chat_completions_js_1.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' } } : {}),
+                ...(0, chat_completions_js_1.chatCompletionFunctionOptions)(options),
+                ...config.requestBody,
+                ...(options.includeUsage ? { stream_options: { include_usage: true } } : {}),
+            };
+            const policy = this.ports.completionPolicy ?? default_js_1.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: (0, chat_completions_js_1.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' } } : {}),
-                    ...(0, chat_completions_js_1.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 (0, cancellation_js_1.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 (0, sse_js_1.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;
                 }
@@ -226,11 +348,17 @@ class CompatibleModelProvider extends chat_provider_js_1.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;
@@ -239,20 +367,13 @@ class CompatibleModelProvider extends chat_provider_js_1.ChatProvider {
                 const parts = (0, chat_completions_js_1.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;
                 }
             }
@@ -260,11 +381,14 @@ class CompatibleModelProvider extends chat_provider_js_1.ChatProvider {
         }
         catch (error) {
             failure = { error };
-            if (!signal.aborted && (0, errors_js_1.getErrorInfo)(error).codes.every(code => code === 'UNKNOWN_ERROR'))
+            if (!signal.aborted && (0, errors_js_1.getErrorInfo)(error).codes.every((code) => code === 'UNKNOWN_ERROR'))
                 (0, errors_js_1.recordErrorContext)(error, { codes: ['MODEL_UPSTREAM'] });
         }
         finally {
-            observation.emit('provider.end', () => ({ complete, ...(failure ? { error: (0, index_js_1.diagnosticError)(failure.error) } : {}) }));
+            observation.emit('provider.end', () => ({
+                complete,
+                ...(failure ? { error: (0, index_js_1.diagnosticError)(failure.error) } : {}),
+            }));
         }
         throw failure.error;
     }
@@ -275,7 +399,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) {
@@ -294,7 +420,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]);
@@ -318,6 +446,8 @@ async function captureErrorBody(response) {
         try {
             reader.releaseLock();
         }
-        catch { /* A pending read is cancelled independently. */ }
+        catch {
+            /* A pending read is cancelled independently. */
+        }
     }
 }