elanous 0.2.22 → 0.2.24

package/src/llm/bedrock-eventstream.ts

@@ -0,0 +1,215 @@
+// ── BEDROCK-RUNTIME-PATH — AWS eventstream(`application/vnd.amazon.eventstream`) 디코더 (2026-10-11) ──
+//
+// `InvokeModelWithResponseStream` 의 응답은 SSE 가 아니라 AWS eventstream «이진 프레임»이다.
+// 📏 레포에 `@smithy/eventstream-codec` 이 없다(rg · node_modules/@smithy 전수) ⇒ 의존성을 늘리지 않고 작은 디코더를 둔다.
+//
+// 프레임 꼴(빅엔디언):
+//   [total length u32][headers length u32][prelude CRC32 u32][headers …][payload …][message CRC32 u32]
+//   prelude CRC = 앞 8바이트의 CRC32 · message CRC = 마지막 4바이트를 뺀 전부의 CRC32.
+// 헤더: [name len u8][name utf8][type u8][value …] — type 7(string)·6(bytes)은 u16 길이 접두.
+//
+// ⛔ CRC 가 안 맞거나 길이가 말이 안 되면 «조용히 건너뛰지 않고» 고정 이름의 에러로 멈춘다 —
+//    깨진 프레임을 JSON 으로 읽어 반쪽 답을 내는 것보다 실패가 낫다.
+
+/** 디코더 에러 — 고정 이름(`BedrockEventStreamError`). 메시지에 페이로드 원문을 싣지 않는다. */
+export class BedrockEventStreamError extends Error {
+  constructor(reason: string) {
+    super(`Bedrock eventstream: ${reason}`);
+    this.name = 'BedrockEventStreamError';
+  }
+}
+
+const CRC_TABLE: Uint32Array = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+
+/** CRC32(IEEE 802.3 · zlib 과 같은 다항식). */
+export function crc32(bytes: Uint8Array): number {
+  let c = 0xffffffff;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]!) & 0xff]! ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+
+export type EventStreamHeaderValue = string | number | boolean | bigint | Uint8Array;
+
+export interface EventStreamMessage {
+  headers: Record<string, EventStreamHeaderValue>;
+  payload: Uint8Array;
+}
+
+const PRELUDE = 12;
+const MIN_FRAME = PRELUDE + 4;
+/** 한 프레임 상한 — AWS 문서의 메시지 최대(16 MiB)와 같다. 넘으면 길이 칸이 깨진 것으로 본다. */
+const MAX_FRAME = 16 * 1024 * 1024;
+
+function decodeHeaders(bytes: Uint8Array): Record<string, EventStreamHeaderValue> {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const text = new TextDecoder();
+  const out: Record<string, EventStreamHeaderValue> = {};
+  let i = 0;
+  const need = (n: number) => { if (i + n > bytes.length) throw new BedrockEventStreamError('헤더가 잘렸다'); };
+  while (i < bytes.length) {
+    need(1);
+    const nameLen = bytes[i]!; i += 1;
+    need(nameLen);
+    const name = text.decode(bytes.subarray(i, i + nameLen)); i += nameLen;
+    need(1);
+    const type = bytes[i]!; i += 1;
+    switch (type) {
+      case 0: out[name] = true; break;
+      case 1: out[name] = false; break;
+      case 2: need(1); out[name] = view.getInt8(i); i += 1; break;
+      case 3: need(2); out[name] = view.getInt16(i); i += 2; break;
+      case 4: need(4); out[name] = view.getInt32(i); i += 4; break;
+      case 5: need(8); out[name] = view.getBigInt64(i); i += 8; break;
+      case 6:
+      case 7: {
+        need(2);
+        const len = view.getUint16(i); i += 2;
+        need(len);
+        const v = bytes.subarray(i, i + len); i += len;
+        out[name] = type === 7 ? text.decode(v) : v.slice();
+        break;
+      }
+      case 8: need(8); out[name] = view.getBigInt64(i); i += 8; break;
+      case 9: need(16); out[name] = bytes.slice(i, i + 16); i += 16; break;
+      default: throw new BedrockEventStreamError(`모르는 헤더 형식 ${type}`);
+    }
+  }
+  return out;
+}
+
+/** 프레임 «하나»를 푼다(정확히 한 프레임 길이의 바이트). CRC 둘 다 검사한다. */
+export function decodeEventStreamFrame(frame: Uint8Array): EventStreamMessage {
+  if (frame.length < MIN_FRAME) throw new BedrockEventStreamError('프레임이 잘렸다');
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const total = view.getUint32(0);
+  const headersLen = view.getUint32(4);
+  if (total !== frame.length) throw new BedrockEventStreamError('프레임 길이가 맞지 않는다');
+  if (view.getUint32(8) !== crc32(frame.subarray(0, 8))) throw new BedrockEventStreamError('prelude CRC 불일치');
+  if (view.getUint32(total - 4) !== crc32(frame.subarray(0, total - 4))) throw new BedrockEventStreamError('message CRC 불일치');
+  if (PRELUDE + headersLen > total - 4) throw new BedrockEventStreamError('헤더 길이가 프레임을 넘는다');
+  const headers = decodeHeaders(frame.subarray(PRELUDE, PRELUDE + headersLen));
+  const payload = frame.slice(PRELUDE + headersLen, total - 4);
+  return { headers, payload };
+}
+
+/** 바이트 청크 스트림 → 프레임 스트림. 청크 경계가 프레임 경계와 무관해도 된다.
+ *  스트림이 프레임 «중간»에서 끝나면 `프레임이 잘렸다` 로 멈춘다. */
+export async function* decodeEventStream(
+  chunks: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
+): AsyncGenerator<EventStreamMessage, void, unknown> {
+  let buf = new Uint8Array(0);
+  const iterable: AsyncIterable<Uint8Array> = (chunks as ReadableStream<Uint8Array>).getReader
+    ? readerIterable(chunks as ReadableStream<Uint8Array>)
+    : (chunks as AsyncIterable<Uint8Array>);
+  for await (const chunk of iterable) {
+    if (!chunk || chunk.length === 0) continue;
+    const next = new Uint8Array(buf.length + chunk.length);
+    next.set(buf, 0);
+    next.set(chunk, buf.length);
+    buf = next;
+    while (buf.length >= PRELUDE) {
+      const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+      const total = view.getUint32(0);
+      if (total < MIN_FRAME || total > MAX_FRAME) throw new BedrockEventStreamError('프레임 길이 칸이 깨졌다');
+      // 길이 칸을 믿기 «전»에 prelude CRC 부터 — 깨진 길이로 끝없이 기다리지 않게.
+      if (view.getUint32(8) !== crc32(buf.subarray(0, 8))) throw new BedrockEventStreamError('prelude CRC 불일치');
+      if (buf.length < total) break;
+      yield decodeEventStreamFrame(buf.subarray(0, total));
+      buf = buf.slice(total);
+    }
+  }
+  if (buf.length > 0) throw new BedrockEventStreamError('프레임이 잘렸다');
+}
+
+async function* readerIterable(stream: ReadableStream<Uint8Array>): AsyncGenerator<Uint8Array, void, unknown> {
+  const reader = stream.getReader();
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      if (value) yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/** 시험·도구용 인코더 — 디코더의 거울(문자열 헤더만). 실 송신 경로에서는 쓰지 않는다. */
+export function encodeEventStreamFrame(headers: Record<string, string>, payload: Uint8Array): Uint8Array {
+  const enc = new TextEncoder();
+  const parts: number[] = [];
+  for (const [name, value] of Object.entries(headers)) {
+    const n = enc.encode(name);
+    const v = enc.encode(value);
+    parts.push(n.length, ...n, 7, (v.length >> 8) & 0xff, v.length & 0xff, ...v);
+  }
+  const headerBytes = Uint8Array.from(parts);
+  const total = PRELUDE + headerBytes.length + payload.length + 4;
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, total);
+  view.setUint32(4, headerBytes.length);
+  view.setUint32(8, crc32(out.subarray(0, 8)));
+  out.set(headerBytes, PRELUDE);
+  out.set(payload, PRELUDE + headerBytes.length);
+  view.setUint32(total - 4, crc32(out.subarray(0, total - 4)));
+  return out;
+}
+
+/** 오류 문면 가림 seam — 호출자가 `redactAwsIdentifiers ∘ redactSecrets` 를 넘긴다(이 모듈은 의존 0). */
+export type BedrockTextRedactor = (text: string) => string;
+
+/** 고정 꼴의 예외 이름만 싣는다(`throttlingException` 등). 그 밖은 `UnknownException`. */
+function safeExceptionType(v: unknown): string {
+  return typeof v === 'string' && /^[A-Za-z][A-Za-z0-9]{0,63}$/.test(v) ? v : 'UnknownException';
+}
+
+/** 스트림 «안»의 AWS 예외 프레임(`:message-type: exception`) — 고정 이름. */
+export class BedrockRuntimeStreamError extends Error {
+  readonly exceptionType: string;
+  constructor(exceptionType: string, detail: string) {
+    super(`Bedrock runtime stream ${exceptionType}${detail ? `: ${detail}` : ''}`);
+    this.name = 'BedrockRuntimeStreamError';
+    this.exceptionType = exceptionType;
+  }
+}
+
+/**
+ * runtime 응답 몸 → Anthropic SSE 꼴의 `data: <json>` 줄.
+ * ⭐ 각 `chunk` 이벤트의 `{"bytes":"<base64>"}` 를 풀면 1st-party 와 같은 Anthropic 스트림 이벤트 JSON 이다 —
+ *    줄로 바꿔 `parseAnthropicSSELines` 에 그대로 넣는다(사용량·도구·추론 파싱을 한 벌로 유지).
+ */
+export async function* bedrockRuntimeSseLines(
+  body: AsyncIterable<Uint8Array> | ReadableStream<Uint8Array>,
+  redact: BedrockTextRedactor = (t) => t,
+): AsyncGenerator<string, void, unknown> {
+  const text = new TextDecoder();
+  for await (const msg of decodeEventStream(body)) {
+    const messageType = msg.headers[':message-type'];
+    if (messageType === 'exception' || messageType === 'error') {
+      const kind = safeExceptionType(msg.headers[':exception-type'] ?? msg.headers[':error-code']);
+      let detail = '';
+      try {
+        const parsed = JSON.parse(text.decode(msg.payload)) as { message?: unknown; Message?: unknown };
+        const m = parsed.message ?? parsed.Message;
+        if (typeof m === 'string') detail = m;
+      } catch { /* 본문 없음 */ }
+      if (!detail && typeof msg.headers[':error-message'] === 'string') detail = msg.headers[':error-message'] as string;
+      throw new BedrockRuntimeStreamError(kind, redact(detail).slice(0, 300));
+    }
+    if (messageType !== 'event' || msg.headers[':event-type'] !== 'chunk') continue;
+    let b64: unknown;
+    try { b64 = (JSON.parse(text.decode(msg.payload)) as { bytes?: unknown }).bytes; } catch { continue; }
+    if (typeof b64 !== 'string' || !b64) continue;
+    const json = Buffer.from(b64, 'base64').toString('utf8').trim();
+    if (json) yield `data: ${json}`;
+  }
+}

