@namzu/sdk 0.1.1 → 0.1.2

package/src/provider/bedrock/client.ts

@@ -2,7 +2,7 @@ import {
 	BedrockRuntimeClient,
 	ConverseCommand,
 	ConverseStreamCommand,
-} from "@aws-sdk/client-bedrock-runtime";
+} from '@aws-sdk/client-bedrock-runtime'
 import type {
 	Message as BedrockMessage,
 	ContentBlock,
@@ -13,10 +13,10 @@ import type {
 	ToolConfiguration,
 	ToolResultContentBlock,
 	ToolUseBlock,
-} from "@aws-sdk/client-bedrock-runtime";
-import { SpanStatusCode } from "@opentelemetry/api";
-import { GENAI, NAMZU, chatSpanName } from "../../telemetry/attributes.js";
-import type { TokenUsage } from "../../types/common/index.js";
+} from '@aws-sdk/client-bedrock-runtime'
+import { SpanStatusCode } from '@opentelemetry/api'
+import { GENAI, NAMZU, chatSpanName } from '../../telemetry/attributes.js'
+import type { TokenUsage } from '../../types/common/index.js'
 import type {
 	ChatCompletionParams,
 	ChatCompletionResponse,
@@ -24,183 +24,168 @@ import type {
 	ModelInfo,
 	StreamChunk,
 	ToolChoice,
-} from "../../types/provider/index.js";
-import type { BedrockConfig } from "../../types/provider/index.js";
-import { toErrorMessage } from "../../utils/error.js";
-import { getRootLogger } from "../../utils/logger.js";
-import { getTracer } from "../telemetry/setup.js";
+} from '../../types/provider/index.js'
+import type { BedrockConfig } from '../../types/provider/index.js'
+import { toErrorMessage } from '../../utils/error.js'
+import { getRootLogger } from '../../utils/logger.js'
+import { getTracer } from '../telemetry/setup.js'
 
-const logger = getRootLogger().child({ component: "BedrockProvider" });
+const logger = getRootLogger().child({ component: 'BedrockProvider' })
 
-function extractSystemBlocks(
-	messages: ChatCompletionParams["messages"],
-): SystemContentBlock[] {
+function extractSystemBlocks(messages: ChatCompletionParams['messages']): SystemContentBlock[] {
 	return messages
-		.filter((m) => m.role === "system")
-		.map((m) => ({ text: typeof m.content === "string" ? m.content : "" }));
+		.filter((m) => m.role === 'system')
+		.map((m) => ({ text: typeof m.content === 'string' ? m.content : '' }))
 }
 
 function toBedrockRole(role: string): ConversationRole {
-	return role === "assistant" ? "assistant" : "user";
+	return role === 'assistant' ? 'assistant' : 'user'
 }
 
-function toBedrockMessages(
-	messages: ChatCompletionParams["messages"],
-): BedrockMessage[] {
-	const out: BedrockMessage[] = [];
+function toBedrockMessages(messages: ChatCompletionParams['messages']): BedrockMessage[] {
+	const out: BedrockMessage[] = []
 
-	let pendingToolResults: ContentBlock[] = [];
+	let pendingToolResults: ContentBlock[] = []
 
 	const flushToolResults = () => {
 		if (pendingToolResults.length > 0) {
-			out.push({ role: "user", content: pendingToolResults });
-			pendingToolResults = [];
+			out.push({ role: 'user', content: pendingToolResults })
+			pendingToolResults = []
 		}
-	};
+	}
 
 	for (const msg of messages) {
-		if (msg.role === "system") continue;
+		if (msg.role === 'system') continue
 
-		if (msg.role === "tool") {
-			const toolMsg = msg as { toolCallId?: string; content?: string };
+		if (msg.role === 'tool') {
+			const toolMsg = msg as { toolCallId?: string; content?: string }
 			const resultBlock: ToolResultContentBlock = {
 				text:
-					typeof toolMsg.content === "string"
-						? toolMsg.content
-						: JSON.stringify(toolMsg.content),
-			};
+					typeof toolMsg.content === 'string' ? toolMsg.content : JSON.stringify(toolMsg.content),
+			}
 			pendingToolResults.push({
 				toolResult: {
-					toolUseId: toolMsg.toolCallId ?? "unknown",
+					toolUseId: toolMsg.toolCallId ?? 'unknown',
 					content: [resultBlock],
 				},
-			});
-			continue;
+			})
+			continue
 		}
 
-		flushToolResults();
+		flushToolResults()
 
-		if (msg.role === "assistant" && "toolCalls" in msg && msg.toolCalls) {
-			const content: ContentBlock[] = [];
+		if (msg.role === 'assistant' && 'toolCalls' in msg && msg.toolCalls) {
+			const content: ContentBlock[] = []
 			if (msg.content) {
-				content.push({ text: msg.content });
+				content.push({ text: msg.content })
 			}
 			for (const tc of msg.toolCalls) {
 				content.push({
 					toolUse: {
 						toolUseId: tc.id,
 						name: tc.function.name,
-						input: JSON.parse(tc.function.arguments || "{}"),
+						input: JSON.parse(tc.function.arguments || '{}'),
 					},
-				});
+				})
 			}
-			out.push({ role: "assistant", content });
-			continue;
+			out.push({ role: 'assistant', content })
+			continue
 		}
 
