elanous 0.2.23 → 0.2.25

package/src/intelligence-map/model-catalog.ts

@@ -620,6 +620,78 @@ export const BUILTIN_CATALOG: ModelCatalog = {
       notes: 'Apache 2.0 · 397B MoE · Q4 ~220GB · M3 Ultra 512GB only',
     },
 
+    // ── DeepSeek V4 · OpenRouter `openrouter/deepseek/<id>` 전용 (OR-DEEPSEEK-TUNE · 2026-10-11)
+    // id 는 OpenRouter slug(`deepseek/` 뒤) 그대로 — llm.ts openRouterReasoningField 가 이 id 로 openWeight 를
+    // 찾는다. 기본 effort 는 YAML 손 레코드(catalog/models/openrouter/ · #26055)의 `reasoning` 이 정본이고,
+    // 레코드가 없을 때만 이 openWeight 폴백(medium)을 탄다. 단가 = deepseek 공급자 엔드포인트 평시가
+    // (v4.1-flash·v4-pro-0813 은 #26055 와 같은 값) · 나머지는 /api/v1/models 목록가(2026-10-11 실측).
+    // effort 상한 xhigh(OpenRouter 는 max 를 400 으로 거부 → src/llm/openrouter-deepseek.ts 가 max→xhigh).
+    // provider 'other' — 직결 deepseek 공급자는 없다(새 공급자 이름을 만들지 않는다).
+    {
+      id: 'deepseek-v4-flash',
+      provider: 'other',
+      family: 'deepseek',
+      contextWindow: 1_048_576,
+      inputPerMtok: 0.03,
+      outputPerMtok: 1.28,
+      local: false,
+      openWeight: true,
+      localPullable: false,
+      tags: ['coding', 'moe', 'cheap', 'open-weight', 'long-context'],
+      bestFor: ['cheap-agentic', 'open-weight-bench'],
+      reasoningEffortCeiling: 'xhigh',
+      releasedAt: '2026-04-24',
+      notes: 'OpenRouter deepseek/deepseek-v4-flash · 1M ctx',
+    },
+    {
+      id: 'deepseek-v4.1-flash',
+      provider: 'other',
+      family: 'deepseek',
+      contextWindow: 1_048_576,
+      inputPerMtok: 0.15,
+      outputPerMtok: 0.60,
+      local: false,
+      openWeight: true,
+      localPullable: false,
+      tags: ['coding', 'moe', 'cheap', 'open-weight', 'long-context'],
+      bestFor: ['cheap-agentic', 'open-weight-bench'],
+      reasoningEffortCeiling: 'xhigh',
+      releasedAt: '2026-09-10',
+      notes: 'OpenRouter deepseek/deepseek-v4.1-flash · 1M ctx',
+    },
+    {
+      id: 'deepseek-v4-pro',
+      provider: 'other',
+      family: 'deepseek',
+      contextWindow: 1_048_576,
+      inputPerMtok: 0.2088,
+      outputPerMtok: 0.4176,
+      local: false,
+      openWeight: true,
+      localPullable: false,
+      tags: ['coding', 'moe', 'open-weight', 'flagship', 'long-context'],
+      bestFor: ['open-frontier', 'open-weight-bench'],
+      reasoningEffortCeiling: 'xhigh',
+      releasedAt: '2026-04-24',
+      notes: 'OpenRouter deepseek/deepseek-v4-pro · 0423 Preview 별칭 — 고정판은 deepseek-v4-pro-0813',
+    },
+    {
+      id: 'deepseek-v4-pro-0813',
+      provider: 'other',
+      family: 'deepseek',
+      contextWindow: 1_048_576,
+      inputPerMtok: 0.66,
+      outputPerMtok: 1.98,
+      local: false,
+      openWeight: true,
+      localPullable: false,
+      tags: ['coding', 'moe', 'open-weight', 'flagship', 'long-context'],
+      bestFor: ['open-frontier', 'open-weight-bench'],
+      reasoningEffortCeiling: 'xhigh',
+      releasedAt: '2026-08-13',
+      notes: 'OpenRouter deepseek/deepseek-v4-pro-0813 · 날짜 고정판',
+    },
+
     // ── GLM 5.x (Zhipu) · `api.z.ai` / `open.bigmodel.cn` · OpenAI-compat
     // GLM-5.1 (2026-04-07) is the current flagship — 754B MoE / 40B
     // active under MIT. All recent GLM models (4.6+) are open-weight,

package/src/intelligence-map/model-watch-intake.ts

@@ -103,6 +103,46 @@ export async function runModelWatchIntake(
   return { candidates, proposal, perSource };
 }
 
