elanous 0.2.23 → 0.2.24

package/src/instance/resolve.ts

@@ -56,6 +56,30 @@ export function resolveInstance(deps: ResolveDeps = {}): InstanceResolution {
   return { kind: 'test', root: normRoot(join(process.cwd(), '.elanous-test')), layer: 'default', why: '소스 트리 밖 실행(격리)' };
 }
 
+/** 부모가 도장으로 물려준 우주와 자식이 실제로 쓰는 우주가 다른가. 비어 있는 쪽은 비교하지 않는다. */
+export function universeMismatch(parentRoot: string | undefined, childRoot: string | undefined): { parentRoot: string; childRoot: string } | null {
+  const parent = parentRoot?.trim();
+  const child = childRoot?.trim();
+  if (!parent || !child) return null;
+  const p = normRoot(parent);
+  const c = normRoot(child);
+  return p === c ? null : { parentRoot: p, childRoot: c };
+}
+
+export type UniverseMeasure = { measurable: true } | { measurable: false; reason: '빈 우주' };
+
+/** 읽을 우주가 비어 있으면 «0» 이 아니라 «측정 불가» 로 말해야 한다. 디렉터리가 없거나 항목이 하나도 없으면 빈 우주다. */
+export function measureUniverse(root: string, entries: (dir: string) => string[] = defaultEntries): UniverseMeasure {
+  return entries(root).length > 0 ? { measurable: true } : { measurable: false, reason: '빈 우주' };
+}
+
+function defaultEntries(dir: string): string[] {
+  try {
+    const { readdirSync } = require('node:fs') as typeof import('node:fs');
+    return readdirSync(dir);
+  } catch { return []; }
+}
+
 /** 명시 config-dir 이 없으면 state-dir 과 config-dir 을 같은 우주로 유지한다. */
 export function configDirFollowingStateDir(
   explicitConfigDir: string | undefined,

package/src/instance/spawn-elanous.ts

@@ -0,0 +1,45 @@
+// 자식 elanous 기동의 단일 입구. 우주는 부모가 한 번 정해 ELANOUS_STATE_DIR 도장으로 물려준다.
+import { spawn, spawnSync, type ChildProcess, type SpawnOptions, type SpawnSyncOptions, type SpawnSyncReturns } from 'node:child_process';
+import { resolve } from 'node:path';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
+import { effectiveInstanceRoot } from './resolve.js';
+
+const DEFAULT_BIN = resolve(import.meta.dir, '../../bin/elanous.mjs');
+
+export interface SpawnElanousOptions {
+  /** 자식이 쓸 우주. 생략하면 부모의 effectiveInstanceRoot(). 명시한 값이 이긴다. */
+  stateDir?: string;
+  /** 실행할 elanous 진입 스크립트. 생략하면 이 트리의 bin/elanous.mjs. */
+  bin?: string;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface ElanousInvocation {
+  command: string;
+  args: string[];
+  env: NodeJS.ProcessEnv;
+}
+
+/** 자식 기동 명세를 만든다. env 는 부모 env 위에 우주 도장(뿌리 ⊕ 출처)을 얹은 것이다. */
+export function elanousInvocation(args: readonly string[], opts: SpawnElanousOptions = {}): ElanousInvocation {
+  const root = opts.stateDir?.trim() || effectiveInstanceRoot();
+  const base = opts.env ?? process.env;
+  return {
+    command: process.execPath,
+    args: [opts.bin ?? DEFAULT_BIN, ...args],
+    env: { ...base, ELANOUS_STATE_DIR: root, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root, base) },
+  };
+}
+
+export function spawnElanous(args: readonly string[], opts: SpawnElanousOptions & Omit<SpawnOptions, 'env' | 'cwd'> = {}): ChildProcess {
+  const { stateDir: _s, bin: _b, env: _e, ...rest } = opts;
+  const inv = elanousInvocation(args, opts);
+  return spawn(inv.command, inv.args, { ...rest, cwd: opts.cwd, env: inv.env });
+}
+
+export function spawnElanousSync(args: readonly string[], opts: SpawnElanousOptions & Omit<SpawnSyncOptions, 'env' | 'cwd'> = {}): SpawnSyncReturns<string | Buffer> {
+  const { stateDir: _s, bin: _b, env: _e, ...rest } = opts;
+  const inv = elanousInvocation(args, opts);
+  return spawnSync(inv.command, inv.args, { ...rest, cwd: opts.cwd, env: inv.env });
+}

package/src/intake-plane/ref-prefetch.ts

@@ -0,0 +1,110 @@
+import type { RegisteredIntakeSource } from './intake-sources.js';
+
+/** listChecklist(v).items 꼴 — 호출 쪽이 다음 두 판 칸을 모아 넘긴다. */
+export interface PrefetchCell {
+  id: string;
+  title: string;
+  status: string;
+  refs?: readonly string[];
+  /** 그 판 날짜(YYYY-MM-DD). 주제 until 로 실린다. */
+  until?: string;
+}
+
+export interface PrefetchTopic {
+  topic: string;
+  cellIds: string[];
+  until?: string;
+}
+
+export interface PrefetchTopicsOpts {
+  max?: number;
+}
+
+/**
+ * 의도적 경계: 이 파일은 제안만 만든다. intake CLI `prefetch --dry-run|--apply` 와
+ * REQ-LEDGER 테마 원천 교체는 다음 조각 — addSource · CLI 를 부르지 않는다.
+ */
+function backtickTokens(title: string): string[] {
+  const tokens: string[] = [];
+  const re = /`([^`]+)`/g;
+  for (let match = re.exec(title); match; match = re.exec(title)) {
+    const token = match[1]!.trim();
+    if (token) tokens.push(token);
+  }
+  return tokens;
+}
+
+function englishProperNouns(title: string): string[] {
+  const stripped = title.replace(/`[^`]*`/g, ' ');
+  const tokens: string[] = [];
+  // CamelCase · 내부 대문자 식별자, 또는 2글자 이상 대문자(하이픈 칸 id 포함).
+  const re = /\b(?:[A-Z][A-Za-z0-9]*[A-Z][A-Za-z0-9]*|[A-Z]{2,}(?:-[A-Z0-9]+)*)\b/g;
+  for (let match = re.exec(stripped); match; match = re.exec(stripped)) tokens.push(match[0]);
+  return tokens;
+}
+
+function rfcNames(refs: readonly string[] | undefined): string[] {
+  if (!refs) return [];
+  const names: string[] = [];
+  for (const ref of refs) {
+    const file = (ref.split('#')[0] ?? '').split('/').pop() ?? '';
+    const stem = file.replace(/\.[A-Za-z0-9]+$/, '').replace(/-\d{4}-\d{2}-\d{2}$/, '');
+    if (stem.startsWith('RFC-') && stem.length > 4) names.push(stem);
+  }
+  return names;
+}
+
+function laterDate(a: string | undefined, b: string | undefined): string | undefined {
+  if (!a) return b;
+  if (!b) return a;
+  return a >= b ? a : b;
+}
+
+function sourceId(topic: string): string {
+  const slug = topic.replace(/[^\w.-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 48);
+  return `ref-prefetch-${slug || 'topic'}`;
+}
+
+export function prefetchTopics(cells: readonly PrefetchCell[], opts: PrefetchTopicsOpts = {}): PrefetchTopic[] {
+  const max = opts.max ?? 5;
+  const byTopic = new Map<string, { topic: string; count: number; cellIds: string[]; until?: string }>();
+  const order: string[] = [];
+  for (const cell of cells) {
+    if (cell.status !== 'yellow') continue;
+    const tokens = new Set([
+      ...englishProperNouns(cell.title),
+      ...backtickTokens(cell.title),
+      ...rfcNames(cell.refs),
+    ]);
+    for (const topic of tokens) {
+      let acc = byTopic.get(topic);
+      if (!acc) {
+        acc = { topic, count: 0, cellIds: [], until: cell.until };
+        byTopic.set(topic, acc);
+        order.push(topic);
+      }
+      acc.count++;
+      if (!acc.cellIds.includes(cell.id)) acc.cellIds.push(cell.id);
+      acc.until = laterDate(acc.until, cell.until);
+    }
+  }
+  return order
+    .map((topic) => byTopic.get(topic)!)
+    .sort((a, b) => b.count - a.count || order.indexOf(a.topic) - order.indexOf(b.topic))
+    .slice(0, Math.max(0, max))
+    .map(({ topic, cellIds, until }) => until === undefined ? { topic, cellIds } : { topic, cellIds, until });
+}
+
+export function prefetchSources(topics: readonly PrefetchTopic[], seat: string, now: Date): RegisteredIntakeSource[] {
+  // 판 날짜를 모르면 until 을 비운다 — now 로 채우면 untilMs(그날 00:00Z) 기준으로 이미 만료된 제안이 된다.
+  void now;
+  return topics.map((entry) => ({
+    id: sourceId(entry.topic),
+    seat,
+    kind: 'github-query',
+    spec: entry.topic,
+    every: '1d',
+    ...(entry.until === undefined ? {} : { until: entry.until }),
+    why: `REF-PREFETCH ⊕ ${entry.cellIds.join(' ')}`,
+  }));
+}

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/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') {