-		const text =
-			typeof msg.content === "string"
-				? msg.content
-				: JSON.stringify(msg.content);
+		const text = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
 		out.push({
 			role: toBedrockRole(msg.role),
 			content: [{ text }],
-		});
+		})
 	}
 
-	flushToolResults();
+	flushToolResults()
 
-	return out;
+	return out
 }
 
-function messagesContainToolBlocks(
-	messages: ChatCompletionParams["messages"],
-): boolean {
+function messagesContainToolBlocks(messages: ChatCompletionParams['messages']): boolean {
 	for (const msg of messages) {
-		if (msg.role === "tool") return true;
+		if (msg.role === 'tool') return true
 		if (
-			msg.role === "assistant" &&
-			"toolCalls" in msg &&
+			msg.role === 'assistant' &&
+			'toolCalls' in msg &&
 			msg.toolCalls &&
 			msg.toolCalls.length > 0
 		) {
-			return true;
+			return true
 		}
 	}
-	return false;
+	return false
 }
 
-function extractToolNamesFromHistory(
-	messages: ChatCompletionParams["messages"],
-): string[] {
-	const names = new Set<string>();
+function extractToolNamesFromHistory(messages: ChatCompletionParams['messages']): string[] {
+	const names = new Set<string>()
 	for (const msg of messages) {
-		if (msg.role === "assistant" && "toolCalls" in msg && msg.toolCalls) {
+		if (msg.role === 'assistant' && 'toolCalls' in msg && msg.toolCalls) {
 			for (const tc of msg.toolCalls) {
-				names.add(tc.function.name);
+				names.add(tc.function.name)
 			}
 		}
 	}
-	return Array.from(names);
+	return Array.from(names)
 }
 
-function toBedrockToolConfig(
-	params: ChatCompletionParams,
-): ToolConfiguration | undefined {
+function toBedrockToolConfig(params: ChatCompletionParams): ToolConfiguration | undefined {
 	if (params.tools && params.tools.length > 0) {
 		const tools: Tool[] = params.tools.map(
 			(t) =>
 				({
 					toolSpec: {
 						name: t.function.name,
-						description: t.function.description ?? "",
+						description: t.function.description ?? '',
 						inputSchema: {
 							json: (t.function.parameters ?? {}) as Record<string, unknown>,
 						},
 					},
 				}) as Tool,
-		);
+		)
 
-		const toolChoice = formatToolChoice(params.toolChoice);
-		return { tools, toolChoice };
+		const toolChoice = formatToolChoice(params.toolChoice)
+		return { tools, toolChoice }
 	}
 
 	if (messagesContainToolBlocks(params.messages)) {
-		const toolNames = extractToolNamesFromHistory(params.messages);
+		const toolNames = extractToolNamesFromHistory(params.messages)
 		if (toolNames.length > 0) {
 			const tools: Tool[] = toolNames.map(
 				(name) =>
 					({
 						toolSpec: {
 							name,
-							description: "(completed)",
-							inputSchema: { json: { type: "object" } },
+							description: '(completed)',
+							inputSchema: { json: { type: 'object' } },
 						},
 					}) as Tool,
-			);
-			return { tools, toolChoice: { auto: {} } };
+			)
+			return { tools, toolChoice: { auto: {} } }
 		}
 	}
 
-	return undefined;
+	return undefined
 }
 
 function formatToolChoice(tc?: ToolChoice) {
-	if (!tc || tc === "auto") return { auto: {} };
-	if (tc === "none") return { auto: {} };
-	if (tc === "required") return { any: {} };
-	if (typeof tc === "object" && tc.type === "function") {
-		return { tool: { name: tc.function.name } };
+	if (!tc || tc === 'auto') return { auto: {} }
+	if (tc === 'none') return { auto: {} }
+	if (tc === 'required') return { any: {} }
+	if (typeof tc === 'object' && tc.type === 'function') {
+		return { tool: { name: tc.function.name } }
 	}
-	return { auto: {} };
+	return { auto: {} }
 }
 
 interface RawBedrockUsage {
-	inputTokens?: number;
-	outputTokens?: number;
-	totalTokens?: number;
-	cacheReadInputTokenCount?: number;
-	cacheWriteInputTokenCount?: number;
+	inputTokens?: number
+	outputTokens?: number
+	totalTokens?: number
+	cacheReadInputTokenCount?: number
+	cacheWriteInputTokenCount?: number
 }
 
 function parseUsage(raw?: RawBedrockUsage): TokenUsage {
@@ -211,85 +196,83 @@ function parseUsage(raw?: RawBedrockUsage): TokenUsage {
 			totalTokens: 0,
 			cachedTokens: 0,
 			cacheWriteTokens: 0,
-		};
+		}
 	}
-	const input = raw.inputTokens ?? 0;
-	const output = raw.outputTokens ?? 0;
+	const input = raw.inputTokens ?? 0
+	const output = raw.outputTokens ?? 0
 	return {
 		promptTokens: input,
 		completionTokens: output,
 		totalTokens: raw.totalTokens ?? input + output,
 		cachedTokens: raw.cacheReadInputTokenCount ?? 0,
 		cacheWriteTokens: raw.cacheWriteInputTokenCount ?? 0,
-	};
+	}
 }
 
-type NamzuFinishReason = ChatCompletionResponse["finishReason"];
+type NamzuFinishReason = ChatCompletionResponse['finishReason']
 
 function mapStopReason(reason?: string): NamzuFinishReason {
 	switch (reason) {
-		case "end_turn":
-		case "stop_sequence":
-			return "stop";
-		case "tool_use":
-			return "tool_calls";
-		case "max_tokens":
-			return "length";
-		case "content_filtered":
-			return "content_filter";
+		case 'end_turn':
+		case 'stop_sequence':
+			return 'stop'
+		case 'tool_use':
+			return 'tool_calls'
+		case 'max_tokens':
+			return 'length'
+		case 'content_filtered':
+			return 'content_filter'
 		default:
-			return "stop";
+			return 'stop'
 	}
 }
 
 function extractResponseContent(content?: ContentBlock[]): {
-	text: string | null;
-	toolCalls: ChatCompletionResponse["message"]["toolCalls"];
+	text: string | null
+	toolCalls: ChatCompletionResponse['message']['toolCalls']
 } {
-	if (!content || content.length === 0)
-		return { text: null, toolCalls: undefined };
+	if (!content || content.length === 0) return { text: null, toolCalls: undefined }
 
-	let text: string | null = null;
-	const toolCalls: NonNullable<ChatCompletionResponse["message"]["toolCalls"]> =
-		[];
+	let text: string | null = null
+	const toolCalls: NonNullable<ChatCompletionResponse['message']['toolCalls']> = []
 
 	for (const block of content) {
-		if ("text" in block && block.text) {
-			text = (text ?? "") + block.text;
+		if ('text' in block && block.text) {
+			text = (text ?? '') + block.text
 		}
-		if ("toolUse" in block && block.toolUse) {
-			const tu = block.toolUse as ToolUseBlock;
+		if ('toolUse' in block && block.toolUse) {
+			const tu = block.toolUse as ToolUseBlock
 			toolCalls.push({
 				id: tu.toolUseId ?? `tool-${Date.now()}`,
-				type: "function",
+				type: 'function',
 				function: {
-					name: tu.name ?? "",
+					name: tu.name ?? '',
 					arguments: JSON.stringify(tu.input ?? {}),
 				},
-			});
+			})
 		}
 	}
 
 	return {
 		text,
 		toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-	};
+	}
 }
 
 export class BedrockProvider implements LLMProvider {
-	readonly id = "bedrock";
-	readonly name = "AWS Bedrock";
+	readonly id = 'bedrock'
+	readonly name = 'AWS Bedrock'
 
-	private client: BedrockRuntimeClient;
-	private config: BedrockConfig;
+	private client: BedrockRuntimeClient
+	private config: BedrockConfig
 
 	constructor(config: BedrockConfig) {
-		this.config = config;
+		this.config = config
 
-		const clientConfig: Record<string, unknown> = {};
+		const clientConfig: Record<string, unknown> = {}
 
 		if (config.region) {
-			clientConfig.region = config.region;
+			clientConfig.region = config.region
 		}
 
 		if (config.accessKeyId && config.secretAccessKey) {
@@ -297,44 +280,42 @@ export class BedrockProvider implements LLMProvider {
 				accessKeyId: config.accessKeyId,
 				secretAccessKey: config.secretAccessKey,
 				...(config.sessionToken ? { sessionToken: config.sessionToken } : {}),
-			};
+			}
 		}
 
-		this.client = new BedrockRuntimeClient(clientConfig);
+		this.client = new BedrockRuntimeClient(clientConfig)
 	}
 
 	async chat(params: ChatCompletionParams): Promise<ChatCompletionResponse> {
-		const tracer = getTracer();
+		const tracer = getTracer()
 
 		return tracer.startActiveSpan(chatSpanName(params.model), async (span) => {
 			span.setAttributes({
-				[GENAI.OPERATION_NAME]: "chat",
-				[GENAI.SYSTEM]: "bedrock",
+				[GENAI.OPERATION_NAME]: 'chat',
+				[GENAI.SYSTEM]: 'bedrock',
 				[GENAI.REQUEST_MODEL]: params.model,
-			});
+			})
 			if (params.temperature !== undefined) {
-				span.setAttribute(GENAI.REQUEST_TEMPERATURE, params.temperature);
+				span.setAttribute(GENAI.REQUEST_TEMPERATURE, params.temperature)
 			}
 			if (params.maxTokens !== undefined) {
-				span.setAttribute(GENAI.REQUEST_MAX_TOKENS, params.maxTokens);
+				span.setAttribute(GENAI.REQUEST_MAX_TOKENS, params.maxTokens)
 			}
 
 			try {
-				const system = extractSystemBlocks(params.messages);
-				const messages = toBedrockMessages(params.messages);
-				const toolConfig = toBedrockToolConfig(params);
-
-				const inferenceConfig: Record<string, unknown> = {};
-				if (params.maxTokens !== undefined)
-					inferenceConfig.maxTokens = params.maxTokens;
-				if (params.temperature !== undefined)
-					inferenceConfig.temperature = params.temperature;
-				if (params.topP !== undefined) inferenceConfig.topP = params.topP;
-				if (params.stop) inferenceConfig.stopSequences = params.stop;
-
-				logger.debug("Sending Bedrock Converse request", {
+				const system = extractSystemBlocks(params.messages)
+				const messages = toBedrockMessages(params.messages)
+				const toolConfig = toBedrockToolConfig(params)
+
+				const inferenceConfig: Record<string, unknown> = {}
+				if (params.maxTokens !== undefined) inferenceConfig.maxTokens = params.maxTokens
+				if (params.temperature !== undefined) inferenceConfig.temperature = params.temperature
+				if (params.topP !== undefined) inferenceConfig.topP = params.topP
+				if (params.stop) inferenceConfig.stopSequences = params.stop
+
+				logger.debug('Sending Bedrock Converse request', {
 					model: params.model,
-				});
+				})
 
 				const command = new ConverseCommand({
 					modelId: params.model,
@@ -342,32 +323,29 @@ export class BedrockProvider implements LLMProvider {
 					messages,
 					toolConfig,
 					inferenceConfig,
-				});
+				})
 
 				const response = await this.client.send(command, {
 					requestTimeout: this.config.timeout ?? 120_000,
-				});
+				})
 
-				const { text, toolCalls } = extractResponseContent(
-					response.output?.message?.content,
-				);
-				const usage = parseUsage(response.usage as RawBedrockUsage | undefined);
-				const finishReason = mapStopReason(response.stopReason);
+				const { text, toolCalls } = extractResponseContent(response.output?.message?.content)
+				const usage = parseUsage(response.usage as RawBedrockUsage | undefined)
+				const finishReason = mapStopReason(response.stopReason)
 
-				const requestId =
-					response.$metadata.requestId ?? `bedrock-${Date.now()}`;
+				const requestId = response.$metadata.requestId ?? `bedrock-${Date.now()}`
 
 				const result: ChatCompletionResponse = {
 					id: requestId,
 					model: params.model,
 					message: {
-						role: "assistant",
+						role: 'assistant',
 						content: text,
 						toolCalls,
 					},
 					finishReason,
 					usage,
-				};
+				}
 
 				span.setAttributes({
 					[GENAI.RESPONSE_ID]: requestId,
@@ -377,37 +355,33 @@ export class BedrockProvider implements LLMProvider {
 					[GENAI.USAGE_OUTPUT_TOKENS]: usage.completionTokens,
 					[NAMZU.CACHE_READ_TOKENS]: usage.cachedTokens,
 					[NAMZU.CACHE_WRITE_TOKENS]: usage.cacheWriteTokens,
-				});
-				span.setStatus({ code: SpanStatusCode.OK });
+				})
+				span.setStatus({ code: SpanStatusCode.OK })
 
-				return result;
+				return result
 			} catch (err) {
 				span.setStatus({
 					code: SpanStatusCode.ERROR,
 					message: toErrorMessage(err),
-				});
-				span.recordException(
-					err instanceof Error ? err : new Error(String(err)),
-				);
-				throw err;
+				})
+				span.recordException(err instanceof Error ? err : new Error(String(err)))
+				throw err
 			} finally {
-				span.end();
+				span.end()
 			}
-		});
+		})
 	}
 
 	async *chatStream(params: ChatCompletionParams): AsyncIterable<StreamChunk> {
-		const system = extractSystemBlocks(params.messages);
-		const messages = toBedrockMessages(params.messages);
-		const toolConfig = toBedrockToolConfig(params);
-
-		const inferenceConfig: Record<string, unknown> = {};
-		if (params.maxTokens !== undefined)
-			inferenceConfig.maxTokens = params.maxTokens;
-		if (params.temperature !== undefined)
-			inferenceConfig.temperature = params.temperature;
-		if (params.topP !== undefined) inferenceConfig.topP = params.topP;
-		if (params.stop) inferenceConfig.stopSequences = params.stop;
+		const system = extractSystemBlocks(params.messages)
+		const messages = toBedrockMessages(params.messages)
+		const toolConfig = toBedrockToolConfig(params)
+
+		const inferenceConfig: Record<string, unknown> = {}
+		if (params.maxTokens !== undefined) inferenceConfig.maxTokens = params.maxTokens
+		if (params.temperature !== undefined) inferenceConfig.temperature = params.temperature
+		if (params.topP !== undefined) inferenceConfig.topP = params.topP
+		if (params.stop) inferenceConfig.stopSequences = params.stop
 
 		const command = new ConverseStreamCommand({
 			modelId: params.model,
@@ -415,66 +389,61 @@ export class BedrockProvider implements LLMProvider {
 			messages,
 			toolConfig,
 			inferenceConfig,
-		});
+		})
 
 		const response = await this.client.send(command, {
 			requestTimeout: this.config.timeout ?? 120_000,
-		});
+		})
 
 		if (!response.stream) {
-			throw new Error("Bedrock returned no stream body");
+			throw new Error('Bedrock returned no stream body')
 		}
 
