@fabric-harness/sdk 0.1.0

package/dist/model.js

@@ -0,0 +1,661 @@
+import { createHash, createHmac } from 'node:crypto';
+export function toolsToModelSchemas(tools) {
+    return [...tools].map((tool) => ({
+        name: tool.name,
+        ...(tool.description !== undefined ? { description: tool.description } : {}),
+        ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
+    }));
+}
+export async function generateWithRuntime(provider, request, options = {}) {
+    const maxAttempts = (options.retries ?? 0) + 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const startedAt = Date.now();
+        const controller = new AbortController();
+        const timeout = options.timeoutMs
+            ? 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' });
+        try {
+            const response = await provider.generate({ ...request, signal: controller.signal });
+            if (timeout)
+                clearTimeout(timeout);
+            options.signal?.removeEventListener('abort', abortListener);
+            await options.onAttempt?.({
+                provider: provider.name,
+                attempt,
+                maxAttempts,
+                status: 'success',
+                durationMs: Date.now() - startedAt,
+                ...(response.usage !== undefined ? { usage: response.usage } : {}),
+            });
+            return response;
+        }
+        catch (error) {
+            if (timeout)
+                clearTimeout(timeout);
+            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);
+            await options.onAttempt?.({
+                provider: provider.name,
+                attempt,
+                maxAttempts,
+                status: canRetry ? 'retry' : 'error',
+                durationMs: Date.now() - startedAt,
+                error: message,
+            });
+            if (!canRetry)
+                break;
+            await delay(retryDelay(options.retryDelayMs ?? 250, attempt));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+export class MockModelProvider {
+    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 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}`);
+        const content = toolSummaries.length > 0
+            ? `Mock response using tool results:\n${toolSummaries.join('\n')}`
+            : `Mock response: ${text}`;
+        return { message: { role: 'assistant', content }, usage: estimateUsage([...request.messages, { role: 'assistant', content }]) };
+    }
+}
+export class OpenAICompatibleModelProvider {
+    name;
+    baseUrl;
+    apiKey;
+    defaultModel;
+    headers;
+    constructor(options) {
+        this.name = options.name ?? 'openai-compatible';
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.apiKey = options.apiKey;
+        if (options.defaultModel !== undefined)
+            this.defaultModel = options.defaultModel;
+        this.headers = options.headers ?? {};
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        if (!model)
+            throw new Error(`${this.name}: model is required.`);
+        const init = {
+            method: 'POST',
+            ...(request.signal !== undefined ? { signal: request.signal } : {}),
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${this.apiKey}`,
+                ...this.headers,
+            },
+            body: JSON.stringify({
+                model,
+                messages: request.messages.map(toOpenAIMessage),
+                ...(request.tools !== undefined ? { tools: request.tools.map(toOpenAITool) } : {}),
+            }),
+        };
+        const response = await fetch(`${this.baseUrl}/chat/completions`, init);
+        if (!response.ok) {
+            const body = await response.text();
+            throw formatProviderHttpError(this.name, model, response.status, response.statusText, body);
+        }
+        let json;
+        try {
+            json = (await response.json());
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`${this.name}: failed to parse response as JSON: ${message}`);
+        }
+        return openAIChatCompletionToModelResponse(json);
+    }
+}
+export class AzureOpenAIModelProvider {
+    name;
+    baseUrl;
+    apiKey;
+    deployment;
+    apiVersion;
+    headers;
+    constructor(options) {
+        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.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',
+            ...(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) } : {}) }),
+        });
+        if (!response.ok)
+            throw formatProviderHttpError(this.name, this.deployment, response.status, response.statusText, await response.text());
+        return openAIChatCompletionToModelResponse(await response.json());
+    }
+}
+export class GeminiModelProvider {
+    name;
+    baseUrl;
+    apiKey;
+    defaultModel;
+    headers;
+    constructor(options) {
+        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;
+        this.headers = options.headers ?? {};
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        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',
+            ...(request.signal !== undefined ? { signal: request.signal } : {}),
+            headers: { 'content-type': 'application/json', ...this.headers },
+            body: JSON.stringify(toGeminiRequest(request)),
+        });
+        if (!response.ok)
+            throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text());
+        return geminiResponseToModelResponse(await response.json());
+    }
+}
+export class VertexAIModelProvider {
+    name;
+    project;
+    location;
+    accessToken;
+    defaultModel;
+    headers;
+    constructor(options) {
+        this.name = options.name ?? 'vertex-ai';
+        this.project = options.project;
+        this.location = options.location ?? 'us-central1';
+        this.accessToken = options.accessToken;
+        if (options.defaultModel !== undefined)
+            this.defaultModel = options.defaultModel;
+        this.headers = options.headers ?? {};
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        if (!model)
+            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',
+            ...(request.signal !== undefined ? { signal: request.signal } : {}),
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${this.accessToken}`, ...this.headers },
+            body: JSON.stringify(toGeminiRequest(request)),
+        });
+        if (!response.ok)
+            throw formatProviderHttpError(this.name, model, response.status, response.statusText, await response.text());
+        return geminiResponseToModelResponse(await response.json());
+    }
+}
+export class BedrockModelProvider {
+    name;
+    region;
+    accessKeyId;
+    secretAccessKey;
+    sessionToken;
+    defaultModel;
+    headers;
+    constructor(options) {
+        this.name = options.name ?? 'bedrock';
+        this.region = options.region;
+        this.accessKeyId = options.accessKeyId;
+        this.secretAccessKey = options.secretAccessKey;
+        if (options.sessionToken !== undefined)
+            this.sessionToken = options.sessionToken;
+        if (options.defaultModel !== undefined)
+            this.defaultModel = options.defaultModel;
+        this.headers = options.headers ?? {};
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        if (!model)
+            throw new Error(`${this.name}: model is required.`);
+        const host = `bedrock-runtime.${this.region}.amazonaws.com`;
+        const pathName = `/model/${encodeURIComponent(model)}/converse`;
+        const body = JSON.stringify(toBedrockRequest(request));
+        const headers = signAwsRequest({
+            method: 'POST',
+            host,
+            path: pathName,
+            region: this.region,
+            service: 'bedrock',
+            accessKeyId: this.accessKeyId,
+            secretAccessKey: this.secretAccessKey,
+            ...(this.sessionToken ? { sessionToken: this.sessionToken } : {}),
+            body,
+            headers: { 'content-type': 'application/json', ...this.headers },
+        });
+        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());
+        return bedrockResponseToModelResponse(await response.json());
+    }
+}
+export class CohereModelProvider {
+    name;
+    baseUrl;
+    apiKey;
+    defaultModel;
+    headers;
+    constructor(options) {
+        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;
+        this.headers = options.headers ?? {};
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        if (!model)
+            throw new Error(`${this.name}: model is required.`);
+        const response = await fetch(`${this.baseUrl}/chat`, {
+            method: 'POST',
+            ...(request.signal !== undefined ? { signal: request.signal } : {}),
+            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());
+        return cohereResponseToModelResponse(await response.json());
+    }
+}
+export class FallbackModelProvider {
+    name;
+    providers;
+    constructor(options) {
+        this.name = options.name ?? 'fallback';
+        if (options.providers.length === 0)
+            throw new Error('FallbackModelProvider requires at least one provider.');
+        this.providers = options.providers;
+    }
+    async generate(request) {
+        const errors = [];
+        for (const provider of this.providers) {
+            try {
+                return await provider.generate(request);
+            }
+            catch (error) {
+                errors.push(`${provider.name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        throw new Error(`${this.name}: all fallback providers failed. ${errors.join(' | ')}`);
+    }
+}
+export class AnthropicModelProvider {
+    name;
+    baseUrl;
+    apiKey;
+    defaultModel;
+    headers;
+    maxTokens;
+    constructor(options) {
+        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;
+        this.headers = options.headers ?? {};
+        this.maxTokens = options.maxTokens ?? 1024;
+    }
+    async generate(request) {
+        const model = request.model ?? this.defaultModel;
+        if (!model)
+            throw new Error(`${this.name}: model is required.`);
+        const { system, messages } = toAnthropicMessages(request.messages);
+        const response = await fetch(`${this.baseUrl}/messages`, {
+            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: this.maxTokens, ...(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());
+        return anthropicResponseToModelResponse(await response.json());
+    }
+}
+export const defaultModelProvider = new MockModelProvider();
+function parseScriptedToolCalls(text) {
+    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);
+    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 }));
+}
+function estimateUsage(messages) {
+    const chars = messages.reduce((sum, message) => sum + message.content.length, 0);
+    return { totalTokens: Math.ceil(chars / 4) };
+}
+function retryDelay(baseMs, attempt) {
+    return Math.min(30_000, Math.round(baseMs * 2 ** Math.max(0, attempt - 1)));
+}
+function isRetryableModelError(error) {
+    if (error instanceof ProviderHttpError)
+        return error.status === 429 || error.status >= 500;
+    if (error instanceof Error && error.name === 'AbortError')
+        return false;
+    return true;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function toOpenAIMessage(message) {
+    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) {
+        return {
+            role: 'assistant',
+            content: message.content || null,
+            tool_calls: message.toolCalls.map(toOpenAIToolCallForMessage),
+        };
+    }
+    return { role: message.role, content: message.content };
+}
+function toOpenAIToolCallForMessage(call) {
+    return {
+        id: call.id,
+        type: 'function',
+        function: {
+            name: call.name,
+            arguments: typeof call.input === 'string' ? call.input : JSON.stringify(call.input),
+        },
+    };
+}
+function toOpenAITool(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            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 };
+    }
+    const objectSchema = schema;
+    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 : {},
+        required: Array.isArray(objectSchema.required) ? objectSchema.required : [],
+    };
+}
+function fromOpenAIToolCall(call) {
+    return {
+        id: call.id,
+        name: call.function.name,
+        input: call.function.arguments ? JSON.parse(call.function.arguments) : {},
+    };
+}
+function openAIChatCompletionToModelResponse(json) {
+    const choice = json.choices?.[0];
+    const message = choice?.message;
+    const result = {
+        ...(message?.content ? { message: { role: 'assistant', content: message.content } } : {}),
+        ...(message?.tool_calls ? { toolCalls: message.tool_calls.map(fromOpenAIToolCall) } : {}),
+    };
+    if (json.usage) {
+        const usage = {};
+        if (json.usage.prompt_tokens !== undefined)
+            usage.inputTokens = json.usage.prompt_tokens;
+        if (json.usage.completion_tokens !== undefined)
+            usage.outputTokens = json.usage.completion_tokens;
+        if (json.usage.total_tokens !== undefined)
+            usage.totalTokens = json.usage.total_tokens;
+        result.usage = usage;
+    }
+    return result;
+}
+function toAnthropicTool(tool) {
+    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 }))] };
+        }
+        return { role: message.role === 'assistant' ? 'assistant' : 'user', content: message.content };
+    });
+    return { ...(system ? { system } : {}), messages: converted };
+}
+function toGeminiRequest(request) {
+    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 }] };
+    });
+    return {
+        ...(system ? { systemInstruction: { parts: [{ text: system }] } } : {}),
+        contents,
+        ...(request.tools?.length ? { tools: [{ functionDeclarations: request.tools.map(toGeminiTool) }] } : {}),
+    };
+}
+function toGeminiTool(tool) {
+    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')
+            texts.push(part.text);
+        if (part.functionCall?.name)
+            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') } } : {}),
+        ...(toolCalls.length > 0 ? { toolCalls } : {}),
+    };
+    if (json.usageMetadata) {
+        const usage = {};
+        if (json.usageMetadata.promptTokenCount !== undefined)
+            usage.inputTokens = json.usageMetadata.promptTokenCount;
+        if (json.usageMetadata.candidatesTokenCount !== undefined)
+            usage.outputTokens = json.usageMetadata.candidatesTokenCount;
+        if (json.usageMetadata.totalTokenCount !== undefined)
+            usage.totalTokens = json.usageMetadata.totalTokenCount;
+        result.usage = usage;
+    }
+    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 }] };
+    });
+    return {
+        ...(system.length ? { system } : {}),
+        messages,
+        ...(request.tools?.length ? { toolConfig: { tools: request.tools.map(toBedrockTool) } } : {}),
+    };
+}
+function toBedrockTool(tool) {
+    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')
+            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 ?? {} });
+    }
+    const result = {
+        ...(texts.length ? { message: { role: 'assistant', content: texts.join('\n') } } : {}),
+        ...(toolCalls.length ? { toolCalls } : {}),
+    };
+    if (json.usage) {
+        const usage = {};
+        if (json.usage.inputTokens !== undefined)
+            usage.inputTokens = json.usage.inputTokens;
+        if (json.usage.outputTokens !== undefined)
+            usage.outputTokens = json.usage.outputTokens;
+        if (json.usage.totalTokens !== undefined)
+            usage.totalTokens = json.usage.totalTokens;
+        result.usage = usage;
+    }
+    return result;
+}
+function toCohereMessage(message) {
+    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 billed = json.usage?.billed_units;
+    if (billed) {
+        const usage = {};
+        if (billed.input_tokens !== undefined)
+            usage.inputTokens = billed.input_tokens;
+        if (billed.output_tokens !== undefined)
+            usage.outputTokens = billed.output_tokens;
+        if (usage.inputTokens !== undefined || usage.outputTokens !== undefined)
+            usage.totalTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+        result.usage = usage;
+    }
+    return result;
+}
+function anthropicResponseToModelResponse(json) {
+    const texts = [];
+    const toolCalls = [];
+    for (const block of json.content ?? []) {
+        if (block.type === 'text' && typeof block.text === 'string')
+            texts.push(block.text);
+        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') } } : {}),
+        ...(toolCalls.length > 0 ? { toolCalls } : {}),
+    };
+    if (json.usage) {
+        const usage = {};
+        if (json.usage.input_tokens !== undefined)
+            usage.inputTokens = json.usage.input_tokens;
+        if (json.usage.output_tokens !== undefined)
+            usage.outputTokens = json.usage.output_tokens;
+        if (usage.inputTokens !== undefined || usage.outputTokens !== undefined)
+            usage.totalTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
+        result.usage = usage;
+    }
+    return result;
+}
+export class ProviderHttpError extends Error {
+    provider;
+    status;
+    statusText;
+    body;
+    constructor(message, provider, status, statusText, body) {
+        super(message);
+        this.provider = provider;
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = 'ProviderHttpError';
+    }
+}
+function signAwsRequest(input) {
+    const now = new Date();
+    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 } : {}),
+    };
+    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 credentialScope = `${dateStamp}/${input.region}/${input.service}/aws4_request`;
+    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}`,
+    };
+}
+function sha256Hex(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function hmac(key, value) {
+    return createHmac('sha256', key).update(value).digest();
+}
+function hmacHex(key, value) {
+    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');
+}
+function formatProviderHttpError(provider, model, status, statusText, body) {
+    let parsedMessage;
+    let code;
+    try {
+        const parsed = JSON.parse(body);
+        parsedMessage = parsed.error?.message;
+        code = parsed.error?.code ?? parsed.error?.type;
+    }
+    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);
+    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 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);
+    if (status >= 500)
+        return new ProviderHttpError(`${provider}: provider unavailable (${status} ${statusText}). ${details}`, provider, status, statusText, body);
+    return new ProviderHttpError(`${provider}: ${status} ${statusText}: ${details}`, provider, status, statusText, body);
+}
+//# sourceMappingURL=model.js.map