+export type PriceField = 'inputPerMtok' | 'outputPerMtok';
+
+export interface PriceChange {
+  id: string;
+  field: PriceField;
+  /** Price currently in the catalog (USD per 1M tokens). */
+  before: number;
+  /** Price the watched page reports. */
+  after: number;
+}
+
+const PRICE_FIELDS: readonly PriceField[] = ['inputPerMtok', 'outputPerMtok'];
+
+/** Price differences between the catalog and the watched pages. The merge
+ *  only fills undefined fields, so a repriced model shows up in
+ *  `proposal.updated` with no trace of the new price — this reports it.
+ *  A catalog price of 0 means "not priced yet" and is not a change. */
+export function detectPriceChanges(result: Pick<WatchIntakeResult, 'candidates' | 'proposal'>): PriceChange[] {
+  const current = new Map(result.proposal.catalog.models.map((model) => [model.id, model]));
+  const updated = new Set(result.proposal.updated);
+  const changes: PriceChange[] = [];
+  for (const candidate of result.candidates) {
+    const entry = current.get(candidate.id);
+    if (!entry || !updated.has(candidate.id)) continue;
+    for (const field of PRICE_FIELDS) {
+      const before = entry[field];
+      const after = candidate[field];
+      if (typeof after !== 'number' || !Number.isFinite(after) || after < 0) continue;
+      if (typeof before !== 'number' || before <= 0 || before === after) continue;
+      changes.push({ id: candidate.id, field, before, after });
+    }
+  }
+  return changes;
+}
+
+export function formatPriceChange(change: PriceChange): string {
+  const label = change.field === 'inputPerMtok' ? 'input' : 'output';
+  return `${change.id} ${label} $${change.before}→$${change.after} /Mtok`;
+}
+
 function errorMessage(error: unknown): string {
   try {
     const message = error instanceof Error ? error.message : String(error);

package/src/intelligence-map/model-watch-mission.ts

@@ -21,7 +21,13 @@ import { lookupLlmTierSpec } from '../model-tier/index.js';
 import type { LlmRunner } from '../model-tier/preset-suggest-llm.js';
 import type { LLMProviderName } from '../user-config.js';
 import { getUserConfig } from '../user-config.js';
-import { runModelWatchIntake, type WatchIntakeResult, type WatchPage } from './model-watch-intake.js';
+import {
+  detectPriceChanges,
+  formatPriceChange,
+  runModelWatchIntake,
+  type WatchIntakeResult,
+  type WatchPage,
+} from './model-watch-intake.js';
 
 export function getModelWatchProposalPath(home: string = homedir()): string {
   return join(home, '.elanous', 'model-watch-proposals.jsonl');
@@ -93,6 +99,13 @@ export async function runModelIntelligenceWatch(
       line: `Classification incomplete for zero-candidate sources: ${abnormalEmptySources.join(', ')}`,
     });
   }
+  const priceChanges = detectPriceChanges(result);
+  if (priceChanges.length > 0) {
+    await safeLog(log, 'intelligence-map.model-watch', 'price-changes', {
+      changes: priceChanges,
+      line: `Price changes vs catalog: ${priceChanges.map(formatPriceChange).join('; ')}`,
+    });
+  }
   await safeLog(log, 'intelligence-map.model-watch', 'pass', {
     pages: pages.length,
     candidates: result.candidates.length,

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

@@ -8,9 +8,10 @@
 import type { LLMProvider } from '../llm.js';
 import type { LLMConfig as UCLLMConfig } from '../user-config.js';
 import { debug, redactSecrets } from '../debug/log.js';
-import { fetchApiWithRetry } from '../session-runtime/retry-api.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 {
@@ -21,6 +22,71 @@ export interface BedrockProviderDeps {
   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 파서를 그대로 쓴다*** —
@@ -39,7 +105,7 @@ export function makeBedrockProvider(cfg: UCLLMConfig, deps: BedrockProviderDeps
       const {
         toAnthropicMessage, effectiveReasoningLevel, usesAdaptiveThinking,
         mapReasoningLevelToAnthropicThinking, mapReasoningLevelToAnthropicEffort,
-        anthropicTemperatureField, parseAnthropicSSELines, sseLineStream, retryOptsFor,
+        anthropicTemperatureField, parseAnthropicSSELines, sseLineStream: anthropicSseLineStream, retryOptsFor,
       } = await import('../llm.js');
       const region = bedrock.resolveBedrockRegion(envDeps);
       if (!region) {
@@ -48,6 +114,49 @@ export function makeBedrockProvider(cfg: UCLLMConfig, deps: BedrockProviderDeps
       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;
@@ -85,46 +194,10 @@ export function makeBedrockProvider(cfg: UCLLMConfig, deps: BedrockProviderDeps
         ...anthropicTemperatureField(familyModel, thinkingActive, opts.temperature),
         ...(tools ? { tools } : {}),
       };
-      const signRequest = () => bedrock.buildSignedBedrockRequest({
-        region,
-        body,
-        ...(deps.env ? { env: deps.env } : {}),
-        ...(deps.resolveCredentials ? { resolveCredentials: deps.resolveCredentials } : {}),
-        ...(deps.sign ? { sign: deps.sign } : {}),
+      const response = await signAndSend({
+        region, body, wireModel, route, deps, envDeps, opts, retryOptsFor,
+        requestLog: { cache, ttl, tools: opts.tools?.length ?? 0 },
       });
-      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,
-        auth: signed.headers['x-api-key'] !== undefined ? 'bearer' : 'sigv4',
-        cache, ttl, tools: opts.tools?.length ?? 0,
-      });
-      // ⛔ 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).
-      const response = deps.send
-        ? await deps.send(signed.url, init)
-        : await fetchApiWithRetry(signed.url, init, {
-          ...retryOptsFor('bedrock', 'Bedrock API', opts.remainingFallbacks),
-          refreshInit: async () => toInit(await signRequest()),
-        });
-      if (!response.ok) {
-        const text = await response.text().catch(() => '');
-        throw new Error(`Bedrock API ${response.status}: ${redactSecrets(text).slice(0, 500)}`);
-      }
       try {
         for await (const ev of parseAnthropicSSELines(sseLineStream(response.body!))) {
           if (ev.type === 'usage') {