@humain/terminal 0.0.3-beta.2 → 0.0.3-beta.3

package/dist/humain/bedrock-provider/vendor/index.bundle.mjs

@@ -0,0 +1,1509 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// packages/ai/src/api/bedrock-converse-stream.ts
+import {
+  BedrockRuntimeClient,
+  BedrockRuntimeServiceException,
+  StopReason as BedrockStopReason,
+  CachePointType,
+  CacheTTL,
+  ConversationRole,
+  ConverseStreamCommand,
+  ImageFormat,
+  ToolResultStatus
+} from "@aws-sdk/client-bedrock-runtime";
+import { NodeHttpHandler } from "@smithy/node-http-handler";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+
+// packages/ai/src/utils/event-stream.ts
+var EventStream = class {
+  constructor(isComplete, extractResult) {
+    this.queue = [];
+    this.waiting = [];
+    this.done = false;
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+    this.finalResultPromise = new Promise((resolve) => {
+      this.resolveFinalResult = resolve;
+    });
+  }
+  push(event) {
+    if (this.done) return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.resolveFinalResult(this.extractResult(event));
+    }
+    const waiter = this.waiting.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+    } else {
+      this.queue.push(event);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== void 0) {
+      this.resolveFinalResult(result);
+    }
+    while (this.waiting.length > 0) {
+      const waiter = this.waiting.shift();
+      waiter({ value: void 0, done: true });
+    }
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.queue.length > 0) {
+        yield this.queue.shift();
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve) => this.waiting.push(resolve));
+        if (result.done) return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResultPromise;
+  }
+};
+var AssistantMessageEventStream = class extends EventStream {
+  constructor() {
+    super(
+      (event) => event.type === "done" || event.type === "error",
+      (event) => {
+        if (event.type === "done") {
+          return event.message;
+        } else if (event.type === "error") {
+          return event.error;
+        }
+        throw new Error("Unexpected event type for final result");
+      }
+    );
+  }
+};
+
+// packages/ai/src/utils/diagnostics.ts
+function appendAssistantMessageDiagnostic(message, diagnostic) {
+  message.diagnostics = [...message.diagnostics ?? [], diagnostic];
+}
+
+// packages/ai/src/models.ts
+function calculateCost(model, usage) {
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+  let rates = model.cost;
+  let matchedThreshold = -1;
+  for (const tier of model.cost.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      rates = tier;
+      matchedThreshold = tier.inputTokensAbove;
+    }
+  }
+  const longWrite = usage.cacheWrite1h ?? 0;
+  const shortWrite = usage.cacheWrite - longWrite;
+  usage.cost.input = rates.input / 1e6 * usage.input;
+  usage.cost.output = rates.output / 1e6 * usage.output;
+  usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+  usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage.cost;
+}
+
+// packages/ai/src/utils/error-body.ts
+var MAX_PROVIDER_ERROR_BODY_CHARS = 4e3;
+function normalizeProviderError(error) {
+  if (!(error instanceof Error)) {
+    return { message: safeJsonStringify(error), messageCarriesBody: false };
+  }
+  const sdkError = error;
+  const status = extractStatus(sdkError);
+  const body = extractBody(sdkError);
+  const messageCarriesBody = body === void 0 || error.message.includes(body);
+  return {
+    status,
+    body,
+    message: error.message,
+    messageCarriesBody
+  };
+}
+function extractStatus(error) {
+  if (typeof error.statusCode === "number") return error.statusCode;
+  if (typeof error.status === "number") return error.status;
+  if (typeof error.$metadata?.httpStatusCode === "number") return error.$metadata.httpStatusCode;
+  if (typeof error.$response?.statusCode === "number") return error.$response.statusCode;
+  return void 0;
+}
+function extractBody(error) {
+  const bodyText = pickBodyText(error);
+  if (bodyText === void 0) return void 0;
+  const trimmed = bodyText.trim();
+  if (trimmed.length === 0) return void 0;
+  return truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS);
+}
+function pickBodyText(error) {
+  if (typeof error.body === "string") return error.body;
+  if (isPlainNonEmptyObject(error.error)) return safeJsonStringify(error.error);
+  const responseBody = error.$response?.body;
+  if (typeof responseBody === "string") return responseBody;
+  if (isReadableStreamLike(responseBody)) return void 0;
+  if (isPlainNonEmptyObject(responseBody)) return safeJsonStringify(responseBody);
+  return void 0;
+}
+function isReadableStreamLike(value) {
+  return typeof value === "object" && value !== null && "pipe" in value && typeof value.pipe === "function";
+}
+function isPlainNonEmptyObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) return false;
+  return Object.keys(value).length > 0;
+}
+function truncateErrorText(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function safeJsonStringify(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+// packages/ai/src/utils/headers.ts
+function providerHeadersToRecord(headers) {
+  if (!headers) return void 0;
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== null) result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// packages/ai/src/utils/json-parse.ts
+import { parse as partialParse } from "partial-json";
+var VALID_JSON_ESCAPES = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function isControlCharacter(char) {
+  const codePoint = char.codePointAt(0);
+  return codePoint !== void 0 && codePoint >= 0 && codePoint <= 31;
+}
+function escapeControlCharacter(char) {
+  switch (char) {
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      return "\\t";
+    default:
+      return `\\u${char.codePointAt(0)?.toString(16).padStart(4, "0") ?? "0000"}`;
+  }
+}
+function repairJson(json) {
+  let repaired = "";
+  let inString = false;
+  for (let index = 0; index < json.length; index++) {
+    const char = json[index];
+    if (!inString) {
+      repaired += char;
+      if (char === '"') {
+        inString = true;
+      }
+      continue;
+    }
+    if (char === '"') {
+      repaired += char;
+      inString = false;
+      continue;
+    }
+    if (char === "\\") {
+      const nextChar = json[index + 1];
+      if (nextChar === void 0) {
+        repaired += "\\\\";
+        continue;
+      }
+      if (nextChar === "u") {
+        const unicodeDigits = json.slice(index + 2, index + 6);
+        if (/^[0-9a-fA-F]{4}$/.test(unicodeDigits)) {
+          repaired += `\\u${unicodeDigits}`;
+          index += 5;
+          continue;
+        }
+      }
+      if (VALID_JSON_ESCAPES.has(nextChar)) {
+        repaired += `\\${nextChar}`;
+        index += 1;
+        continue;
+      }
+      repaired += "\\\\";
+      continue;
+    }
+    repaired += isControlCharacter(char) ? escapeControlCharacter(char) : char;
+  }
+  return repaired;
+}
+function parseJsonWithRepair(json) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    const repairedJson = repairJson(json);
+    if (repairedJson !== json) {
+      return JSON.parse(repairedJson);
+    }
+    throw error;
+  }
+}
+function parseStreamingJson(partialJson) {
+  if (!partialJson || partialJson.trim() === "") {
+    return {};
+  }
+  try {
+    return parseJsonWithRepair(partialJson);
+  } catch {
+    try {
+      const result = partialParse(partialJson);
+      return result ?? {};
+    } catch {
+      try {
+        const result = partialParse(repairJson(partialJson));
+        return result ?? {};
+      } catch {
+        return {};
+      }
+    }
+  }
+}
+
+// packages/ai/src/utils/provider-env.ts
+var procEnvCache = null;
+function getBunSandboxEnvValue(name) {
+  if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) {
+    return void 0;
+  }
+  if (procEnvCache === null) {
+    procEnvCache = /* @__PURE__ */ new Map();
+    try {
+      const { readFileSync } = __require("node:fs");
+      const data = readFileSync("/proc/self/environ", "utf-8");
+      for (const entry of data.split("\0")) {
+        const idx = entry.indexOf("=");
+        if (idx > 0) {
+          procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));
+        }
+      }
+    } catch {
+    }
+  }
+  return procEnvCache.get(name);
+}
+function getProviderEnvValue(name, env) {
+  return env?.[name] || (typeof process !== "undefined" ? process.env[name] : void 0) || getBunSandboxEnvValue(name) || void 0;
+}
+
+// packages/ai/src/utils/node-http-proxy.ts
+var DEFAULT_PROXY_PORTS = {
+  ftp: 21,
+  gopher: 70,
+  http: 80,
+  https: 443,
+  ws: 80,
+  wss: 443
+};
+function getProxyEnv(key, env) {
+  const lowercaseKey = key.toLowerCase();
+  const uppercaseKey = key.toUpperCase();
+  return env?.[lowercaseKey] || env?.[uppercaseKey] || getProviderEnvValue(lowercaseKey) || getProviderEnvValue(uppercaseKey) || "";
+}
+function parseProxyTargetUrl(targetUrl) {
+  if (targetUrl instanceof URL) {
+    return targetUrl;
+  }
+  try {
+    return new URL(targetUrl);
+  } catch {
+    return void 0;
+  }
+}
+function shouldProxyHostname(hostname, port, env) {
+  const noProxy = getProxyEnv("no_proxy", env).toLowerCase();
+  if (!noProxy) {
+    return true;
+  }
+  if (noProxy === "*") {
+    return false;
+  }
+  return noProxy.split(/[,\s]/).every((proxy) => {
+    if (!proxy) {
+      return true;
+    }
+    const parsedProxy = proxy.match(/^(.+):(\d+)$/);
+    let proxyHostname = parsedProxy ? parsedProxy[1] : proxy;
+    const proxyPort = parsedProxy ? Number.parseInt(parsedProxy[2], 10) : 0;
+    if (proxyPort && proxyPort !== port) {
+      return true;
+    }
+    if (!/^[.*]/.test(proxyHostname)) {
+      return hostname !== proxyHostname;
+    }
+    if (proxyHostname.startsWith("*")) {
+      proxyHostname = proxyHostname.slice(1);
+    }
+    return !hostname.endsWith(proxyHostname);
+  });
+}
+function getProxyForUrl(targetUrl, env) {
+  const parsedUrl = parseProxyTargetUrl(targetUrl);
+  if (!parsedUrl?.protocol || !parsedUrl.host) {
+    return "";
+  }
+  const protocol = parsedUrl.protocol.split(":", 1)[0];
+  const hostname = parsedUrl.host.replace(/:\d*$/, "");
+  const port = Number.parseInt(parsedUrl.port, 10) || DEFAULT_PROXY_PORTS[protocol] || 0;
+  if (!shouldProxyHostname(hostname, port, env)) {
+    return "";
+  }
+  let proxy = getProxyEnv(`${protocol}_proxy`, env) || getProxyEnv("all_proxy", env);
+  if (proxy && !proxy.includes("://")) {
+    proxy = `${protocol}://${proxy}`;
+  }
+  return proxy;
+}
+var UNSUPPORTED_PROXY_PROTOCOL_MESSAGE = "Unsupported proxy protocol. SOCKS and PAC proxy URLs are not supported; use an HTTP or HTTPS proxy URL.";
+function resolveHttpProxyUrlForTarget(targetUrl, env) {
+  const proxy = getProxyForUrl(targetUrl, env);
+  if (!proxy) {
+    return void 0;
+  }
+  let proxyUrl;
+  try {
+    proxyUrl = new URL(proxy);
+  } catch (error) {
+    throw new Error(
+      `Invalid proxy URL ${JSON.stringify(proxy)}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (proxyUrl.protocol !== "http:" && proxyUrl.protocol !== "https:") {
+    throw new Error(`${UNSUPPORTED_PROXY_PROTOCOL_MESSAGE} Got ${proxyUrl.protocol}`);
+  }
+  return proxyUrl;
+}
+
+// packages/ai/src/utils/sanitize-unicode.ts
+function sanitizeSurrogates(text) {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+// packages/ai/src/api/constrained-sampling.ts
+function resolveJsonSchemaStrictSampling(tool, supportsStrictMode) {
+  const config = tool.constrainedSampling;
+  if (!config || config.type !== "json_schema") {
+    return void 0;
+  }
+  if (supportsStrictMode) {
+    return true;
+  }
+  if (config.strict === "require") {
+    throw new Error(
+      `Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`
+    );
+  }
+  return void 0;
+}
+
+// packages/ai/src/utils/estimate.ts
+var CHARS_PER_TOKEN = 4;
+var ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify2(value) {
+  try {
+    return JSON.stringify(value) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+function estimateTextAndImageContentChars(content) {
+  if (typeof content === "string") return content.length;
+  let chars = 0;
+  for (const block of content) chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+  return chars;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTextAndImageContentTokens(content) {
+  return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(message) {
+  let chars = 0;
+  if (message.role === "user") return estimateTextAndImageContentTokens(message.content);
+  if (message.role === "toolResult") return estimateTextAndImageContentTokens(message.content);
+  for (const block of message.content) {
+    if (block.type === "text") {
+      chars += block.text.length;
+    } else if (block.type === "thinking") {
+      chars += block.thinking.length;
+    } else {
+      chars += block.name.length + safeJsonStringify2(block.arguments).length;
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function getLastAssistantUsageInfo(messages) {
+  let latestPrefixTimestamp = Number.NEGATIVE_INFINITY;
+  let usageInfo;
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role === "assistant") {
+      const assistant = message;
+      const usageAppliesToPrefix = assistant.timestamp >= latestPrefixTimestamp;
+      if (usageAppliesToPrefix && assistant.stopReason !== "aborted" && assistant.stopReason !== "error" && calculateContextTokens(assistant.usage) > 0) {
+        usageInfo = { usage: assistant.usage, index: i };
+      }
+    }
+    latestPrefixTimestamp = Math.max(latestPrefixTimestamp, message.timestamp);
+  }
+  return usageInfo;
+}
+function estimateMessages(messages) {
+  const usageInfo = getLastAssistantUsageInfo(messages);
+  if (usageInfo) {
+    const usageTokens = calculateContextTokens(usageInfo.usage);
+    let trailingTokens = 0;
+    for (let i = usageInfo.index + 1; i < messages.length; i++) {
+      trailingTokens += estimateMessageTokens(messages[i]);
+    }
+    return { tokens: usageTokens + trailingTokens, usageTokens, trailingTokens, lastUsageIndex: usageInfo.index };
+  }
+  let tokens = 0;
+  for (const message of messages) tokens += estimateMessageTokens(message);
+  return { tokens, usageTokens: 0, trailingTokens: tokens, lastUsageIndex: null };
+}
+function estimateToolsTokens(tools) {
+  if (!tools || tools.length === 0) return 0;
+  return estimateTextTokens(safeJsonStringify2(tools));
+}
+function isMessageArray(value) {
+  return Array.isArray(value);
+}
+function estimateContextTokens(context) {
+  if (isMessageArray(context)) return estimateMessages(context);
+  const estimate = estimateMessages(context.messages);
+  if (estimate.lastUsageIndex !== null) {
+    const addedNames = new Set(
+      context.messages.slice(estimate.lastUsageIndex + 1).filter((message) => message.role === "toolResult").flatMap((message) => message.addedToolNames ?? [])
+    );
+    const addedToolTokens = estimateToolsTokens(context.tools?.filter((tool) => addedNames.has(tool.name)));
+    return {
+      tokens: estimate.tokens + addedToolTokens,
+      usageTokens: estimate.usageTokens,
+      trailingTokens: estimate.trailingTokens + addedToolTokens,
+      lastUsageIndex: estimate.lastUsageIndex
+    };
+  }
+  const prefixTokens = (context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+  return {
+    tokens: estimate.tokens + prefixTokens,
+    usageTokens: estimate.usageTokens,
+    trailingTokens: estimate.trailingTokens + prefixTokens,
+    lastUsageIndex: estimate.lastUsageIndex
+  };
+}
+
+// packages/ai/src/api/simple-options.ts
+var CONTEXT_SAFETY_TOKENS = 4096;
+var MIN_MAX_TOKENS = 1;
+function clampMaxTokensToContext(model, context, maxTokens) {
+  if (model.contextWindow <= 0) return Math.max(MIN_MAX_TOKENS, maxTokens);
+  const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;
+  return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+function buildBaseOptions(model, context, options, apiKey) {
+  const samplingParams = model.samplingParams || options?.samplingParams ? { ...model.samplingParams, ...options?.samplingParams } : void 0;
+  return {
+    temperature: options?.temperature,
+    samplingParams,
+    maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
+    signal: options?.signal,
+    telemetryContext: options?.telemetryContext,
+    apiKey: apiKey || options?.apiKey,
+    fetch: options?.fetch,
+    transport: options?.transport,
+    cacheRetention: options?.cacheRetention,
+    sessionId: options?.sessionId,
+    headers: options?.headers,
+    onPayload: options?.onPayload,
+    onResponse: options?.onResponse,
+    timeoutMs: options?.timeoutMs,
+    websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    metadata: options?.metadata,
+    env: options?.env
+  };
+}
+var MIN_ANSWER_TOKENS = 1024;
+function clampReasoning(effort) {
+  return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+  const defaultBudgets = {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384
+  };
+  const budgets = { ...defaultBudgets, ...customBudgets };
+  const level = clampReasoning(reasoningLevel);
+  let thinkingBudget = budgets[level];
+  const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+  if (maxTokens <= thinkingBudget) {
+    thinkingBudget = Math.max(0, maxTokens - MIN_ANSWER_TOKENS);
+  }
+  return { maxTokens, thinkingBudget };
+}
+
+// packages/ai/src/api/transform-messages.ts
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+  const result = [];
+  let previousWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!previousWasPlaceholder) {
+        result.push({ type: "text", text: placeholder });
+      }
+      previousWasPlaceholder = true;
+      continue;
+    }
+    result.push(block);
+    previousWasPlaceholder = block.text === placeholder;
+  }
+  return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+  if (model.input.includes("image")) {
+    return messages;
+  }
+  return messages.map((msg) => {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+      };
+    }
+    if (msg.role === "toolResult") {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+      };
+    }
+    return msg;
+  });
+}
+function transformMessages(messages, model, normalizeToolCallId2) {
+  const toolCallIdMap = /* @__PURE__ */ new Map();
+  const normalizedMessages = messages.map((msg) => msg.content == null ? { ...msg, content: [] } : msg);
+  const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
+  const transformed = imageAwareMessages.map((msg) => {
+    if (msg.role === "user") {
+      return msg;
+    }
+    if (msg.role === "toolResult") {
+      const normalizedId = toolCallIdMap.get(msg.toolCallId);
+      if (normalizedId && normalizedId !== msg.toolCallId) {
+        return { ...msg, toolCallId: normalizedId };
+      }
+      return msg;
+    }
+    if (msg.role === "assistant") {
+      const assistantMsg = msg;
+      const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+      const transformedContent = assistantMsg.content.flatMap((block) => {
+        if (block.type === "thinking") {
+          if (block.redacted) {
+            return isSameModel ? block : [];
+          }
+          if (isSameModel && block.thinkingSignature) return block;
+          if (!block.thinking || block.thinking.trim() === "") return [];
+          if (isSameModel) return block;
+          return {
+            type: "text",
+            text: block.thinking
+          };
+        }
+        if (block.type === "text") {
+          if (isSameModel) return block;
+          return {
+            type: "text",
+            text: block.text
+          };
+        }
+        if (block.type === "toolCall") {
+          const toolCall = block;
+          let normalizedToolCall = toolCall;
+          if (!isSameModel && toolCall.thoughtSignature) {
+            normalizedToolCall = { ...toolCall };
+            delete normalizedToolCall.thoughtSignature;
+          }
+          if (!isSameModel && normalizeToolCallId2) {
+            const normalizedId = normalizeToolCallId2(toolCall.id, model, assistantMsg);
+            if (normalizedId !== toolCall.id) {
+              toolCallIdMap.set(toolCall.id, normalizedId);
+              normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+            }
+          }
+          return normalizedToolCall;
+        }
+        return block;
+      });
+      return {
+        ...assistantMsg,
+        content: transformedContent
+      };
+    }
+    return msg;
+  });
+  const result = [];
+  let pendingToolCalls = [];
+  let existingToolResultIds = /* @__PURE__ */ new Set();
+  const insertSyntheticToolResults = () => {
+    if (pendingToolCalls.length > 0) {
+      for (const tc of pendingToolCalls) {
+        if (!existingToolResultIds.has(tc.id)) {
+          result.push({
+            role: "toolResult",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            content: [{ type: "text", text: "No result provided" }],
+            isError: true,
+            timestamp: Date.now()
+          });
+        }
+      }
+      pendingToolCalls = [];
+      existingToolResultIds = /* @__PURE__ */ new Set();
+    }
+  };
+  for (let i = 0; i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      insertSyntheticToolResults();
+      const assistantMsg = msg;
+      if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+        continue;
+      }
+      const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        pendingToolCalls = toolCalls;
+        existingToolResultIds = /* @__PURE__ */ new Set();
+      }
+      result.push(msg);
+    } else if (msg.role === "toolResult") {
+      existingToolResultIds.add(msg.toolCallId);
+      result.push(msg);
+    } else if (msg.role === "user") {
+      insertSyntheticToolResults();
+      result.push(msg);
+    } else {
+      result.push(msg);
+    }
+  }
+  insertSyntheticToolResults();
+  return result;
+}
+
+// packages/ai/src/api/bedrock-converse-stream.ts
+var EMPTY_TEXT_PLACEHOLDER = "<empty>";
+var stream = (model, context, options = {}) => {
+  const stream2 = new AssistantMessageEventStream();
+  (async () => {
+    const output = {
+      role: "assistant",
+      content: [],
+      api: "bedrock-converse-stream",
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+      },
+      stopReason: "pending",
+      timestamp: Date.now()
+    };
+    const blocks = output.content;
+    const optionsProfile = options.profile || options.env?.AWS_PROFILE;
+    const config = {
+      profile: optionsProfile || getProviderEnvValue("AWS_PROFILE", options.env)
+    };
+    const configuredRegion = getConfiguredBedrockRegion(options);
+    const hasAmbientConfiguredProfile = Boolean(getProviderEnvValue("AWS_PROFILE"));
+    const endpointRegion = getStandardBedrockEndpointRegion(model.baseUrl);
+    const useExplicitEndpoint = shouldUseExplicitBedrockEndpoint(
+      model.baseUrl,
+      configuredRegion,
+      hasAmbientConfiguredProfile
+    );
+    if (useExplicitEndpoint) {
+      config.endpoint = model.baseUrl;
+    }
+    const skipAuth = getProviderEnvValue("AWS_BEDROCK_SKIP_AUTH", options.env) === "1";
+    const bearerToken = options.bearerToken || options.apiKey || getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK", options.env) || void 0;
+    const useBearerToken = bearerToken !== void 0 && !skipAuth;
+    if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+      const arnRegionMatch = model.id.match(/^arn:aws(?:-[a-z0-9-]+)?:bedrock:([a-z0-9-]+):/);
+      if (arnRegionMatch) {
+        config.region = arnRegionMatch[1];
+      } else if (configuredRegion) {
+        config.region = configuredRegion;
+      } else if (endpointRegion && useExplicitEndpoint) {
+        config.region = endpointRegion;
+      } else if (!hasAmbientConfiguredProfile) {
+        config.region = "us-east-1";
+      }
+      if (skipAuth) {
+        config.credentials = {
+          accessKeyId: "dummy-access-key",
+          secretAccessKey: "dummy-secret-key"
+        };
+      }
+      const credentials = getConfiguredBedrockCredentials(options.env);
+      if (!skipAuth && credentials && !optionsProfile) {
+        config.credentials = credentials;
+      }
+      const proxyUrl = shouldBypassBedrockProxy(model.baseUrl) ? void 0 : resolveHttpProxyUrlForTarget(model.baseUrl, options.env);
+      if (proxyUrl) {
+        config.requestHandler = new NodeHttpHandler({
+          httpAgent: new HttpProxyAgent(proxyUrl),
+          httpsAgent: new HttpsProxyAgent(proxyUrl)
+        });
+      } else if (shouldUseBedrockHttp1Handler(model.baseUrl, options.env)) {
+        config.requestHandler = new NodeHttpHandler();
+      }
+    } else {
+      config.region = configuredRegion || (endpointRegion && useExplicitEndpoint ? endpointRegion : void 0) || "us-east-1";
+    }
+    if (useBearerToken) {
+      config.token = { token: bearerToken };
+      config.authSchemePreference = ["httpBearerAuth"];
+    }
+    let responseRequestId;
+    let client;
+    try {
+      client = new BedrockRuntimeClient(config);
+      const customHeaders = providerHeadersToRecord(options.headers);
+      if (customHeaders) {
+        addCustomHeadersMiddleware(client, customHeaders);
+      }
+      const cacheRetention = resolveCacheRetention(options.cacheRetention, options.env);
+      const inferenceMaxTokens = options.maxTokens ?? (isAnthropicClaudeModel(model) ? model.maxTokens : void 0);
+      let commandInput = {
+        modelId: model.id,
+        messages: convertMessages(context, model, cacheRetention, options.env),
+        system: buildSystemPrompt(context.systemPrompt, model, cacheRetention, options.env),
+        inferenceConfig: {
+          ...inferenceMaxTokens !== void 0 && { maxTokens: inferenceMaxTokens },
+          ...options.temperature !== void 0 && { temperature: options.temperature }
+        },
+        toolConfig: convertToolConfig(context.tools, options.toolChoice, model.compat?.supportsStrictMode ?? false),
+        additionalModelRequestFields: buildAdditionalModelRequestFields(model, options),
+        ...options.requestMetadata !== void 0 && { requestMetadata: options.requestMetadata }
+      };
+      const nextCommandInput = await options?.onPayload?.(commandInput, model);
+      if (nextCommandInput !== void 0) {
+        commandInput = nextCommandInput;
+      }
+      const command = new ConverseStreamCommand(commandInput);
+      const response = await client.send(command, { abortSignal: options.signal });
+      responseRequestId = normalizeDiagnosticValue(response.$metadata.requestId);
+      if (response.$metadata.httpStatusCode !== void 0) {
+        const responseHeaders = {};
+        if (response.$metadata.requestId) {
+          responseHeaders["x-amzn-requestid"] = response.$metadata.requestId;
+        }
+        await options?.onResponse?.({ status: response.$metadata.httpStatusCode, headers: responseHeaders }, model);
+      }
+      for await (const item of response.stream) {
+        if (item.messageStart) {
+          if (item.messageStart.role !== ConversationRole.ASSISTANT) {
+            throw new Error("Unexpected assistant message start but got user message start instead");
+          }
+          stream2.push({ type: "start", partial: output });
+        } else if (item.contentBlockStart) {
+          handleContentBlockStart(item.contentBlockStart, blocks, output, stream2);
+        } else if (item.contentBlockDelta) {
+          handleContentBlockDelta(item.contentBlockDelta, blocks, output, stream2);
+        } else if (item.contentBlockStop) {
+          handleContentBlockStop(item.contentBlockStop, blocks, output, stream2);
+        } else if (item.messageStop) {
+          output.rawStopReason = item.messageStop.stopReason;
+          const { stopReason, errorMessage } = mapStopReason(item.messageStop.stopReason);
+          output.stopReason = stopReason;
+          if (errorMessage) {
+            output.errorMessage = errorMessage;
+          }
+        } else if (item.metadata) {
+          handleMetadata(item.metadata, model, output);
+        } else if (item.internalServerException) {
+          throw item.internalServerException;
+        } else if (item.modelStreamErrorException) {
+          throw item.modelStreamErrorException;
+        } else if (item.validationException) {
+          throw item.validationException;
+        } else if (item.throttlingException) {
+          throw item.throttlingException;
+        } else if (item.serviceUnavailableException) {
+          throw item.serviceUnavailableException;
+        }
+      }
+      if (options.signal?.aborted) {
+        throw new Error("Request was aborted");
+      }
+      if (output.stopReason === "pending") {
+        throw new Error("Bedrock stream ended without a stop reason");
+      }
+      if (output.stopReason === "error" || output.stopReason === "aborted") {
+        throw new Error(output.errorMessage || "An unknown error occurred");
+      }
+      stream2.push({ type: "done", reason: output.stopReason, message: output });
+      stream2.end();
+    } catch (error) {
+      for (const block of output.content) {
+        delete block.index;
+        delete block.partialJson;
+      }
+      output.stopReason = options.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = formatBedrockError(error);
+      if (output.stopReason === "error") {
+        appendBedrockFailureDiagnostic(output, error, responseRequestId);
+      }
+      stream2.push({ type: "error", reason: output.stopReason, error: output });
+      stream2.end();
+    } finally {
+      client?.destroy?.();
+    }
+  })();
+  return stream2;
+};
+var BEDROCK_ERROR_PREFIXES = {
+  InternalServerException: "Internal server error",
+  ModelStreamErrorException: "Model stream error",
+  ValidationException: "Validation error",
+  ThrottlingException: "Throttling error",
+  ServiceUnavailableException: "Service unavailable"
+};
+var BEDROCK_DATA_RETENTION_DOCS_URL = "https://docs.aws.amazon.com/bedrock/latest/userguide/data-retention.html";
+function formatBedrockError(error) {
+  const norm = normalizeProviderError(error);
+  const core = !norm.messageCarriesBody && norm.status !== void 0 && norm.body !== void 0 ? `${norm.status}: ${norm.body}` : norm.message;
+  const dataRetentionHint = /data retention mode/i.test(core) ? ` See ${BEDROCK_DATA_RETENTION_DOCS_URL} for supported data retention modes.` : "";
+  if (error instanceof BedrockRuntimeServiceException) {
+    const prefix = BEDROCK_ERROR_PREFIXES[error.name] ?? error.name;
+    return `${prefix}: ${core}${dataRetentionHint}`;
+  }
+  return `${core}${dataRetentionHint}`;
+}
+var MAX_BEDROCK_DIAGNOSTIC_VALUE_CHARS = 200;
+function normalizeDiagnosticValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_BEDROCK_DIAGNOSTIC_VALUE_CHARS) return void 0;
+  return trimmed;
+}
+function extractBedrockErrorCode(error) {
+  if (!(error instanceof Error) || !error.name.endsWith("Exception")) return void 0;
+  return normalizeDiagnosticValue(error.name);
+}
+function appendBedrockFailureDiagnostic(output, error, fallbackRequestId) {
+  const metadata = error?.$metadata;
+  const details = {};
+  if (typeof metadata?.httpStatusCode === "number") details.status = metadata.httpStatusCode;
+  const errorCode = extractBedrockErrorCode(error);
+  if (errorCode !== void 0) details.errorCode = errorCode;
+  const requestId = normalizeDiagnosticValue(metadata?.requestId) ?? fallbackRequestId;
+  if (requestId !== void 0) details.requestId = requestId;
+  if (Object.keys(details).length === 0) return;
+  appendAssistantMessageDiagnostic(output, { type: "bedrock_response_failure", timestamp: Date.now(), details });
+}
+var RESERVED_HEADER_EXACT = /* @__PURE__ */ new Set(["authorization", "host"]);
+function isReservedHeader(key) {
+  const lower = key.toLowerCase();
+  return lower.startsWith("x-amz-") || RESERVED_HEADER_EXACT.has(lower);
+}
+function addCustomHeadersMiddleware(client, headers) {
+  const middleware = (next) => async (args) => {
+    const request = args.request;
+    if (request && typeof request === "object" && "headers" in request) {
+      const requestHeaders = request.headers;
+      for (const [key, value] of Object.entries(headers)) {
+        if (!isReservedHeader(key)) {
+          requestHeaders[key] = value;
+        }
+      }
+    }
+    return next(args);
+  };
+  client.middlewareStack.add(middleware, { step: "build", name: "pi-ai-custom-headers", priority: "low" });
+}
+var streamSimple = (model, context, options) => {
+  const base = buildBaseOptions(model, context, options, void 0);
+  if (!options?.reasoning) {
+    return stream(model, context, { ...base, reasoning: void 0 });
+  }
+  if (isAnthropicClaudeModel(model)) {
+    if (supportsAdaptiveThinking(model.id, model.name)) {
+      return stream(model, context, {
+        ...base,
+        reasoning: options.reasoning,
+        thinkingBudgets: options.thinkingBudgets
+      });
+    }
+    const adjusted = adjustMaxTokensForThinking(
+      base.maxTokens,
+      model.maxTokens,
+      options.reasoning,
+      options.thinkingBudgets
+    );
+    const maxTokens = clampMaxTokensToContext(model, context, adjusted.maxTokens);
+    return stream(model, context, {
+      ...base,
+      maxTokens,
+      reasoning: options.reasoning,
+      thinkingBudgets: {
+        ...options.thinkingBudgets || {},
+        [clampReasoning(options.reasoning)]: Math.min(adjusted.thinkingBudget, Math.max(0, maxTokens - 1024))
+      }
+    });
+  }
+  return stream(model, context, {
+    ...base,
+    reasoning: options.reasoning,
+    thinkingBudgets: options.thinkingBudgets
+  });
+};
+function handleContentBlockStart(event, blocks, output, stream2) {
+  const index = event.contentBlockIndex;
+  const start = event.start;
+  if (start?.toolUse) {
+    const block = {
+      type: "toolCall",
+      id: start.toolUse.toolUseId || "",
+      name: start.toolUse.name || "",
+      arguments: {},
+      partialJson: "",
+      index
+    };
+    output.content.push(block);
+    stream2.push({ type: "toolcall_start", contentIndex: blocks.length - 1, partial: output });
+  }
+}
+function handleContentBlockDelta(event, blocks, output, stream2) {
+  const contentBlockIndex = event.contentBlockIndex;
+  const delta = event.delta;
+  let index = blocks.findIndex((b) => b.index === contentBlockIndex);
+  let block = blocks[index];
+  if (delta?.text !== void 0) {
+    if (!block) {
+      const newBlock = { type: "text", text: "", index: contentBlockIndex };
+      output.content.push(newBlock);
+      index = blocks.length - 1;
+      block = blocks[index];
+      stream2.push({ type: "text_start", contentIndex: index, partial: output });
+    }
+    if (block.type === "text") {
+      block.text += delta.text;
+      stream2.push({ type: "text_delta", contentIndex: index, delta: delta.text, partial: output });
+    }
+  } else if (delta?.toolUse && block?.type === "toolCall") {
+    block.partialJson = (block.partialJson || "") + (delta.toolUse.input || "");
+    block.arguments = parseStreamingJson(block.partialJson);
+    stream2.push({ type: "toolcall_delta", contentIndex: index, delta: delta.toolUse.input || "", partial: output });
+  } else if (delta?.reasoningContent) {
+    let thinkingBlock = block;
+    let thinkingIndex = index;
+    if (!thinkingBlock) {
+      const newBlock = { type: "thinking", thinking: "", thinkingSignature: "", index: contentBlockIndex };
+      output.content.push(newBlock);
+      thinkingIndex = blocks.length - 1;
+      thinkingBlock = blocks[thinkingIndex];
+      stream2.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: output });
+    }
+    if (thinkingBlock?.type === "thinking") {
+      if (delta.reasoningContent.text) {
+        thinkingBlock.thinking += delta.reasoningContent.text;
+        stream2.push({
+          type: "thinking_delta",
+          contentIndex: thinkingIndex,
+          delta: delta.reasoningContent.text,
+          partial: output
+        });
+      }
+      if (delta.reasoningContent.signature) {
+        thinkingBlock.thinkingSignature = (thinkingBlock.thinkingSignature || "") + delta.reasoningContent.signature;
+      }
+    }
+  }
+}
+function handleMetadata(event, model, output) {
+  if (event.usage) {
+    output.usage.input = event.usage.inputTokens || 0;
+    output.usage.output = event.usage.outputTokens || 0;
+    output.usage.cacheRead = event.usage.cacheReadInputTokens || 0;
+    output.usage.cacheWrite = event.usage.cacheWriteInputTokens || 0;
+    output.usage.totalTokens = event.usage.totalTokens || output.usage.input + output.usage.output;
+    calculateCost(model, output.usage);
+  }
+}
+function handleContentBlockStop(event, blocks, output, stream2) {
+  const index = blocks.findIndex((b) => b.index === event.contentBlockIndex);
+  const block = blocks[index];
+  if (!block) return;
+  delete block.index;
+  switch (block.type) {
+    case "text":
+      stream2.push({ type: "text_end", contentIndex: index, content: block.text, partial: output });
+      break;
+    case "thinking":
+      stream2.push({ type: "thinking_end", contentIndex: index, content: block.thinking, partial: output });
+      break;
+    case "toolCall":
+      block.arguments = parseStreamingJson(block.partialJson);
+      delete block.partialJson;
+      stream2.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: output });
+      break;
+  }
+}
+function getModelMatchCandidates(modelId, modelName) {
+  const values = modelName ? [modelId, modelName] : [modelId];
+  return values.flatMap((value) => {
+    const lower = value.toLowerCase();
+    return [lower, lower.replace(/[\s_.:]+/g, "-")];
+  });
+}
+function supportsAdaptiveThinking(modelId, modelName) {
+  const candidates = getModelMatchCandidates(modelId, modelName);
+  return candidates.some(
+    (s) => s.includes("opus-4-6") || s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("opus-5") || s.includes("sonnet-4-6") || s.includes("sonnet-5") || s.includes("fable-5")
+  );
+}
+function supportsNativeXhighEffort(model) {
+  const candidates = getModelMatchCandidates(model.id, model.name);
+  return candidates.some(
+    (s) => s.includes("opus-4-7") || s.includes("opus-4-8") || s.includes("opus-5") || s.includes("sonnet-5") || s.includes("fable-5")
+  );
+}
+function mapThinkingLevelToEffort(model, level) {
+  if (level === "xhigh" && supportsNativeXhighEffort(model)) return "xhigh";
+  const mapped = level ? model.thinkingLevelMap?.[level] : void 0;
+  if (typeof mapped === "string") return mapped;
+  switch (level) {
+    case "minimal":
+    case "low":
+      return "low";
+    case "medium":
+      return "medium";
+    case "high":
+      return "high";
+    default:
+      return "high";
+  }
+}
+function resolveCacheRetention(cacheRetention, env) {
+  if (cacheRetention) {
+    return cacheRetention;
+  }
+  if (getProviderEnvValue("HUMAIN_TERMINAL_CACHE_RETENTION", env) === "long" || getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
+    return "long";
+  }
+  return "short";
+}
+function isAnthropicClaudeModel(model) {
+  const id = model.id.toLowerCase();
+  const name = model.name?.toLowerCase() ?? "";
+  return id.includes("anthropic.claude") || id.includes("anthropic/claude") || name.includes("anthropic.claude") || name.includes("anthropic/claude") || name.includes("claude");
+}
+function supportsPromptCaching(model, env) {
+  const candidates = getModelMatchCandidates(model.id, model.name);
+  const hasClaudeRef = candidates.some((s) => s.includes("claude"));
+  if (!hasClaudeRef) {
+    if (getProviderEnvValue("AWS_BEDROCK_FORCE_CACHE", env) === "1") return true;
+    return false;
+  }
+  if (candidates.some((s) => s.includes("fable-5") || s.includes("opus-5") || s.includes("sonnet-5"))) return true;
+  if (candidates.some((s) => s.includes("-4-"))) return true;
+  if (candidates.some((s) => s.includes("claude-3-7-sonnet"))) return true;
+  if (candidates.some((s) => s.includes("claude-3-5-haiku"))) return true;
+  return false;
+}
+function supportsThinkingSignature(model) {
+  return isAnthropicClaudeModel(model);
+}
+function buildSystemPrompt(systemPrompt, model, cacheRetention, env) {
+  if (!systemPrompt) return void 0;
+  const blocks = [{ text: sanitizeSurrogates(systemPrompt) }];
+  if (cacheRetention !== "none" && supportsPromptCaching(model, env)) {
+    blocks.push({
+      cachePoint: { type: CachePointType.DEFAULT, ...cacheRetention === "long" ? { ttl: CacheTTL.ONE_HOUR } : {} }
+    });
+  }
+  return blocks;
+}
+function normalizeToolCallId(id) {
+  const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+}
+function createNonBlankTextBlock(text) {
+  const sanitized = sanitizeSurrogates(text);
+  return sanitized.trim().length === 0 ? void 0 : { text: sanitized };
+}
+function createRequiredTextBlock(text) {
+  return createNonBlankTextBlock(text) ?? { text: EMPTY_TEXT_PLACEHOLDER };
+}
+function convertToolResultContent(content) {
+  const result = [];
+  for (const c of content) {
+    if (c.type === "image") {
+      result.push({ image: createImageBlock(c.mimeType, c.data) });
+    } else {
+      const textBlock = createNonBlankTextBlock(c.text);
+      if (textBlock) result.push(textBlock);
+    }
+  }
+  if (result.length === 0) result.push({ text: EMPTY_TEXT_PLACEHOLDER });
+  return result;
+}
+function convertMessages(context, model, cacheRetention, env) {
+  const result = [];
+  const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+  for (let i = 0; i < transformedMessages.length; i++) {
+    const m = transformedMessages[i];
+    switch (m.role) {
+      case "user": {
+        const content = [];
+        if (typeof m.content === "string") {
+          content.push(createRequiredTextBlock(m.content));
+        } else {
+          for (const c of m.content) {
+            switch (c.type) {
+              case "text": {
+                const textBlock = createNonBlankTextBlock(c.text);
+                if (textBlock) content.push(textBlock);
+                break;
+              }
+              case "image":
+                content.push({ image: createImageBlock(c.mimeType, c.data) });
+                break;
+              default:
+                continue;
+            }
+          }
+          if (content.length === 0) content.push({ text: EMPTY_TEXT_PLACEHOLDER });
+        }
+        result.push({
+          role: ConversationRole.USER,
+          content
+        });
+        break;
+      }
+      case "assistant": {
+        if (m.content.length === 0) {
+          continue;
+        }
+        const contentBlocks = [];
+        for (const c of m.content) {
+          switch (c.type) {
+            case "text": {
+              const textBlock = createNonBlankTextBlock(c.text);
+              if (!textBlock) continue;
+              contentBlocks.push(textBlock);
+              break;
+            }
+            case "toolCall":
+              contentBlocks.push({
+                toolUse: { toolUseId: c.id, name: c.name, input: c.arguments }
+              });
+              break;
+            case "thinking": {
+              const thinking = sanitizeSurrogates(c.thinking);
+              if (thinking.trim().length === 0) continue;
+              if (supportsThinkingSignature(model)) {
+                if (!c.thinkingSignature || c.thinkingSignature.trim().length === 0) {
+                  contentBlocks.push({ text: thinking });
+                } else {
+                  contentBlocks.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: thinking,
+                        signature: c.thinkingSignature
+                      }
+                    }
+                  });
+                }
+              } else {
+                contentBlocks.push({
+                  reasoningContent: {
+                    reasoningText: { text: thinking }
+                  }
+                });
+              }
+              break;
+            }
+            default:
+              continue;
+          }
+        }
+        if (contentBlocks.length === 0) {
+          continue;
+        }
+        result.push({
+          role: ConversationRole.ASSISTANT,
+          content: contentBlocks
+        });
+        break;
+      }
+      case "toolResult": {
+        const toolResults = [];
+        toolResults.push({
+          toolResult: {
+            toolUseId: m.toolCallId,
+            content: convertToolResultContent(m.content),
+            status: m.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS
+          }
+        });
+        let j = i + 1;
+        while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
+          const nextMsg = transformedMessages[j];
+          toolResults.push({
+            toolResult: {
+              toolUseId: nextMsg.toolCallId,
+              content: convertToolResultContent(nextMsg.content),
+              status: nextMsg.isError ? ToolResultStatus.ERROR : ToolResultStatus.SUCCESS
+            }
+          });
+          j++;
+        }
+        i = j - 1;
+        result.push({
+          role: ConversationRole.USER,
+          content: toolResults
+        });
+        break;
+      }
+      default:
+        continue;
+    }
+  }
+  if (cacheRetention !== "none" && supportsPromptCaching(model, env) && result.length > 0) {
+    const lastMessage = result[result.length - 1];
+    if (lastMessage.role === ConversationRole.USER && lastMessage.content) {
+      lastMessage.content.push({
+        cachePoint: {
+          type: CachePointType.DEFAULT,
+          ...cacheRetention === "long" ? { ttl: CacheTTL.ONE_HOUR } : {}
+        }
+      });
+    }
+  }
+  return result;
+}
+function convertToolConfig(tools, toolChoice, supportsStrictMode) {
+  if (!tools?.length) return void 0;
+  if (toolChoice === "none") return void 0;
+  const bedrockTools = tools.map((tool) => {
+    const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictMode);
+    return {
+      toolSpec: {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: { json: tool.parameters },
+        ...strict === true ? { strict: true } : {}
+      }
+    };
+  });
+  let bedrockToolChoice;
+  switch (toolChoice) {
+    case "auto":
+      bedrockToolChoice = { auto: {} };
+      break;
+    case "any":
+      bedrockToolChoice = { any: {} };
+      break;
+    default:
+      if (toolChoice?.type === "tool") {
+        bedrockToolChoice = { tool: { name: toolChoice.name } };
+      }
+  }
+  return { tools: bedrockTools, toolChoice: bedrockToolChoice };
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case BedrockStopReason.END_TURN:
+    case BedrockStopReason.STOP_SEQUENCE:
+      return { stopReason: "stop" };
+    case BedrockStopReason.MAX_TOKENS:
+    case BedrockStopReason.MODEL_CONTEXT_WINDOW_EXCEEDED:
+      return { stopReason: "length" };
+    case BedrockStopReason.TOOL_USE:
+      return { stopReason: "toolUse" };
+    default:
+      return reason ? { stopReason: "error", errorMessage: `Provider stopped with: ${reason}` } : { stopReason: "error" };
+  }
+}
+function getConfiguredBedrockRegion(options) {
+  return options.region || getProviderEnvValue("AWS_REGION", options.env) || getProviderEnvValue("AWS_DEFAULT_REGION", options.env) || void 0;
+}
+function getConfiguredBedrockCredentials(env) {
+  const accessKeyId = getProviderEnvValue("AWS_ACCESS_KEY_ID", env);
+  const secretAccessKey = getProviderEnvValue("AWS_SECRET_ACCESS_KEY", env);
+  if (!accessKeyId || !secretAccessKey) {
+    return void 0;
+  }
+  const sessionToken = getProviderEnvValue("AWS_SESSION_TOKEN", env);
+  return {
+    accessKeyId,
+    secretAccessKey,
+    ...sessionToken ? { sessionToken } : {}
+  };
+}
+function getStandardBedrockEndpointRegion(baseUrl) {
+  if (!baseUrl) {
+    return void 0;
+  }
+  try {
+    const { hostname } = new URL(baseUrl);
+    const match = hostname.toLowerCase().match(/^bedrock-runtime(?:-fips)?\.([a-z0-9-]+)\.amazonaws\.com(?:\.cn)?$/);
+    return match?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function shouldUseExplicitBedrockEndpoint(baseUrl, configuredRegion, hasAmbientConfiguredProfile) {
+  const endpointRegion = getStandardBedrockEndpointRegion(baseUrl);
+  if (!endpointRegion) {
+    return true;
+  }
+  return !configuredRegion && !hasAmbientConfiguredProfile;
+}
+function shouldUseBedrockHttp1Handler(baseUrl, env) {
+  if (getProviderEnvValue("AWS_BEDROCK_FORCE_HTTP1", env) === "1") {
+    return true;
+  }
+  if (!baseUrl) {
+    return false;
+  }
+  try {
+    return new URL(baseUrl).protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function shouldBypassBedrockProxy(baseUrl) {
+  if (!baseUrl) {
+    return false;
+  }
+  try {
+    const url = new URL(baseUrl);
+    return url.protocol === "http:" && isLoopbackHostname(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "localhost" || hostname === "0.0.0.0" || hostname === "[::1]" || hostname.startsWith("127.");
+}
+function isGovCloudBedrockTarget(model, options) {
+  const region = getConfiguredBedrockRegion(options);
+  if (region?.toLowerCase().startsWith("us-gov-")) {
+    return true;
+  }
+  const modelId = model.id.toLowerCase();
+  return modelId.startsWith("us-gov.") || modelId.startsWith("arn:aws-us-gov:");
+}
+function buildAdditionalModelRequestFields(model, options) {
+  if (!options.reasoning || !model.reasoning) {
+    return void 0;
+  }
+  if (isAnthropicClaudeModel(model)) {
+    const display = isGovCloudBedrockTarget(model, options) ? void 0 : options.thinkingDisplay ?? "summarized";
+    const result = supportsAdaptiveThinking(model.id, model.name) ? {
+      thinking: { type: "adaptive", ...display !== void 0 ? { display } : {} },
+      output_config: { effort: mapThinkingLevelToEffort(model, options.reasoning) }
+    } : (() => {
+      const defaultBudgets = {
+        minimal: 1024,
+        low: 2048,
+        medium: 8192,
+        high: 16384,
+        xhigh: 16384,
+        // Budget-based Claude clamps extended levels to high
+        max: 16384
+      };
+      const level = options.reasoning === "xhigh" || options.reasoning === "max" ? "high" : options.reasoning;
+      const budget = options.thinkingBudgets?.[level] ?? defaultBudgets[options.reasoning];
+      return {
+        thinking: {
+          type: "enabled",
+          budget_tokens: budget,
+          ...display !== void 0 ? { display } : {}
+        }
+      };
+    })();
+    if (!supportsAdaptiveThinking(model.id, model.name) && (options.interleavedThinking ?? true)) {
+      result.anthropic_beta = ["interleaved-thinking-2025-05-14"];
+    }
+    return result;
+  }
+  return void 0;
+}
+function createImageBlock(mimeType, data) {
+  let format;
+  switch (mimeType) {
+    case "image/jpeg":
+    case "image/jpg":
+      format = ImageFormat.JPEG;
+      break;
+    case "image/png":
+      format = ImageFormat.PNG;
+      break;
+    case "image/gif":
+      format = ImageFormat.GIF;
+      break;
+    case "image/webp":
+      format = ImageFormat.WEBP;
+      break;
+    default:
+      throw new Error(`Unknown image type: ${mimeType}`);
+  }
+  const binaryString = atob(data);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return { source: { bytes }, format };
+}
+
+// packages/ai/src/bedrock-provider.ts
+var bedrockProviderModule = {
+  stream,
+  streamSimple
+};
+export {
+  bedrockProviderModule
+};