elanous 0.2.21 → 0.2.23

package/src/knowledge/write.ts

@@ -7,14 +7,21 @@
 //   - automatic tag / kind merge into frontmatter
 //   - Poka-Yoke validation → atomic-write ONLY on pass
 
-import { existsSync, statSync } from 'node:fs';
-import { join, resolve, sep } from 'node:path';
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { gunzipSync } from 'node:zlib';
+import { isAbsolute, join, resolve, sep } from 'node:path';
+import { packDirDeterministic } from '../market/tgz.js';
+import { verifyIndex } from '../market/signed-index.js';
 import {
   writeNote,
   type ObsidianVault,
 } from '../auto-research/obsidian-bridge.js';
 import type { PokaSchema, ValidationFailure } from '../cft/pokayoke.js';
 import { validate } from '../cft/pokayoke.js';
+import { isPackSlug, isPackVersion, packIdString, type Pack, type PackId } from './kgs/pack.js';
+import { isKnowledgeKind, type KnowledgeCard } from './kgs/types.js';
+import { kgsStoreSingleton, type KgsSqliteStore } from './kgs/sqlite-store.js';
 import type {
   KnowledgeKind,
   KnowledgeWriteInput,
@@ -141,6 +148,231 @@ export function knowledgeWrite(
   return { ok: true, path: abs, relPath: rel };
 }
 
+/** KPACK1 directory manifest. Market signatures belong to the index, not this file. */
+export interface KnowledgePackManifest {
+  kind: 'knowledge-pack';
+  name: string;
+  version: string;
+  description: string;
+  signature: { alg: 'ed25519'; keyId: string };
+  dependencies: readonly { market: string; name: string; version: string }[];
+  license: string;
+  visibility: 'public' | 'internal';
+  content: readonly { type: 'document' | 'glossary' | 'procedure' | 'rule' | 'qa'; path: string }[];
+}
+
+/** Verified marketplace evidence is required when installing from a market. The URL→key binding is caller-owned. */
+export interface KnowledgePackMarketProof {
+  marketplaceBytes: Uint8Array;
+  signatureText: string;
+  trustedKeys: ReadonlyArray<{ keyId: string; publicKey: string }>;
+  artifactBytes: Uint8Array;
+  lastSequence?: number;
+}
+
+export type KnowledgePackStore = Pick<KgsSqliteStore, 'readPack' | 'writePack' | 'deletePack' | 'replacePack'>;
+
+function object(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function requiredString(value: unknown, field: string): asserts value is string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`KPACK1: ${field} must be a non-empty string`);
+}
+
+/** Never follow a symlink, including any ancestor of an enumerated content file. */
+function safePackFile(root: string, path: string): string {
+  if (!path || isAbsolute(path) || path.includes('\\') || path.split('/').some(part => !part || part === '.' || part === '..')) {
+    throw new Error(`KPACK1: unsafe path: ${path}`);
+  }
+  let current = root;
+  for (const part of path.split('/')) {
+    current = join(current, part);
+    const stat = lstatSync(current);
+    if (stat.isSymbolicLink()) throw new Error(`KPACK1: symbolic link: ${path}`);
+  }
+  if (!lstatSync(current).isFile()) throw new Error(`KPACK1: not a file: ${path}`);
+  return current;
+}
+
+/** Validate the manifest and all listed content before any store mutation. */
+export function validateKnowledgePack(directory: string): { manifest: KnowledgePackManifest; pack: Pack } {
+  if (!lstatSync(directory).isDirectory() || lstatSync(directory).isSymbolicLink()) throw new Error('KPACK1: not a directory');
+  // The packer traverses the whole directory and refuses even unlisted symlinks/special files.
+  packDirDeterministic(directory);
+  return validatePackFiles(path => readFileSync(safePackFile(directory, path), 'utf8'));
+}
+
+/** Read the regular files of a deterministic ustar gzip archive (as produced by packDirDeterministic). */
+const MAX_ARCHIVE_BYTES = 32 * 1024 * 1024;
+
+function archiveFiles(archive: Uint8Array): Map<string, string> {
+  if (archive.byteLength > MAX_ARCHIVE_BYTES) throw new Error('KPACK1: archive too large');
+  let tar: Buffer;
+  // Bound the inflated size so a small compressed bomb cannot exhaust memory.
+  try { tar = gunzipSync(archive, { maxOutputLength: MAX_ARCHIVE_BYTES }); }
+  catch (error) { throw new Error(`KPACK1: archive unreadable or larger than ${MAX_ARCHIVE_BYTES} bytes: ${String(error)}`); }
+  const files = new Map<string, string>();
+  const field = (header: Buffer, offset: number, width: number) => {
+    const raw = header.subarray(offset, offset + width);
+    const end = raw.indexOf(0);
+    return raw.subarray(0, end < 0 ? width : end).toString('utf8');
+  };
+  for (let offset = 0; offset + 512 <= tar.length;) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every(byte => byte === 0)) break;
+    const type = field(header, 156, 1);
+    if (type !== '0' && type !== '') throw new Error('KPACK1: archive contains a non-regular entry');
+    const size = Number.parseInt(field(header, 124, 12).trim(), 8);
+    if (!Number.isSafeInteger(size) || size < 0 || offset + 512 + size > tar.length) throw new Error('KPACK1: malformed archive');
+    const name = field(header, 0, 100);
+    const prefix = field(header, 345, 155);
+    const path = prefix ? `${prefix}/${name}` : name;
+    if (files.has(path)) throw new Error(`KPACK1: duplicate archive entry: ${path}`);
+    files.set(path, tar.subarray(offset + 512, offset + 512 + size).toString('utf8'));
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+  return files;
+}
+
+/** Validate from verified archive bytes, so what is stored is exactly what the signature covered. */
+export function validateKnowledgePackArchive(archive: Uint8Array): { manifest: KnowledgePackManifest; pack: Pack } {
+  const files = archiveFiles(archive);
+  return validatePackFiles((path) => {
+    const content = files.get(path);
+    if (content === undefined) throw new Error(`KPACK1: missing from archive: ${path}`);
+    return content;
+  });
+}
+
+function validatePackFiles(read: (path: string) => string): { manifest: KnowledgePackManifest; pack: Pack } {
+  const value: unknown = JSON.parse(read('knowledge-pack.json'));
+  if (!object(value) || value.kind !== 'knowledge-pack') throw new Error('KPACK1: invalid kind');
+  if (!isPackSlug(value.name) || !isPackVersion(value.version)) throw new Error('KPACK1: invalid name or version');
+  requiredString(value.description, 'description');
+  requiredString(value.license, 'license');
+  if (!object(value.signature) || value.signature.alg !== 'ed25519' || typeof value.signature.keyId !== 'string' || !/^[a-fA-F0-9]{8}$/.test(value.signature.keyId)) throw new Error('KPACK1: invalid signature declaration');
+  if (value.visibility !== 'public' && value.visibility !== 'internal') throw new Error('KPACK1: invalid visibility');
+  if (!Array.isArray(value.dependencies) || !Array.isArray(value.content) || value.content.length === 0 || value.content.length > 200) throw new Error('KPACK1: invalid dependencies or content');
+  for (const dep of value.dependencies) {
+    if (!object(dep) || typeof dep.market !== 'string' || !/^https:\/\//.test(dep.market) || !isPackSlug(dep.name) || typeof dep.version !== 'string' || !dep.version.trim()) throw new Error('KPACK1: invalid dependency');
+  }
+  // No dependency resolver is available in standalone storage; never silently install an incomplete pack.
+  if (value.dependencies.length) throw new Error('KPACK1: dependencies require a verified resolver');
+  const seen = new Set<string>();
+  const cards: KnowledgeCard[] = [];
+  for (const entry of value.content) {
+    if (!object(entry) || !['document', 'glossary', 'procedure', 'rule', 'qa'].includes(entry.type as string) || typeof entry.path !== 'string' || !entry.path.startsWith('content/') || !entry.path.endsWith('.json')) throw new Error('KPACK1: invalid content entry');
+    if (seen.has(entry.path)) throw new Error(`KPACK1: duplicate content: ${entry.path}`);
+    seen.add(entry.path);
+    const item: unknown = JSON.parse(read(entry.path));
+    if (!object(item) || item.type !== entry.type) throw new Error(`KPACK1: invalid content: ${entry.path}`);
+    requiredString(item.title, `${entry.path}.title`);
+    requiredString(item.source, `${entry.path}.source`);
+    if (item.kind !== undefined && !isKnowledgeKind(item.kind)) throw new Error(`KPACK1: invalid content kind: ${entry.path}`);
+    const fields: Record<string, readonly string[]> = {
+      document: ['body'], glossary: ['term', 'definition'], procedure: ['preconditions'],
+      rule: ['scope', 'basis'], qa: ['question', 'answer'],
+    };
+    for (const field of fields[entry.type as string]!) requiredString(item[field], `${entry.path}.${field}`);
+    if (entry.type === 'procedure' && (!Array.isArray(item.steps) || !item.steps.length || !item.steps.every((step: unknown) => typeof step === 'string' && step.trim()))) throw new Error(`KPACK1: ${entry.path}.steps must be non-empty strings`);
+    const body = entry.type === 'document' ? item.body as string : entry.type === 'procedure'
+      ? `${item.preconditions}\n${(item.steps as string[]).join('\n')}`
+      : fields[entry.type as string]!.map(field => item[field]).join('\n');
+    const id = `card:${createHash('sha256').update(entry.path).digest('hex').slice(0, 16)}`;
+    const timestamp = '1970-01-01T00:00:00.000Z';
+    cards.push({ schema_version: 2, id, title: item.title, body, kind: isKnowledgeKind(item.kind) ? item.kind : 'card',
+      nature: 'fact', reliability: 'self-reported', author: value.name,
+      createdAt: timestamp, updatedAt: timestamp, source: { kind: 'external', url: item.source }, tags: [] });
+  }
+  const manifest = value as unknown as KnowledgePackManifest;
+  return { manifest, pack: {
+    schema_version: 2,
+    metadata: { id: { slug: manifest.name, version: manifest.version }, title: manifest.name,
+      intent: manifest.description, audience: manifest.visibility === 'public' ? 'public' : 'team',
+      kind: 'generic', createdAt: '1970-01-01T00:00:00.000Z', updatedAt: '1970-01-01T00:00:00.000Z',
+      author: manifest.name, tags: [] }, cards,
+  } };
+}
+
+/**
+ * Market path: verify the signed index and artifact first, then build the pack
+ * from those verified bytes (never from a second read of the directory).
+ */
+function verifiedMarketPack(directory: string, proof: KnowledgePackMarketProof): { manifest: KnowledgePackManifest; pack: Pack } {
+  const verified = verifyIndex(proof);
+  if (!verified.ok) throw new Error(`KPACK1: index ${verified.reason}: ${verified.detail}`);
+  const artifact = Buffer.from(proof.artifactBytes);
+  const sha256 = createHash('sha256').update(artifact).digest('hex');
+  const listed = verified.index.knowledgePacks?.filter(pack => pack.artifact.bytes === artifact.byteLength && pack.artifact.sha256.toLowerCase() === sha256) ?? [];
+  if (!listed.length) throw new Error('KPACK1: artifact hash or size mismatch');
+  const result = validateKnowledgePackArchive(artifact);
+  const { manifest } = result;
+  if (verified.keyId !== manifest.signature.keyId) throw new Error('KPACK1: manifest keyId differs from signed index');
+  const entry = listed.find(pack => pack.name === manifest.name && pack.version === manifest.version);
+  if (!entry || entry.visibility !== manifest.visibility || (entry.visibility === 'internal' && !entry.enterpriseId)) throw new Error('KPACK1: pack absent from signed index');
+  // The local directory must still be the extraction of this artifact.
+  validateKnowledgePack(directory);
+  if (Buffer.compare(Buffer.from(packDirDeterministic(directory)), artifact) !== 0) throw new Error('KPACK1: extracted directory differs from verified artifact');
+  return result;
+}
+
+/** Local-path installs validate content; market installs additionally require signed-index and archive proof. */
+export function installKnowledgePack(directory: string, store: KnowledgePackStore = kgsStoreSingleton(), proof?: KnowledgePackMarketProof): string {
+  const { manifest, pack } = proof ? verifiedMarketPack(directory, proof) : validateKnowledgePack(directory);
+  if (store.readPack(manifest.name, manifest.version)) throw new Error(`KPACK1: already installed: ${packIdString(pack.metadata.id)}`);
+  store.writePack(pack);
+  return packIdString(pack.metadata.id);
+}
+
+export function removeKnowledgePack(id: PackId, store: KnowledgePackStore = kgsStoreSingleton()): boolean {
+  if (!isPackSlug(id.slug) || !isPackVersion(id.version)) throw new Error('KPACK1: invalid pack id');
+  return store.deletePack(id.slug, id.version);
+}
+
+function comparePackVersions(next: string, previous: string): number {
+  if (!isPackVersion(next) || !isPackVersion(previous)) throw new Error('KPACK1: invalid pack version');
+  const nextSeparator = next.indexOf('-');
+  const previousSeparator = previous.indexOf('-');
+  const nextCore = nextSeparator < 0 ? next : next.slice(0, nextSeparator);
+  const previousCore = previousSeparator < 0 ? previous : previous.slice(0, previousSeparator);
+  const nextPre = nextSeparator < 0 ? undefined : next.slice(nextSeparator + 1);
+  const previousPre = previousSeparator < 0 ? undefined : previous.slice(previousSeparator + 1);
+  const left = nextCore.split('.').map(BigInt);
+  const right = previousCore.split('.').map(BigInt);
+  for (let i = 0; i < 3; i++) {
+    if (left[i] !== right[i]) return left[i]! > right[i]! ? 1 : -1;
+  }
+  if (nextPre === previousPre) return 0;
+  if (!nextPre) return 1;
+  if (!previousPre) return -1;
+  const nextIdentifiers = nextPre.split('.');
+  const previousIdentifiers = previousPre.split('.');
+  for (let i = 0; i < Math.min(nextIdentifiers.length, previousIdentifiers.length); i++) {
+    const nextIdentifier = nextIdentifiers[i]!;
+    const previousIdentifier = previousIdentifiers[i]!;
+    if (nextIdentifier === previousIdentifier) continue;
+    const nextNumeric = /^\d+$/.test(nextIdentifier);
+    const previousNumeric = /^\d+$/.test(previousIdentifier);
+    if (nextNumeric && previousNumeric) {
+      return BigInt(nextIdentifier) > BigInt(previousIdentifier) ? 1 : -1;
+    }
+    if (nextNumeric) return -1;
+    if (previousNumeric) return 1;
+    return nextIdentifier > previousIdentifier ? 1 : -1;
+  }
+  return Math.sign(nextIdentifiers.length - previousIdentifiers.length);
+}
+
+/** Atomically switch one installed version after the replacement has passed validation. */
+export function upgradeKnowledgePack(previous: PackId, directory: string, store: KnowledgePackStore = kgsStoreSingleton(), proof?: KnowledgePackMarketProof): string {
+  if (!isPackSlug(previous.slug) || !isPackVersion(previous.version)) throw new Error('KPACK1: invalid previous pack id');
+  const { manifest, pack } = proof ? verifiedMarketPack(directory, proof) : validateKnowledgePack(directory);
+  if (manifest.name !== previous.slug || comparePackVersions(manifest.version, previous.version) <= 0) throw new Error('KPACK1: upgrade requires a newer version of the same pack');
+  store.replacePack(previous, pack);
+  return packIdString(pack.metadata.id);
+}
+
 /** Test helper — size of the KIND_SCHEMAS dict for assertion. */
 export function _kindSchemaCountForTest(): number {
   return Object.keys(KIND_SCHEMAS).length;

package/src/llm/bedrock-provider.ts

@@ -0,0 +1,175 @@
+// ── 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 { fetchApiWithRetry } from '../session-runtime/retry-api.js';
+import { isVisionCapableModel } from '../llm-vision-capability.js';
+import * as bedrock from './bedrock.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>;
+}
+
+/**
+ * ⭐ 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, 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);
+      // ⭐ 캐시: 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 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,
+        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') {
+            // ⭐ 벤치 «캐시 칸 맞대기» — 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';
+}