@fabric-harness/sdk 2.1.1 → 2.2.0

package/dist/model.js

@@ -1,5 +1,5 @@
-import { createHash, createHmac } from 'node:crypto';
-import { applyEstimatedCost } from './model-pricing.js';
+import { createHash, createHmac } from "node:crypto";
+import { applyEstimatedCost } from "./model-pricing.js";
 export function toolsToModelSchemas(tools) {
     return [...tools].map((tool) => ({
         name: tool.name,
@@ -18,7 +18,7 @@ export async function generateWithRuntime(provider, request, options = {}) {
     // a pending backoff without tearing down an in-flight model call.
     const retryAbortController = new AbortController();
     const onCallerAbort = () => retryAbortController.abort(options.signal?.reason);
-    options.signal?.addEventListener('abort', onCallerAbort, { once: true });
+    options.signal?.addEventListener("abort", onCallerAbort, { once: true });
     try {
         for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
             if (options.signal?.aborted) {
@@ -30,18 +30,24 @@ export async function generateWithRuntime(provider, request, options = {}) {
                 ? setTimeout(() => controller.abort(new Error(`Model call timed out after ${options.timeoutMs}ms`)), options.timeoutMs)
                 : undefined;
             const abortListener = () => controller.abort(options.signal?.reason);
-            options.signal?.addEventListener('abort', abortListener, { once: true });
-            await options.onAttempt?.({ provider: provider.name, attempt, maxAttempts, status: 'start', ...(request.model !== undefined ? { model: request.model } : {}) });
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+            await options.onAttempt?.({
+                provider: provider.name,
+                attempt,
+                maxAttempts,
+                status: "start",
+                ...(request.model !== undefined ? { model: request.model } : {}),
+            });
             try {
                 const response = await provider.generate({ ...request, signal: controller.signal });
                 if (timeout)
                     clearTimeout(timeout);
-                options.signal?.removeEventListener('abort', abortListener);
+                options.signal?.removeEventListener("abort", abortListener);
                 await options.onAttempt?.({
                     provider: provider.name,
                     attempt,
                     maxAttempts,
-                    status: 'success',
+                    status: "success",
                     durationMs: Date.now() - startedAt,
                     ...(request.model !== undefined ? { model: request.model } : {}),
                     ...(response.usage !== undefined ? { usage: response.usage } : {}),
@@ -51,7 +57,7 @@ export async function generateWithRuntime(provider, request, options = {}) {
             catch (error) {
                 if (timeout)
                     clearTimeout(timeout);
-                options.signal?.removeEventListener('abort', abortListener);
+                options.signal?.removeEventListener("abort", abortListener);
                 lastError = error;
                 const message = error instanceof Error ? error.message : String(error);
                 const canRetry = attempt < maxAttempts && !options.signal?.aborted && isRetryableModelError(error);
@@ -59,7 +65,7 @@ export async function generateWithRuntime(provider, request, options = {}) {
                     provider: provider.name,
                     attempt,
                     maxAttempts,
-                    status: canRetry ? 'retry' : 'error',
+                    status: canRetry ? "retry" : "error",
                     durationMs: Date.now() - startedAt,
                     ...(request.model !== undefined ? { model: request.model } : {}),
                     error: message,
@@ -77,26 +83,29 @@ export async function generateWithRuntime(provider, request, options = {}) {
         }
     }
     finally {
-        options.signal?.removeEventListener('abort', onCallerAbort);
+        options.signal?.removeEventListener("abort", onCallerAbort);
     }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 export class MockModelProvider {
-    name = 'mock';
+    name = "mock";
     async generate(request) {
-        const latest = [...request.messages].reverse().find((message) => message.role === 'user');
-        const text = latest?.content ?? '';
-        const hasToolResults = request.messages.some((message) => message.role === 'tool');
+        const latest = [...request.messages].reverse().find((message) => message.role === "user");
+        const text = latest?.content ?? "";
+        const hasToolResults = request.messages.some((message) => message.role === "tool");
         const scripted = hasToolResults ? [] : parseScriptedToolCalls(text);
         if (scripted.length > 0)
             return { toolCalls: scripted, usage: estimateUsage(request.messages) };
         const toolSummaries = request.messages
-            .filter((message) => message.role === 'tool')
-            .map((message) => `${message.name ?? 'tool'}: ${message.content}`);
+            .filter((message) => message.role === "tool")
+            .map((message) => `${message.name ?? "tool"}: ${message.content}`);
         const content = toolSummaries.length > 0
-            ? `Mock response using tool results:\n${toolSummaries.join('\n')}`
+            ? `Mock response using tool results:\n${toolSummaries.join("\n")}`
             : `Mock response: ${text}`;
-        return { message: { role: 'assistant', content }, usage: estimateUsage([...request.messages, { role: 'assistant', content }]) };
+        return {
+            message: { role: "assistant", content },
+            usage: estimateUsage([...request.messages, { role: "assistant", content }]),
+        };
     }
 }
 // ─── Reasoning effort ────────────────────────────────────────────────────────
@@ -116,53 +125,53 @@ const REASONING_MODEL_PATTERNS = [
 ];
 /** Whether a model id (with or without provider prefix) is a known reasoning model. */
 export function modelSupportsReasoning(model) {
-    const id = model.includes('/') ? model.slice(model.lastIndexOf('/') + 1) : model;
+    const id = model.includes("/") ? model.slice(model.lastIndexOf("/") + 1) : model;
     return REASONING_MODEL_PATTERNS.some((re) => re.test(id));
 }
 /** True when a reasoning control should be applied for this model + requested level. */
 function shouldApplyReasoning(model, level) {
-    return level !== undefined && level !== 'off' && modelSupportsReasoning(model);
+    return level !== undefined && level !== "off" && modelSupportsReasoning(model);
 }
 /** OpenAI / Workers-AI style `reasoning_effort` value. */
 function openAIReasoningEffort(level) {
     switch (level) {
-        case 'minimal':
-        case 'low':
-            return 'low';
-        case 'medium':
-            return 'medium';
-        case 'high':
-        case 'xhigh':
-            return 'high';
+        case "minimal":
+        case "low":
+            return "low";
+        case "medium":
+            return "medium";
+        case "high":
+        case "xhigh":
+            return "high";
     }
 }
 /** Anthropic extended-thinking token budget (>= 1024; `max_tokens` must exceed it). */
 function anthropicThinkingBudget(level) {
     switch (level) {
-        case 'minimal':
+        case "minimal":
             return 1024;
-        case 'low':
+        case "low":
             return 2048;
-        case 'medium':
+        case "medium":
             return 4096;
-        case 'high':
+        case "high":
             return 8192;
-        case 'xhigh':
+        case "xhigh":
             return 16384;
     }
 }
 /** Gemini `thinkingConfig.thinkingBudget` token count. */
 function geminiThinkingBudget(level) {
     switch (level) {
-        case 'minimal':
+        case "minimal":
             return 512;
-        case 'low':
+        case "low":
             return 1024;
-        case 'medium':
+        case "medium":
             return 4096;
-        case 'high':
+        case "high":
             return 12288;
-        case 'xhigh':
+        case "xhigh":
             return 24576;
     }
 }
@@ -175,9 +184,10 @@ export class OpenAICompatibleModelProvider {
     headers;
     rateLimiter;
     rateLimitKey;
+    fetchImpl;
     constructor(options) {
-        this.name = options.name ?? 'openai-compatible';
-        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.name = options.name ?? "openai-compatible";
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
         this.apiKey = options.apiKey;
         this.tokenProvider = options.tokenProvider;
         if (options.defaultModel !== undefined)
@@ -185,11 +195,16 @@ export class OpenAICompatibleModelProvider {
         this.headers = options.headers ?? {};
         this.rateLimiter = options.rateLimiter;
         this.rateLimitKey = `${this.name}:${rateLimitKeyForApiKey(this.apiKey)}`;
+        this.fetchImpl = options.fetchImpl ?? fetch;
     }
     /** Resolves the bearer token for a request: the rotating `tokenProvider` if set, else `apiKey`. */
     async authToken() {
         return this.tokenProvider ? await this.tokenProvider() : this.apiKey;
     }
+    /** Resolve dynamic headers per attempt so request-scoped metadata never becomes stale. */
+    async requestHeaders() {
+        return typeof this.headers === "function" ? await this.headers() : this.headers;
+    }
     async generate(request) {
         const model = request.model ?? this.defaultModel;
         if (!model)
@@ -197,22 +212,25 @@ export class OpenAICompatibleModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const token = await this.authToken();
+        const headers = await this.requestHeaders();
         const init = {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: {
-                'content-type': 'application/json',
+                "content-type": "application/json",
                 authorization: `Bearer ${token}`,
-                ...this.headers,
+                ...headers,
             },
             body: JSON.stringify({
                 model,
                 messages: request.messages.map(toOpenAIMessage),
                 ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
-                ...(shouldApplyReasoning(model, request.thinkingLevel) ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) } : {}),
+                ...(shouldApplyReasoning(model, request.thinkingLevel)
+                    ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) }
+                    : {}),
             }),
         };
-        const response = await fetch(`${this.baseUrl}/chat/completions`, init);
+        const response = await this.fetchImpl(`${this.baseUrl}/chat/completions`, init);
         if (!response.ok) {
             const body = await response.text();
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, body, response.headers);
@@ -236,14 +254,15 @@ export class OpenAICompatibleModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const token = await this.authToken();
+        const headers = await this.requestHeaders();
         const init = {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: {
-                'content-type': 'application/json',
+                "content-type": "application/json",
                 authorization: `Bearer ${token}`,
-                accept: 'text/event-stream',
-                ...this.headers,
+                accept: "text/event-stream",
+                ...headers,
             },
             body: JSON.stringify({
                 model,
@@ -251,10 +270,12 @@ export class OpenAICompatibleModelProvider {
                 stream_options: { include_usage: true },
                 messages: request.messages.map(toOpenAIMessage),
                 ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
-                ...(shouldApplyReasoning(model, request.thinkingLevel) ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) } : {}),
+                ...(shouldApplyReasoning(model, request.thinkingLevel)
+                    ? { reasoning_effort: openAIReasoningEffort(request.thinkingLevel) }
+                    : {}),
             }),
         };
-        const response = await fetch(`${this.baseUrl}/chat/completions`, init);
+        const response = await this.fetchImpl(`${this.baseUrl}/chat/completions`, init);
         if (!response.ok || !response.body) {
             const body = await response.text();
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, body, response.headers);
@@ -264,15 +285,15 @@ export class OpenAICompatibleModelProvider {
         const toolCallBuffers = new Map();
         let usage;
         for await (const event of decodeOpenAISSE(response.body)) {
-            if (event === '[DONE]')
+            if (event === "[DONE]")
                 break;
             const json = safeJsonParse(event);
             if (!json)
                 continue;
             const choice = json.choices?.[0];
             const delta = choice?.delta;
-            const contentDelta = typeof delta?.content === 'string' ? delta.content : '';
-            const reasoningDelta = typeof delta?.reasoning_content === 'string' ? delta.reasoning_content : '';
+            const contentDelta = typeof delta?.content === "string" ? delta.content : "";
+            const reasoningDelta = typeof delta?.reasoning_content === "string" ? delta.reasoning_content : "";
             if (contentDelta) {
                 text.push(contentDelta);
                 yield { textDelta: contentDelta };
@@ -284,14 +305,14 @@ export class OpenAICompatibleModelProvider {
             const toolCalls = delta?.tool_calls;
             if (toolCalls) {
                 for (const tc of toolCalls) {
-                    const idx = typeof tc.index === 'number' ? tc.index : 0;
-                    const buf = toolCallBuffers.get(idx) ?? { args: '' };
-                    if (typeof tc.id === 'string')
+                    const idx = typeof tc.index === "number" ? tc.index : 0;
+                    const buf = toolCallBuffers.get(idx) ?? { args: "" };
+                    if (typeof tc.id === "string")
                         buf.id = tc.id;
                     const fn = tc.function;
                     if (fn?.name)
                         buf.name = fn.name;
-                    if (typeof fn?.arguments === 'string')
+                    if (typeof fn?.arguments === "string")
                         buf.args += fn.arguments;
                     toolCallBuffers.set(idx, buf);
                 }
@@ -299,22 +320,22 @@ export class OpenAICompatibleModelProvider {
             const u = json.usage;
             if (u) {
                 usage = {};
-                if (typeof u.prompt_tokens === 'number')
+                if (typeof u.prompt_tokens === "number")
                     usage.inputTokens = u.prompt_tokens;
-                if (typeof u.completion_tokens === 'number')
+                if (typeof u.completion_tokens === "number")
                     usage.outputTokens = u.completion_tokens;
-                if (typeof u.total_tokens === 'number')
+                if (typeof u.total_tokens === "number")
                     usage.totalTokens = u.total_tokens;
             }
         }
         const done = {
-            ...(text.length ? { message: { role: 'assistant', content: text.join('') } } : {}),
-            ...(thinking.length ? { thinking: thinking.join('') } : {}),
+            ...(text.length ? { message: { role: "assistant", content: text.join("") } } : {}),
+            ...(thinking.length ? { thinking: thinking.join("") } : {}),
             ...(toolCallBuffers.size > 0
                 ? {
                     toolCalls: [...toolCallBuffers.values()].map((buf, index) => ({
                         id: buf.id ?? `openai-stream-${index + 1}`,
-                        name: buf.name ?? '',
+                        name: buf.name ?? "",
                         input: buf.args ? JSON.parse(buf.args) : {},
                     })),
                 }
@@ -334,23 +355,26 @@ export class AzureOpenAIModelProvider {
     apiVersion;
     headers;
     constructor(options) {
-        this.name = options.name ?? 'azure-openai';
-        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.name = options.name ?? "azure-openai";
+        this.baseUrl = options.baseUrl.replace(/\/$/, "");
         this.apiKey = options.apiKey;
         this.deployment = options.deployment;
-        this.apiVersion = options.apiVersion ?? '2024-10-21';
+        this.apiVersion = options.apiVersion ?? "2024-10-21";
         this.headers = options.headers ?? {};
     }
     async generate(request) {
         const response = await fetch(`${this.baseUrl}/openai/deployments/${encodeURIComponent(this.deployment)}/chat/completions?api-version=${encodeURIComponent(this.apiVersion)}`, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
-            headers: { 'content-type': 'application/json', 'api-key': this.apiKey, ...this.headers },
-            body: JSON.stringify({ messages: request.messages.map(toOpenAIMessage), ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}) }),
+            headers: { "content-type": "application/json", "api-key": this.apiKey, ...this.headers },
+            body: JSON.stringify({
+                messages: request.messages.map(toOpenAIMessage),
+                ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
+            }),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, this.deployment, response.status, response.statusText, await response.text(), response.headers);
-        const result = openAIChatCompletionToModelResponse(await response.json());
+        const result = openAIChatCompletionToModelResponse((await response.json()));
         applyEstimatedCost(`azure-openai/${this.deployment}`, result.usage);
         return result;
     }
@@ -362,8 +386,8 @@ export class GeminiModelProvider {
     defaultModel;
     headers;
     constructor(options) {
-        this.name = options.name ?? 'gemini';
-        this.baseUrl = (options.baseUrl ?? 'https://generativelanguage.googleapis.com/v1beta').replace(/\/$/, '');
+        this.name = options.name ?? "gemini";
+        this.baseUrl = (options.baseUrl ?? "https://generativelanguage.googleapis.com/v1beta").replace(/\/$/, "");
         this.apiKey = options.apiKey;
         if (options.defaultModel !== undefined)
             this.defaultModel = options.defaultModel;
@@ -374,14 +398,14 @@ export class GeminiModelProvider {
         if (!model)
             throw new Error(`${this.name}: model is required.`);
         const response = await fetch(`${this.baseUrl}/models/${encodeURIComponent(model)}:generateContent?key=${encodeURIComponent(this.apiKey)}`, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
-            headers: { 'content-type': 'application/json', ...this.headers },
+            headers: { "content-type": "application/json", ...this.headers },
             body: JSON.stringify(toGeminiRequest(request, model)),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
-        const result = geminiResponseToModelResponse(await response.json());
+        const result = geminiResponseToModelResponse((await response.json()));
         applyEstimatedCost(`gemini/${model}`, result.usage);
         return result;
     }
@@ -394,9 +418,9 @@ export class VertexAIModelProvider {
     defaultModel;
     headers;
     constructor(options) {
-        this.name = options.name ?? 'vertex-ai';
+        this.name = options.name ?? "vertex-ai";
         this.project = options.project;
-        this.location = options.location ?? 'us-central1';
+        this.location = options.location ?? "us-central1";
         this.accessToken = options.accessToken;
         if (options.defaultModel !== undefined)
             this.defaultModel = options.defaultModel;
@@ -408,14 +432,18 @@ export class VertexAIModelProvider {
             throw new Error(`${this.name}: model is required.`);
         const url = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${encodeURIComponent(this.project)}/locations/${encodeURIComponent(this.location)}/publishers/google/models/${encodeURIComponent(model)}:generateContent`;
         const response = await fetch(url, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${this.accessToken}`, ...this.headers },
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${this.accessToken}`,
+                ...this.headers,
+            },
             body: JSON.stringify(toGeminiRequest(request, model)),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
-        const result = geminiResponseToModelResponse(await response.json());
+        const result = geminiResponseToModelResponse((await response.json()));
         applyEstimatedCost(`gemini/${model}`, result.usage);
         return result;
     }
@@ -429,7 +457,7 @@ export class BedrockModelProvider {
     defaultModel;
     headers;
     constructor(options) {
-        this.name = options.name ?? 'bedrock';
+        this.name = options.name ?? "bedrock";
         this.region = options.region;
         this.accessKeyId = options.accessKeyId;
         this.secretAccessKey = options.secretAccessKey;
@@ -447,21 +475,26 @@ export class BedrockModelProvider {
         const pathName = `/model/${encodeURIComponent(model)}/converse`;
         const body = JSON.stringify(toBedrockRequest(request));
         const headers = signAwsRequest({
-            method: 'POST',
+            method: "POST",
             host,
             path: pathName,
             region: this.region,
-            service: 'bedrock',
+            service: "bedrock",
             accessKeyId: this.accessKeyId,
             secretAccessKey: this.secretAccessKey,
             ...(this.sessionToken ? { sessionToken: this.sessionToken } : {}),
             body,
-            headers: { 'content-type': 'application/json', ...this.headers },
+            headers: { "content-type": "application/json", ...this.headers },
+        });
+        const response = await fetch(`https://${host}${pathName}`, {
+            method: "POST",
+            ...(request.signal !== undefined ? { signal: request.signal } : {}),
+            headers,
+            body,
         });
-        const response = await fetch(`https://${host}${pathName}`, { method: 'POST', ...(request.signal !== undefined ? { signal: request.signal } : {}), headers, body });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
-        const result = bedrockResponseToModelResponse(await response.json());
+        const result = bedrockResponseToModelResponse((await response.json()));
         applyEstimatedCost(`bedrock/${model}`, result.usage);
         return result;
     }
@@ -473,8 +506,8 @@ export class CohereModelProvider {
     defaultModel;
     headers;
     constructor(options) {
-        this.name = options.name ?? 'cohere';
-        this.baseUrl = (options.baseUrl ?? 'https://api.cohere.com/v2').replace(/\/$/, '');
+        this.name = options.name ?? "cohere";
+        this.baseUrl = (options.baseUrl ?? "https://api.cohere.com/v2").replace(/\/$/, "");
         this.apiKey = options.apiKey;
         if (options.defaultModel !== undefined)
             this.defaultModel = options.defaultModel;
@@ -485,14 +518,18 @@ export class CohereModelProvider {
         if (!model)
             throw new Error(`${this.name}: model is required.`);
         const response = await fetch(`${this.baseUrl}/chat`, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
-            headers: { 'content-type': 'application/json', authorization: `Bearer ${this.apiKey}`, ...this.headers },
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${this.apiKey}`,
+                ...this.headers,
+            },
             body: JSON.stringify({ model, messages: request.messages.map(toCohereMessage) }),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
-        const result = cohereResponseToModelResponse(await response.json());
+        const result = cohereResponseToModelResponse((await response.json()));
         applyEstimatedCost(`cohere/${model}`, result.usage);
         return result;
     }
@@ -501,9 +538,9 @@ export class FallbackModelProvider {
     name;
     providers;
     constructor(options) {
-        this.name = options.name ?? 'fallback';
+        this.name = options.name ?? "fallback";
         if (options.providers.length === 0)
-            throw new Error('FallbackModelProvider requires at least one provider.');
+            throw new Error("FallbackModelProvider requires at least one provider.");
         this.providers = options.providers;
     }
     async generate(request) {
@@ -516,7 +553,7 @@ export class FallbackModelProvider {
                 errors.push(`${provider.name}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        throw new Error(`${this.name}: all fallback providers failed. ${errors.join(' | ')}`);
+        throw new Error(`${this.name}: all fallback providers failed. ${errors.join(" | ")}`);
     }
 }
 export class AnthropicModelProvider {
@@ -529,8 +566,8 @@ export class AnthropicModelProvider {
     rateLimiter;
     rateLimitKey;
     constructor(options) {
-        this.name = options.name ?? 'anthropic';
-        this.baseUrl = (options.baseUrl ?? 'https://api.anthropic.com/v1').replace(/\/$/, '');
+        this.name = options.name ?? "anthropic";
+        this.baseUrl = (options.baseUrl ?? "https://api.anthropic.com/v1").replace(/\/$/, "");
         this.apiKey = options.apiKey;
         if (options.defaultModel !== undefined)
             this.defaultModel = options.defaultModel;
@@ -546,17 +583,35 @@ export class AnthropicModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const { system, messages } = toAnthropicMessages(request.messages);
-        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? anthropicThinkingBudget(request.thinkingLevel) : undefined;
-        const maxTokens = thinkingBudget !== undefined ? Math.max(this.maxTokens, thinkingBudget + 1024) : this.maxTokens;
+        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel)
+            ? anthropicThinkingBudget(request.thinkingLevel)
+            : undefined;
+        const maxTokens = thinkingBudget !== undefined
+            ? Math.max(this.maxTokens, thinkingBudget + 1024)
+            : this.maxTokens;
         const response = await fetch(`${this.baseUrl}/messages`, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
-            headers: { 'content-type': 'application/json', 'x-api-key': this.apiKey, 'anthropic-version': '2023-06-01', ...this.headers },
-            body: JSON.stringify({ model, max_tokens: maxTokens, ...(thinkingBudget !== undefined ? { thinking: { type: 'enabled', budget_tokens: thinkingBudget } } : {}), ...(system ? { system } : {}), messages, ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}) }),
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": this.apiKey,
+                "anthropic-version": "2023-06-01",
+                ...this.headers,
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: maxTokens,
+                ...(thinkingBudget !== undefined
+                    ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
+                    : {}),
+                ...(system ? { system } : {}),
+                messages,
+                ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}),
+            }),
         });
         if (!response.ok)
             throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text(), response.headers);
-        const result = anthropicResponseToModelResponse(await response.json());
+        const result = anthropicResponseToModelResponse((await response.json()));
         applyEstimatedCost(`anthropic/${model}`, result.usage);
         return result;
     }
@@ -567,23 +622,29 @@ export class AnthropicModelProvider {
         if (this.rateLimiter)
             await this.rateLimiter.acquire(this.rateLimitKey, request.signal ? { signal: request.signal } : undefined);
         const { system, messages } = toAnthropicMessages(request.messages);
-        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? anthropicThinkingBudget(request.thinkingLevel) : undefined;
-        const maxTokens = thinkingBudget !== undefined ? Math.max(this.maxTokens, thinkingBudget + 1024) : this.maxTokens;
+        const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel)
+            ? anthropicThinkingBudget(request.thinkingLevel)
+            : undefined;
+        const maxTokens = thinkingBudget !== undefined
+            ? Math.max(this.maxTokens, thinkingBudget + 1024)
+            : this.maxTokens;
         const response = await fetch(`${this.baseUrl}/messages`, {
-            method: 'POST',
+            method: "POST",
             ...(request.signal !== undefined ? { signal: request.signal } : {}),
             headers: {
-                'content-type': 'application/json',
-                'x-api-key': this.apiKey,
-                'anthropic-version': '2023-06-01',
-                accept: 'text/event-stream',
+                "content-type": "application/json",
+                "x-api-key": this.apiKey,
+                "anthropic-version": "2023-06-01",
+                accept: "text/event-stream",
                 ...this.headers,
             },
             body: JSON.stringify({
                 model,
                 stream: true,
                 max_tokens: maxTokens,
-                ...(thinkingBudget !== undefined ? { thinking: { type: 'enabled', budget_tokens: thinkingBudget } } : {}),
+                ...(thinkingBudget !== undefined
+                    ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
+                    : {}),
                 ...(system ? { system } : {}),
                 messages,
                 ...(request.tools !== undefined ? { tools: request.tools.map(toAnthropicTool) } : {}),
@@ -596,79 +657,79 @@ export class AnthropicModelProvider {
         const toolCallBuffers = new Map();
         let usage;
         for await (const event of decodeAnthropicSSE(response.body)) {
-            const type = event.event ?? '';
+            const type = event.event ?? "";
             const data = event.data;
             if (!data)
                 continue;
-            if (type === 'content_block_start') {
-                const idx = typeof data.index === 'number' ? data.index : 0;
+            if (type === "content_block_start") {
+                const idx = typeof data.index === "number" ? data.index : 0;
                 const block = data.content_block;
-                if (block?.type === 'tool_use') {
-                    const buf = { args: '' };
-                    if (typeof block.id === 'string')
+                if (block?.type === "tool_use") {
+                    const buf = { args: "" };
+                    if (typeof block.id === "string")
                         buf.id = block.id;
-                    if (typeof block.name === 'string')
+                    if (typeof block.name === "string")
                         buf.name = block.name;
                     toolCallBuffers.set(idx, buf);
                 }
             }
-            else if (type === 'content_block_delta') {
-                const idx = typeof data.index === 'number' ? data.index : 0;
+            else if (type === "content_block_delta") {
+                const idx = typeof data.index === "number" ? data.index : 0;
                 const delta = data.delta;
                 const dt = delta?.type;
-                if (dt === 'text_delta' && typeof delta?.text === 'string') {
+                if (dt === "text_delta" && typeof delta?.text === "string") {
                     text.push(delta.text);
                     yield { textDelta: delta.text };
                 }
-                else if (dt === 'thinking_delta' && typeof delta?.thinking === 'string') {
+                else if (dt === "thinking_delta" && typeof delta?.thinking === "string") {
                     thinking.push(delta.thinking);
                     yield { thinkingDelta: delta.thinking };
                 }
-                else if (dt === 'input_json_delta' && typeof delta?.partial_json === 'string') {
+                else if (dt === "input_json_delta" && typeof delta?.partial_json === "string") {
                     const buf = toolCallBuffers.get(idx);
                     if (buf)
                         buf.args += delta.partial_json;
                 }
             }
-            else if (type === 'message_delta') {
+            else if (type === "message_delta") {
                 const u = data.usage;
                 if (u) {
                     usage = usage ?? {};
-                    if (typeof u.input_tokens === 'number')
+                    if (typeof u.input_tokens === "number")
                         usage.inputTokens = u.input_tokens;
-                    if (typeof u.output_tokens === 'number')
+                    if (typeof u.output_tokens === "number")
                         usage.outputTokens = u.output_tokens;
-                    if (typeof u.cache_read_input_tokens === 'number')
+                    if (typeof u.cache_read_input_tokens === "number")
                         usage.cachedInputTokens = u.cache_read_input_tokens;
-                    if (typeof u.cache_creation_input_tokens === 'number')
+                    if (typeof u.cache_creation_input_tokens === "number")
                         usage.cacheWriteTokens = u.cache_creation_input_tokens;
                     if (usage.inputTokens !== undefined || usage.outputTokens !== undefined) {
                         usage.totalTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
                     }
                 }
             }
-            else if (type === 'message_start') {
+            else if (type === "message_start") {
                 const message = data.message;
                 const u = message?.usage;
                 if (u) {
                     usage = {};
-                    if (typeof u.input_tokens === 'number')
+                    if (typeof u.input_tokens === "number")
                         usage.inputTokens = u.input_tokens;
-                    if (typeof u.cache_read_input_tokens === 'number')
+                    if (typeof u.cache_read_input_tokens === "number")
                         usage.cachedInputTokens = u.cache_read_input_tokens;
-                    if (typeof u.cache_creation_input_tokens === 'number')
+                    if (typeof u.cache_creation_input_tokens === "number")
                         usage.cacheWriteTokens = u.cache_creation_input_tokens;
                 }
             }
         }
         const done = {
-            ...(text.length ? { message: { role: 'assistant', content: text.join('') } } : {}),
-            ...(thinking.length ? { thinking: thinking.join('') } : {}),
+            ...(text.length ? { message: { role: "assistant", content: text.join("") } } : {}),
+            ...(thinking.length ? { thinking: thinking.join("") } : {}),
             ...(toolCallBuffers.size > 0
                 ? {
                     toolCalls: [...toolCallBuffers.values()].map((buf, index) => ({
                         id: buf.id ?? `anthropic-stream-${index + 1}`,
-                        name: buf.name ?? '',
+                        name: buf.name ?? "",
                         input: buf.args ? JSON.parse(buf.args) : {},
                     })),
                 }
@@ -682,17 +743,21 @@ export class AnthropicModelProvider {
 }
 export const defaultModelProvider = new MockModelProvider();
 function parseScriptedToolCalls(text) {
-    const marker = '```fabric-tool-calls';
+    const marker = "```fabric-tool-calls";
     const start = text.indexOf(marker);
     if (start === -1)
         return [];
-    const jsonStart = text.indexOf('\n', start);
-    const end = text.indexOf('```', jsonStart + 1);
+    const jsonStart = text.indexOf("\n", start);
+    const end = text.indexOf("```", jsonStart + 1);
     if (jsonStart === -1 || end === -1)
         return [];
     const raw = text.slice(jsonStart + 1, end).trim();
     const parsed = JSON.parse(raw);
-    return parsed.map((call, index) => ({ id: call.id ?? `mock-tool-${index + 1}`, name: call.tool, input: call.input }));
+    return parsed.map((call, index) => ({
+        id: call.id ?? `mock-tool-${index + 1}`,
+        name: call.tool,
+        input: call.input,
+    }));
 }
 function estimateUsage(messages) {
     const chars = messages.reduce((sum, message) => sum + message.content.length, 0);
@@ -706,7 +771,7 @@ function calculateRetryDelay(baseMs, attempt) {
 function isRetryableModelError(error) {
     if (error instanceof ProviderHttpError)
         return error.status === 429 || error.status >= 500;
-    if (error instanceof Error && error.name === 'AbortError')
+    if (error instanceof Error && error.name === "AbortError")
         return false;
     const message = error instanceof Error ? error.message : String(error);
     return /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|network.?error|connection.?(?:reset|refused|lost)|socket hang up|fetch failed|timed? out|timeout|terminated/i.test(message);
@@ -719,30 +784,38 @@ function sleepWithAbort(ms, signal) {
         return Promise.reject(createAbortError(signal.reason));
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
-            signal.removeEventListener('abort', onAbort);
+            signal.removeEventListener("abort", onAbort);
             resolve();
         }, ms);
         const onAbort = () => {
             clearTimeout(timer);
-            signal.removeEventListener('abort', onAbort);
+            signal.removeEventListener("abort", onAbort);
             reject(createAbortError(signal.reason));
         };
-        signal.addEventListener('abort', onAbort, { once: true });
+        signal.addEventListener("abort", onAbort, { once: true });
     });
 }
 function createAbortError(reason) {
-    const message = reason instanceof Error ? reason.message : typeof reason === 'string' ? reason : 'This operation was aborted';
+    const message = reason instanceof Error
+        ? reason.message
+        : typeof reason === "string"
+            ? reason
+            : "This operation was aborted";
     const err = new Error(message);
-    err.name = 'AbortError';
+    err.name = "AbortError";
     return err;
 }
 export function toOpenAIMessage(message) {
-    if (message.role === 'tool') {
-        return { role: 'tool', tool_call_id: message.toolCallId ?? message.name ?? 'tool', content: message.content };
+    if (message.role === "tool") {
+        return {
+            role: "tool",
+            tool_call_id: message.toolCallId ?? message.name ?? "tool",
+            content: message.content,
+        };
     }
-    if (message.role === 'assistant' && message.toolCalls?.length) {
+    if (message.role === "assistant" && message.toolCalls?.length) {
         return {
-            role: 'assistant',
+            role: "assistant",
             content: message.content || null,
             tool_calls: message.toolCalls.map(toOpenAIToolCallForMessage),
         };
@@ -752,33 +825,37 @@ export function toOpenAIMessage(message) {
 function toOpenAIToolCallForMessage(call) {
     return {
         id: call.id,
-        type: 'function',
+        type: "function",
         function: {
             name: call.name,
-            arguments: typeof call.input === 'string' ? call.input : JSON.stringify(call.input),
+            arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input),
         },
     };
 }
 export function toOpenAITool(tool) {
     return {
-        type: 'function',
+        type: "function",
         function: {
             name: tool.name,
-            description: tool.description ?? '',
+            description: tool.description ?? "",
             parameters: normalizeOpenAIParameters(tool.inputSchema),
         },
     };
 }
 function normalizeOpenAIParameters(schema) {
-    if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
-        return { type: 'object', properties: {}, required: [], additionalProperties: false };
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return { type: "object", properties: {}, required: [], additionalProperties: false };
     }
     const objectSchema = schema;
-    if (objectSchema.type !== 'object')
-        return { type: 'object', properties: {}, required: [], additionalProperties: false };
+    if (objectSchema.type !== "object")
+        return { type: "object", properties: {}, required: [], additionalProperties: false };
     return {
         ...objectSchema,
-        properties: typeof objectSchema.properties === 'object' && objectSchema.properties !== null && !Array.isArray(objectSchema.properties) ? objectSchema.properties : {},
+        properties: typeof objectSchema.properties === "object" &&
+            objectSchema.properties !== null &&
+            !Array.isArray(objectSchema.properties)
+            ? objectSchema.properties
+            : {},
         required: Array.isArray(objectSchema.required) ? objectSchema.required : [],
     };
 }
@@ -792,9 +869,12 @@ function fromOpenAIToolCall(call) {
 export function openAIChatCompletionToModelResponse(json) {
     const choice = json.choices?.[0];
     const message = choice?.message;
-    const reasoning = typeof message?.reasoning_content === 'string' ? message.reasoning_content : undefined;
+    const content = openAIMessageText(message?.content);
+    const reasoning = typeof message?.reasoning_content === "string"
+        ? message.reasoning_content
+        : openAIReasoningText(message?.content);
     const result = {
-        ...(message?.content ? { message: { role: 'assistant', content: message.content } } : {}),
+        ...(content ? { message: { role: "assistant", content } } : {}),
         ...(reasoning ? { thinking: reasoning } : {}),
         ...(message?.tool_calls ? { toolCalls: message.tool_calls.map(fromOpenAIToolCall) } : {}),
     };
@@ -810,53 +890,147 @@ export function openAIChatCompletionToModelResponse(json) {
     }
     return result;
 }
+function openAIMessageText(content) {
+    if (typeof content === "string")
+        return content;
+    const text = content
+        ?.flatMap((part) => {
+        if ((part.type === "text" || part.type === "output_text") && typeof part.text === "string") {
+            return [part.text];
+        }
+        return [];
+    })
+        .join("");
+    return text || undefined;
+}
+function openAIReasoningText(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const reasoning = content
+        .filter((part) => part.type === "reasoning")
+        .flatMap((part) => part.summary ?? [])
+        .flatMap((summary) => (typeof summary.text === "string" ? [summary.text] : []))
+        .join("\n");
+    return reasoning || undefined;
+}
 function toAnthropicTool(tool) {
-    return { name: tool.name, description: tool.description ?? '', input_schema: normalizeOpenAIParameters(tool.inputSchema) };
+    return {
+        name: tool.name,
+        description: tool.description ?? "",
+        input_schema: normalizeOpenAIParameters(tool.inputSchema),
+    };
 }
 function toAnthropicMessages(messages) {
-    const system = messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n') || undefined;
-    const converted = messages.filter((message) => message.role !== 'system').map((message) => {
-        if (message.role === 'tool')
-            return { role: 'user', content: [{ type: 'tool_result', tool_use_id: message.toolCallId ?? message.name ?? 'tool', content: message.content }] };
-        if (message.role === 'assistant' && message.toolCalls?.length) {
-            return { role: 'assistant', content: [{ type: 'text', text: message.content || '' }, ...message.toolCalls.map((call) => ({ type: 'tool_use', id: call.id, name: call.name, input: call.input }))] };
+    const system = messages
+        .filter((message) => message.role === "system")
+        .map((message) => message.content)
+        .join("\n\n") || undefined;
+    const converted = messages
+        .filter((message) => message.role !== "system")
+        .map((message) => {
+        if (message.role === "tool")
+            return {
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: message.toolCallId ?? message.name ?? "tool",
+                        content: message.content,
+                    },
+                ],
+            };
+        if (message.role === "assistant" && message.toolCalls?.length) {
+            return {
+                role: "assistant",
+                content: [
+                    { type: "text", text: message.content || "" },
+                    ...message.toolCalls.map((call) => ({
+                        type: "tool_use",
+                        id: call.id,
+                        name: call.name,
+                        input: call.input,
+                    })),
+                ],
+            };
         }
-        return { role: message.role === 'assistant' ? 'assistant' : 'user', content: message.content };
+        return {
+            role: message.role === "assistant" ? "assistant" : "user",
+            content: message.content,
+        };
     });
     return { ...(system ? { system } : {}), messages: converted };
 }
 function toGeminiRequest(request, model) {
-    const system = request.messages.filter((message) => message.role === 'system').map((message) => message.content).join('\n\n');
-    const contents = request.messages.filter((message) => message.role !== 'system').map((message) => {
-        if (message.role === 'tool')
-            return { role: 'user', parts: [{ functionResponse: { name: message.name ?? 'tool', response: { content: message.content } } }] };
-        if (message.role === 'assistant' && message.toolCalls?.length)
-            return { role: 'model', parts: message.toolCalls.map((call) => ({ functionCall: { name: call.name, args: call.input ?? {} } })) };
-        return { role: message.role === 'assistant' ? 'model' : 'user', parts: [{ text: message.content }] };
+    const system = request.messages
+        .filter((message) => message.role === "system")
+        .map((message) => message.content)
+        .join("\n\n");
+    const contents = request.messages
+        .filter((message) => message.role !== "system")
+        .map((message) => {
+        if (message.role === "tool")
+            return {
+                role: "user",
+                parts: [
+                    {
+                        functionResponse: {
+                            name: message.name ?? "tool",
+                            response: { content: message.content },
+                        },
+                    },
+                ],
+            };
+        if (message.role === "assistant" && message.toolCalls?.length)
+            return {
+                role: "model",
+                parts: message.toolCalls.map((call) => ({
+                    functionCall: { name: call.name, args: call.input ?? {} },
+                })),
+            };
+        return {
+            role: message.role === "assistant" ? "model" : "user",
+            parts: [{ text: message.content }],
+        };
     });
-    const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel) ? geminiThinkingBudget(request.thinkingLevel) : undefined;
+    const thinkingBudget = shouldApplyReasoning(model, request.thinkingLevel)
+        ? geminiThinkingBudget(request.thinkingLevel)
+        : undefined;
     return {
         ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
         contents,
-        ...(request.tools?.length ? { tools: [{ functionDeclarations: request.tools.map(toGeminiTool) }] } : {}),
-        ...(thinkingBudget !== undefined ? { generationConfig: { thinkingConfig: { thinkingBudget } } } : {}),
+        ...(request.tools?.length
+            ? { tools: [{ functionDeclarations: request.tools.map(toGeminiTool) }] }
+            : {}),
+        ...(thinkingBudget !== undefined
+            ? { generationConfig: { thinkingConfig: { thinkingBudget } } }
+            : {}),
     };
 }
 function toGeminiTool(tool) {
-    return { name: tool.name, description: tool.description ?? '', parameters: normalizeOpenAIParameters(tool.inputSchema) };
+    return {
+        name: tool.name,
+        description: tool.description ?? "",
+        parameters: normalizeOpenAIParameters(tool.inputSchema),
+    };
 }
 function geminiResponseToModelResponse(json) {
     const parts = json.candidates?.[0]?.content?.parts ?? [];
     const texts = [];
     const toolCalls = [];
     for (const [index, part] of parts.entries()) {
-        if (typeof part.text === 'string')
+        if (typeof part.text === "string")
             texts.push(part.text);
         if (part.functionCall?.name)
-            toolCalls.push({ id: `gemini-tool-${index + 1}`, name: part.functionCall.name, input: part.functionCall.args ?? {} });
+            toolCalls.push({
+                id: `gemini-tool-${index + 1}`,
+                name: part.functionCall.name,
+                input: part.functionCall.args ?? {},
+            });
     }
     const result = {
-        ...(texts.length > 0 ? { message: { role: 'assistant', content: texts.join('\n') } } : {}),
+        ...(texts.length > 0
+            ? { message: { role: "assistant", content: texts.join("\n") } }
+            : {}),
         ...(toolCalls.length > 0 ? { toolCalls } : {}),
     };
     if (json.usageMetadata) {
@@ -872,13 +1046,35 @@ function geminiResponseToModelResponse(json) {
     return result;
 }
 function toBedrockRequest(request) {
-    const system = request.messages.filter((message) => message.role === 'system').map((message) => ({ text: message.content }));
-    const messages = request.messages.filter((message) => message.role !== 'system').map((message) => {
-        if (message.role === 'tool')
-            return { role: 'user', content: [{ toolResult: { toolUseId: message.toolCallId ?? message.name ?? 'tool', content: [{ text: message.content }] } }] };
-        if (message.role === 'assistant' && message.toolCalls?.length)
-            return { role: 'assistant', content: message.toolCalls.map((call) => ({ toolUse: { toolUseId: call.id, name: call.name, input: call.input ?? {} } })) };
-        return { role: message.role === 'assistant' ? 'assistant' : 'user', content: [{ text: message.content }] };
+    const system = request.messages
+        .filter((message) => message.role === "system")
+        .map((message) => ({ text: message.content }));
+    const messages = request.messages
+        .filter((message) => message.role !== "system")
+        .map((message) => {
+        if (message.role === "tool")
+            return {
+                role: "user",
+                content: [
+                    {
+                        toolResult: {
+                            toolUseId: message.toolCallId ?? message.name ?? "tool",
+                            content: [{ text: message.content }],
+                        },
+                    },
+                ],
+            };
+        if (message.role === "assistant" && message.toolCalls?.length)
+            return {
+                role: "assistant",
+                content: message.toolCalls.map((call) => ({
+                    toolUse: { toolUseId: call.id, name: call.name, input: call.input ?? {} },
+                })),
+            };
+        return {
+            role: message.role === "assistant" ? "assistant" : "user",
+            content: [{ text: message.content }],
+        };
     });
     return {
         ...(system.length ? { system } : {}),
@@ -888,20 +1084,30 @@ function toBedrockRequest(request) {
     };
 }
 function toBedrockTool(tool) {
-    return { toolSpec: { name: tool.name, description: tool.description ?? '', inputSchema: { json: normalizeOpenAIParameters(tool.inputSchema) } } };
+    return {
+        toolSpec: {
+            name: tool.name,
+            description: tool.description ?? "",
+            inputSchema: { json: normalizeOpenAIParameters(tool.inputSchema) },
+        },
+    };
 }
 function bedrockResponseToModelResponse(json) {
     const content = json.output?.message?.content ?? [];
     const texts = [];
     const toolCalls = [];
     for (const part of content) {
-        if (typeof part.text === 'string')
+        if (typeof part.text === "string")
             texts.push(part.text);
         if (part.toolUse?.toolUseId && part.toolUse.name)
-            toolCalls.push({ id: part.toolUse.toolUseId, name: part.toolUse.name, input: part.toolUse.input ?? {} });
+            toolCalls.push({
+                id: part.toolUse.toolUseId,
+                name: part.toolUse.name,
+                input: part.toolUse.input ?? {},
+            });
     }
     const result = {
-        ...(texts.length ? { message: { role: 'assistant', content: texts.join('\n') } } : {}),
+        ...(texts.length ? { message: { role: "assistant", content: texts.join("\n") } } : {}),
         ...(toolCalls.length ? { toolCalls } : {}),
     };
     if (json.usage) {
@@ -917,12 +1123,21 @@ function bedrockResponseToModelResponse(json) {
     return result;
 }
 function toCohereMessage(message) {
-    const role = message.role === 'assistant' ? 'assistant' : message.role === 'system' ? 'system' : message.role === 'tool' ? 'tool' : 'user';
+    const role = message.role === "assistant"
+        ? "assistant"
+        : message.role === "system"
+            ? "system"
+            : message.role === "tool"
+                ? "tool"
+                : "user";
     return { role, content: message.content };
 }
 function cohereResponseToModelResponse(json) {
-    const content = json.message?.content?.map((part) => part.text).filter((text) => typeof text === 'string').join('\n') ?? '';
-    const result = content ? { message: { role: 'assistant', content } } : {};
+    const content = json.message?.content
+        ?.map((part) => part.text)
+        .filter((text) => typeof text === "string")
+        .join("\n") ?? "";
+    const result = content ? { message: { role: "assistant", content } } : {};
     const billed = json.usage?.billed_units;
     if (billed) {
         const usage = {};
@@ -941,16 +1156,19 @@ function anthropicResponseToModelResponse(json) {
     const thinkingChunks = [];
     const toolCalls = [];
     for (const block of json.content ?? []) {
-        if (block.type === 'text' && typeof block.text === 'string')
+        if (block.type === "text" && typeof block.text === "string")
             texts.push(block.text);
-        if ((block.type === 'thinking' || block.type === 'redacted_thinking') && typeof block.text === 'string')
+        if ((block.type === "thinking" || block.type === "redacted_thinking") &&
+            typeof block.text === "string")
             thinkingChunks.push(block.text);
-        if (block.type === 'tool_use' && typeof block.id === 'string' && typeof block.name === 'string')
+        if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string")
             toolCalls.push({ id: block.id, name: block.name, input: block.input ?? {} });
     }
     const result = {
-        ...(texts.length > 0 ? { message: { role: 'assistant', content: texts.join('\n') } } : {}),
-        ...(thinkingChunks.length > 0 ? { thinking: thinkingChunks.join('\n') } : {}),
+        ...(texts.length > 0
+            ? { message: { role: "assistant", content: texts.join("\n") } }
+            : {}),
+        ...(thinkingChunks.length > 0 ? { thinking: thinkingChunks.join("\n") } : {}),
         ...(toolCalls.length > 0 ? { toolCalls } : {}),
     };
     if (json.usage) {
@@ -975,7 +1193,7 @@ function anthropicResponseToModelResponse(json) {
  * stable across processes (with the same key) without leaking secrets.
  */
 function rateLimitKeyForApiKey(apiKey) {
-    return createHash('sha256').update(apiKey).digest('hex').slice(0, 8);
+    return createHash("sha256").update(apiKey).digest("hex").slice(0, 8);
 }
 function safeJsonParse(value) {
     try {
@@ -1001,17 +1219,17 @@ function splitLines(buffer, pendingCR) {
     let pending = false;
     // If previous chunk ended with \r and this one starts with \n, skip the \n
     // as it completes a split CRLF sequence.
-    if (pendingCR && buffer.length > 0 && buffer[0] === '\n') {
+    if (pendingCR && buffer.length > 0 && buffer[0] === "\n") {
         start = 1;
     }
     for (let i = start; i < buffer.length; i++) {
         const ch = buffer[i];
-        if (ch === '\n') {
+        if (ch === "\n") {
             lines.push(buffer.slice(start, i));
             start = i + 1;
         }
-        else if (ch === '\r') {
-            if (i + 1 < buffer.length && buffer[i + 1] === '\n') {
+        else if (ch === "\r") {
+            if (i + 1 < buffer.length && buffer[i + 1] === "\n") {
                 // CRLF within the same buffer
                 lines.push(buffer.slice(start, i));
                 i++; // skip the \n
@@ -1034,7 +1252,7 @@ function splitLines(buffer, pendingCR) {
 async function* decodeOpenAISSE(stream) {
     const decoder = new TextDecoder();
     const reader = stream.getReader();
-    let buffer = '';
+    let buffer = "";
     let pendingCR = false;
     try {
         while (true) {
@@ -1047,9 +1265,9 @@ async function* decodeOpenAISSE(stream) {
             buffer = remainder;
             for (const line of lines) {
                 const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith(':'))
+                if (!trimmed || trimmed.startsWith(":"))
                     continue;
-                if (trimmed.startsWith('data:')) {
+                if (trimmed.startsWith("data:")) {
                     const payload = trimmed.slice(5).trim();
                     if (!payload)
                         continue;
@@ -1069,7 +1287,7 @@ async function* decodeOpenAISSE(stream) {
 async function* decodeAnthropicSSE(stream) {
     const decoder = new TextDecoder();
     const reader = stream.getReader();
-    let buffer = '';
+    let buffer = "";
     let pendingEvent;
     let pendingCR = false;
     try {
@@ -1087,11 +1305,11 @@ async function* decodeAnthropicSSE(stream) {
                     pendingEvent = undefined;
                     continue;
                 }
-                if (trimmed.startsWith('event:')) {
+                if (trimmed.startsWith("event:")) {
                     pendingEvent = trimmed.slice(6).trim();
                     continue;
                 }
-                if (trimmed.startsWith('data:')) {
+                if (trimmed.startsWith("data:")) {
                     const payload = trimmed.slice(5).trim();
                     if (!payload)
                         continue;
@@ -1123,7 +1341,7 @@ export class ProviderHttpError extends Error {
         this.status = status;
         this.statusText = statusText;
         this.body = body;
-        this.name = 'ProviderHttpError';
+        this.name = "ProviderHttpError";
         if (retryAfterMs !== undefined && Number.isFinite(retryAfterMs) && retryAfterMs > 0) {
             this.retryAfterMs = retryAfterMs;
         }
@@ -1154,41 +1372,57 @@ export function parseRetryAfterMs(headerValue) {
 }
 function signAwsRequest(input) {
     const now = new Date();
-    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
+    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
     const dateStamp = amzDate.slice(0, 8);
     const headers = {
         ...input.headers,
         host: input.host,
-        'x-amz-date': amzDate,
-        ...(input.sessionToken ? { 'x-amz-security-token': input.sessionToken } : {}),
+        "x-amz-date": amzDate,
+        ...(input.sessionToken ? { "x-amz-security-token": input.sessionToken } : {}),
     };
-    const signedHeaders = Object.keys(headers).map((key) => key.toLowerCase()).sort();
-    const canonicalHeaders = signedHeaders.map((key) => `${key}:${headers[Object.keys(headers).find((candidate) => candidate.toLowerCase() === key) ?? key]?.trim()}\n`).join('');
+    const signedHeaders = Object.keys(headers)
+        .map((key) => key.toLowerCase())
+        .sort();
+    const canonicalHeaders = signedHeaders
+        .map((key) => `${key}:${headers[Object.keys(headers).find((candidate) => candidate.toLowerCase() === key) ?? key]?.trim()}\n`)
+        .join("");
     const payloadHash = sha256Hex(input.body);
-    const canonicalRequest = [input.method, input.path, '', canonicalHeaders, signedHeaders.join(';'), payloadHash].join('\n');
+    const canonicalRequest = [
+        input.method,
+        input.path,
+        "",
+        canonicalHeaders,
+        signedHeaders.join(";"),
+        payloadHash,
+    ].join("\n");
     const credentialScope = `${dateStamp}/${input.region}/${input.service}/aws4_request`;
-    const stringToSign = ['AWS4-HMAC-SHA256', amzDate, credentialScope, sha256Hex(canonicalRequest)].join('\n');
+    const stringToSign = [
+        "AWS4-HMAC-SHA256",
+        amzDate,
+        credentialScope,
+        sha256Hex(canonicalRequest),
+    ].join("\n");
     const signingKey = awsSigningKey(input.secretAccessKey, dateStamp, input.region, input.service);
     const signature = hmacHex(signingKey, stringToSign);
     return {
         ...headers,
-        authorization: `AWS4-HMAC-SHA256 Credential=${input.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders.join(';')}, Signature=${signature}`,
+        authorization: `AWS4-HMAC-SHA256 Credential=${input.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders.join(";")}, Signature=${signature}`,
     };
 }
 function sha256Hex(value) {
-    return createHash('sha256').update(value).digest('hex');
+    return createHash("sha256").update(value).digest("hex");
 }
 function hmac(key, value) {
-    return createHmac('sha256', key).update(value).digest();
+    return createHmac("sha256", key).update(value).digest();
 }
 function hmacHex(key, value) {
-    return createHmac('sha256', key).update(value).digest('hex');
+    return createHmac("sha256", key).update(value).digest("hex");
 }
 function awsSigningKey(secret, date, region, service) {
-    return hmac(hmac(hmac(hmac(`AWS4${secret}`, date), region), service), 'aws4_request');
+    return hmac(hmac(hmac(hmac(`AWS4${secret}`, date), region), service), "aws4_request");
 }
 function formatProviderHttpError(provider, model, status, statusText, body, headers) {
-    const retryAfterMs = headers ? parseRetryAfterMs(headers.get('retry-after')) : undefined;
+    const retryAfterMs = headers ? parseRetryAfterMs(headers.get("retry-after")) : undefined;
     let parsedMessage;
     let code;
     try {
@@ -1199,13 +1433,14 @@ function formatProviderHttpError(provider, model, status, statusText, body, head
     catch { }
     const details = parsedMessage ?? body.slice(0, 500);
     if (status === 401 || status === 403)
-        return new ProviderHttpError(`${provider}: authentication/authorization failed for model "${model ?? 'unknown'}" (${status}). Check API key and provider permissions. ${details}`, provider, status, statusText, body);
+        return new ProviderHttpError(`${provider}: authentication/authorization failed for model "${model ?? "unknown"}" (${status}). Check API key and provider permissions. ${details}`, provider, status, statusText, body);
     if (status === 400 && /model/i.test(details))
-        return new ProviderHttpError(`${provider}: provider rejected model "${model ?? 'unknown'}". Check FABRIC_MODEL/model access/base URL. ${details}`, provider, status, statusText, body);
-    if (status === 400 && (/schema|function|tool/i.test(details) || code === 'invalid_function_parameters'))
+        return new ProviderHttpError(`${provider}: provider rejected model "${model ?? "unknown"}". Check FABRIC_MODEL/model access/base URL. ${details}`, provider, status, statusText, body);
+    if (status === 400 &&
+        (/schema|function|tool/i.test(details) || code === "invalid_function_parameters"))
         return new ProviderHttpError(`${provider}: provider rejected a tool schema. Run fabric-harness doctor --tools. ${details}`, provider, status, statusText, body);
     if (status === 429)
-        return new ProviderHttpError(`${provider}: rate limited for model "${model ?? 'unknown'}". ${details}`, provider, status, statusText, body, retryAfterMs);
+        return new ProviderHttpError(`${provider}: rate limited for model "${model ?? "unknown"}". ${details}`, provider, status, statusText, body, retryAfterMs);
     if (status >= 500)
         return new ProviderHttpError(`${provider}: provider unavailable (${status} ${statusText}). ${details}`, provider, status, statusText, body, retryAfterMs);
     return new ProviderHttpError(`${provider}: ${status} ${statusText}: ${details}`, provider, status, statusText, body, retryAfterMs);