-		const requestId = response.$metadata.requestId ?? `bedrock-${Date.now()}`;
+		const requestId = response.$metadata.requestId ?? `bedrock-${Date.now()}`
 
-		const activeToolCalls = new Map<
-			number,
-			{ id: string; name: string; args: string }
-		>();
-		let toolCallIndex = 0;
+		const activeToolCalls = new Map<number, { id: string; name: string; args: string }>()
+		let toolCallIndex = 0
 
 		for await (const event of response.stream as AsyncIterable<ConverseStreamOutput>) {
 			try {
-				if ("contentBlockDelta" in event && event.contentBlockDelta?.delta) {
-					const delta = event.contentBlockDelta.delta;
-					if ("text" in delta && delta.text) {
+				if ('contentBlockDelta' in event && event.contentBlockDelta?.delta) {
+					const delta = event.contentBlockDelta.delta
+					if ('text' in delta && delta.text) {
 						yield {
 							id: requestId,
 							delta: { content: delta.text },
-						};
+						}
 					}
 
-					if ("toolUse" in delta && delta.toolUse) {
-						const idx =
-							event.contentBlockDelta.contentBlockIndex ?? toolCallIndex;
-						const active = activeToolCalls.get(idx);
+					if ('toolUse' in delta && delta.toolUse) {
+						const idx = event.contentBlockDelta.contentBlockIndex ?? toolCallIndex
+						const active = activeToolCalls.get(idx)
 						if (active) {
-							active.args += delta.toolUse.input ?? "";
+							active.args += delta.toolUse.input ?? ''
 							yield {
 								id: requestId,
 								delta: {
 									toolCalls: [
 										{
 											index: idx,
-											function: { arguments: delta.toolUse.input ?? "" },
+											function: { arguments: delta.toolUse.input ?? '' },
 										},
 									],
 								},
-							};
+							}
 						}
 					}
 				}
 
-				if ("contentBlockStart" in event && event.contentBlockStart?.start) {
-					const start = event.contentBlockStart.start;
-					if ("toolUse" in start && start.toolUse) {
-						const idx =
-							event.contentBlockStart.contentBlockIndex ?? toolCallIndex;
+				if ('contentBlockStart' in event && event.contentBlockStart?.start) {
+					const start = event.contentBlockStart.start
+					if ('toolUse' in start && start.toolUse) {
+						const idx = event.contentBlockStart.contentBlockIndex ?? toolCallIndex
 						activeToolCalls.set(idx, {
 							id: start.toolUse.toolUseId ?? `tool-${Date.now()}`,
-							name: start.toolUse.name ?? "",
-							args: "",
-						});
+							name: start.toolUse.name ?? '',
+							args: '',
+						})
 						yield {
 							id: requestId,
 							delta: {
@@ -482,46 +451,46 @@ export class BedrockProvider implements LLMProvider {
 									{
 										index: idx,
 										id: start.toolUse.toolUseId,
-										type: "function",
-										function: { name: start.toolUse.name ?? "" },
+										type: 'function',
+										function: { name: start.toolUse.name ?? '' },
 									},
 								],
 							},
-						};
-						toolCallIndex = idx + 1;
+						}
+						toolCallIndex = idx + 1
 					}
 				}
 
-				if ("contentBlockStop" in event) {
+				if ('contentBlockStop' in event) {
 				}
 
-				if ("messageStop" in event && event.messageStop) {
+				if ('messageStop' in event && event.messageStop) {
 					yield {
 						id: requestId,
 						delta: {},
 						finishReason: mapStopReason(event.messageStop.stopReason),
-					};
+					}
 				}
 
-				if ("metadata" in event && event.metadata?.usage) {
-					const usage = parseUsage(event.metadata.usage as RawBedrockUsage);
+				if ('metadata' in event && event.metadata?.usage) {
+					const usage = parseUsage(event.metadata.usage as RawBedrockUsage)
 					yield {
 						id: requestId,
 						delta: {},
 						usage,
-					};
+					}
 				}
 			} catch (parseErr) {
-				logger.warn("Failed to process Bedrock stream event", {
+				logger.warn('Failed to process Bedrock stream event', {
 					error: toErrorMessage(parseErr),
-				});
+				})
 				yield {
 					id: requestId,
 					delta: { content: undefined },
 					finishReason: undefined,
 					usage: undefined,
 					error: `Stream parse error: ${toErrorMessage(parseErr)}`,
-				};
+				}
 			}
 		}
 	}
