genai-lite 0.14.0 → 0.15.0

package/dist/llm/LLMService.js

@@ -6,6 +6,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLMService = void 0;
+const node_crypto_1 = require("node:crypto");
 const defaultLogger_1 = require("../logging/defaultLogger");
 const config_1 = require("./config");
 const template_1 = require("../prompting/template");
@@ -20,6 +21,8 @@ const SettingsManager_1 = require("./services/SettingsManager");
 const ModelResolver_1 = require("./services/ModelResolver");
 const withRetry_1 = require("../shared/services/withRetry");
 const types_1 = require("./clients/types");
+const preparedAdapterUtils_1 = require("./clients/preparedAdapterUtils");
+const tokenization_1 = require("./tokenization");
 /**
  * Main process service for LLM operations
  *
@@ -33,6 +36,7 @@ const types_1 = require("./clients/types");
  */
 class LLMService {
     constructor(getApiKey, options = {}) {
+        this.preparedCalls = new WeakMap();
         this.getApiKey = getApiKey;
         this.retryOptions = options.retry;
         this.defaultTimeoutMs = options.timeoutMs;
@@ -93,12 +97,14 @@ class LLMService {
         const resolvedModelId = resolved.modelId;
         const modelInfo = resolved.modelInfo;
         const source = this.getCapabilitySource(resolvedProviderId, resolvedModelId);
+        const capabilities = this.buildModelCapabilities(modelInfo, source);
         return {
             object: "model.capabilities",
             provider: resolvedProviderId,
             model: resolvedModelId,
             modelInfo: { ...modelInfo },
-            structuredOutput: this.getStructuredOutputSupport(modelInfo, source),
+            structuredOutput: capabilities.structuredOutput,
+            capabilities,
         };
     }
     /**
@@ -171,81 +177,119 @@ class LLMService {
      */
     async sendMessage(request, callOptions) {
         this.logger.info(`LLMService.sendMessage called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
+        const canonical = await this.prepareMessage(request, { mode: "complete" });
+        if (this.isFailureResponse(canonical)) {
+            return canonical;
+        }
+        return this.sendPrepared(canonical, callOptions);
+    }
+    /**
+     * Resolves and freezes the final semantic provider request without retrieving
+     * credentials or creating transport state.
+     */
+    async prepareMessage(request, options) {
+        if (!options ||
+            (options.mode !== "complete" && options.mode !== "stream")) {
+            return this.createPreparedFailure(request.providerId ?? "unknown", request.modelId ?? "unknown", types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, "Prepared-call mode must be either 'complete' or 'stream'.", "validation_error");
+        }
+        const result = await this.prepareCanonicalRequest(request, options.mode);
+        if ("error" in result) {
+            return result.error;
+        }
+        const handle = Object.create(null);
+        Object.defineProperties(handle, {
+            mode: {
+                value: options.mode,
+                enumerable: true,
+                configurable: false,
+                writable: false,
+            },
+            toJSON: {
+                value: () => {
+                    throw new TypeError("Prepared LLM calls cannot be serialized.");
+                },
+                enumerable: false,
+                configurable: false,
+                writable: false,
+            },
+        });
+        Object.freeze(handle);
+        this.preparedCalls.set(handle, result.prepared);
+        return handle;
+    }
+    /** Returns the immutable inspection view for a service-owned prepared call. */
+    async inspectPrepared(handle) {
+        const prepared = this.preparedCalls.get(handle);
+        if (!prepared) {
+            return this.createPreparedHandleError(handle, types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, "The prepared call is invalid, forged, or belongs to another LLMService instance.");
+        }
+        return (0, preparedAdapterUtils_1.deepFreeze)({
+            provider: prepared.providerId,
+            model: prepared.modelId,
+            mode: prepared.adapterPrepared.mode,
+            request: structuredClone(prepared.adapterPrepared.requestView),
+            promptAccounting: structuredClone(prepared.adapterPrepared.promptAccounting),
+            ...(prepared.adapterPrepared.outputTokenLimit && {
+                outputTokenLimit: structuredClone(prepared.adapterPrepared.outputTokenLimit),
+            }),
+            bindings: structuredClone(prepared.adapterPrepared.bindings),
+        });
+    }
+    /** Dispatches a reusable complete-mode prepared call. */
+    async sendPrepared(handle, callOptions) {
+        const resolved = this.resolvePreparedHandle(handle, "complete");
+        if ("error" in resolved) {
+            return resolved.error;
+        }
+        const prepared = resolved.prepared;
+        const adapter = prepared.clientAdapter;
+        if (!adapter.sendPrepared) {
+            return this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.PREPARED_CALL_UNSUPPORTED, `Prepared calls are not supported for provider '${prepared.providerId}'.`, "unsupported_feature");
+        }
+        const apiKey = await this.resolveDispatchApiKey(prepared);
+        if (this.isFailureResponse(apiKey)) {
+            return apiKey;
+        }
+        const adapterOptions = this.createAdapterOptions(callOptions);
+        const retryOnTimeout = this.retryOptions?.retryOnTimeout ?? true;
+        const retryableCodes = new Set([
+            types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED,
+            types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR,
+            ...(retryOnTimeout ? [types_1.ADAPTER_ERROR_CODES.REQUEST_TIMEOUT] : []),
+        ]);
         try {
-            const preparedResult = await this.prepareRequest(request, callOptions);
-            if ("error" in preparedResult) {
-                return preparedResult.error;
-            }
-            const prepared = preparedResult.prepared;
-            try {
-                this.logger.info(`Making LLM request with ${prepared.clientAdapter.constructor.name} for provider: ${prepared.providerId}`);
-                // Unified retry layer: adapters never throw, so retry decisions are made on
-                // RETURNED failure responses. SDK-internal retries are disabled (maxRetries: 0
-                // at client construction) — this loop is the single owner of retry behavior.
-                const retryOnTimeout = this.retryOptions?.retryOnTimeout ?? true;
-                const retryableCodes = new Set([
-                    types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED,
-                    types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR,
-                    ...(retryOnTimeout ? [types_1.ADAPTER_ERROR_CODES.REQUEST_TIMEOUT] : []),
-                ]);
-                const result = await (0, withRetry_1.withRetry)(() => prepared.clientAdapter.sendMessage(prepared.internalRequest, prepared.apiKey, prepared.adapterOptions), (res) => {
-                    if (res.object !== 'error') {
-                        return { retry: false };
-                    }
-                    const code = String(res.error.code);
-                    const status = res.error.status;
-                    const retryable = retryableCodes.has(code) ||
-                        (code === types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR &&
-                            typeof status === 'number' &&
-                            (status === 408 || status === 409 || status >= 500));
-                    return { retry: retryable, retryAfterMs: res.error.retryAfterMs };
-                }, {
-                    ...this.retryOptions,
-                    ...(callOptions?.maxRetries !== undefined && {
-                        maxRetries: callOptions.maxRetries,
-                    }),
-                    signal: callOptions?.signal,
-                    logger: this.logger,
-                    label: `${prepared.providerId}/${prepared.modelId}`,
-                });
-                const processedResult = this.postProcessResponse(result, prepared);
-                if (processedResult.object === "chat.completion") {
-                    this.logger.info(`LLM request completed successfully for model: ${prepared.modelId}`);
+            const result = await (0, withRetry_1.withRetry)(async () => {
+                const revalidation = await this.revalidatePrepared(prepared, adapterOptions);
+                if (revalidation) {
+                    return revalidation;
                 }
-                return processedResult;
-            }
-            catch (error) {
-                this.logger.error("Error in LLMService.sendMessage:", error);
+                return adapter.sendPrepared(prepared.adapterPrepared, apiKey, adapterOptions);
+            }, (response) => {
+                if (response.object !== "error") {
+                    return { retry: false };
+                }
+                const code = String(response.error.code);
+                const status = response.error.status;
                 return {
-                    provider: prepared.providerId,
-                    model: prepared.modelId,
-                    error: {
-                        message: error instanceof Error
-                            ? error.message
-                            : "An unknown error occurred during message sending.",
-                        code: "PROVIDER_ERROR",
-                        type: "server_error",
-                        providerError: error,
-                    },
-                    object: "error",
+                    retry: retryableCodes.has(code) ||
+                        (code === types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR &&
+                            typeof status === "number" &&
+                            (status === 408 || status === 409 || status >= 500)),
+                    retryAfterMs: response.error.retryAfterMs,
                 };
-            }
+            }, {
+                ...this.retryOptions,
+                ...(callOptions?.maxRetries !== undefined && {
+                    maxRetries: callOptions.maxRetries,
+                }),
+                signal: callOptions?.signal,
+                logger: this.logger,
+                label: `${prepared.providerId}/${prepared.modelId}`,
+            });
+            return this.postProcessResponse(result, prepared);
         }
         catch (error) {
-            this.logger.error("Error in LLMService.sendMessage (outer):", error);
-            return {
-                provider: request.providerId || request.presetId || 'unknown',
-                model: request.modelId || request.presetId || 'unknown',
-                error: {
-                    message: error instanceof Error
-                        ? error.message
-                        : "An unknown error occurred.",
-                    code: "UNEXPECTED_ERROR",
-                    type: "server_error",
-                    providerError: error,
-                },
-                object: "error",
-            };
+            return this.createUnexpectedDispatchFailure(prepared, error);
         }
     }
     /**
@@ -256,83 +300,146 @@ class LLMService {
      * are yielded as a single `error` event.
      */
     async *streamMessage(request, callOptions) {
+        const attemptId = (0, node_crypto_1.randomUUID)();
         this.logger.info(`LLMService.streamMessage called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
+        const canonical = await this.prepareMessage(request, { mode: "stream" });
+        if (this.isFailureResponse(canonical)) {
+            yield { attemptId, type: "error", error: canonical };
+            return;
+        }
+        yield* this.streamPreparedWithAttempt(canonical, callOptions, attemptId);
+        return;
+    }
+    /** Dispatches a reusable stream-mode prepared call with no automatic retries. */
+    async *streamPrepared(handle, callOptions) {
+        yield* this.streamPreparedWithAttempt(handle, callOptions, (0, node_crypto_1.randomUUID)());
+    }
+    async *streamPreparedWithAttempt(handle, callOptions, attemptId) {
+        const resolved = this.resolvePreparedHandle(handle, "stream");
+        if ("error" in resolved) {
+            yield { attemptId, type: "error", error: resolved.error };
+            return;
+        }
+        const prepared = resolved.prepared;
+        const adapter = prepared.clientAdapter;
+        if (!adapter.streamPrepared) {
+            yield {
+                attemptId,
+                type: "error",
+                error: this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.PREPARED_CALL_UNSUPPORTED, `Prepared streaming is not supported for provider '${prepared.providerId}'.`, "unsupported_feature"),
+            };
+            return;
+        }
+        const apiKey = await this.resolveDispatchApiKey(prepared);
+        if (this.isFailureResponse(apiKey)) {
+            yield { attemptId, type: "error", error: apiKey };
+            return;
+        }
+        const cancellation = new AbortController();
+        const signal = callOptions?.signal
+            ? AbortSignal.any([callOptions.signal, cancellation.signal])
+            : cancellation.signal;
+        const adapterOptions = this.createAdapterOptions({
+            ...callOptions,
+            signal,
+        });
+        const partialState = {
+            provider: prepared.providerId,
+            model: prepared.modelId,
+            started: false,
+            choices: new Map(),
+        };
+        let iterator;
+        let terminal = false;
         try {
-            const preparedResult = await this.prepareRequest(request, callOptions);
-            if ("error" in preparedResult) {
-                yield { type: "error", error: preparedResult.error };
-                return;
-            }
-            const prepared = preparedResult.prepared;
-            if (!prepared.clientAdapter.streamMessage) {
-                yield {
-                    type: "error",
-                    error: {
-                        provider: prepared.providerId,
-                        model: prepared.modelId,
-                        error: {
-                            message: `Streaming is not supported for provider '${prepared.providerId}'.`,
-                            code: "PROVIDER_ERROR",
-                            type: "unsupported_feature",
-                        },
-                        object: "error",
-                    },
-                };
+            const revalidation = await this.revalidatePrepared(prepared, adapterOptions);
+            if (revalidation) {
+                yield { attemptId, type: "error", error: revalidation };
                 return;
             }
-            try {
-                for await (const event of prepared.clientAdapter.streamMessage(prepared.internalRequest, prepared.apiKey, prepared.adapterOptions)) {
-                    if (event.type === "complete") {
-                        const processedResult = this.postProcessResponse(event.response, prepared);
-                        if (processedResult.object === "error") {
-                            yield { type: "error", error: processedResult };
-                        }
-                        else {
-                            yield { type: "complete", response: processedResult };
-                        }
-                        continue;
+            iterator = adapter
+                .streamPrepared(prepared.adapterPrepared, apiKey, adapterOptions)[Symbol.asyncIterator]();
+            while (!terminal) {
+                const step = await this.nextStreamEvent(iterator, signal);
+                if (step.done) {
+                    break;
+                }
+                const event = step.value;
+                this.observeStreamPartial(partialState, event);
+                if (event.type === "adapter_evidence") {
+                    continue;
+                }
+                if (event.type === "complete") {
+                    const processed = this.postProcessResponse(event.response, prepared);
+                    if (processed.object === "error") {
+                        const failure = this.finalizeStreamFailure(processed, partialState, attemptId, prepared);
+                        terminal = true;
+                        yield {
+                            attemptId,
+                            type: "error",
+                            error: failure,
+                        };
+                    }
+                    else {
+                        terminal = true;
+                        yield { attemptId, type: "complete", response: processed };
                     }
-                    yield event;
+                    break;
                 }
+                if (event.type === "error") {
+                    const failure = this.finalizeStreamFailure(event.error, partialState, attemptId, prepared);
+                    terminal = true;
+                    yield {
+                        attemptId,
+                        type: "error",
+                        error: failure,
+                    };
+                    break;
+                }
+                const { observedEvidence: _observedEvidence, ...publicEvent } = event;
+                yield { ...publicEvent, attemptId };
             }
-            catch (error) {
-                this.logger.error("Error in LLMService.streamMessage:", error);
+            if (!terminal) {
+                terminal = true;
+                const aborted = signal.aborted;
                 yield {
+                    attemptId,
                     type: "error",
-                    error: {
-                        provider: prepared.providerId,
-                        model: prepared.modelId,
-                        error: {
-                            message: error instanceof Error
-                                ? error.message
-                                : "An unknown error occurred during message streaming.",
-                            code: "PROVIDER_ERROR",
-                            type: "server_error",
-                            providerError: error,
-                        },
-                        object: "error",
-                    },
+                    error: this.finalizeStreamFailure(this.createPreparedFailure(prepared.providerId, prepared.modelId, aborted
+                        ? types_1.ADAPTER_ERROR_CODES.REQUEST_ABORTED
+                        : types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, aborted
+                        ? "The streaming request was aborted."
+                        : "The provider stream ended without a terminal event.", aborted ? "abort_error" : "server_error"), partialState, attemptId, prepared),
                 };
             }
         }
         catch (error) {
-            this.logger.error("Error in LLMService.streamMessage (outer):", error);
-            yield {
-                type: "error",
-                error: {
-                    provider: request.providerId || request.presetId || 'unknown',
-                    model: request.modelId || request.presetId || 'unknown',
-                    error: {
-                        message: error instanceof Error
+            if (!terminal) {
+                terminal = true;
+                const aborted = signal.aborted;
+                yield {
+                    attemptId,
+                    type: "error",
+                    error: this.finalizeStreamFailure(this.createPreparedFailure(prepared.providerId, prepared.modelId, aborted
+                        ? types_1.ADAPTER_ERROR_CODES.REQUEST_ABORTED
+                        : types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, aborted
+                        ? "The streaming request was aborted."
+                        : error instanceof Error
                             ? error.message
-                            : "An unknown error occurred.",
-                        code: "UNEXPECTED_ERROR",
-                        type: "server_error",
-                        providerError: error,
-                    },
-                    object: "error",
-                },
-            };
+                            : "An unknown streaming error occurred.", aborted ? "abort_error" : "server_error", error), partialState, attemptId, prepared),
+                };
+            }
+        }
+        finally {
+            cancellation.abort();
+            if (iterator?.return) {
+                try {
+                    void Promise.resolve(iterator.return()).catch(() => undefined);
+                }
+                catch {
+                    // Iterator cleanup is best-effort and must never replace the terminal.
+                }
+            }
         }
     }
     async resolveAndValidateCapabilities(request, options) {
@@ -386,12 +493,45 @@ class LLMService {
                 resolvedRequest,
                 finalSettings,
                 capabilities,
+                ...(resolved.adapterPreparationState !== undefined && {
+                    adapterPreparationState: resolved.adapterPreparationState,
+                }),
             },
         };
     }
     buildModelCapabilities(modelInfo, source) {
+        const structuredOutput = this.getStructuredOutputSupport(modelInfo, source);
+        const tokenProfile = (0, tokenization_1.resolveTokenProfile)(modelInfo.providerId, modelInfo.id);
+        const reportsUsage = modelInfo.providerId === "openai" ||
+            modelInfo.providerId === "anthropic" ||
+            modelInfo.providerId === "gemini" ||
+            modelInfo.providerId === "mistral" ||
+            modelInfo.providerId === "openrouter" ||
+            modelInfo.providerId === "llamacpp";
         return {
-            structuredOutput: this.getStructuredOutputSupport(modelInfo, source),
+            structuredOutput,
+            ...(modelInfo.contextWindow !== undefined && {
+                contextWindow: {
+                    tokens: modelInfo.contextWindow,
+                    source,
+                },
+            }),
+            contentTokenCounting: tokenProfile.status === "available" ? "exact" : "unavailable",
+            preparedMessageTokenCounting: modelInfo.providerId === "llamacpp" ? "runtime" : "unavailable",
+            ...(tokenProfile.status === "available" && {
+                tokenProfileId: tokenProfile.profile.id,
+                tokenProfileMappingRevision: tokenProfile.mappingRevision,
+            }),
+            ...(reportsUsage && {
+                reportsPromptUsage: true,
+                reportsCompletionUsage: true,
+            }),
+            distinguishesLimitCause: modelInfo.providerId === "anthropic" ||
+                modelInfo.providerId === "gemini",
+            structuredOutputDelivery: {
+                native: structuredOutput,
+                prompt: "instruction_only",
+            },
         };
     }
     getStructuredOutputSupport(modelInfo, source) {
@@ -415,7 +555,329 @@ class LLMService {
     getCapabilitySource(providerId, modelId) {
         return (0, config_1.getModelById)(modelId, providerId) ? "registry" : "fallback";
     }
-    async prepareRequest(request, callOptions) {
+    isFailureResponse(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            value.object === "error");
+    }
+    createPreparedFailure(provider, model, code, message, type, providerError) {
+        return {
+            provider,
+            model,
+            error: {
+                message,
+                code,
+                type,
+                ...(providerError !== undefined && { providerError }),
+            },
+            object: "error",
+        };
+    }
+    createPreparedHandleError(handle, code, message) {
+        const mode = typeof handle === "object" && handle !== null && "mode" in handle
+            ? String(handle.mode ?? "unknown")
+            : "unknown";
+        return this.createPreparedFailure("unknown", "unknown", code, message, mode === "unknown" ? "invalid_request_error" : "validation_error");
+    }
+    resolvePreparedHandle(handle, expectedMode) {
+        if ((typeof handle !== "object" && typeof handle !== "function") ||
+            handle === null) {
+            return {
+                error: this.createPreparedHandleError(handle, types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, "The prepared call is invalid or forged."),
+            };
+        }
+        const prepared = this.preparedCalls.get(handle);
+        if (!prepared) {
+            return {
+                error: this.createPreparedHandleError(handle, types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, "The prepared call is invalid, forged, or belongs to another LLMService instance."),
+            };
+        }
+        if (prepared.adapterPrepared.mode !== expectedMode) {
+            return {
+                error: this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.PREPARED_CALL_MODE_MISMATCH, `A '${prepared.adapterPrepared.mode}' prepared call cannot be dispatched as '${expectedMode}'.`, "validation_error"),
+            };
+        }
+        return { prepared };
+    }
+    async resolveDispatchApiKey(prepared) {
+        try {
+            const apiKey = await this.getApiKey(prepared.providerId);
+            if (!apiKey) {
+                return this.createPreparedFailure(prepared.providerId, prepared.modelId, "API_KEY_ERROR", `API key for provider '${prepared.providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`, "authentication_error");
+            }
+            if (prepared.clientAdapter.validateApiKey &&
+                !prepared.clientAdapter.validateApiKey(apiKey)) {
+                return this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY, `Invalid API key format for provider '${prepared.providerId}'. Please check your API key.`, "authentication_error");
+            }
+            return apiKey;
+        }
+        catch (error) {
+            return this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, error instanceof Error
+                ? error.message
+                : "An unknown error occurred while retrieving credentials.", "server_error", error);
+        }
+    }
+    createAdapterOptions(callOptions) {
+        const timeoutMs = callOptions?.timeoutMs ?? this.defaultTimeoutMs;
+        return {
+            ...(callOptions?.signal && { signal: callOptions.signal }),
+            ...(timeoutMs !== undefined && { timeoutMs }),
+        };
+    }
+    async revalidatePrepared(prepared, options) {
+        if (!prepared.clientAdapter.revalidatePreparedRequest) {
+            return undefined;
+        }
+        const result = await prepared.clientAdapter.revalidatePreparedRequest(prepared.adapterPrepared, options);
+        return result.valid ? undefined : result.error;
+    }
+    async nextStreamEvent(iterator, signal) {
+        if (signal.aborted) {
+            throw new Error("Streaming request aborted");
+        }
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                reject(new Error("Streaming request aborted"));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            Promise.resolve(iterator.next()).then((result) => {
+                signal.removeEventListener("abort", onAbort);
+                resolve(result);
+            }, (error) => {
+                signal.removeEventListener("abort", onAbort);
+                reject(error);
+            });
+        });
+    }
+    observeStreamPartial(state, event) {
+        const observed = event.observedEvidence;
+        if (observed?.choice) {
+            const choice = this.getStreamPartialChoice(state, observed.choice.index);
+            if (observed.choice.rawContentDelta !== undefined) {
+                choice.rawContent =
+                    (choice.rawContent ?? "") + observed.choice.rawContentDelta;
+            }
+            if (observed.choice.rawContentParts) {
+                choice.rawContentParts = [
+                    ...(choice.rawContentParts ?? []),
+                    ...observed.choice.rawContentParts,
+                ];
+            }
+            if (observed.choice.rawAnswerAccounting) {
+                choice.rawAnswerAccounting =
+                    observed.choice.rawAnswerAccounting;
+            }
+            if (observed.choice.finishReason !== undefined) {
+                choice.finishReason = observed.choice.finishReason;
+            }
+            if (observed.choice.termination) {
+                choice.termination = observed.choice.termination;
+            }
+        }
+        if (observed?.usageEvidence) {
+            state.usageEvidence = {
+                ...(state.usageEvidence ?? {}),
+                ...observed.usageEvidence,
+            };
+        }
+        if (observed?.usage) {
+            state.usage = {
+                ...(state.usage ?? {}),
+                ...Object.fromEntries(Object.entries(observed.usage).filter(([, value]) => value !== undefined)),
+            };
+        }
+        if (event.type === "adapter_evidence") {
+            return;
+        }
+        if (event.type === "start") {
+            state.started = true;
+            state.provider = event.provider;
+            state.model = event.model;
+            state.id = event.id;
+            state.created = event.created;
+            return;
+        }
+        if (event.type === "content_delta" || event.type === "reasoning_delta") {
+            const choice = this.getStreamPartialChoice(state, event.index);
+            if (event.type === "content_delta") {
+                choice.content += event.delta;
+            }
+            else {
+                choice.reasoning += event.delta;
+            }
+            return;
+        }
+        if (event.type === "usage") {
+            state.usage = {
+                ...(state.usage ?? {}),
+                ...Object.fromEntries(Object.entries(event.usage).filter(([, value]) => value !== undefined)),
+            };
+        }
+    }
+    getStreamPartialChoice(state, index) {
+        let choice = state.choices.get(index);
+        if (!choice) {
+            choice = { content: "", reasoning: "" };
+            state.choices.set(index, choice);
+        }
+        return choice;
+    }
+    finalizeStreamFailure(failure, state, attemptId, prepared) {
+        const processed = this.postProcessResponse(this.attachStreamPartial(failure, state, attemptId), prepared);
+        return processed;
+    }
+    attachStreamPartial(failure, state, attemptId) {
+        const hasEvidence = state.started ||
+            state.choices.size > 0 ||
+            state.usage !== undefined ||
+            state.usageEvidence !== undefined;
+        if (!hasEvidence) {
+            return failure;
+        }
+        const choices = Array.from(state.choices.entries())
+            .sort(([left], [right]) => left - right)
+            .map(([index, choice]) => ({
+            index,
+            message: {
+                role: "assistant",
+                content: choice.content,
+            },
+            ...(choice.reasoning.length > 0 && {
+                reasoning: choice.reasoning,
+            }),
+            ...(choice.rawContent !== undefined && {
+                rawContent: choice.rawContent,
+            }),
+            ...(choice.rawContentParts && {
+                rawContentParts: choice.rawContentParts,
+            }),
+            ...(choice.rawAnswerAccounting && {
+                rawAnswerAccounting: choice.rawAnswerAccounting,
+            }),
+            finish_reason: choice.finishReason ?? null,
+            termination: choice.termination ?? {
+                rawReason: null,
+                kind: "unknown",
+            },
+        }));
+        const observed = {
+            id: state.id ?? attemptId,
+            provider: state.provider,
+            model: state.model,
+            created: state.created ?? Math.floor(Date.now() / 1000),
+            choices,
+            ...(state.usage && { usage: state.usage }),
+            ...(state.usageEvidence && {
+                usageEvidence: state.usageEvidence,
+            }),
+        };
+        if (!failure.partialResponse) {
+            return { ...failure, partialResponse: observed };
+        }
+        const provided = failure.partialResponse;
+        const choicesByIndex = new Map(observed.choices.map((choice, position) => [
+            choice.index ?? position,
+            choice,
+        ]));
+        for (const [position, choice] of provided.choices.entries()) {
+            const index = choice.index ?? position;
+            const prior = choicesByIndex.get(index);
+            choicesByIndex.set(index, {
+                ...(prior ?? {}),
+                ...choice,
+                message: {
+                    ...(prior?.message ?? { role: "assistant", content: "" }),
+                    ...choice.message,
+                },
+                ...(choice.rawContentParts === undefined &&
+                    prior?.rawContentParts && {
+                    rawContentParts: prior.rawContentParts,
+                }),
+            });
+        }
+        const usage = {
+            ...(observed.usage ?? {}),
+            ...Object.fromEntries(Object.entries(provided.usage ?? {}).filter(([, value]) => value !== undefined)),
+        };
+        const usageEvidence = {
+            ...(observed.usageEvidence ?? {}),
+            ...Object.fromEntries(Object.entries(provided.usageEvidence ?? {}).filter(([, value]) => value !== undefined)),
+        };
+        return {
+            ...failure,
+            partialResponse: {
+                ...observed,
+                ...provided,
+                choices: Array.from(choicesByIndex.entries())
+                    .sort(([left], [right]) => left - right)
+                    .map(([, choice]) => choice),
+                ...(Object.keys(usage).length > 0 && { usage }),
+                ...(Object.keys(usageEvidence).length > 0 && {
+                    usageEvidence,
+                }),
+            },
+        };
+    }
+    isValidPreparedAccounting(accounting) {
+        if (accounting.status === "unavailable") {
+            return true;
+        }
+        return accounting.count !== undefined || accounting.upperBound !== undefined;
+    }
+    createEffectiveOutputTokenLimit(request, providerId, modelInfo, filteredMaxTokens) {
+        if (filteredMaxTokens === undefined ||
+            !Number.isSafeInteger(filteredMaxTokens) ||
+            filteredMaxTokens <= 0) {
+            return undefined;
+        }
+        const presetId = request.presetId;
+        const preset = presetId
+            ? this.presetManager
+                .getPresets()
+                .find((candidate) => candidate.id === presetId)
+            : undefined;
+        const source = request.settings?.maxTokens !== undefined
+            ? "request"
+            : preset?.settings.maxTokens !== undefined
+                ? "preset"
+                : modelInfo.defaultSettings?.maxTokens !== undefined ||
+                    modelInfo.maxTokens !== undefined
+                    ? "model_default"
+                    : "library_default";
+        const hardLimit = modelInfo.hardOutputTokenLimit;
+        const tokens = hardLimit
+            ? Math.min(filteredMaxTokens, hardLimit.tokens)
+            : filteredMaxTokens;
+        const counts = hardLimit?.counts ??
+            (providerId === "mistral"
+                ? "visible_output"
+                : providerId === "openrouter"
+                    ? "provider_defined"
+                    : providerId === "openai" ||
+                        providerId === "anthropic" ||
+                        providerId === "gemini" ||
+                        providerId === "llamacpp"
+                        ? "visible_and_reasoning"
+                        : "unknown");
+        return {
+            tokens,
+            source,
+            ...(tokens !== filteredMaxTokens && {
+                requestedTokens: filteredMaxTokens,
+                clamp: {
+                    tokens,
+                    source: hardLimit.source,
+                },
+            }),
+            counts,
+        };
+    }
+    createUnexpectedDispatchFailure(prepared, error) {
+        return this.createPreparedFailure(prepared.providerId, prepared.modelId, types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, error instanceof Error
+            ? error.message
+            : "An unknown error occurred during prepared dispatch.", "server_error", error);
+    }
+    async prepareCanonicalRequest(request, mode) {
         const validation = await this.resolveAndValidateCapabilities(request, {
             validateStructure: true,
             detectLocalCapabilities: true,
@@ -423,7 +885,7 @@ class LLMService {
         if ("error" in validation) {
             return { error: validation.error };
         }
-        const { providerId, modelId, modelInfo, resolvedRequest, finalSettings, } = validation.context;
+        const { providerId, modelId, modelInfo, resolvedRequest, finalSettings, adapterPreparationState, } = validation.context;
         // Get provider info for parameter filtering
         const providerInfo = (0, config_1.getProviderById)(providerId);
         if (!providerInfo) {
@@ -442,6 +904,11 @@ class LLMService {
         }
         // Filter out unsupported parameters
         const filteredSettings = this.settingsManager.filterUnsupportedParameters(finalSettings, modelInfo, providerInfo);
+        const outputTokenLimit = this.createEffectiveOutputTokenLimit(request, providerId, modelInfo, filteredSettings.maxTokens);
+        if (outputTokenLimit?.clamp &&
+            filteredSettings.maxTokens !== outputTokenLimit.tokens) {
+            filteredSettings.maxTokens = outputTokenLimit.tokens;
+        }
         const internalRequest = {
             ...resolvedRequest,
             settings: filteredSettings,
@@ -454,43 +921,34 @@ class LLMService {
         });
         // Get client adapter
         const clientAdapter = this.adapterRegistry.getAdapter(providerId);
+        if (!clientAdapter.prepareRequest) {
+            return {
+                error: this.createPreparedFailure(providerId, modelId, types_1.ADAPTER_ERROR_CODES.PREPARED_CALL_UNSUPPORTED, `Prepared calls are not supported for provider '${providerId}'.`, "unsupported_feature"),
+            };
+        }
         try {
-            const apiKey = await this.getApiKey(providerId);
-            if (!apiKey) {
+            const adapterResult = await clientAdapter.prepareRequest(internalRequest, {
+                mode,
+                modelInfo,
+                outputTokenLimit,
+                ...(adapterPreparationState !== undefined && {
+                    providerState: adapterPreparationState,
+                }),
+            });
+            if ("error" in adapterResult) {
+                return { error: adapterResult.error };
+            }
+            if (!this.isValidPreparedAccounting(adapterResult.prepared.promptAccounting)) {
                 return {
-                    error: {
-                        provider: providerId,
-                        model: modelId,
-                        error: {
-                            message: `API key for provider '${providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`,
-                            code: "API_KEY_ERROR",
-                            type: "authentication_error",
-                        },
-                        object: "error",
-                    },
+                    error: this.createPreparedFailure(providerId, modelId, types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, "The adapter returned invalid prepared prompt accounting.", "server_error"),
                 };
             }
-            // Validate API key format if adapter supports it
-            if (clientAdapter.validateApiKey && !clientAdapter.validateApiKey(apiKey)) {
+            if (adapterResult.prepared.mode !== mode) {
                 return {
-                    error: {
-                        provider: providerId,
-                        model: modelId,
-                        error: {
-                            message: `Invalid API key format for provider '${providerId}'. Please check your API key.`,
-                            code: "INVALID_API_KEY",
-                            type: "authentication_error",
-                        },
-                        object: "error",
-                    },
+                    error: this.createPreparedFailure(providerId, modelId, types_1.ADAPTER_ERROR_CODES.INVALID_PREPARED_CALL, `The adapter prepared mode '${String(adapterResult.prepared.mode)}' instead of '${mode}'.`, "server_error"),
                 };
             }
-            const adapterOptions = {
-                ...(callOptions?.signal && { signal: callOptions.signal }),
-                ...((callOptions?.timeoutMs ?? this.defaultTimeoutMs) !== undefined && {
-                    timeoutMs: callOptions?.timeoutMs ?? this.defaultTimeoutMs,
-                }),
-            };
+            const adapterPrepared = (0, preparedAdapterUtils_1.deepFreeze)(adapterResult.prepared);
             return {
                 prepared: {
                     providerId,
@@ -499,33 +957,59 @@ class LLMService {
                     resolvedRequest,
                     internalRequest,
                     clientAdapter,
-                    apiKey,
-                    adapterOptions,
+                    adapterPrepared,
                 },
             };
         }
         catch (error) {
-            this.logger.error("Error preparing LLM request:", error);
             return {
-                error: {
-                    provider: providerId,
-                    model: modelId,
-                    error: {
-                        message: error instanceof Error
-                            ? error.message
-                            : "An unknown error occurred during request preparation.",
-                        code: "PROVIDER_ERROR",
-                        type: "server_error",
-                        providerError: error,
-                    },
-                    object: "error",
-                },
+                error: this.createPreparedFailure(providerId, modelId, types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, error instanceof Error
+                    ? error.message
+                    : "An unknown error occurred during request preparation.", "server_error", error),
             };
         }
     }
     postProcessResponse(result, prepared) {
         if (result.object === "error") {
-            return result;
+            if (!result.partialResponse) {
+                return result;
+            }
+            const processed = this.postProcessResponse({
+                ...result.partialResponse,
+                object: "chat.completion",
+            }, prepared);
+            if (processed.object === "error") {
+                return {
+                    ...result,
+                    ...(processed.partialResponse && {
+                        partialResponse: processed.partialResponse,
+                    }),
+                };
+            }
+            const { object: _object, ...partialResponse } = processed;
+            return { ...result, partialResponse };
+        }
+        const tokenProfile = (0, tokenization_1.resolveTokenProfile)(prepared.providerId, prepared.modelId);
+        if (tokenProfile.status === "available") {
+            for (const choice of result.choices) {
+                const rawContent = choice.rawContent ?? choice.message.content;
+                choice.rawContent ?? (choice.rawContent = rawContent);
+                if (!choice.rawAnswerAccounting) {
+                    const counted = (0, tokenization_1.countTextTokens)(rawContent, tokenProfile.profile);
+                    if (counted.status === "available") {
+                        choice.rawAnswerAccounting = {
+                            tokens: counted.count.tokens,
+                            method: counted.count.method,
+                            source: "library",
+                            tokenizerId: counted.count.tokenizerId,
+                            tokenProfileRevision: counted.count.tokenProfileRevision,
+                            reasoning: choice.reasoning && choice.reasoning.length > 0
+                                ? "excluded"
+                                : "unknown",
+                        };
+                    }
+                }
+            }
         }
         // Post-process for thinking tag fallback
         // This feature extracts reasoning from XML tags when native reasoning is not active.
@@ -542,6 +1026,7 @@ class LLMService {
             // Process the response - extract thinking tags if present
             const choice = result.choices[0];
             if (choice?.message?.content) {
+                choice.rawContent ?? (choice.rawContent = choice.message.content);
                 const { extracted, remaining } = (0, parser_1.extractInitialTaggedContent)(choice.message.content, tagName);
                 if (extracted !== null) {
                     // Success: thinking tag found
@@ -557,6 +1042,9 @@ class LLMService {
                         choice.reasoning = extracted;
                     }
                     choice.message.content = remaining;
+                    if (choice.rawAnswerAccounting) {
+                        choice.rawAnswerAccounting.reasoning = "included_extracted";
+                    }
                 }
                 else {
                     // Tag was not found
@@ -585,7 +1073,8 @@ class LLMService {
                                 model: result.model,
                                 created: result.created,
                                 choices: result.choices,
-                                usage: result.usage
+                                usage: result.usage,
+                                usageEvidence: result.usageEvidence,
                             }
                         };
                     }