Session s23281e5fc47

6773fbf chore(deps): switch package manager from bun to pnpm (#578)
a2809df fix(gateway): prevent session header leaks and harden fetch interceptor (#580)
aa71cad fix(gateway): per-provider auth and upstream snapshots to prevent cross-contamination (#579)
cb5901e fix(core): normalize provider API paths in fetch interceptor (#577)
166eebd fix(gateway): use original fetch for upstream calls to prevent interceptor loop (#576)
270ddc6 refactor(gateway): replace 5 last* SessionState fields with UpstreamSnapshot (#575)
2db852f fix(gateway,opencode,pi): transparent provider routing via fetch-level interception (#574)
3624c22 fix(gateway): couple recall follow-up stream flag to its consumer (#573)
0823301 feat(build): migrate standalone binary from Bun --compile to Node SEA via fossilize (#564)
851e9c2 fix(gateway): route worker calls through session's provider (#572)
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
main

packages/gateway/src/cch.ts:108:  const hash = Bun.hash.xxHash64(bodyWithPlaceholder, WORKER_SEED);
packages/gateway/src/cch.ts:494:    const hash = Bun.hash.xxHash64(bodyWithPlaceholder, seed);
packages/gateway/src/server.ts:13: * Uses `Bun.serve()` — this package targets Bun exclusively.
packages/gateway/src/server.ts:486:  // Spawn one Bun.serve() per host address. This allows binding to
packages/gateway/src/server.ts:494:    const s = Bun.serve({
packages/gateway/src/server.ts:498:      // 255 is the maximum allowed by Bun.
packages/gateway/src/api.ts:81:    const decompressed = Bun.zstdDecompressSync(raw as Uint8Array<ArrayBuffer>);
packages/gateway/src/index.ts:37:if (typeof Bun !== "undefined" && Bun.main === import.meta.path) {
packages/gateway/src/cache-analytics.ts:29:  return Bun.zstdCompressSync(Buffer.from(body));
packages/gateway/src/cache-analytics.ts:34:    Bun.zstdDecompressSync(compressed as Uint8Array<ArrayBuffer>),
packages/gateway/src/cli/lib/upgrade.ts:297:  ...

38
packages/gateway/src/server.ts
packages/gateway/src/cch.ts
packages/gateway/src/api.ts
packages/gateway/src/index.ts
packages/gateway/src/cache-analytics.ts
packages/gateway/src/cli/agents.ts
packages/gateway/src/cli/start.ts
packages/gateway/src/cli/remote.ts
packages/gateway/src/cli/lib/upgrade.ts
packages/gateway/src/cli/lib/delta-upgrade.ts
packages/gateway/src/cli/lib/version-check.ts
packages/gateway/src/cli/lib/bspatch.ts
packages/gateway/src/cli/lib/binary.ts
packages/gateway/src/cli/lib/patch-cache.ts

packages/gateway/src/cli/lib/bspatch.ts:7
packages/gateway/src/cli/lib/patch-cache.ts:5
packages/gateway/src/server.ts:4
packages/gateway/src/cli/lib/upgrade.ts:3
packages/gateway/src/cli/lib/delta-upgrade.ts:3
packages/gateway/src/cli/lib/binary.ts:3
packages/gateway/src/cli/agents.ts:3
packages/gateway/src/cli/lib/version-check.ts:2
packages/gateway/src/cch.ts:2
packages/gateway/src/cache-analytics.ts:2
packages/gateway/src/index.ts:1
packages/gateway/src/cli/start.ts:1
packages/gateway/src/cli/remote.ts:1
packages/gateway/src/api.ts:1

packages/pi/src/index.ts
packages/opencode/test/gateway-smoke.test.ts
packages/opencode/scripts/list-sessions.ts
packages/opencode/eval/session_eval.ts
packages/opencode/eval/extract_session.ts
packages/opencode/eval/coding_eval.ts
packages/opencode/eval/backfill.ts
packages/gateway/test/cch.test.ts
packages/gateway/src/server.ts
packages/gateway/test/idle.test.ts
packages/gateway/src/cch.ts
packages/gateway/src/cache-analytics.ts
packages/gateway/src/api.ts
packages/gateway/src/index.ts
packages/gateway/src/cli/agents.ts
packages/gateway/src/cli/lib/upgrade.ts
packages/gateway/src/cli/lib/delta-upgrade.ts
packages/gateway/src/cli/lib/patch-cache.ts
packages/gateway/src/cli/lib/version-check.ts
packages/gateway/src/cli/lib/bspatch.ts
packages/gateway/src/cli/start.ts
packages/gateway/src/cli/lib/binary.ts
packages/gateway/src/cli/remote.ts
packages/gateway/script/build-binary-sea.ts
packages/gateway/script/bundle.ts
packages/gateway/test/api.test.ts
packages/gateway/script/node-polyfil...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/script/node-polyfills.ts</path>
<type>file</type>
<content>
1: /**
2:  * Bun → Node.js polyfills for the npm CJS bundle.
3:  *
4:  * Injected at esbuild bundle time via `inject`. Source code stays Bun-native;
5:  * these polyfills are invisible to developers and only activate when running
6:  * under Node.js.
7:  *
8:  * Polyfilled APIs:
9:  *  - Bun.serve()              → node:http createServer + WinterCG Request/Response
10:  *  - Bun.zstdCompressSync()   → node:zlib zstdCompressSync (Node ≥ 22.15)
11:  *  - Bun.zstdDecompressSync() → node:zlib zstdDecompressSync (Node ≥ 22.15)
12:  *  - Bun.which()              → child_process execFileSync which/where
13:  *  - Bun.main                 → null (only used in guarded direct-execution check)
14:  *
15:  * NOT polyfilled (already handled):
16:  *  - bun:sqlite   → esbuild plugin rewrites to node:sqlite
17:  *  - ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/package.json</path>
<type>file</type>
<content>
1: {
2:   "name": "@loreai/gateway",
3:   "version": "0.24.1",
4:   "type": "module",
5:   "license": "FSL-1.1-Apache-2.0",
6:   "description": "Lore as a transparent LLM proxy — context management for any AI coding client",
7:   "main": "./dist/index.cjs",
8:   "types": "./dist/index.d.cts",
9:   "exports": {
10:     ".": {
11:       "bun": "./dist/index.bun.js",
12:       "types": "./dist/index.d.cts",
13:       "require": "./dist/index.cjs",
14:       "default": "./dist/index.cjs"
15:     }
16:   },
17:   "bin": {
18:     "lore": "./dist/bin.cjs",
19:     "lore-gateway": "./dist/bin.cjs"
20:   },
21:   "scripts": {
22:     "typecheck": "tsc --noEmit",
23:     "build": "tsx script/build.ts",
24:     "bundle": "tsx script/bundle.ts",
25:     "build:binary": "tsx script/build.ts --binary",
26:     "build:binary:sea": ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/script/build.ts</path>
<type>file</type>
<content>
1: /**
2:  * Build @loreai/gateway.
3:  *
4:  * Two build modes:
5:  *
6:  *   1. `bun run script/build.ts` (default)
7:  *      Produces dist/index.js — publishable ESM bundle for npm.
8:  *      @loreai/core is external (workspace dep, installed alongside).
9:  *
10:  *   2. `bun run script/build.ts --binary`
11:  *      Delegates to `script/build-binary-sea.ts` which produces a
12:  *      standalone Node SEA binary via fossilize. The legacy Bun
13:  *      `--compile` pipeline was removed in #551 in favor of Node SEA
14:  *      because Bun's WASM engine has unfixed bugs that cause ONNX
15:  *      embedding OOM on all platforms (oven-sh/bun#18145, #25677, #31158). ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/script/bundle.ts</path>
<type>file</type>
<content>
1: /**
2:  * Bundle @loreai/gateway into a self-contained CJS package for npm/npx.
3:  *
4:  * Produces:
5:  *   dist/index.cjs — single CJS bundle (gateway + core + all JS deps)
6:  *   dist/bin.cjs   — thin CLI wrapper with Node.js version check
7:  *
8:  * Everything is bundled except:
9:  *   - node:* built-ins (resolved at runtime)
10:  *
11:  * The Bun → Node.js polyfill layer (script/node-polyfills.ts) is injected at
12:  * bundle time so the source code stays Bun-native.
13:  *
14:  * Debug IDs are injected into the JS + sourcemap after bundling for Sentry
15:  * source map resolution. When SENTRY_AUTH_TOKEN is set, sourcemaps are
16:  * uploaded to Sentry and then deleted (they shouldn't ship to users). ...

[
  {
    "content": "Explore gateway src Bun.* usages in detail",
    "status": "in_progress",
    "priority": "high"
  },
  {
    "content": "Plan polyfill extensions (hash, file, write, sleep, semver, mmap, CryptoHasher)",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Extend node-polyfills.ts with Node equivalents",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Verify all Bun.* in gateway src have polyfills or guards",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Run lint, typecheck, and tests",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Commit and create PR",
    "status": "pending",
    "priority": "medium"
  }
]

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cch.ts</path>
<type>file</type>
<content>
95: 
96: // ---------------------------------------------------------------------------
97: // Signing
98: // ---------------------------------------------------------------------------
99: 
100: /**
101:  * Compute the `cch` hash for a JSON request body containing `cch=00000`.
102:  * Returns the body with the placeholder replaced by the computed hash.
103:  *
104:  * @param bodyWithPlaceholder — JSON string containing `cch=00000`
105:  * @returns body with `cch=00000` replaced by `cch=XXXXX`
106:  */
107: export function signBody(bodyWithPlaceholder: string): string {
108:   const hash = Bun.hash.xxHash64(bodyWithPlaceholder, WORKER_SEED);
109:   const cch = (hash & 0xfffffn).toString(16).padStart(5, "0");
110:   return bodyWithPlaceholder.replace(CCH_PLACEHOLDER, `cch=${cch}`);
111: }
112: 
113: /**
114:  * Compute the ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cch.ts</path>
<type>file</type>
<content>
485:   if (!cchMatch) return null;
486: 
487:   const clientCch = cchMatch[1].toLowerCase();
488:   const bodyWithPlaceholder = body.replace(
489:     `cch=${cchMatch[1]}`,
490:     CCH_PLACEHOLDER,
491:   );
492: 
493:   for (const seed of Object.values(VERSION_SEEDS)) {
494:     const hash = Bun.hash.xxHash64(bodyWithPlaceholder, seed);
495:     const ourCch = (hash & 0xfffffn).toString(16).padStart(5, "0");
496:     if (ourCch === clientCch) return true;
497:   }
498: 
499:   return false;
500: }
501: 
502: // ---------------------------------------------------------------------------
503: // Test helpers
504: // ---------------------------------------------------------------------------
505: 
506: /** @internal Reset module state for tests. */
507: export function _resetForTest(): void {
508:   ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
1: /**
2:  * HTTP server for the Lore gateway proxy.
3:  *
4:  * Routes:
5:  *   POST /v1/messages            → Anthropic protocol
6:  *   POST /v1/chat/completions    → OpenAI Chat Completions protocol
7:  *   POST /v1/responses           → OpenAI Responses API protocol
8:  *   POST /v1/responses/compact   → Codex compaction (Responses API)
9:  *   POST /v1/compact             → Explicit compaction summary (Pi plugin, etc.)
10:  *   GET  /v1/models              → Passthrough to upstream
11:  *   GET  /health                 → Health check
12:  *
13:  * Uses `Bun.serve()` — this package targets Bun exclusively.
14:  */
15: import { DEFAULT_PORT, type GatewayConfig } from "./config";
16: import { bootstrapDailySpend, getDailyBudget } from "./cost-tracker";
17: import type { GatewayRequest } from "./translate/types";
18: ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
480:       const msg = e instanceof Error ? e.message : "Internal server error";
481:       console.error(`[lore] uncaught error: ${msg}`);
482:       return errorResponse(500, "api_error", msg);
483:     }
484:   };
485: 
486:   // Spawn one Bun.serve() per host address. This allows binding to
487:   // specific interfaces (e.g. 127.0.0.1 + a Tailscale IP) without
488:   // opening to 0.0.0.0.
489:   //
490:   // Pin the resolved port after the first bind so that when config.port
491:   // is 0 (OS-assigned), all hosts share the same actual port.
492:   let resolvedPort = config.port;
493:   const servers = config.hosts.map((host) => {
494:     const s = Bun.serve({
495:       port: resolvedPort,
496:       hostname: host,
497:       // Bun defaults to 10s which is too short for LLM streaming responses. ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/api.ts</path>
<type>file</type>
<content>
70: }
71: 
72: /**
73:  * Parse request body with optional zstd decompression.
74:  * Checks `Content-Encoding: zstd` header — if present, decompresses
75:  * the raw bytes before JSON-parsing.
76:  */
77: async function parseBody<T = unknown>(req: Request): Promise<T> {
78:   const encoding = req.headers.get("content-encoding");
79:   if (encoding === "zstd") {
80:     const raw = new Uint8Array(await req.arrayBuffer());
81:     const decompressed = Bun.zstdDecompressSync(raw as Uint8Array<ArrayBuffer>);
82:     return JSON.parse(new TextDecoder().decode(decompressed)) as T;
83:   }
84:   return (await req.json()) as T;
85: }
86: 
87: /**
88:  * Resolve a project from URL params + query string.
89:  *

(Showing lines 70-89 of 665. Use offset=90 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/index.ts</path>
<type>file</type>
<content>
1: /**
2:  * Lore Gateway — package entry point.
3:  *
4:  * Library exports for programmatic use, plus `_cli()` for the CLI binary.
5:  *
6:  * Library usage:
7:  *   import { startServer, loadConfig } from "@loreai/gateway";
8:  *
9:  * CLI usage (via bin wrapper):
10:  *   lore start
11:  *   lore run claude
12:  */
13: import "../instrument";
14: 
15: // ---------------------------------------------------------------------------
16: // Library API
17: // ---------------------------------------------------------------------------
18: 
19: export { loadConfig, DEFAULT_PORTS, DEFAULT_PORT } from "./config";
20: export type { GatewayConfig } from "./config";
21: export { startServer } from "./server";
22: export { handleRequest, resetPipelineState } from "./pipeline";
23: export { readPortFile } from "./portfile";
24: ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cache-analytics.ts</path>
<type>file</type>
<content>
1: /**
2:  * Cache analytics — deterministic cache-bust detection using API request
3:  * body prefix comparison and Anthropic response cache fields.
4:  *
5:  * Instead of fingerprinting internal message representations, this module
6:  * compares the actual serialized JSON request body byte-for-byte across
7:  * turns. When the prefix diverges, it maps the byte offset back to a
8:  * semantic location in the JSON structure (e.g. "messages[3].content[1]").
9:  *
10:  * The API response's `cache_read_input_tokens` and
11:  * `cache_creation_input_tokens` provide ground-truth confirmation.
12:  *
13:  * Request bodies are stored zstd-compressed (~99.9% reduction on
14:  * repetitive JSON) to keep per-session memory overhead low. ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/agents.ts</path>
<type>file</type>
<content>
1: /**
2:  * Agent registry — known AI coding agents that can be launched through
3:  * the gateway.
4:  *
5:  * Each agent defines:
6:  *  - How to detect it (binary name on PATH)
7:  *  - What env vars to set so it talks through the gateway
8:  */
9: import { getGitRemote } from "@loreai/core";
10: 
11: // ---------------------------------------------------------------------------
12: // which() — cross-runtime binary lookup
13: // ---------------------------------------------------------------------------
14: 
15: /**
16:  * Find a binary on PATH. Uses Bun.which() when available (Bun runtime),
17:  * falls back to `which`/`where` via child_process (Node.js runtime).
18:  */
19: function which(binary: string): string | null {
20:   // Bun runtime
21:   if (typeof Bun !== "undefined" && typeof Bun.which === ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/start.ts</path>
<type>file</type>
<content>
265:     await shutdown();
266:     safeExit(0);
267:   };
268: 
269:   process.on("SIGINT", () => onSignal());
270:   process.on("SIGTERM", () => onSignal());
271: 
272:   // Keep the process alive (Bun.serve already does this, but be explicit)
273:   return new Promise(() => {});
274: }

(End of file - total 274 lines)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/remote.ts</path>
<type>file</type>
<content>
110:     "Content-Type": "application/json",
111:   };
112: 
113:   let payload: BodyInit | undefined;
114:   if (body !== undefined) {
115:     const json = JSON.stringify(body);
116:     if (opts?.compress) {
117:       headers["Content-Encoding"] = "zstd";
118:       payload = new Uint8Array(Bun.zstdCompressSync(Buffer.from(json)));
119:     } else {
120:       payload = json;
121:     }
122:   }
123: 
124:   const res = await fetch(`${baseUrl}${path}`, {

(Showing lines 110-124 of 139. Use offset=125 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/upgrade.ts</path>
<type>file</type>
<content>
285:  * Stream a response body through gzip decompression to disk.
286:  */
287: async function streamDecompressToFile(
288:   body: ReadableStream<Uint8Array>,
289:   destPath: string,
290: ): Promise<void> {
291:   const stream = body.pipeThrough(
292:     new DecompressionStream("gzip") as unknown as TransformStream<
293:       Uint8Array,
294:       Uint8Array
295:     >,
296:   );
297:   const writer = Bun.file(destPath).writer();
298:   try {
299:     for await (const chunk of stream) {
300:       writer.write(chunk);
301:     }
302:   } finally {
303:     await writer.end();
304:   }
305: }
306: 
307: function getNightlyGzFilename(): string {
308:   return `${getPlatformBinaryName()}.gz`;
309: }
310: 
311: /**
312:  * Download a nightly binary from GHCR and decompress it. ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/delta-upgrade.ts</path>
<type>file</type>
<content>
320:   allTags: string[],
321:   currentVersion: string,
322:   targetVersion: string,
323: ): string[] {
324:   const chainTags: { tag: string; version: string }[] = [];
325: 
326:   for (const tag of allTags) {
327:     const version = tag.slice(PATCH_TAG_PREFIX.length);
328:     if (
329:       Bun.semver.order(version, currentVersion) === 1 &&
330:       Bun.semver.order(version, targetVersion) !== 1
331:     ) {
332:       chainTags.push({ tag, version });
333:     }
334:   }
335: 
336:   chainTags.sort((a, b) => Bun.semver.order(a.version, b.version));
337:   return chainTags.map((t) => t.tag);
338: }
339: 
340: type NightlyChainValidation = {
341:   digests: string[];
342:   totalSize: number;
343:   expectedSha256: string;
344: };
345: 
346: type ValidateChainOpts = {
347:   manifests: ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/version-check.ts</path>
<type>file</type>
<content>
210:   channel: "stable" | "nightly",
211:   latestVersion: string,
212:   signal: AbortSignal,
213: ): Promise<void> {
214:   if (Bun.semver.order(latestVersion, VERSION) !== 1) {
215:     return;
216:   }
217:   try {
218:     if (channel === "nightly") {
219:       await prefetchNightlyPatches(latestVersion, signal);
220:     } else {
221:       await prefetchStablePatches(latestVersion, signal);
222:     }
223:   } catch {
224:     // Pre-fetch is best-effort

(Showing lines 210-224 of 389. Use offset=225 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/version-check.ts</path>
<type>file</type>
<content>
310:       return null;
311:     }
312: 
313:     // Only notify if latest is strictly newer than current
314:     if (Bun.semver.order(latestVersion, VERSION) !== 1) {
315:       return null;
316:     }
317: 
318:     // Gate 3: daily rate limit across CLI invocations
319:     if (!canNotifyAgain(lastNotified)) {
320:       return null;
321:     }
322: 
323:     const channel = getReleaseChannel();
324:     const label =

(Showing lines 310-324 of 389. Use offset=325 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/binary.ts</path>
<type>file</type>
<content>
70: }
71: 
72: /**
73:  * Compare two version strings and return their ordering.
74:  *
75:  * Uses `Bun.semver.order` which handles both stable (`X.Y.Z`) and
76:  * nightly (`X.Y.Z-dev.<unix-seconds>`) versions correctly.
77:  */
78: export function compareVersions(a: string, b: string): -1 | 0 | 1 {
79:   return Bun.semver.order(a, b);
80: }
81: 
82: /**
83:  * Check whether moving from `current` to `target` is a downgrade.
84:  */
85: export function isDowngrade(current: string, target: string): boolean {
86:   return compareVersions(current, target) === 1;
87: }
88: 
89: /**
90:  * Get the binary filename for the current platform.
91:  */
92: export function getBinaryFilename(): string {
93:   return process.platform === "win32" ? "lore.exe" : "lore";
94: }
95: 
96: /**
97:  * Build paths object from an ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/binary.ts</path>
<type>file</type>
<content>
325:   try {
326:     if (resolve(sourcePath) !== resolve(tempPath)) {
327:       try {
328:         await unlink(tempPath);
329:       } catch {
330:         // Ignore if doesn't exist
331:       }
332: 
333:       await Bun.write(tempPath, Bun.file(sourcePath));
334: 
335:       if (process.platform !== "win32") {
336:         await chmod(tempPath, 0o755);
337:       }
338:     }
339: 

(Showing lines 325-339 of 359. Use offset=340 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/bspatch.ts</path>
<type>file</type>
<content>
1: /**
2:  * Streaming TRDIFF10 Binary Patch Application
3:  *
4:  * Implements the bspatch algorithm for applying binary delta patches in the
5:  * TRDIFF10 format (produced by zig-bsdiff with `--use-zstd`). Designed for
6:  * minimal memory usage during CLI self-upgrades:
7:  *
8:  * - Old binary: copy-then-mmap for 0 JS heap (CoW on btrfs/xfs/APFS),
9:  *   falling back to `arrayBuffer()` if copy/mmap fails
10:  * - Diff/extra blocks: streamed via `DecompressionStream('zstd')`
11:  * - Output: written incrementally to disk via `Bun.file().writer()`
12:  * - Integrity: SHA-256 computed inline via `Bun.CryptoHasher`
13:  *
14:  * TRDIFF10 format (from zig-bsdiff):
15:  * ```
16:  * [0..8]   magic: "TRDIFF10"
17:  * [8..16]  controlLen: i64 LE (compressed size of control block)
18:  * [16..24] diffLen:    i64 ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/patch-cache.ts</path>
<type>file</type>
<content>
1: /**
2:  * Patch Cache
3:  *
4:  * File-based cache for delta upgrade patches. Patches are downloaded
5:  * during background version checks so that `lore upgrade` can apply
6:  * them offline without any network calls.
7:  *
8:  * Cache location: <configDir>/patch-cache/
9:  * - <fromVersion>-<toVersion>.patch — raw binary patch data
10:  * - chain-<fromVersion>-<toVersion>.json — chain metadata
11:  *
12:  * Uses file-based storage to avoid bloating a DB with 50-80KB binary
13:  * blobs. Channel-agnostic — the same version-based naming works for
14:  * both nightly (GHCR) and stable (GitHub Releases) channels.
15:  *
16:  * Adapted from Sentry CLI's patch-cache.ts for Lore. ...

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/upgrade.ts</path>
<type>file</type>
<content>
1: /**
2:  * Upgrade Module
3:  *
4:  * Orchestrates binary self-upgrade: version fetching, delta patch
5:  * application with full-download fallback, and binary replacement.
6:  *
7:  * Lore is distributed as a standalone binary only — no package manager
8:  * detection or Homebrew support needed. The upgrade flow is:
9:  *
10:  * 1. Check latest version (GitHub Releases for stable, GHCR for nightly)

(Showing lines 1-10 of 494. Use offset=11 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/upgrade.ts</path>
<type>file</type>
<content>
385:  * Wait for a freshly written binary to become visible by path.
386:  * Handles Windows filesystem visibility race.
387:  */
388: async function waitForBinaryVisible(path: string): Promise<number> {
389:   for (let attempt = 1; attempt <= VERIFY_MAX_ATTEMPTS; attempt++) {
390:     const size = probeBinaryFile(path);
391:     if (size !== null) return size;
392:     if (attempt === VERIFY_MAX_ATTEMPTS) break;
393:     const delay = VERIFY_BASE_DELAY_MS * 2 ** (attempt - 1);
394:     await Bun.sleep(delay);
395:   }
396:   throw new UpgradeError(
397:     "execution_failed",
398:     `Downloaded binary is missing or empty at ${path}. ` +
399:       "This is usually transient — rerun `lore upgrade` to retry.",

(Showing lines 385-399 of 494. Use offset=400 to continue.)
</content>

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/start.ts</path>
<type>file</type>
<content>
1: /**
2:  * `lore start` — start the gateway server without auto-launching an agent.
3:  *
4:  * Extracted from the old top-level index.ts boot logic.
5:  */
6: import { loadConfig, DEFAULT_PORTS, type GatewayConfig } from "../config";
7: import { startServer } from "../server";
8: import { resetPipelineState } from "../pipeline";
9: import { writePortFile, removePortFile } from "../portfile";
10: import { embedding } from "@loreai/core";
11: import { safeExit } from "./exit";
12: 
13: export interface StartOptions {
14:   port?: number;
15:   hosts?: string[];

(Showing lines 1-15 of 274. Use offset=16 to continue.)
</content>

(no output)

[
  {
    "content": "Investigate NVIDIA endpoint response rendering issue in UI",
    "status": "in_progress",
    "priority": "high"
  },
  {
    "content": "Check if NVIDIA responses have different structure/format that breaks UI rendering",
    "status": "pending",
    "priority": "high"
  },
  {
    "content": "Check if header forwarding or path normalization affects NVIDIA responses",
    "status": "pending",
    "priority": "medium"
  }
]

<path>/home/byk/.local/share/opencode/worktree/51d1015fd1f616acf9a5ffaad9331ec6b304586b/clever-circuit/packages/gateway/src/cli/lib/version-check.ts</path>
<type>file</type>
<content>
1: /**
2:  * Background Version Check
3:  *
4:  * Provides "new version available" notifications for the Lore CLI.
5:  * On startup, a non-blocking background fetch checks for the latest version.
6:  * The result is cached to disk and displayed on subsequent invocations.
7:  *
8:  * For nightly builds (version contains "-dev."), checks GHCR via the OCI
9:  * manifest annotation. For stable builds, checks GitHub Releases.
10:  *
11:  * Adapted from Sentry CLI's version-check.ts for Lore:
12:  * - File-based persistence instead of SQLite
13:  * - No Sentry SDK telemetry — errors are silently swallowed
14:  * - Inline ANSI codes instead of external color library
15:  */
16: 
17: import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
18: import { join } from "node:path";
19: import { ...

Found 156 matches (showing first 100)
/home/byk/Code/opencode-lore/packages/gateway/src/translate/types.ts:
  Line 9:  * Design: types are intentionally minimal — only fields that Lore's context

  Line 308:   /** Resolved upstream base URL (e.g., "https://api.minimax.io/anthropic"). */

  Line 418:    *  "minimax-coding-plan", "openrouter"). Workers and auth resolution use


/home/byk/Code/opencode-lore/packages/gateway/test/cache-warmer.test.ts:
  Line 1796:   test("requires minimum turns", () => {


/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 936:     // "minimax-coding-plan"), while worker model providerIDs are canonical

  Line 3310:   // Build a minimal GatewayRequest for session identification.

  Line 3313:   const minimalReq: GatewayRequest = {

  Line 3325:   const { sessionID, isNew } = await identifySession(minimalReq, projectPath);


/home/byk/Code/opencode-lore/packages/gateway/src/cache-warmer.ts:
  Line 87: /** Minimum completed turns before ...

Found 6 matches
/home/byk/Code/opencode-lore/packages/gateway/src/translate/types.ts:
  Line 316:   /** Non-managed headers to forward upstream (anthropic-beta, etc.). */

  Line 485: const GATEWAY_MANAGED_HEADERS = new Set([

  Line 514:  * Forward non-managed headers from the client request to the upstream.

  Line 527:     if (!lower.startsWith("x-lore-") && !GATEWAY_MANAGED_HEADERS.has(lower)) {


/home/byk/Code/opencode-lore/packages/opencode/src/index.ts:
  Line 17:  * original headers. The gateway forwards non-managed headers upstream.


/home/byk/Code/opencode-lore/packages/gateway/src/translate/anthropic.ts:
  Line 351:   // anthropic-beta, user-agent, etc.), then overlay gateway-managed headers

Found 62 matches
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 116:   createStreamAccumulator,

  Line 117:   createRecallAwareAccumulator,

  Line 121:   type StreamAccumulator,

  Line 122:   type RecallAwareAccumulator,

  Line 1803:  * When `recallContext` is provided, uses a recall-aware accumulator that

  Line 1824:     ? createRecallAwareAccumulator(RECALL_TOOL_NAME, { scaleClientUsage: true })

  Line 1826:   const accumulator: StreamAccumulator =

  Line 1827:     recallAccum ?? createStreamAccumulator({ scaleClientUsage: true });

  Line 1867:         // The accumulator sees the original (un-offset) data so postResponse()

  Line 1877:           const forwarded = accumulator.processEvent(event, data);

  Line 1956:         // down into t:<id> source citations). ...

Found 157 matches (showing first 100)
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 109: import { buildOpenAIUpstreamRequest } from "./translate/openai";

  Line 114: import { accumulateResponsesSSEStream } from "./stream/openai-responses";

  Line 118:   parseSSEStream,

  Line 119:   buildSSETextResponse,

  Line 120:   formatSSEEvent,

  Line 908:       ? { anthropic: config.workerUpstream, openai: config.workerUpstream }

  Line 909:       : { anthropic: config.upstreamAnthropic, openai: config.upstreamOpenAI };

  Line 1801:  * Create a streaming SSE response from upstream with parallel accumulation.

  Line 1811: function buildStreamingResponse(

  Line 1857:         // Parse and forward upstream SSE events

  Line 1876:         for await (const { event, data } of parseSSEStream(reader)) {

  Line 1922:               const warningSSE =

  Line 1926:               if (!safeEnqueue(encoder.encode(warningSSE))) break;

  Line 1995:               ...

6773fbf chore(deps): switch package manager from bun to pnpm (#578)
a2809df fix(gateway): prevent session header leaks and harden fetch interceptor (#580)
aa71cad fix(gateway): per-provider auth and upstream snapshots to prevent cross-contamination (#579)
cb5901e fix(core): normalize provider API paths in fetch interceptor (#577)
166eebd fix(gateway): use original fetch for upstream calls to prevent interceptor loop (#576)
270ddc6 refactor(gateway): replace 5 last* SessionState fields with UpstreamSnapshot (#575)
2db852f fix(gateway,opencode,pi): transparent provider routing via fetch-level interception (#574)
3624c22 fix(gateway): couple recall follow-up stream flag to its consumer (#573)
0823301 feat(build): migrate standalone binary from Bun --compile to Node SEA via fossilize (#564)
851e9c2 fix(gateway): route worker calls through session's provider (#572)
282da7b fix(gateway,opencode): transparent provider routing and protocol preservation (#571)
4cbe8e8 fix(core): replace O(N²) ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/config.ts</path>
<type>file</type>
<content>
140: };
141: 
142: /**
143:  * Model prefix → upstream provider routing table.
144:  *
145:  * Ordered from most-specific to most-general so that e.g. `claude-3-5-haiku`
146:  * matches `claude-` before any catch-all. Unknown models fall back to the
147:  * env-var-configured defaults.
148:  */
149: const UPSTREAM_ROUTES: Array<{
150:   prefix: string;
151:   url: string;
152:   protocol: "anthropic" | "openai" | "openai-responses";
153: }> = [
154:   // Anthropic
155:   {
156:     prefix: "claude-",
157:     url: "https://api.anthropic.com",
158:     protocol: "anthropic",
159:   },
160:   // Nvidia NIM
161:   {
162:     prefix: "nvidia/",
163:     url: "https://integrate.api.nvidia.com",
164:     protocol: "openai",
165:   },
166:   {
167:     prefix: "meta/",
168:     url: "https://integrate.api.nvidia.com",
169:     protocol: "openai",
170:   },
171:   {
172:     prefix: ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/translate/types.ts</path>
<type>file</type>
<content>
480: /**
481:  * Headers that the gateway manages itself — never forwarded from the client.
482:  * Auth headers are listed because each request builder handles them
483:  * explicitly (extractAuth + authHeaders) to preserve the correct scheme.
484:  */
485: const GATEWAY_MANAGED_HEADERS = new Set([
486:   // HTTP framing
487:   "content-type",
488:   "content-length",
489:   "host",
490:   "connection",
491:   "transfer-encoding",
492:   "accept-encoding",
493:   // Lore-specific (injected by fetch interceptor / plugin hooks)
494:   "x-lore-provider",
495:   "x-lore-upstream-url",
496:   "x-lore-session-id",
497:   "x-lore-project",
498:   "x-lore-git-remote",
499:   "x-lore-agent",
500:   "x-lore-no-store",
501:   "x-lore-recall-invoked",
502:   // Protocol version — set explicitly by each builder
503:   "anthropic-version",
504:   // Session identification — consumed by ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
4650:       // Update for next iteration
4651:       currentModifiedReq = followUp;
4652:       currentResp = continuationResp;
4653:       // Loop continues — hasRecallToolUse checked at top
4654:     }
4655: 
4656:     // Depth exhausted or no more recall — finalize
4657:     if (hasRecallToolUse(currentResp)) {
4658:       log.warn(
4659:         `recall depth exhausted (${MAX_RECALL_DEPTH}) — stripping remaining recall`,
4660:       );
4661:       currentResp = replaceRecallWithMarker(currentResp);
4662:     }
4663:     currentResp.usage = cumulativeUsage;
4664:     postResponse(
4665:       req,
4666:       currentResp,
4667:       sessionState,
4668:       config,
4669:       requestBody,
4670:       genAiSpan,
4671:     );
4672:     const recallHeaders =
4673:       recallDepth > 0 ? ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/stream/openai.ts</path>
<type>file</type>
<content>
1: /**
2:  * Anthropic SSE → OpenAI Chat Completions SSE streaming translator.
3:  *
4:  * Reads Anthropic-format SSE events from an upstream Response and emits
5:  * OpenAI Chat Completions streaming chunks incrementally, so the client
6:  * receives tokens as they arrive rather than waiting for the full response.
7:  *
8:  * Anthropic lifecycle:
9:  *   message_start → content_block_start → content_block_delta (repeated)
10:  *   → content_block_stop → message_delta → message_stop
11:  *
12:  * OpenAI Chat Completions streaming lifecycle:
13:  *   chunk with delta.role → chunk with delta.content (repeated)
14:  *   → chunk with finish_reason → data: [DONE]
15:  *
16:  * Uses `parseSSEStream` from the Anthropic stream module to parse upstream
17:  * events, and `createStreamAccumulator` to build the internal GatewayResponse
18:  * (for pipeline post-processing that may read ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
230:     return errorResponse(400, "invalid_request_error", "Invalid JSON body");
231:   }
232: 
233:   let gatewayReq: GatewayRequest;
234:   try {
235:     gatewayReq = parseOpenAIRequest(body, headersToRecord(req.headers));
236:   } catch (e) {
237:     const msg = e instanceof Error ? e.message : "Failed to parse request";
238:     return errorResponse(400, "invalid_request_error", msg);
239:   }
240: 
241:   let pipelineResp: Response;
242:   try {
243:     pipelineResp = await handleRequest(gatewayReq, config);
244:   } catch (e) {
245:     const msg = e instanceof Error ? e.message : "Pipeline error";
246:     console.error(`[lore] pipeline error: ${msg}`);
247:     return errorResponse(502, "api_error", `Gateway pipeline error: ${msg}`);
248:   }
249: 
250:   // Pipeline always returns internal Anthropic-format response. ...

Found 8 matches
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 2215: async function accumulateNonStreamResponse(

  Line 2389: async function accumulateNonStreamOpenAIStream(

  Line 4571:       // continuation is consumed (accumulateNonStreamResponse).

  Line 4581:         parseJSON: accumulateNonStreamResponse,

  Line 4694:       const resp = await accumulateNonStreamOpenAIStream(upstreamResponse);

  Line 4715:   const resp = await accumulateNonStreamResponse(


/home/byk/Code/opencode-lore/packages/gateway/src/recall.ts:
  Line 404:  * `parseJSON` wraps `accumulateNonStreamResponse`.

  Line 431:  * the upstream response: `false` → JSON via `accumulateNonStreamResponse()`,

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2380: }
2381: 
2382: /**
2383:  * Accumulate a streaming upstream OpenAI Chat Completions SSE response
2384:  * into a GatewayResponse.
2385:  *
2386:  * OpenAI SSE chunks have a different format from Anthropic:
2387:  *   data: {"id":"...","choices":[{"delta":{"content":"..."},"finish_reason":null}]}
2388:  */
2389: async function accumulateNonStreamOpenAIStream(
2390:   upstreamResponse: Response,
2391: ): Promise<GatewayResponse> {
2392:   let id = "";
2393:   let model = "";
2394:   let stopReason = "end_turn";
2395:   let textContent = "";
2396:   const toolCalls = new Map<
2397:     number,
2398:     { id: string; name: string; args: string }
2399:   >();
2400:   let inputTokens = 0;
2401:   let outputTokens = 0;
2402:   let cachedTokens: number | undefined;
2403: 
2404:   if (!upstreamResponse.body) {
2405:     throw new Error("Upstream response has no body");
2406:   }
2407:  ...

<path>/home/byk/Code/opencode-lore/packages/core/src/fetch-interceptor.ts</path>
<type>file</type>
<content>
1: /**
2:  * Fetch-level interception for transparent LLM API proxy routing.
3:  *
4:  * Instead of overwriting provider baseURLs early (which loses original auth
5:  * and URL context), this interceptor wraps `globalThis.fetch` to redirect
6:  * outgoing LLM API calls through the Lore gateway at the HTTP level.
7:  *
8:  * The SDK builds requests normally (correct auth, correct URL for each
9:  * provider), and the interceptor transparently reroutes them through the
10:  * gateway while preserving all original headers.
11:  */
12: import * as log from "./log";
13: 
14: /** Configuration for the fetch interceptor. */
15: export type FetchInterceptorConfig = {
16:   /** Base URL of the Lore gateway (e.g., "http://127.0.0.1:3207"). */
17:   gatewayBase: string;
18:   /**
19:    * Dynamic headers to inject on every intercepted request. ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
870:         // TO this sessionID — remove them too.
871:         for (const [key, sid] of headerSessionIndex) {
872:           if (sid === sessionID) headerSessionIndex.delete(key);
873:         }
874:         ltmSessionCache.delete(sessionID);
875:         ltmPinnedText.delete(sessionID);
876:         stableLtmCache.delete(sessionID);
877:         cwdWarned.delete(sessionID);
878:       },
879:     );
880:   }
881: 
882:   log.info(`gateway pipeline initialized: ${projectPath}`);
883: }
884: 
885: function getLLMClient(config: GatewayConfig): LLMClient {
886:   if (!llmClient) {
887:     const cfg = loreConfig();
888:     const defaultModel = cfg.model ?? ...

Found 31 matches
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 952:                 if (protocolToProviderID(s.protocol) === workerProviderID) {

  Line 1586:   effectiveProtocol: "anthropic" | "openai" | "openai-responses";

  Line 1642:   const effectiveProtocol =

  Line 1643:     req.protocol === "openai-responses"

  Line 1645:       : (providerRouteUsable?.protocol ?? modelRoute?.protocol ?? req.protocol);

  Line 1651:     (effectiveProtocol === "anthropic"

  Line 1680:       `protocol=${effectiveProtocol}, ` +

  Line 1697:   if (effectiveProtocol === "openai-responses") {

  Line 1715:   } else if (effectiveProtocol === "openai") {

  Line 1760:   if (effectiveProtocol === "anthropic") {

  Line 1785:     return { response, serializedBody, effectiveProtocol };

  Line 1793:   return { response, serializedBody, effectiveProtocol };

  Line 2861:       req.protocol === "openai-responses"

  Line 2863:         : (lpRouteUsable?.protocol ?? ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
4490:     }
4491: 
4492:     genAiSpan.setStatus({
4493:       code: 2,
4494:       message: `HTTP ${upstreamResponse.status}`,
4495:     });
4496:     genAiSpan.end();
4497:     return new Response(errorBody, {
4498:       status: upstreamResponse.status,
4499:       headers: { "content-type": "application/json" },
4500:     });
4501:   }
4502: 
4503:   // Run the recall-interception loop over an already-accumulated
4504:   // (internal Anthropic-format) GatewayResponse and return the client HTTP
4505:   // response. Shared by the non-streaming path AND the OpenAI/openai-responses
4506:   // streaming paths — those accumulate the upstream SSE into the same internal
4507:   // Anthropic-format response, so the recall loop is protocol-agnostic here.
4508:   // Without this, a `recall` tool_use injected by the gateway would leak to the
4509:   // client (e.g. ...

diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 71b7e5b..5a7aec6 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -68,8 +68,9 @@ import type {
   GatewayToolUseBlock,
   GatewayToolResultBlock,
   SessionState,
+  UpstreamSnapshot,
 } from "./translate/types";
-import { blocksToText } from "./translate/types";
+import { blocksToText, forwardClientHeaders } from "./translate/types";
 import type { GatewayConfig } from "./config";
 import {
   getProjectPath,
@@ -215,6 +216,7 @@ import {
   replaceRecallWithMarker,
   isRecallMarker,
 } from "./recall";
+import { upstreamFetch } from "./fetch";
 
 // ---------------------------------------------------------------------------
 // Module state
@@ -893,10 +895,12 @@ function getLLMClient(config: GatewayConfig): LLMClient {
     // routing workers to a different provider (e.g. MiniMax) while sessions
     // continue using Anthropic. ...

diff --git a/packages/gateway/src/server.ts b/packages/gateway/src/server.ts
index f4ffc17..3096890 100644
--- a/packages/gateway/src/server.ts
+++ b/packages/gateway/src/server.ts
@@ -32,6 +32,7 @@ import {
   handleResponsesCompactEndpoint,
   accumulateResponsesNonStreamJSON,
 } from "./pipeline";
+import { upstreamFetch } from "./fetch";
 
 // ---------------------------------------------------------------------------
 // Version — best-effort from package.json, falls back gracefully
@@ -195,9 +196,12 @@ async function handleModelsPassthrough(
     const anthropicVersion = req.headers.get("anthropic-version");
     if (anthropicVersion) headers["anthropic-version"] = anthropicVersion;
 
-    const upstream = await fetch(`${config.upstreamAnthropic}/v1/models`, {
-      headers,
-    });
+    const upstream = await upstreamFetch(
+      `${config.upstreamAnthropic}/v1/models`,
+      {
+        headers,
+      },
+    );
     // Clone to a new Response so we can append CORS ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
1570: 
1571:   // No matching session → create new.
1572:   const sessionID = generateSessionID();
1573:   return { sessionID, isNew: true, tier: 3 };
1574: }
1575: 
1576: // ---------------------------------------------------------------------------
1577: // Upstream forwarding
1578: // ---------------------------------------------------------------------------
1579: 
1580: /** Result from forwardToUpstream — includes the serialized body for cache analytics. */
1581: type UpstreamResult = {
1582:   response: Response;
1583:   /** The serialized JSON body sent to the upstream provider. */
1584:   serializedBody: string;
1585:   /** The wire protocol used for the upstream request (may differ from ingress). */
1586:   effectiveProtocol: "anthropic" | "openai" | "openai-responses";
1587: };
1588: 
1589: /**
1590:  * Forward a request to the upstream provider (Anthropic or OpenAI). ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2200:       "content-type": "text/event-stream",
2201:       "cache-control": "no-cache",
2202:       connection: "keep-alive",
2203:     },
2204:   });
2205: }
2206: 
2207: /**
2208:  * Accumulate a non-streaming upstream response into a GatewayResponse.
2209:  *
2210:  * Dispatches to the correct parser based on the upstream wire protocol:
2211:  *  - "anthropic": Anthropic Messages API format
2212:  *  - "openai": OpenAI Chat Completions API format
2213:  *  - "openai-responses": OpenAI Responses API format
2214:  */
2215: async function accumulateNonStreamResponse(
2216:   upstreamResponse: Response,
2217:   protocol: "anthropic" | "openai" | "openai-responses" = "anthropic",
2218: ): Promise<GatewayResponse> {
2219:   const json = (await upstreamResponse.json()) as Record<string, unknown>;
2220: 
2221:   switch (protocol) {
2222:     case "openai":
2223:       return ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/fetch.ts</path>
<type>file</type>
<content>
1: /**
2:  * Upstream-safe fetch for the gateway.
3:  *
4:  * When the gateway runs in-process alongside a plugin (OpenCode, Pi),
5:  * `globalThis.fetch` may be patched by the fetch interceptor to redirect
6:  * LLM API calls through the gateway. The gateway's own upstream calls
7:  * must bypass this interception to avoid an infinite loop.
8:  *
9:  * This module re-exports the original, un-intercepted `fetch` via
10:  * `getOriginalFetch()` from `@loreai/core`. All gateway code that
11:  * makes HTTP requests to upstream LLM providers (or any external
12:  * endpoint) should use `upstreamFetch` instead of bare `fetch`.
13:  *
14:  * When no interceptor is installed (standalone gateway, CLI), this
15:  * falls back to `globalThis.fetch`.
16:  */
17: import { getOriginalFetch } from "@loreai/core";
18: 
19: /**
20:  * Fetch function that bypasses the plugin's fetch interceptor. ...

Found 6 matches
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 2510: function nonStreamHttpResponse(

  Line 3257:   return nonStreamHttpResponse(resp);

  Line 4562:         return nonStreamHttpResponse(

  Line 4607:         return nonStreamHttpResponse(

  Line 4628:         return nonStreamHttpResponse(

  Line 4674:     return nonStreamHttpResponse(

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2505: 
2506: /**
2507:  * Convert a GatewayResponse to a non-streaming HTTP Response.
2508:  * Scales usage fields to prevent client auto-compaction.
2509:  */
2510: function nonStreamHttpResponse(
2511:   resp: GatewayResponse,
2512:   extraHeaders?: Record<string, string>,
2513: ): Response {
2514:   // Scale usage so the client's token total stays below auto-compact threshold.
2515:   // postResponse() has already consumed the real values for calibration/bustRate.
2516:   const scaledUsage = scaleUsageForClient({
2517:     input_tokens: resp.usage.inputTokens,
2518:     output_tokens: resp.usage.outputTokens,
2519:     cache_read_input_tokens: resp.usage.cacheReadInputTokens,
2520:     cache_creation_input_tokens: resp.usage.cacheCreationInputTokens,
2521:   });
2522:   const scaledResp: GatewayResponse = {
2523:     ...resp,
2524:     usage: {
2525:       inputTokens: ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/translate/openai.ts</path>
<type>file</type>
<content>
1: /**
2:  * OpenAI ↔ Gateway translation layer.
3:  *
4:  * Converts between OpenAI's `/v1/chat/completions` API format and the gateway's
5:  * internal `GatewayRequest`/`GatewayResponse` types.
6:  */
7: import type {
8:   GatewayContentBlock,
9:   GatewayMessage,
10:   GatewayRequest,
11:   GatewayResponse,
12:   GatewayTool,
13: } from "./types";
14: import { blocksToText, forwardClientHeaders } from "./types";
15: import { extractAuth } from "../auth";
16: 
17: // ---------------------------------------------------------------------------
18: // OpenAI → GatewayRequest
19: // ---------------------------------------------------------------------------
20: 
21: export function parseOpenAIRequest(
22:   body: unknown,
23:   headers: Record<string, string>,
24: ): GatewayRequest {
25:   const raw = (body ?? ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
1: /**
2:  * HTTP server for the Lore gateway proxy.
3:  *
4:  * Routes:
5:  *   POST /v1/messages            → Anthropic protocol
6:  *   POST /v1/chat/completions    → OpenAI Chat Completions protocol
7:  *   POST /v1/responses           → OpenAI Responses API protocol
8:  *   POST /v1/responses/compact   → Codex compaction (Responses API)
9:  *   POST /v1/compact             → Explicit compaction summary (Pi plugin, etc.)
10:  *   GET  /v1/models              → Passthrough to upstream
11:  *   GET  /health                 → Health check
12:  *
13:  * Uses `Bun.serve()` — this package targets Bun exclusively.
14:  */
15: import { DEFAULT_PORT, type GatewayConfig } from "./config";
16: import { bootstrapDailySpend, getDailyBudget } from "./cost-tracker";
17: import type { GatewayRequest } from "./translate/types";
18: import {
19:   parseAnthropicRequest,
20:   ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
1800: /**
1801:  * Create a streaming SSE response from upstream with parallel accumulation.
1802:  *
1803:  * When `recallContext` is provided, uses a recall-aware accumulator that
1804:  * transparently intercepts recall tool_use blocks:
1805:  *  - **Case 1 (recall-only)**: pauses client stream, executes recall, sends
1806:  *    a follow-up request, and pipes the continuation into the same HTTP
1807:  *    response stream.
1808:  *  - **Case 2 (mixed tools)**: suppresses recall blocks, stores the pending
1809:  *    result for injection into the next request.
1810:  */
1811: function buildStreamingResponse(
1812:   upstreamResponse: Response,
1813:   onComplete: (response: GatewayResponse) => void,
1814:   recallContext?: {
1815:     modifiedReq: GatewayRequest;
1816:     config: GatewayConfig;
1817:     sessionState: SessionState;
1818:     cacheOptions: ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
4390:     );
4391: 
4392:     if (delay > 0) {
4393:       // Cap delay to avoid pushing the next request past the cache TTL boundary.
4394:       // Use prevRequestTime (the request before this one) to compute how much
4395:       // of the cache TTL window has already been consumed.
4396:       const ttlMs = resolvedConversationTTL === "1h" ? 3_600_000 : 300_000;
4397:       const elapsed = sessionState.prevRequestTime
4398:         ? Date.now() - sessionState.prevRequestTime
4399:         : 0; // first request — no prior timing, full TTL available
4400:       const maxSafe = Math.max(0, (ttlMs - elapsed) * 0.5) / 1000;
4401:       const actualDelay = Math.min(delay, maxSafe);
4402: 
4403:       if (actualDelay > 0.5) {
4404:         // don't bother sleeping < 500ms
4405:         log.info(
4406:           `budget-throttle: sleeping ${actualDelay.toFixed(1)}s ` +
4407:             ...

Found 12 matches
/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 105:   buildAnthropicNonStreamResponse,

  Line 106:   parseAnthropicResponseJSON,

  Line 2231: // Anthropic non-stream JSON → GatewayResponse: use shared parseAnthropicResponseJSON

  Line 2232: const accumulateAnthropicNonStreamJSON = parseAnthropicResponseJSON;

  Line 2531:   const body = buildAnthropicNonStreamResponse(scaledResp);


/home/byk/Code/opencode-lore/packages/gateway/src/server.ts:
  Line 20:   parseAnthropicResponseJSON,

  Line 265:   const gatewayResp = parseAnthropicResponseJSON(

  Line 336:     : parseAnthropicResponseJSON(respBody);


/home/byk/Code/opencode-lore/packages/gateway/src/translate/anthropic.ts:
  Line 498: // buildAnthropicNonStreamResponse

  Line 504:  * This is the inverse of `buildAnthropicNonStreamResponse`. Used when the

  Line 508: export function parseAnthropicResponseJSON(

  Line 567: export function buildAnthropicNonStreamResponse(

<path>/home/byk/Code/opencode-lore/packages/gateway/src/translate/anthropic.ts</path>
<type>file</type>
<content>
498: // buildAnthropicNonStreamResponse
499: // ---------------------------------------------------------------------------
500: 
501: /**
502:  * Parse an Anthropic-format response JSON back into a `GatewayResponse`.
503:  *
504:  * This is the inverse of `buildAnthropicNonStreamResponse`. Used when the
505:  * pipeline returns Anthropic-format JSON that needs to be translated to
506:  * another protocol (OpenAI Chat Completions, OpenAI Responses API).
507:  */
508: export function parseAnthropicResponseJSON(
509:   json: Record<string, unknown>,
510: ): GatewayResponse {
511:   const content: GatewayContentBlock[] = [];
512:   const rawContent = json.content as Array<Record<string, unknown>> | undefined;
513:   if (rawContent) {
514:     for (const block of rawContent) {
515:       switch (block.type) {
516:         case "text":
517:           content.push({ type: ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
1: /**
2:  * Anthropic SSE stream handling.
3:  *
4:  * Parses upstream Anthropic streaming responses (named SSE events), accumulates
5:  * the full response into a `GatewayResponse`, and provides helpers for
6:  * generating synthetic SSE event sequences (e.g. for compaction interception).
7:  *
8:  * Anthropic uses named SSE events with a lifecycle:
9:  *   message_start -> content_block_start/delta/stop (repeated) -> message_delta -> message_stop
10:  *
11:  * All functions are pure (no side effects) except `parseSSEStream` which is
12:  * an async generator consuming a byte stream.
13:  */
14: import type {
15:   GatewayContentBlock,
16:   GatewayResponse,
17:   GatewayUsage,
18: } from "../translate/types";
19: import { scaleUsageForClient } from "../compaction";
20: 
21: // ---------------------------------------------------------------------------
22: // SSE ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
105: // Stream accumulator
106: // ---------------------------------------------------------------------------
107: 
108: /** Intermediate block state during streaming. */
109: type AccumulatingBlock =
110:   | { type: "text"; text: string }
111:   | { type: "thinking"; thinking: string; signature: string }
112:   | { type: "tool_use"; id: string; name: string; partialJson: string };
113: 
114: /** State machine that processes Anthropic SSE events and builds a GatewayResponse. */
115: export interface StreamAccumulator {
116:   /** Process a single SSE event. Returns the event line(s) to forward to client. */
117:   processEvent(eventType: string, data: string): string;
118:   /** Get the accumulated response after stream ends. */
119:   getResponse(): GatewayResponse;
120:   /** Whether the stream has completed (message_stop received). ...

diff --git a/packages/core/src/fetch-interceptor.ts b/packages/core/src/fetch-interceptor.ts
index 3a52ef0..961a7f0 100644
--- a/packages/core/src/fetch-interceptor.ts
+++ b/packages/core/src/fetch-interceptor.ts
@@ -25,7 +25,8 @@ export type FetchInterceptorConfig = {
 /**
  * LLM API path patterns that should be intercepted.
  * These are the standard paths used by Anthropic, OpenAI Chat Completions,
- * and OpenAI Responses API endpoints.
+ * and OpenAI Responses API endpoints. Some providers prefix with /api
+ * (e.g., OpenRouter uses /api/v1/chat/completions).
  */
 const LLM_API_PATH_PATTERN =
   /\/v1\/(messages|chat\/completions|responses)(\/.*)?$/;
@@ -52,8 +53,7 @@ export function shouldIntercept(url: string, gatewayBase: string): boolean {
       host === "localhost" ||
       host === "127.0.0.1" ||
       host === "0.0.0.0" ||
-      host === "::1" ||
-      host === "[::1]"
+      host === "::1" // URL.hostname strips brackets from IPv6
     )
       return false;
     ...

diff --git a/packages/gateway/src/translate/types.ts b/packages/gateway/src/translate/types.ts
index 07f8abc..0538fa1 100644
--- a/packages/gateway/src/translate/types.ts
+++ b/packages/gateway/src/translate/types.ts
@@ -299,6 +299,24 @@ export type CacheAnalytics = {
   bustCount: number;
 };
 
+/** Routing snapshot captured from the last successful session request.
+ *  Workers (distillation, curation) and the cache warmer use this
+ *  to route through the same upstream with matching credentials.
+ *  Single source of truth — replaces lastModel, lastProtocol,
+ *  lastProviderID, lastUpstreamUrl, lastAnthropicBeta. */
+export interface UpstreamSnapshot {
+  /** Resolved upstream base URL (e.g., "https://api.minimax.io/anthropic"). */
+  url: string;
+  /** Wire protocol used for the request. */
+  protocol: "anthropic" | "openai" | "openai-responses";
+  /** Provider ID from X-Lore-Provider header (for worker model selection). */
+  providerID?: string;
+  /** Session model ID (for ...

diff --git a/packages/gateway/src/auth.ts b/packages/gateway/src/auth.ts
index 1fad51e..f3363b2 100644
--- a/packages/gateway/src/auth.ts
+++ b/packages/gateway/src/auth.ts
@@ -82,18 +82,57 @@ export function authFingerprint(cred: AuthCredential): string {
 // Per-session registry
 // ---------------------------------------------------------------------------
 
-const sessionAuth = new Map<string, AuthCredential>();
+/**
+ * Per-session, per-provider credential registry. Outer key is Lore session ID,
+ * inner key is provider ID (e.g. "anthropic", "minimax-coding-plan"). This
+ * prevents cross-contamination when a user switches providers mid-conversation
+ * within the same OpenCode session.
+ */
+const sessionAuth = new Map<string, Map<string, AuthCredential>>();
 
-export function setSessionAuth(sessionID: string, cred: AuthCredential): void {
-  sessionAuth.set(sessionID, cred);
+/**
+ * Store a credential for a specific (session, provider) pair. ...

(no output)

No files found

Found 9 matches
/home/byk/Code/opencode-lore/packages/gateway/src/translate/types.ts:
  Line 521: export function forwardClientHeaders(


/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts:
  Line 73: import { blocksToText, forwardClientHeaders } from "./translate/types";

  Line 2872:       headers: forwardClientHeaders(req.rawHeaders),


/home/byk/Code/opencode-lore/packages/gateway/src/translate/openai.ts:
  Line 14: import { blocksToText, forwardClientHeaders } from "./types";

  Line 481:     ...forwardClientHeaders(req.rawHeaders),


/home/byk/Code/opencode-lore/packages/gateway/src/translate/openai-responses.ts:
  Line 21: import { blocksToText, forwardClientHeaders } from "./types";

  Line 269:     ...forwardClientHeaders(req.rawHeaders),


/home/byk/Code/opencode-lore/packages/gateway/src/translate/anthropic.ts:
  Line 15: import { forwardClientHeaders } from "./types";

  Line 354:     ...forwardClientHeaders(req.rawHeaders),

<path>/home/byk/Code/opencode-lore/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2490:     content.push({ type: "tool_use", id: tc.id, name: tc.name, input });
2491:   }
2492: 
2493:   return {
2494:     id,
2495:     model,
2496:     content,
2497:     stopReason,
2498:     usage: {
2499:       inputTokens,
2500:       outputTokens,
2501:       cacheReadInputTokens: cachedTokens,
2502:     },
2503:   };
2504: }
2505: 
2506: /**
2507:  * Convert a GatewayResponse to a non-streaming HTTP Response.
2508:  * Scales usage fields to prevent client auto-compaction.
2509:  */
2510: function nonStreamHttpResponse(
2511:   resp: GatewayResponse,
2512:   extraHeaders?: Record<string, string>,
2513: ): Response {
2514:   // Scale usage so the client's token total stays below auto-compact threshold.

(Showing lines 2490-2514 of 5398. Use offset=2515 to continue.)
</content>

<path>/home/byk/Code/opencode-lore/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
247:     return errorResponse(502, "api_error", `Gateway pipeline error: ${msg}`);
248:   }
249: 
250:   // Pipeline always returns internal Anthropic-format response.
251:   // Translate back to OpenAI format before returning to the client.
252:   if (!pipelineResp.ok) {
253:     // Upstream or pipeline error — forward as-is
254:     return withCors(pipelineResp);
255:   }
256: 
257:   const contentType = pipelineResp.headers.get("content-type") ?? "";
258:   if (contentType.includes("text/event-stream")) {
259:     // True streaming: translate Anthropic SSE → OpenAI Chat Completions SSE incrementally
260:     return withCors(translateAnthropicStreamToOpenAI(pipelineResp));
261:   }
262: 
263:   // Non-streaming: translate Anthropic wire JSON → GatewayResponse → OpenAI
264:   const respBody = await pipelineResp.json();
265:   const gatewayResp = parseAnthropicResponseJSON(
266:     ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
222: async function handleOpenAIChatCompletions(
223:   req: Request,
224:   config: GatewayConfig,
225: ): Promise<Response> {
226:   let body: unknown;
227:   try {
228:     body = await req.json();
229:   } catch {
230:     return errorResponse(400, "invalid_request_error", "Invalid JSON body");
231:   }
232: 
233:   let gatewayReq: GatewayRequest;
234:   try {
235:     gatewayReq = parseOpenAIRequest(body, headersToRecord(req.headers));
236:   } catch (e) {
237:     const msg = e instanceof Error ? e.message : "Failed to parse request";
238:     return errorResponse(400, "invalid_request_error", msg);
239:   }
240: 
241:   let pipelineResp: Response;
242:   try {
243:     pipelineResp = await handleRequest(gatewayReq, config);
244:   } catch (e) {
245:     const msg = e instanceof Error ? e.message : "Pipeline error";
246:     console.error(`[lore] pipeline error: ${msg}`);
247:    ...

<path>/home/byk/Code/opencode-lore/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
350:   ready?: Promise<void>;
351: } {
352:   // Defensive defaults for public API consumers who may pass incomplete config.
353:   // loadConfig() always provides these, but startServer is a public export.
354:   config = config ?? ({} as GatewayConfig);
355:   if (!config.hosts?.length) {
356:     console.error(
357:       `[lore] warning: config.hosts is empty or missing, defaulting to ["127.0.0.1"]. ` +
358:         `Use loadConfig() or startGateway() for a fully-populated config.`,
359:     );
360:     config = { ...config, hosts: ["127.0.0.1"] };
361:   }
362:   if (!Number.isFinite(config.port) || config.port < 0) {
363:     config = { ...config, port: DEFAULT_PORT };
364:   }
365: 
366:   // Bootstrap the daily spend counter from DB (recovers today's spend after restart)
367:   if (getDailyBudget() > 0) {
368:     bootstrapDailySpend();
369:   }
370: 
371:   // Shared fetch ...