@@ -529,8 +498,8 @@ export class BedrockProvider implements LLMProvider {
 	async listModels(): Promise<ModelInfo[]> {
 		return [
 			{
-				id: "anthropic.claude-sonnet-4-20250514",
-				name: "Claude Sonnet 4 (Bedrock)",
+				id: 'anthropic.claude-sonnet-4-20250514',
+				name: 'Claude Sonnet 4 (Bedrock)',
 				contextWindow: 200_000,
 				maxOutputTokens: 64_000,
 				inputPrice: 3.0,
@@ -539,8 +508,8 @@ export class BedrockProvider implements LLMProvider {
 				supportsStreaming: true,
 			},
 			{
-				id: "anthropic.claude-haiku-4-20250514",
-				name: "Claude Haiku 4 (Bedrock)",
+				id: 'anthropic.claude-haiku-4-20250514',
+				name: 'Claude Haiku 4 (Bedrock)',
 				contextWindow: 200_000,
 				maxOutputTokens: 64_000,
 				inputPrice: 0.8,
@@ -549,8 +518,8 @@ export class BedrockProvider implements LLMProvider {
 				supportsStreaming: true,
 			},
 			{
-				id: "amazon.nova-pro-v1:0",
-				name: "Amazon Nova Pro",
+				id: 'amazon.nova-pro-v1:0',
+				name: 'Amazon Nova Pro',
 				contextWindow: 300_000,
 				maxOutputTokens: 5_000,
 				inputPrice: 0.8,
@@ -558,22 +527,22 @@ export class BedrockProvider implements LLMProvider {
 				supportsToolUse: true,
 				supportsStreaming: true,
 			},
-		];
+		]
 	}
 
 	async healthCheck(): Promise<boolean> {
 		try {
 			const command = new ConverseCommand({
-				modelId: "anthropic.claude-haiku-4-20250514",
-				messages: [{ role: "user", content: [{ text: "hi" }] }],
+				modelId: 'anthropic.claude-haiku-4-20250514',
+				messages: [{ role: 'user', content: [{ text: 'hi' }] }],
 				inferenceConfig: { maxTokens: 1 },
-			});
+			})
 			const response = await this.client.send(command, {
 				requestTimeout: 5000,
-			});
-			return response.$metadata.httpStatusCode === 200;
+			})
+			return response.$metadata.httpStatusCode === 200
 		} catch {
-			return false;
+			return false
 		}
 	}
 }