package/src/llm/bedrock-provider.ts

@@ -0,0 +1,248 @@
+// ── BEDROCK-PROVIDER — 공급자 본체(`makeBedrockProvider`) ──
+//
+// ⭐ OP Q3(10-11): `llm.ts` 에 새 provider 를 통째로 더하지 않는다 — 첫 «분리된 공급자» 선례(RFC #25983 방향).
+//   자격·리전·서명·모델 id = `./bedrock.ts` · 이 파일 = 공급자 본체 · `llm.ts` = import ⊕ 표 배선만.
+// ⛔ 순환 방지: `../llm.js` 는 «타입»만 정적으로 가져오고, 값(Anthropic 메시지 변환·추론 배선·SSE 파서)은
+//   호출 때 동적 import 한다 — llm.ts 가 이 모듈을 정적으로 import 해도 로드 순서가 꼬이지 않는다.
+
+import type { LLMProvider } from '../llm.js';
+import type { LLMConfig as UCLLMConfig } from '../user-config.js';
+import { debug, redactSecrets } from '../debug/log.js';
+import { ApiHttpError, fetchApiWithRetry, type FetchApiWithRetryOpts } from '../session-runtime/retry-api.js';
+import { isVisionCapableModel } from '../llm-vision-capability.js';
+import * as bedrock from './bedrock.js';
+import { bedrockRuntimeSseLines } from './bedrock-eventstream.js';
+
+/** BEDROCK-PROVIDER 시험 seam — 자격·서명·HTTP 를 주입한다(실 AWS 호출 0). */
+export interface BedrockProviderDeps {
+  env?: Record<string, string | undefined>;
+  resolveCredentials?: import('./bedrock.js').BedrockCredentialResolver;
+  sign?: import('./bedrock.js').BedrockSigner;
+  /** HTTP 송신 — 기본은 `fetchApiWithRetry`(재시도·과부하 폴백 공용). */
+  send?: (url: string, init: RequestInit) => Promise<Response>;
+}
+
+/** 서명 ⊕ 송신 ⊕ 에러 마스킹 — 세 경로(mantle·runtime·mantle-openai)가 «한 벌»을 쓴다. 응답은 `ok` 인 것만 돌려준다. */
+async function signAndSend(input: {
+  region: string;
+  body: Record<string, unknown>;
+  wireModel: string;
+  route: bedrock.BedrockRoute;
+  deps: BedrockProviderDeps;
+  envDeps: { env?: Record<string, string | undefined> };
+  opts: { signal?: AbortSignal; remainingFallbacks?: number };
+  retryOptsFor: (provider: string, errorPrefix: string, remainingFallbacks?: number) => FetchApiWithRetryOpts;
+  requestLog: Record<string, unknown>;
+}): Promise<Response> {
+  const { region, body, wireModel, route, deps, envDeps, opts } = input;
+  const signRequest = () => bedrock.buildSignedBedrockRequest({
+    region,
+    body,
+    ...(deps.env ? { env: deps.env } : {}),
+    ...(deps.resolveCredentials ? { resolveCredentials: deps.resolveCredentials } : {}),
+    ...(deps.sign ? { sign: deps.sign } : {}),
+  });
+  let signed: Awaited<ReturnType<typeof signRequest>>;
+  try {
+    signed = await signRequest();
+  } catch (err) {
+    debug.log('llm.bedrock', 'credentials-unresolved', {
+      provider: 'bedrock', region, model: wireModel,
+      // ⛔ 임의 err.name 을 싣지 않는다 — 우리 에러면 그 고정 이름, 아니면 허용 목록/고정 문자열.
+      errName: err instanceof bedrock.BedrockCredentialsUnresolvedError ? err.name : bedrock.sanitizeCredentialErrorName(err),
+      credentialSignal: bedrock.bedrockCredentialSignalLabel(envDeps),
+    }, { level: 'warn' });
+    throw err;
+  }
+  debug.log('llm.bedrock', 'request', {
+    provider: 'bedrock', region, model: wireModel, route,
+    auth: signed.headers['x-api-key'] !== undefined || signed.headers.authorization?.startsWith('Bearer ') ? 'bearer' : 'sigv4',
+    ...input.requestLog,
+  });
+  // ⛔ redirect:'error' — 검증한 호스트 밖으로 리다이렉트를 따라가 자격 헤더(x-api-key·x-amz-security-token)가 새지 않게.
+  const toInit = (req: typeof signed): RequestInit => ({
+    method: 'POST', headers: req.headers, body: req.body, redirect: 'error', ...(opts.signal ? { signal: opts.signal } : {}),
+  });
+  const init = toInit(signed);
+  // ⭐ 재시도마다 다시 서명한다 — SigV4 는 `x-amz-date` 기준 수 분만 유효(긴 retry-after 뒤 옛 서명은 403).
+  let response: Response;
+  try {
+    response = deps.send
+      ? await deps.send(signed.url, init)
+      : await fetchApiWithRetry(signed.url, init, {
+        ...input.retryOptsFor('bedrock', 'Bedrock API', opts.remainingFallbacks),
+        refreshInit: async () => toInit(await signRequest()),
+      });
+  } catch (err) {
+    // ⛔ 403 본문이 IAM 주체 ARN·계정 번호를 싣는다 — 같은 꼴(ApiHttpError · status·retryAfter 유지)로 본문만 가려 다시 던진다.
+    if (err instanceof ApiHttpError) {
+      throw new ApiHttpError({ status: err.status, bodyText: bedrock.redactAwsIdentifiers(err.bodyText), provider: err.provider, errorPrefix: 'Bedrock API', ...(err.retryAfter !== undefined ? { retryAfter: err.retryAfter } : {}) });
+    }
+    throw err;
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => '');
+    throw new Error(`Bedrock API ${response.status}: ${bedrock.redactAwsIdentifiers(redactSecrets(text)).slice(0, 500)}`);
+  }
+  return response;
+}
+
+/**
+ * ⭐ AWS Bedrock 의 Claude(«Claude in Amazon Bedrock» 메시지 엔드포인트 · SigV4 `bedrock-mantle`).
+ * 몸·SSE 는 Anthropic 1st-party 와 같은 꼴이라 ***메시지 변환·캐시 4슬롯·SSE 파서를 그대로 쓴다*** —
+ * 다른 것은 «주소 ⊕ 서명 ⊕ 모델 id(`anthropic.` 접두)» 셋뿐이다.
+ * ⛔ 명시(provider=bedrock)할 때만 고른다 — 자동 순서·폴백 체인에 «없다».
+ * ⚠️ `anthropic-beta` 헤더는 싣지 않는다(이 엔드포인트의 수용 여부 미확인 · 5.5 계열은 adaptive 가 기본이다).
+ */
+export function makeBedrockProvider(cfg: UCLLMConfig, deps: BedrockProviderDeps = {}): LLMProvider {
+  const configuredModel = cfg.model ? bedrock.resolveBedrockModelId(cfg.model) : bedrock.BEDROCK_DEFAULT_MODEL;
+  const envDeps = deps.env ? { env: deps.env } : {};
+  return {
+    name: 'bedrock',
+    defaultModel: configuredModel,
+    available: () => bedrock.bedrockAvailable(envDeps),
+    async *streamChat(messages, opts = {}) {
+      const {
+        toAnthropicMessage, effectiveReasoningLevel, usesAdaptiveThinking,
+        mapReasoningLevelToAnthropicThinking, mapReasoningLevelToAnthropicEffort,
+        anthropicTemperatureField, parseAnthropicSSELines, sseLineStream: anthropicSseLineStream, retryOptsFor,
+      } = await import('../llm.js');
+      const region = bedrock.resolveBedrockRegion(envDeps);
+      if (!region) {
+        throw new Error('Bedrock unavailable: AWS 리전이 없다 — AWS_REGION(또는 AWS_DEFAULT_REGION) 또는 ~/.aws/config 프로필 region');
+      }
+      const wireModel = bedrock.resolveBedrockModelId(opts.model || configuredModel);
+      // 계열 판정(adaptive·vision·temperature)은 1st-party 꼴 id 로 — 헬퍼들이 `anthropic.` 접두를 모른다.
+      const familyModel = bedrock.bedrockCanonicalClaudeId(wireModel);
+      // ⭐ BEDROCK-RUNTIME-PATH — 경로는 모델 표의 `route` 칸(bedrock.ts)이 정한다. 몸·캐시 4슬롯·파서는 한 벌이고,
+      //   다른 것은 «주소·서명 서비스·응답 프레이밍» 셋뿐 — runtime 은 eventstream 프레임을 `data:` 줄로 바꿔 같은 파서에 넣는다.
+      const route = bedrock.bedrockRouteFor(wireModel);
+      debug.log('llm.bedrock', 'route', { model: wireModel, route });
+      if (route === 'mantle-openai') {
+        // 비-Anthropic 모델 — OpenAI chat.completions 몸·SSE. Anthropic 쪽 조립(캐시 4슬롯·추론 배선)은 거치지 않는다.
+        const { toOpenAIMessages, toOpenAITools, parseOpenAISSELines } = await import('../llm.js');
+        const tools = toOpenAITools(opts.tools);
+        const body = {
+          model: wireModel,
+          messages: messages.flatMap((m) => toOpenAIMessages(m)),
+          // OpenAI 추론 계열(openai.*)은 max_tokens 를 400 으로 거부한다(10-11 실물: unsupported_parameter) — max_completion_tokens 로.
+          ...(wireModel.startsWith('openai.') ? { max_completion_tokens: opts.maxTokens ?? 2048 } : { max_tokens: opts.maxTokens ?? 2048 }),
+          ...(opts.temperature !== undefined ? { temperature: opts.temperature } : {}),
+          ...(tools ? { tools } : {}),
+          stream_options: { include_usage: true },
+        };
+        // 이 모델들은 고정 리전(us-east-1)에서만 나온다 — 사용자 리전은 «자격 해석 가능 여부»에만 쓴다.
+        const openaiRegion = bedrock.bedrockRegionFor(wireModel, region);
+        const response = await signAndSend({
+          region: openaiRegion, body, wireModel, route, deps, envDeps, opts, retryOptsFor,
+          requestLog: { tools: opts.tools?.length ?? 0 },
+        });
+        try {
+          for await (const ev of parseOpenAISSELines(anthropicSseLineStream(response.body!))) {
+            if (ev.type === 'usage') {
+              debug.log('llm.bedrock', 'usage', {
+                provider: 'bedrock', region: openaiRegion, model: wireModel, route,
+                inputTokens: ev.usage.inputTokens ?? 0,
+                outputTokens: ev.usage.outputTokens ?? 0,
+              });
+            }
+            yield ev;
+          }
+        } catch (err: any) {
+          if (err?.name === 'AbortError') return;
+          throw err;
+        }
+        return;
+      }
+      const sseLineStream = route === 'runtime'
+        ? (b: ReadableStream<Uint8Array>) => bedrockRuntimeSseLines(b, (t) => bedrock.redactAwsIdentifiers(redactSecrets(t)))
+        : anthropicSseLineStream;
+      // ⭐ 캐시: Anthropic 공급자와 «같은 자리» 4슬롯(system·tools·history·anchor).
+      const { getDefaultCacheTTL } = await import('../config.js');
+      const cache = opts.promptCache !== false;
+      const ttl = opts.promptCacheTTL ?? getDefaultCacheTTL();
+      const {
+        toAnthropicSystemBlocks, toAnthropicToolsCached,
+        applyHistoryCacheBreakpoint, applyAnchorCacheBreakpoint,
+      } = await import('../prompt-cache/anthropic.js');
+      const system = toAnthropicSystemBlocks(messages, { cache, ttl });
+      const acceptUserImages = isVisionCapableModel('anthropic', familyModel, 'userMessage');
+      let convo = messages
+        .filter(m => m.role !== 'system')
+        .map(m => toAnthropicMessage(m, { acceptUserMessageImages: acceptUserImages }));
+      convo = applyAnchorCacheBreakpoint(convo, { cache, ttl });
+      convo = applyHistoryCacheBreakpoint(convo, { cache, ttl });
+      const tools = toAnthropicToolsCached(opts.tools, { cache, ttl });
+      // makeAnthropicProvider 와 같은 추론 배선 — 4.8+/5.x 는 adaptive ⊕ output_config.effort.
+      const effLevel = effectiveReasoningLevel(cfg, 'anthropic', familyModel);
+      const adaptive = usesAdaptiveThinking(familyModel);
+      const thinking = adaptive ? undefined : mapReasoningLevelToAnthropicThinking(effLevel);
+      const effort = adaptive ? mapReasoningLevelToAnthropicEffort(effLevel) : undefined;
+      const thinkingActive = Boolean(thinking) || Boolean(effort);
+      const maxTokens = thinking
+        ? Math.max(opts.maxTokens ?? 2048, Math.floor(thinking.budget_tokens * 1.5) + 2048)
+        : effort
+          ? Math.max(opts.maxTokens ?? 8192, 8192)
+          : (opts.maxTokens ?? 2048);
+      const body = {
+        model: wireModel,
+        messages: convo,
+        ...(system !== undefined ? { system } : {}),
+        max_tokens: maxTokens,
+        ...(thinking ? { thinking } : {}),
+        ...(effort ? { thinking: { type: 'adaptive' }, output_config: { effort } } : {}),
+        ...anthropicTemperatureField(familyModel, thinkingActive, opts.temperature),
+        ...(tools ? { tools } : {}),
+      };
+      const response = await signAndSend({
+        region, body, wireModel, route, deps, envDeps, opts, retryOptsFor,
+        requestLog: { cache, ttl, tools: opts.tools?.length ?? 0 },
+      });
+      try {
+        for await (const ev of parseAnthropicSSELines(sseLineStream(response.body!))) {
+          if (ev.type === 'usage') {
+            // ⭐ 벤치 «캐시 칸 맞대기» — provider=bedrock 과 cachedInput 을 한 줄에.
+            debug.log('llm.bedrock', 'usage', {
+              provider: 'bedrock', region, model: wireModel,
+              inputTokens: ev.usage.inputTokens ?? 0,
+              outputTokens: ev.usage.outputTokens ?? 0,
+              cachedInput: ev.usage.cacheReadInputTokens ?? 0,
+              cacheCreationInput: ev.usage.cacheCreationInputTokens ?? 0,
+            });
+          }
+          yield ev;
+        }
+      } catch (err: any) {
+        if (err?.name === 'AbortError') return;
+        throw err;
+      }
+    },
+    async *chat(messages, opts = {}) {
+      const { textOnly } = await import('../llm.js');
+      yield* textOnly(this.streamChat!(messages, opts));
+    },
+  };
+}
+
+/** PROVIDERS.bedrock — 설정 무관 기본 인스턴스를 처음 쓸 때 한 번 만든다(가용 판정은 호출 때 env·파일을 다시 본다). */
+let bedrockSingletonInstance: LLMProvider | undefined;
+function bedrockSingleton(): LLMProvider {
+  bedrockSingletonInstance ??= makeBedrockProvider({ provider: 'bedrock' });
+  return bedrockSingletonInstance;
+}
+
+export const BedrockProvider: LLMProvider = {
+  name: 'bedrock',
+  get defaultModel() { return bedrockSingleton().defaultModel; },
+  available: () => bedrockSingleton().available(),
+  streamChat: (messages, opts = {}) => bedrockSingleton().streamChat!(messages, opts),
+  chat: (messages, opts = {}) => bedrockSingleton().chat(messages, opts),
+};
+
+/** bedrock 이 받는 모델 꼴 — `anthropic.claude-…`·`bedrock/…` ⊕ 1st-party claude id ⊕ 모르는 꼴(추론 프로필 ARN 등 · 엔드포인트가 판정).
+ *  `inferProvider` 는 llm.ts 의 추론기를 인자로 받는다(순환 없이). */
+export function isBedrockCompatibleModel(model: string, inferProvider: (m: string) => string | null): boolean {
+  if (bedrock.isBedrockModelId(model)) return true;
+  const implied = inferProvider(model);
+  return implied === null || implied === 'anthropic';
+}