autohand-cli 0.9.0 → 0.9.1

package/dist/{chunk-QKP772OZ.js → chunk-JPFRI4L4.js}

@@ -1,10 +1,14 @@
 import {
-  NVIDIAProvider
-} from "./chunk-CCVMREXI.js";
+  NVIDIAProvider,
+  normalizeLLMUsage
+} from "./chunk-4567QNRB.js";
 import {
   ApiError,
   classifyApiError
 } from "./chunk-FQVG6ZHF.js";
+import {
+  isAwsBedrockProviderEnabled
+} from "./chunk-LANGD5CO.js";
 
 // src/providers/OllamaProvider.ts
 var DEFAULT_TIMEOUT = 12e4;
@@ -182,14 +186,10 @@ var OllamaProvider = class {
         };
       });
     }
-    let usage;
-    if (data.prompt_eval_count !== void 0 || data.eval_count !== void 0) {
-      usage = {
-        promptTokens: data.prompt_eval_count ?? 0,
-        completionTokens: data.eval_count ?? 0,
-        totalTokens: (data.prompt_eval_count ?? 0) + (data.eval_count ?? 0)
-      };
-    }
+    const usage = normalizeLLMUsage({
+      prompt_tokens: data.prompt_eval_count,
+      completion_tokens: data.eval_count
+    });
     return {
       id: `ollama-${Date.now()}`,
       created: Math.floor(new Date(data.created_at).getTime() / 1e3),
@@ -812,6 +812,8 @@ async function refreshChatGPTAuth(auth) {
 
 // src/providers/OpenAIProvider.ts
 var OPENAI_MODELS = [
+  "gpt-5.5",
+  "gpt-5.5-pro",
   "gpt-5.4",
   "gpt-5.4-pro",
   "gpt-5.4-mini",
@@ -859,6 +861,11 @@ var OpenAIProvider = class {
   setModel(model) {
     this.model = model;
   }
+  getCapabilities() {
+    return {
+      nativeToolCalling: true
+    };
+  }
   async listModels() {
     return [...OPENAI_MODELS];
   }
@@ -885,7 +892,7 @@ var OpenAIProvider = class {
       messages: request.messages.map((msg) => {
         const mapped = {
           role: msg.role === "system" ? "system" : msg.role === "user" ? "user" : msg.role === "tool" ? "tool" : "assistant",
-          content: msg.content
+          content: this.toChatCompletionContent(msg.content)
         };
         if (msg.role === "assistant" && msg.tool_calls?.length) {
           mapped.tool_calls = msg.tool_calls;
@@ -968,14 +975,7 @@ var OpenAIProvider = class {
         }
       }));
     }
-    let usage;
-    if (data.usage) {
-      usage = {
-        promptTokens: data.usage.prompt_tokens,
-        completionTokens: data.usage.completion_tokens,
-        totalTokens: data.usage.total_tokens
-      };
-    }
+    const usage = normalizeLLMUsage(data.usage);
     return {
       id: data.id,
       created: data.created,
@@ -995,7 +995,7 @@ var OpenAIProvider = class {
       stream: true,
       tool_choice: "auto",
       parallel_tool_calls: true,
-      input: request.messages.flatMap((msg) => this.toResponsesInputItems(msg))
+      input: this.toResponsesInputItems(request.messages)
     };
     if (this.reasoningEffort && VALID_REASONING_EFFORTS.has(this.reasoningEffort)) {
       body.reasoning = {
@@ -1059,11 +1059,7 @@ var OpenAIProvider = class {
     const data = await this.parseCodexStream(response);
     const toolCalls = this.extractResponsesToolCalls(data.output);
     const content = this.extractResponsesContent(data);
-    const usage = data.usage ? {
-      promptTokens: data.usage.input_tokens ?? 0,
-      completionTokens: data.usage.output_tokens ?? 0,
-      totalTokens: data.usage.total_tokens ?? (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0)
-    } : void 0;
+    const usage = normalizeLLMUsage(data.usage);
     return {
       id: data.id,
       created: data.created_at ?? Math.floor(Date.now() / 1e3),
@@ -1115,13 +1111,42 @@ ${error.rawDetail}` : friendlyMessage,
     const text = await response.text();
     let currentEvent = "";
     let completedData = null;
+    let streamedOutputText = "";
+    const streamedOutputItems = /* @__PURE__ */ new Map();
     for (const line of text.split("\n")) {
       if (line.startsWith("event: ")) {
         currentEvent = line.slice(7).trim();
         continue;
       }
-      if (line.startsWith("data: ") && currentEvent === "response.completed") {
-        completedData = JSON.parse(line.slice(6));
+      if (!line.startsWith("data: ")) {
+        continue;
+      }
+      const dataLine = line.slice(6);
+      const eventData = JSON.parse(dataLine);
+      const eventType = this.getCodexStreamEventType(currentEvent, eventData);
+      const eventRecord = eventData && typeof eventData === "object" ? eventData : {};
+      if (eventType === "response.output_text.delta") {
+        if (typeof eventRecord.delta === "string") {
+          streamedOutputText += eventRecord.delta;
+        }
+        continue;
+      }
+      if (eventType === "response.output_text.done") {
+        if (typeof eventRecord.text === "string" && eventRecord.text.trim()) {
+          streamedOutputText = eventRecord.text;
+        }
+        continue;
+      }
+      if (eventType === "response.output_item.added" || eventType === "response.output_item.done") {
+        this.captureStreamedOutputItem(eventData, streamedOutputItems);
+        continue;
+      }
+      if (eventType === "response.function_call_arguments.done") {
+        this.captureStreamedFunctionCallArguments(eventData, streamedOutputItems);
+        continue;
+      }
+      if (eventType === "response.completed") {
+        completedData = this.extractCompletedResponse(eventData);
         break;
       }
     }
@@ -1133,8 +1158,74 @@ ${error.rawDetail}` : friendlyMessage,
         false
       );
     }
+    if ((!Array.isArray(completedData.output) || completedData.output.length === 0) && streamedOutputItems.size > 0) {
+      completedData.output = [...streamedOutputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+    }
+    if (!this.extractResponsesContent(completedData) && streamedOutputText.trim()) {
+      completedData.output_text = streamedOutputText;
+    }
     return completedData;
   }
+  getCodexStreamEventType(currentEvent, eventData) {
+    if (currentEvent) {
+      return currentEvent;
+    }
+    if (eventData && typeof eventData === "object" && "type" in eventData) {
+      const type = eventData.type;
+      return typeof type === "string" ? type : "";
+    }
+    return "";
+  }
+  captureStreamedOutputItem(eventData, outputItems) {
+    if (!eventData || typeof eventData !== "object") {
+      return;
+    }
+    const event = eventData;
+    if (!event.item || typeof event.output_index !== "number") {
+      return;
+    }
+    const existing = outputItems.get(event.output_index);
+    if (existing?.type === "function_call" && event.item.type === "function_call") {
+      outputItems.set(event.output_index, {
+        ...existing,
+        ...event.item,
+        arguments: event.item.arguments || existing.arguments
+      });
+      return;
+    }
+    outputItems.set(event.output_index, event.item);
+  }
+  captureStreamedFunctionCallArguments(eventData, outputItems) {
+    if (!eventData || typeof eventData !== "object") {
+      return;
+    }
+    const event = eventData;
+    if (typeof event.output_index !== "number" || typeof event.name !== "string" || typeof event.arguments !== "string") {
+      return;
+    }
+    const existing = outputItems.get(event.output_index);
+    if (existing?.type === "function_call") {
+      outputItems.set(event.output_index, {
+        ...existing,
+        name: event.name,
+        arguments: event.arguments
+      });
+      return;
+    }
+    outputItems.set(event.output_index, {
+      type: "function_call",
+      id: event.item_id,
+      call_id: event.item_id,
+      name: event.name,
+      arguments: event.arguments
+    });
+  }
+  extractCompletedResponse(eventData) {
+    if (eventData && typeof eventData === "object" && "response" in eventData && eventData.response) {
+      return eventData.response;
+    }
+    return eventData;
+  }
   async buildAuthHeaders() {
     if (this.authMode === "chatgpt") {
       if (!this.chatgptAuth?.accessToken || !this.chatgptAuth.accountId) {
@@ -1161,12 +1252,73 @@ ${error.rawDetail}` : friendlyMessage,
     }
     return (configBaseUrl || OPENAI_API_BASE_URL).replace(/\/$/, "");
   }
-  toResponsesInputItems(msg) {
+  isContentPartsArray(content) {
+    return Array.isArray(content);
+  }
+  toChatCompletionContent(content) {
+    if (!this.isContentPartsArray(content)) {
+      return content;
+    }
+    return content.map((part) => {
+      if (part.type === "text") {
+        return { type: "text", text: part.text };
+      }
+      if (part.type === "image_url") {
+        return {
+          type: "image_url",
+          image_url: part.image_url
+        };
+      }
+      return null;
+    }).filter((part) => part !== null);
+  }
+  toResponsesMessageContent(role, content) {
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    if (!this.isContentPartsArray(content)) {
+      return [{ type: textType, text: content }];
+    }
+    const parts = [];
+    for (const part of content) {
+      if (part.type === "text") {
+        parts.push({ type: textType, text: part.text });
+        continue;
+      }
+      if (part.type === "image_url" && role !== "assistant") {
+        parts.push({
+          type: "input_image",
+          image_url: part.image_url.url
+        });
+      }
+    }
+    return parts;
+  }
+  toResponsesInputItems(messages) {
+    const assistantToolCallIds = /* @__PURE__ */ new Set();
+    const toolOutputIds = /* @__PURE__ */ new Set();
+    for (const msg of messages) {
+      if (msg.role === "assistant" && msg.tool_calls?.length) {
+        for (const toolCall of msg.tool_calls) {
+          assistantToolCallIds.add(toolCall.id);
+        }
+      }
+      if (msg.role === "tool" && msg.tool_call_id) {
+        toolOutputIds.add(msg.tool_call_id);
+      }
+    }
+    const matchedToolCallIds = new Set(
+      [...assistantToolCallIds].filter((id) => toolOutputIds.has(id))
+    );
+    return messages.flatMap((msg) => this.toResponsesInputItemsForMessage(msg, matchedToolCallIds));
+  }
+  toResponsesInputItemsForMessage(msg, matchedToolCallIds) {
     const items = [];
     if (msg.role === "system") {
       return items;
     }
     if (msg.role === "tool" && msg.tool_call_id) {
+      if (!matchedToolCallIds.has(msg.tool_call_id)) {
+        return items;
+      }
       items.push({
         type: "function_call_output",
         call_id: msg.tool_call_id,
@@ -1175,14 +1327,18 @@ ${error.rawDetail}` : friendlyMessage,
       return items;
     }
     if (msg.content) {
+      const content = this.toResponsesMessageContent(msg.role, msg.content);
       items.push({
         type: "message",
         role: msg.role === "tool" ? "user" : msg.role,
-        content: [{ type: "input_text", text: msg.content }]
+        content
       });
     }
     if (msg.role === "assistant" && msg.tool_calls?.length) {
       for (const toolCall of msg.tool_calls) {
+        if (!matchedToolCallIds.has(toolCall.id)) {
+          continue;
+        }
         items.push({
           type: "function_call",
           call_id: toolCall.id,
@@ -1776,14 +1932,7 @@ var OpenRouterClient = class {
         };
       });
     }
-    let usage;
-    if (json?.usage) {
-      usage = {
-        promptTokens: json.usage.prompt_tokens ?? 0,
-        completionTokens: json.usage.completion_tokens ?? 0,
-        totalTokens: json.usage.total_tokens ?? 0
-      };
-    }
+    const usage = normalizeLLMUsage(json?.usage);
     return {
       id: json.id ?? "autohand-local",
       created: json.created ?? Date.now(),
@@ -2338,14 +2487,7 @@ var LLMGatewayClient = class {
         };
       });
     }
-    let usage;
-    if (json?.usage) {
-      usage = {
-        promptTokens: json.usage.prompt_tokens ?? 0,
-        completionTokens: json.usage.completion_tokens ?? 0,
-        totalTokens: json.usage.total_tokens ?? 0
-      };
-    }
+    const usage = normalizeLLMUsage(json?.usage);
     return {
       id: json.id ?? "llmgateway-response",
       created: json.created ?? Date.now(),
@@ -2817,14 +2959,7 @@ var AzureClient = class {
         };
       });
     }
-    let usage;
-    if (json?.usage) {
-      usage = {
-        promptTokens: json.usage.prompt_tokens ?? 0,
-        completionTokens: json.usage.completion_tokens ?? 0,
-        totalTokens: json.usage.total_tokens ?? 0
-      };
-    }
+    const usage = normalizeLLMUsage(json?.usage);
     return {
       id: json.id ?? "autohand-azure",
       created: json.created ?? Date.now(),
@@ -3377,14 +3512,7 @@ var VertexAIProvider = class {
         };
       });
     }
-    let usage;
-    if (json?.usage) {
-      usage = {
-        promptTokens: json.usage.prompt_tokens ?? 0,
-        completionTokens: json.usage.completion_tokens ?? 0,
-        totalTokens: json.usage.total_tokens ?? 0
-      };
-    }
+    const usage = normalizeLLMUsage(json?.usage);
     return {
       id: json.id ?? "vertexai-response",
       created: json.created ?? Date.now(),
@@ -3414,14 +3542,7 @@ var VertexAIProvider = class {
         }
       }));
     }
-    let usage;
-    if (json?.usage) {
-      usage = {
-        promptTokens: json.usage.input_tokens ?? 0,
-        completionTokens: json.usage.output_tokens ?? 0,
-        totalTokens: (json.usage.input_tokens ?? 0) + (json.usage.output_tokens ?? 0)
-      };
-    }
+    const usage = normalizeLLMUsage(json?.usage);
     const stopReason = json?.stop_reason;
     let finishReason;
     if (stopReason === "end_turn" || stopReason === "stop_sequence") {
@@ -3756,14 +3877,7 @@ var XAIProvider = class {
     return parts.join("\n").trim();
   }
   mapXAIUsage(usage) {
-    if (!usage) return void 0;
-    const input = usage.input_tokens ?? 0;
-    const output = usage.output_tokens ?? 0;
-    return {
-      promptTokens: input,
-      completionTokens: output,
-      totalTokens: usage.total_tokens ?? input + output
-    };
+    return normalizeLLMUsage(usage);
   }
   async parseXAIStream(response) {
     const text = await response.text();
@@ -4132,6 +4246,544 @@ var DeepSeekProvider = class {
   }
 };
 
+// src/providers/BedrockProvider.ts
+import {
+  BedrockRuntimeClient,
+  ConverseCommand
+} from "@aws-sdk/client-bedrock-runtime";
+import {
+  BedrockClient,
+  ListFoundationModelsCommand
+} from "@aws-sdk/client-bedrock";
+import { fromIni } from "@aws-sdk/credential-providers";
+var BEDROCK_DEFAULT_REGION = "us-east-1";
+var BEDROCK_DEFAULT_MODEL = "anthropic.claude-3-5-sonnet-20241022-v2:0";
+var BEDROCK_MODELS = [
+  BEDROCK_DEFAULT_MODEL,
+  "anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "anthropic.claude-sonnet-4-20250514-v1:0",
+  "amazon.nova-pro-v1:0",
+  "amazon.nova-lite-v1:0",
+  "meta.llama3-1-70b-instruct-v1:0",
+  "openai.gpt-oss-120b-1:0"
+];
+function resolveBedrockRegion(region) {
+  return region?.trim() || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || BEDROCK_DEFAULT_REGION;
+}
+function getBedrockRuntimeEndpoint(region) {
+  return `https://bedrock-runtime.${region}.amazonaws.com`;
+}
+function getBedrockOpenAIEndpoint(_mode, region) {
+  return `${getBedrockRuntimeEndpoint(region)}/openai/v1`;
+}
+function resolveBedrockEndpoint(mode, region, configuredEndpoint) {
+  if (configuredEndpoint?.trim()) {
+    return configuredEndpoint.replace(/\/+$/, "");
+  }
+  if (mode === "converse") {
+    return getBedrockRuntimeEndpoint(region);
+  }
+  return getBedrockOpenAIEndpoint(mode, region);
+}
+function resolveBedrockAuthMode(mode, configured) {
+  if (configured) return configured;
+  return mode === "converse" ? "aws-credentials" : "bedrock-api-key";
+}
+function parseToolArguments(argumentsJson) {
+  try {
+    return JSON.parse(argumentsJson);
+  } catch {
+    return {};
+  }
+}
+function toTextContent(content) {
+  return content ? [{ text: content }] : [];
+}
+function toToolUseBlocks(toolCalls) {
+  return toolCalls.map((toolCall) => ({
+    toolUse: {
+      toolUseId: toolCall.id,
+      name: toolCall.function.name,
+      input: parseToolArguments(toolCall.function.arguments)
+    }
+  }));
+}
+function toConverseMessage(message) {
+  if (message.role === "system") {
+    return null;
+  }
+  if (message.role === "tool") {
+    return {
+      role: "user",
+      content: [
+        {
+          toolResult: {
+            toolUseId: message.tool_call_id ?? message.name ?? "tool_result",
+            content: [{ text: message.content }]
+          }
+        }
+      ]
+    };
+  }
+  if (message.role === "assistant") {
+    const content = [
+      ...toTextContent(message.content),
+      ...message.tool_calls?.length ? toToolUseBlocks(message.tool_calls) : []
+    ];
+    return {
+      role: "assistant",
+      content: content.length > 0 ? content : [{ text: "" }]
+    };
+  }
+  return {
+    role: "user",
+    content: toTextContent(message.content)
+  };
+}
+function toOpenAIMessage(message) {
+  const mapped = {
+    role: message.role,
+    content: message.role === "assistant" && message.tool_calls?.length ? message.content || null : message.content
+  };
+  if (message.name) mapped.name = message.name;
+  if (message.role === "tool" && message.tool_call_id) {
+    mapped.tool_call_id = message.tool_call_id;
+  }
+  if (message.role === "assistant" && message.tool_calls?.length) {
+    mapped.tool_calls = message.tool_calls;
+  }
+  return mapped;
+}
+function toResponsesInputItem(message) {
+  if (message.role === "tool" && message.tool_call_id) {
+    return [
+      {
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: message.content
+      }
+    ];
+  }
+  if (message.role === "assistant" && message.tool_calls?.length) {
+    return message.tool_calls.map((toolCall) => ({
+      type: "function_call",
+      call_id: toolCall.id,
+      name: toolCall.function.name,
+      arguments: toolCall.function.arguments
+    }));
+  }
+  if (message.role === "system") {
+    return [];
+  }
+  const contentType = message.role === "assistant" ? "output_text" : "input_text";
+  return [
+    {
+      role: message.role,
+      content: [{ type: contentType, text: message.content }]
+    }
+  ];
+}
+function toOpenAITools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters ?? { type: "object", properties: {} }
+    }
+  }));
+}
+function toResponsesTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters ?? { type: "object", properties: {} }
+  }));
+}
+function toConverseTools(tools) {
+  return tools.map((tool) => ({
+    toolSpec: {
+      name: tool.name,
+      description: tool.description,
+      inputSchema: {
+        json: tool.parameters ?? { type: "object", properties: {} }
+      }
+    }
+  }));
+}
+function normalizeStopReason(stopReason) {
+  if (stopReason === "tool_use" || stopReason === "tool_calls") {
+    return "tool_calls";
+  }
+  if (stopReason === "max_tokens" || stopReason === "length") {
+    return "length";
+  }
+  if (stopReason === "content_filter") {
+    return "content_filter";
+  }
+  return "stop";
+}
+function toolCallsFromConverseBlocks(blocks) {
+  return blocks.filter(
+    (block) => "toolUse" in block && Boolean(block.toolUse)
+  ).map((block) => ({
+    id: block.toolUse.toolUseId,
+    type: "function",
+    function: {
+      name: block.toolUse.name,
+      arguments: JSON.stringify(block.toolUse.input ?? {})
+    }
+  }));
+}
+function textFromConverseBlocks(blocks) {
+  return blocks.filter((block) => "text" in block).map((block) => block.text).join("");
+}
+function isBedrockAwsError(error) {
+  return error instanceof Error;
+}
+function classifyBedrockError(error) {
+  if (!isBedrockAwsError(error)) {
+    return new ApiError(String(error), "unknown", 0, true);
+  }
+  if (error.name === "AbortError") {
+    return new ApiError("Request cancelled.", "cancelled", 0, false);
+  }
+  const status = error["$metadata"]?.httpStatusCode ?? 0;
+  const message = error.message || error.name;
+  const lower = `${error.name} ${message}`.toLowerCase();
+  let code;
+  if (lower.includes("credential") || lower.includes("signature") || lower.includes("unrecognizedclient") || lower.includes("expiredtoken")) {
+    code = "auth_failed";
+  } else if (lower.includes("accessdenied") || lower.includes("access denied") || lower.includes("not authorized") || lower.includes("model access")) {
+    code = "access_denied";
+  } else if (lower.includes("resourcenotfound") || lower.includes("model not found") || lower.includes("not found") || lower.includes("not available")) {
+    code = "model_not_found";
+  } else if (lower.includes("throttl") || lower.includes("quota") || lower.includes("toomanyrequests")) {
+    code = "rate_limited";
+  } else if (lower.includes("validation") || lower.includes("unsupported") || lower.includes("api mode")) {
+    code = "invalid_request";
+  } else if (lower.includes("network") || lower.includes("enotfound") || lower.includes("econn") || lower.includes("private endpoint")) {
+    code = "network_error";
+  }
+  if (code) {
+    const friendly = {
+      auth_failed: "AWS Bedrock credentials were not found or were rejected. Configure AWS credentials, AWS_PROFILE, instance metadata, or choose Bedrock API key auth.",
+      access_denied: "AWS Bedrock denied access. Enable model access in the AWS console and verify IAM permissions for this model.",
+      model_not_found: "The selected Bedrock model is not available in this region. Check the model ID, inference profile, ARN, and region.",
+      invalid_request: "Bedrock rejected the request. The selected model may not support this API mode or native tool use.",
+      rate_limited: "AWS Bedrock throttled the request or quota was exceeded. Wait and retry, or request a quota increase.",
+      network_error: "Unable to reach the AWS Bedrock endpoint. Check region, endpoint, private networking, and proxy settings.",
+      timeout: "The AWS Bedrock request timed out.",
+      cancelled: "Request cancelled.",
+      context_overflow: "The conversation is too long for this Bedrock model.",
+      payment_required: "AWS Bedrock billing or account setup is required.",
+      server_error: "AWS Bedrock encountered a service error. Please try again later.",
+      unknown: "AWS Bedrock returned an unexpected error."
+    };
+    return new ApiError(`${friendly[code]}
+${message}`, code, status, code === "rate_limited" || code === "server_error", void 0, message);
+  }
+  return classifyApiError(status, message);
+}
+async function readErrorBody(response) {
+  try {
+    return await response.text();
+  } catch {
+    return "";
+  }
+}
+var BedrockProvider = class {
+  apiMode;
+  authMode;
+  region;
+  endpoint;
+  profile;
+  apiKey;
+  model;
+  runtimeClient;
+  modelClient;
+  constructor(config) {
+    this.apiMode = config.apiMode ?? "converse";
+    this.authMode = resolveBedrockAuthMode(this.apiMode, config.authMode);
+    this.region = resolveBedrockRegion(config.region);
+    this.endpoint = resolveBedrockEndpoint(this.apiMode, this.region, config.endpoint);
+    this.profile = config.profile;
+    this.apiKey = config.apiKey;
+    this.model = config.model || BEDROCK_DEFAULT_MODEL;
+  }
+  getName() {
+    return "bedrock";
+  }
+  setModel(model) {
+    this.model = model;
+  }
+  getCapabilities() {
+    return { nativeToolCalling: true };
+  }
+  async listModels() {
+    if (this.apiMode !== "converse") {
+      return [...BEDROCK_MODELS];
+    }
+    try {
+      const response = await this.getModelClient().send(
+        new ListFoundationModelsCommand({})
+      );
+      const summaries = response.modelSummaries ?? [];
+      const modelIds = summaries.map((summary) => summary.modelId).filter((modelId) => Boolean(modelId));
+      return modelIds.length > 0 ? modelIds : [...BEDROCK_MODELS];
+    } catch {
+      return [...BEDROCK_MODELS];
+    }
+  }
+  async isAvailable() {
+    if (this.authMode === "bedrock-api-key") {
+      return Boolean(this.apiKey);
+    }
+    try {
+      await this.listModels();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async complete(request) {
+    if (!this.region) {
+      throw new ApiError(
+        "AWS Bedrock region is missing. Set bedrock.region, AWS_REGION, or AWS_DEFAULT_REGION.",
+        "invalid_request",
+        0,
+        false
+      );
+    }
+    if (this.apiMode === "converse") {
+      return this.completeWithConverse(request);
+    }
+    return this.completeWithOpenAICompatible(request);
+  }
+  getCredentials() {
+    if (this.profile) {
+      return fromIni({ profile: this.profile });
+    }
+    return void 0;
+  }
+  getRuntimeClient() {
+    if (!this.runtimeClient) {
+      this.runtimeClient = new BedrockRuntimeClient({
+        region: this.region,
+        endpoint: this.endpoint,
+        credentials: this.getCredentials()
+      });
+    }
+    return this.runtimeClient;
+  }
+  getModelClient() {
+    if (!this.modelClient) {
+      this.modelClient = new BedrockClient({
+        region: this.region,
+        credentials: this.getCredentials()
+      });
+    }
+    return this.modelClient;
+  }
+  async completeWithConverse(request) {
+    if (this.authMode === "bedrock-api-key") {
+      throw new ApiError(
+        "Bedrock Converse uses AWS credential-chain auth. Choose apiMode openai-chat/openai-responses to use Bedrock API keys.",
+        "invalid_request",
+        0,
+        false
+      );
+    }
+    const contentMessages = request.messages.map(toConverseMessage).filter((message) => message !== null);
+    const system = request.messages.filter((message) => message.role === "system" && message.content).map((message) => ({ text: message.content }));
+    const body = {
+      modelId: request.model ?? this.model,
+      messages: contentMessages,
+      inferenceConfig: {
+        ...request.maxTokens !== void 0 && { maxTokens: request.maxTokens },
+        ...request.temperature !== void 0 && { temperature: request.temperature }
+      }
+    };
+    if (system.length > 0) {
+      body.system = system;
+    }
+    if (request.tools?.length) {
+      body.toolConfig = {
+        tools: toConverseTools(request.tools),
+        ...request.toolChoice && request.toolChoice !== "auto" ? { toolChoice: this.toConverseToolChoice(request.toolChoice) } : {}
+      };
+    }
+    try {
+      const data = await this.getRuntimeClient().send(
+        new ConverseCommand(body)
+      );
+      const blocks = data.output?.message?.content ?? [];
+      const toolCalls = toolCallsFromConverseBlocks(blocks);
+      return {
+        id: `bedrock-${Date.now()}`,
+        created: Math.floor(Date.now() / 1e3),
+        content: textFromConverseBlocks(blocks),
+        ...toolCalls.length > 0 && { toolCalls },
+        finishReason: normalizeStopReason(data.stopReason),
+        usage: normalizeLLMUsage(data.usage),
+        raw: data
+      };
+    } catch (error) {
+      throw classifyBedrockError(error);
+    }
+  }
+  toConverseToolChoice(toolChoice) {
+    if (!toolChoice || toolChoice === "auto") return void 0;
+    if (toolChoice === "none") return { auto: {} };
+    if (toolChoice === "required") return { any: {} };
+    return { tool: { name: toolChoice.function.name } };
+  }
+  async completeWithOpenAICompatible(request) {
+    if (this.authMode !== "bedrock-api-key") {
+      throw new ApiError(
+        "Bedrock OpenAI-compatible modes require authMode bedrock-api-key and bedrock.apiKey.",
+        "auth_failed",
+        0,
+        false
+      );
+    }
+    if (!this.apiKey) {
+      throw new ApiError(
+        "Bedrock API key is missing. Set bedrock.apiKey for OpenAI-compatible Bedrock modes.",
+        "auth_failed",
+        0,
+        false
+      );
+    }
+    if (this.apiMode === "openai-chat") {
+      return this.completeWithOpenAIChat(request);
+    }
+    return this.completeWithOpenAIResponses(request);
+  }
+  async completeWithOpenAIChat(request) {
+    const body = {
+      model: request.model ?? this.model,
+      messages: request.messages.map(toOpenAIMessage),
+      ...request.temperature !== void 0 && { temperature: request.temperature },
+      ...request.maxTokens !== void 0 && { max_tokens: request.maxTokens }
+    };
+    if (request.tools?.length) {
+      body.tools = toOpenAITools(request.tools);
+      if (request.toolChoice) body.tool_choice = request.toolChoice;
+    }
+    const data = await this.fetchJson("/chat/completions", body, request.signal);
+    const choice = data.choices?.[0];
+    if (!choice?.message) {
+      throw new ApiError(
+        "Malformed Bedrock OpenAI chat response: missing choice message.",
+        "invalid_request",
+        200,
+        false,
+        void 0,
+        JSON.stringify(data)
+      );
+    }
+    return {
+      id: data.id ?? `bedrock-chat-${Date.now()}`,
+      created: data.created ?? Math.floor(Date.now() / 1e3),
+      content: choice.message.content ?? "",
+      ...choice.message.tool_calls?.length && { toolCalls: choice.message.tool_calls },
+      finishReason: normalizeStopReason(choice.finish_reason),
+      usage: normalizeLLMUsage(data.usage),
+      raw: data
+    };
+  }
+  async completeWithOpenAIResponses(request) {
+    const instructions = request.messages.filter((message) => message.role === "system").map((message) => message.content).join("\n\n");
+    const body = {
+      model: request.model ?? this.model,
+      input: request.messages.flatMap(toResponsesInputItem),
+      ...instructions && { instructions },
+      ...request.maxTokens !== void 0 && { max_output_tokens: request.maxTokens }
+    };
+    if (request.tools?.length) {
+      body.tools = toResponsesTools(request.tools);
+      if (request.toolChoice) body.tool_choice = request.toolChoice;
+    }
+    const data = await this.fetchJson("/responses", body, request.signal);
+    const functionCalls = (data.output ?? []).filter(
+      (item) => item.type === "function_call" && typeof item.name === "string" && typeof item.arguments === "string"
+    ).map((item) => ({
+      id: item.call_id ?? item.id ?? `call_${Date.now()}`,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments: item.arguments
+      }
+    }));
+    return {
+      id: data.id ?? `bedrock-responses-${Date.now()}`,
+      created: data.created_at ?? Math.floor(Date.now() / 1e3),
+      content: data.output_text ?? "",
+      ...functionCalls.length > 0 && { toolCalls: functionCalls },
+      finishReason: functionCalls.length > 0 ? "tool_calls" : "stop",
+      usage: normalizeLLMUsage(data.usage),
+      raw: data
+    };
+  }
+  async fetchJson(path, body, signal) {
+    let response;
+    try {
+      response = await fetch(`${this.endpoint}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(body),
+        signal
+      });
+    } catch (error) {
+      const err = error;
+      if (err.name === "AbortError" && signal?.aborted) {
+        throw new ApiError("Request cancelled.", "cancelled", 0, false);
+      }
+      if (err.name === "AbortError") {
+        throw new ApiError("The Bedrock request timed out.", "timeout", 0, true);
+      }
+      throw new ApiError(
+        "Unable to connect to the Bedrock OpenAI-compatible endpoint. Check region, endpoint, private networking, and proxy settings.",
+        "network_error",
+        0,
+        true,
+        void 0,
+        err.message
+      );
+    }
+    if (!response.ok) {
+      const errorBody = await readErrorBody(response);
+      const classified = classifyApiError(response.status, errorBody, response.headers);
+      throw new ApiError(
+        `AWS Bedrock request failed.
+${classified.message}`,
+        classified.code,
+        classified.httpStatus,
+        classified.retryable,
+        classified.retryAfterMs,
+        classified.rawDetail
+      );
+    }
+    try {
+      return await response.json();
+    } catch (error) {
+      throw new ApiError(
+        "Malformed Bedrock response: response body was not valid JSON.",
+        "invalid_request",
+        response.status,
+        false,
+        void 0,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+};
+
 // src/providers/ProviderFactory.ts
 var ProviderNotConfiguredError = class extends Error {
   constructor(providerName) {
@@ -4169,6 +4821,9 @@ var ProviderFactory = class {
    */
   static create(config) {
     const providerName = config.provider || "openrouter";
+    if (providerName === "bedrock" && !isAwsBedrockProviderEnabled(config)) {
+      return new UnconfiguredProvider("bedrock");
+    }
     switch (providerName) {
       case "ollama":
         if (!config.ollama) {
@@ -4230,6 +4885,11 @@ var ProviderFactory = class {
           return new UnconfiguredProvider("deepseek");
         }
         return new DeepSeekProvider(config.deepseek, config.network);
+      case "bedrock":
+        if (!config.bedrock) {
+          return new UnconfiguredProvider("bedrock");
+        }
+        return new BedrockProvider(config.bedrock);
       case "openrouter":
       default:
         if (!config.openrouter) {
@@ -4242,8 +4902,11 @@ var ProviderFactory = class {
    * Get all available provider names.
    * MLX is only included on Apple Silicon (macOS + arm64).
    */
-  static getProviderNames() {
+  static getProviderNames(config) {
     const providers = ["zai", "xai", "vertexai", "nvidia", "openrouter", "openai", "ollama", "llmgateway", "llamacpp", "deepseek", "cerebras", "azure"];
+    if (isAwsBedrockProviderEnabled(config)) {
+      providers.splice(providers.indexOf("azure"), 0, "bedrock");
+    }
     if (isMLXSupported()) {
       providers.push("mlx");
     }
@@ -4254,8 +4917,11 @@ var ProviderFactory = class {
    * Note: This checks if the name is a valid provider type, not if it's available on this platform.
    * MLX is always a valid provider name, but may not be available on non-Apple Silicon systems.
    */
-  static isValidProvider(name) {
-    const allProviders = ["openrouter", "ollama", "openai", "llamacpp", "mlx", "llmgateway", "azure", "zai", "vertexai", "xai", "cerebras", "nvidia", "deepseek"];
+  static isValidProvider(name, config) {
+    if (name === "bedrock" && !isAwsBedrockProviderEnabled(config)) {
+      return false;
+    }
+    const allProviders = ["openrouter", "ollama", "openai", "llamacpp", "mlx", "llmgateway", "azure", "zai", "vertexai", "xai", "cerebras", "nvidia", "deepseek", "bedrock"];
     return allProviders.includes(name);
   }
 };
@@ -4277,6 +4943,11 @@ export {
   CEREBRAS_MODELS,
   DEEPSEEK_DEFAULT_BASE_URL,
   DEEPSEEK_MODELS,
+  BEDROCK_DEFAULT_REGION,
+  BEDROCK_DEFAULT_MODEL,
+  BEDROCK_MODELS,
+  resolveBedrockEndpoint,
+  resolveBedrockAuthMode,
   ProviderNotConfiguredError,
   ProviderFactory
 };
@@ -4289,3 +4960,8 @@ export {
  * Google Cloud CLI authentication utilities
  * @license Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */