Dashboard › opencode-lore › Session 1EbEKs6sbQ8V
1EbEKs6sbQ8VDDUfTREAD-ONLY research in /home/byk/Code/opencode-lore-recall-recovery. Do not edit/VCS/server/prod DB. Map exact minimal fixes/tests for three security findings on frozen candidate b61b0861: (1) codex.rate_limits schema currently permits arbitrary free-form/nested/private content and cumulative array may grow request-wide; design bounded allowlisted numeric/categorical schema, event/byte cap, ordering/dedupe semantics compatible with existing benign Q1/Q2/Q3 tests, hostile newline/oversized/multi-round regressions. (2) failed recovery terminal usage overflow during mergeFailedContinuationMetadata inside recovery catch can escape failRecall/accounting; identify exact branch and test fixture for individually valid MAX_SAFE_INTEGER usage plus prior usage. (3) executeRecall logs/captures original exception; design fixed error-level categorical log+capture preserving visibility without exception content, with hostile newline regression against registered sink/capture/persistent seam. Cite exact file:line/symbols and recommend smallest patches/tests. Also identify any interaction with the separate envelope-validation agent; do not overlap implementation.
/home/byk/Code/opencode-lore-recall-recovery/AGENTS.md
No files found
/home/byk/Code/opencode-lore-recall-recovery/package.json /home/byk/Code/opencode-lore-recall-recovery/packages/website/package.json /home/byk/Code/opencode-lore-recall-recovery/packages/pi/package.json /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/package.json /home/byk/Code/opencode-lore-recall-recovery/packages/opencode/package.json /home/byk/Code/opencode-lore-recall-recovery/packages/core/package.json
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/openai-responses-recall-aware-stream.test.ts
<path>/home/byk/Code/opencode-lore-recall-recovery/AGENTS.md</path> <type>file</type> <content> 1: <!-- This section is maintained by the coding agent via lore (https://github.com/BYK/loreai) --> 2: ## Long-term Knowledge 3: 4: For long-term knowledge entries managed by [lore](https://github.com/BYK/loreai) (gotchas, patterns, decisions, architecture), see [`.lore.md`](.lore.md) in the project root. 5: <!-- End lore-managed section --> 6: 7: ## Review 8: 9: See [`quality/REVIEW.md`](quality/REVIEW.md) for the review heuristics and workflow — regression-test discipline, adversarial-order state setup, fan-out registry coverage, recurring bug-class batteries, and the two-reviewer rule. Every non-trivial PR requires an adversarial correctness review before merge. 10: 11: # Project Overview 12: 13: Lore is a **three-tier memory architecture** for AI coding agents. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/package.json</path>
<type>file</type>
<content>
1: {
2: "name": "lore-monorepo",
3: "private": true,
4: "type": "module",
5: "license": "FSL-1.1-Apache-2.0",
6: "description": "Monorepo root for Lore — three-tier memory architecture",
7: "main": "./packages/opencode/src/index.ts",
8: "exports": {
9: ".": "./packages/opencode/src/index.ts"
10: },
11: "packageManager": "pnpm@10.28.0",
12: "volta": {
13: "node": "24.16.0",
14: "pnpm": "10.28.0"
15: },
16: "pnpm": {
17: "onlyBuiltDependencies": [
18: "esbuild",
19: "onnxruntime-node",
20: "sharp"
21: ],
22: "overrides": {
23: "basic-ftp": "5.3.1",
24: "ip-address": "10.2.0",
25: "fast-xml-parser": "5.7.3",
26: "@huggingface/hub": "2.11.0",
27: "onnxruntime-node": "1.27.0",
28: "yaml": ">=2.8.3",
29: "esbuild": ">=0.28.1",
30: "@opentelemetry/core": ">=2.8.0",
31: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/quality/REVIEW.md</path> <type>file</type> <content> 1: # Review Heuristics — Lore 2: 3: This document codifies the review bar for pull requests. It exists because 4: adversarial review has repeatedly caught correctness bugs that a green test 5: suite missed — skip/early-return branches, lifecycle sequences, and fan-out 6: registry gaps. Institutionalizing these patterns so they compound. 7: 8: The review workflow (§6) is referenced from AGENTS.md. 9: 10: --- 11: 12: ## 1. Regression-test discipline 13: 14: Every adversarial-review finding that surfaces a defect **must** land a 15: deterministic regression test in the same PR. The test: 16: - fails on the base branch (proving it reproduces the bug), 17: - passes on the fix (proving the fix works), 18: - drives the *real* precondition, not an artificially-constructed state (e.g. ...
Found 23 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts:
Line 1282: emit("codex.rate_limits", quota);
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
Line 588: case "codex.rate_limits": {
Line 592: const quota: Record<string, unknown> = { type: "codex.rate_limits" };
Line 595: "rate_limits",
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/codex-usage-provisional.test.ts:
Line 22: type: "codex.rate_limits",
Line 23: rate_limits: {
Line 48: `event: codex.rate_limits\ndata: ${JSON.stringify(quota)}\n\n${await response.text()}`,
Line 104: .filter((frame) => frame.startsWith("event: codex.rate_limits\n"))
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/codex-usage-metadata.test.ts:
Line 11: type: "codex.rate_limits",
Line 13: rate_limits: {
Line 58: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/llm-adapter.ts:
Line 4772: // worker call against that sibling is the recovery probe.
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/worker-model.ts:
Line 85: * being served from a stale entry, defeating auto-recovery.
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts:
Line 1329: "Continue the user's task using the accepted recall results and the context already available. Give your best supported answer or use an available non-recall tool. Do not request recall and do not mention recovery or provider failures.";
Line 1348: if (!resultMessage) throw new Error("recall recovery result message missing");
Line 1776: const recovery = buildRecallRecoveryRequest(
Line 1784: ? ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/pi/test/internal.test.ts:
Line 20: captureException: vi.fn(),
Line 24: log.registerSink(silentSink);
Line 275: log.registerSink({
Line 279: captureException: vi.fn(),
Line 300: log.registerSink({
Line 304: captureException: vi.fn(),
Line 317: log.registerSink({
Line 321: captureException: vi.fn(),
Line 392: log.registerSink({
Line 396: captureException: vi.fn(),
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cch.test.ts:
Line 946: captureException: () => {},
Line 951: log.registerSink({
Line 955: captureException: () => {},
Line 960: log.registerSink(silentSink);
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/auth.test.ts:
Line 481: // provided", which is the persistent 401 reported in #829. ...
Found 74 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/llm-adapter.ts: Line 2526: validateOpenAIUsage(data.usage, "malformed OpenAI response body"); Line 3169: * Detect a provider error envelope embedded in an otherwise-2xx body and return Line 3947: // success, so the JSON error-envelope check below never applies Line 4035: // A 2xx whose body is a provider error envelope (e.g. OpenRouter Line 4146: // Data-policy error surfaced as an HTTP 200 error-envelope Line 4148: // status — see the transient-envelope handling above). The Line 4158: // explaining OpenRouter's own error). An HTTP-200 envelope is Line 4169: `(HTTP 200 error-envelope) — blocklisting and re-resolving ` + Line 4180: message: "data-policy (HTTP 200 envelope)", /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/cch.ts: Line ...
Found 20 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts:
Line 788: // This happens when recall-only follow-up piped continuation content
Line 802: // Truncate assistant message at the tool_use (remove continuation)
Line 821: // Split: insert tool_result user message + continuation assistant
Line 823: const continuationMsg: GatewayMessage = {
Line 827: req.messages.splice(i + 1, 0, toolResultMsg, continuationMsg);
Line 1188: /** A final recall continuation must give the client an answer, refusal, or tool handoff. */
Line 1196: // A usable sibling must not hide an undispatchable tool call. Validate every
Line 1249: if (finalRecallRound) log.info("recall final continuation: budget exhausted");
Line 1331: /** Build the single request-local synthesis attempt after recall continuation failure. */
Line 1549: /** SSE reader for the continuation stream — pipe through parseSSEStream(). ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path> <type>file</type> <content> 1: /** 2: * OpenAI Responses API SSE stream accumulator. 3: * 4: * Parses upstream Responses API streaming events and accumulates the full 5: * response into a `GatewayResponse`. The Responses API uses a different 6: * SSE event lifecycle than Anthropic: 7: * 8: * response.created → response.in_progress → 9: * response.output_item.added → response.output_text.delta (repeated) → 10: * response.output_item.done → response.function_call_arguments.delta → 11: * response.function_call_arguments.done → 12: * response.completed 13: * 14: * Reuses `parseSSEStream` from the Anthropic stream module since the 15: * underlying SSE wire format is the same. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
530: return snapshot;
531: }
532: const finalizedContent = finalizedResponsesMessageContent(
533: outputIndex,
534: terminalContentParts,
535: ).map((part) =>
536: part.kind === "text"
537: ? { type: "output_text", text: part.value }
538: : { type: "refusal", refusal: part.value },
539: );
540: return finalizedContent.length > 0
541: ? { ...snapshot, content: finalizedContent }
542: : snapshot;
543: }
544:
545: /** Validated unsuccessful terminal, carrying usage for accounting-only paths. */
546: export class ResponsesTerminalError extends Error {
547: constructor(
548: readonly response: GatewayResponse,
549: readonly status: string,
550: ) {
551: super(`upstream Responses request ended with status ${status}`);
552: this.name = "ResponsesTerminalError";
553: }
554: }
555:
556: export ...
Found 17 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/types.ts:
Line 349: codexRateLimits?: Array<Record<string, unknown>>;
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts:
Line 1281: for (const quota of resp.codexRateLimits ?? []) {
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
Line 60: codexRateLimits?: Array<Record<string, unknown>>;
Line 602: (state.codexRateLimits ??= []).push(quota);
Line 897: ...(state.codexRateLimits
Line 898: ? { codexRateLimits: state.codexRateLimits }
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 18154: const cumulativeCodexRateLimits = [...(resp.codexRateLimits ?? [])];
Line 18202: ? { codexRateLimits: cumulativeCodexRateLimits }
Line 18341: if (error.response.codexRateLimits?.length) {
Line 18342: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
860: if (item.text) {
861: content.push({ type: "text", text: item.text });
862: }
863: } else if (item.type === "tool_use") {
864: let input: unknown = {};
865: if (item.args) {
866: try {
867: input = JSON.parse(item.args);
868: } catch {
869: input = item.args;
870: }
871: }
872: content.push({
873: type: "tool_use",
874: id: item.callId || item.id,
875: name: item.name,
876: input,
877: });
878: }
879: }
880:
881: let stopReason = state.stopReason;
882: // If we saw tool_use, map stop reason accordingly
883: if (content.some((b) => b.type === "tool_use") && stopReason === "end_turn") {
884: stopReason = "tool_use";
885: }
886:
887: return {
888: id: state.id,
889: model: state.model,
890: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/types.ts</path>
<type>file</type>
<content>
320: /**
321: * True when a response body is Server-Sent Events rather than a JSON object —
322: * even if the provider mislabeled or omitted the `content-type`.
323: *
324: * Detected by the header OR by sniffing the body prefix: an LLM-completion SSE
325: * stream always begins with a `data:` or `event:` field, whereas a JSON body
326: * begins with `{` or `[`. Some providers (the ChatGPT/Copilot/Codex backend,
327: * DeepSeek) return SSE even when a NON-streaming request was made — and
328: * sometimes WITHOUT the `text/event-stream` content-type — so a header-only
329: * check misses them and `JSON.parse`-ing the SSE body throws
330: * (`Unexpected token 'e', "event: res"...` — LOREAI-GATEWAY-38 / -1P).
331: *
332: * Recognizes every legal field/comment that may precede the first data event. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts</path>
<type>file</type>
<content>
1240:
1241: function incompleteDetails(stopReason: string): { reason: string } {
1242: return {
1243: reason:
1244: stopReason === "content_filter" ? "content_filter" : "max_output_tokens",
1245: };
1246: }
1247:
1248: function buildOpenAIResponsesStreamResponse(resp: GatewayResponse): Response {
1249: const usage = resp.usage ?? ZERO_USAGE;
1250: const encoder = new TextEncoder();
1251:
1252: const stream = new ReadableStream({
1253: start(controller) {
1254: const respId = resp.id.startsWith("resp_") ? resp.id : `resp_${resp.id}`;
1255: const created = Math.floor(Date.now() / 1000);
1256:
1257: function emit(eventType: string, data: Record<string, unknown>) {
1258: controller.enqueue(
1259: encoder.encode(
1260: `event: ${eventType}\ndata: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/codex-usage-metadata.test.ts</path>
<type>file</type>
<content>
1: import { describe, expect, test } from "vitest";
2: import fc from "fast-check";
3: import {
4: accumulateResponsesSSEStream,
5: ResponsesTerminalError,
6: streamResponsesPassthrough,
7: } from "../src/stream/openai-responses";
8: import { buildOpenAIResponsesResponse } from "../src/translate/openai-responses";
9:
10: const limits = {
11: type: "codex.rate_limits",
12: plan_type: "pro",
13: rate_limits: {
14: primary: { used_percent: 12.5, window_minutes: 300, reset_at: 2000000000 },
15: secondary: {
16: used_percent: 75,
17: window_minutes: 10080,
18: reset_at: 2000100000,
19: },
20: },
21: credits: { has_credits: true, unlimited: false, balance: "12.34" },
22: };
23:
24: function upstream(
25: events: Record<string, unknown>[],
26: incomplete = false,
27: ): Response {
28: const status = ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts</path>
<type>file</type>
<content>
1: import { afterEach, describe, expect, test, vi } from "vitest";
2: import { db, ltm, loadSessionTracking, temporal } from "@loreai/core";
3: import * as core from "@loreai/core";
4: import { loadConfig } from "../src/config";
5: import { clearAllCosts, getSessionCosts } from "../src/cost-tracker";
6: import {
7: accumulateNonStreamResponse,
8: buildStreamingResponse,
9: getActiveSessions,
10: handleRequest,
11: resetPipelineState,
12: setRecallPersistenceCommitObserverForTest,
13: setUpstreamInterceptor,
14: streamingPostResponsePendingForTest,
15: } from "../src/pipeline";
16: import type { GatewayRequest } from "../src/translate/types";
17: import { parseAnthropicResponseJSON } from "../src/translate/anthropic";
18: import {
19: _resetForTest as resetWorkerHealth,
20: _setNowForTest as setWorkerHealthTime,
21: ...
Found 100 matches (more matches available) /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cache-bust-oracle.e2e.test.ts: Line 47: /** ~1200 tokens per message so a long history overflows the budget and the /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cache-bust-metric.test.ts: Line 4: // readpath-capture.test.ts). A full factory replaces the shared instance for /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-admin-contract.test.ts: Line 151: let capturedExitCode: number | undefined; Line 154: capturedExitCode = process.exitCode; Line 162: expect(capturedExitCode).toBe(1); Line 186: let capturedExitCode: number | undefined; Line 189: capturedExitCode = process.exitCode; Line 197: expect(capturedExitCode).toBe(1); Line 227: let capturedExitCode: number | undefined; Line 230: capturedExitCode = process.exitCode; Line 241: ...
Found 7 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts:
Line 197: content: "private provider diagnostic",
Line 225: expect(body).not.toContain("private provider diagnostic");
Line 285: "overflow",
Line 329: if (usageKind === "overflow")
Line 330: json.usage[outputKey] = Number.MAX_SAFE_INTEGER;
Line 361: test.each(["valid", "negative", "overflow"] as const)(
Line 370: usageKind === "overflow" ? Number.MAX_SAFE_INTEGER : 100,
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts</path>
<type>file</type>
<content>
240:
241: test.each([
242: ["vertex", "https://aiplatform.googleapis.com"],
243: ["minimax", "https://api.minimax.io"],
244: ] as const)(
245: "%s recovery omits serialized provider cache controls",
246: async (provider, upstreamURL) => {
247: knowledge();
248: const alias = crypto.randomUUID();
249: const req = request("anthropic", alias);
250: req.rawHeaders["x-lore-provider"] = provider;
251: req.rawHeaders["x-lore-upstream-url"] = upstreamURL;
252: const cfg = config();
253: if (provider === "vertex") {
254: cfg.vertexProject = "test-vertex-project";
255: cfg.vertexRegion = "global";
256: _setTestVertexTokenProvider(() => Promise.resolve("test-vertex-token"));
257: }
258: let calls = 0;
259: const bodies: string[] = [];
260: setUpstreamInterceptor(async (body) => {
261: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18090: if (
18091: upstreamResponse.status === 400 &&
18092: (errorBody.includes("prompt is too long") ||
18093: errorBody.includes("context_length_exceeded") ||
18094: errorBody.includes("maximum context length"))
18095: ) {
18096: const anthropicMatch = errorBody.match(
18097: /prompt is too long: (\d+) tokens > (\d+) maximum/,
18098: );
18099: const openaiMatch =
18100: !anthropicMatch &&
18101: errorBody.match(/resulted in (\d+) tokens.*?(\d+) tokens/);
18102: const match = anthropicMatch || openaiMatch;
18103: // Default to 1.3 (maps to layer 3) when the format can't be parsed,
18104: // since an unparseable error suggests an unexpected situation where
18105: // aggressive compression is safer.
18106: const overshootRatio = match ? ...
Found 6 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts: Line 7175: ? mergeRecallUsage( Line 7616: cumulativeUsage = mergeRecallUsage( Line 16048: export function mergeRecallUsage( Line 18336: mergeRecallUsage( Line 18398: mergeRecallUsage(cumulativeUsage, recovered.usage ?? ZERO_USAGE), Line 18516: mergeRecallUsage(cumulativeUsage, contUsage),
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
16005: state.lastUpstream?.protocol,
16006: state.resolvedConversationTTL,
16007: );
16008: if (!profile) return false;
16009:
16010: // /lore:warm:keep sessions: consider warm if the last warmup was within
16011: // 2 TTL windows. The warmer fires once per TTL window, so 2× provides a
16012: // safety margin while still expiring if the warmer has stopped
16013: // (e.g. circuit breaker tripped, process-level failure).
16014: if (warmup.forceKeepWarm) {
16015: return Date.now() - warmup.lastWarmupAt < profile.ttlMs * 2;
16016: }
16017:
16018: return Date.now() - warmup.lastWarmupAt < profile.ttlMs;
16019: }
16020:
16021: /**
16022: * Decide whether to skip post-idle compaction (PR2b). ...
Found 61 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts:
Line 149: const outcome = calls === 1 ? "recall" : calls === 2 ? "invalid" : "answer";
Line 150: const response = providerResponse("openai-responses", calls, outcome, true);
Line 187: if (calls === 2) return new Response("failure", { status: 503 });
Line 264: if (calls === 2) return new Response("failure", { status: 503 });
Line 295: if (calls < FINAL_RECALL_CALL)
Line 297: if (calls > FINAL_RECALL_CALL)
Line 305: const json = await providerResponse(protocol, calls, "invalid").json();
Line 348: expect(calls).toBe(FINAL_RECALL_CALL + 1);
Line 426: (["failure", "commit", "capacity", "late-capacity"] as const).flatMap(
Line 503: mode === "failure" || calls === 1 ? "recall" : "answer",
Line 518: expect(response.status).toBe(mode === "failure" ? 502 : 200);
Line 534: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts</path>
<type>file</type>
<content>
575: ++calls,
576: calls === 2 ? "answer" : "recall",
577: (body as Record<string, unknown>).stream === true,
578: ),
579: );
580: const response = await handleRequest(req, config());
581: expect(await response.text()).toContain("Completed answer");
582: await settled();
583: expect(stateFor(alias).recallStore.size).toBe(0);
584: expect(ltm.transferCount(id)).toBe(0);
585: });
586:
587: const query =
588: "transactional glacier orchard telescope cobalt lantern mercury compass velvet island";
589: let productiveRecallIds: string[] | undefined;
590:
591: /**
592: * Terminal-recall fixtures start with a search then use distinct detail reads,
593: * so they remain productive. They use the minimum legal emergency cap to test
594: * finalization without coupling the test runtime to the production default. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts</path>
<type>file</type>
<content>
1320: beforeTracking,
1321: );
1322: },
1323: );
1324:
1325: function config() {
1326: const cfg = loadConfig();
1327: cfg.remoteGateway = false;
1328: cfg.hostedMode = false;
1329: return cfg;
1330: }
1331:
1332: const createdKnowledge = new Set<string>();
1333:
1334: function knowledge(title = query) {
1335: const id = ltm.create({
1336: projectPath: `/test/buffered-recall-origin/${crypto.randomUUID()}`,
1337: category: "gotcha",
1338: title,
1339: content: `${query}: preserve transaction boundaries.`,
1340: scope: "project",
1341: crossProject: true,
1342: // The fixture deliberately needs independently addressable records. The
1343: // production fuzzy-dedup guard otherwise merges these near-identical
1344: // test entries into one logical source.
1345: id: ...
Found 1 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts: Line 993: function request(
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-buffered-transaction.test.ts</path>
<type>file</type>
<content>
970: expect(received).not.toContain("data: [DONE]");
971: expect(received).not.toContain("event: response.completed");
972: expect(received).not.toMatch(/"finish_reason":"|"finishReason":/);
973: }
974: } else {
975: expect(response.status).toBe(502);
976: await response.text();
977: }
978: await settled();
979: expect(calls).toBe(FINAL_RECALL_CALL + (stream ? 0 : 1));
980: expect(
981: db()
982: .query(
983: "SELECT COUNT(*) AS count FROM temporal_messages WHERE session_id = ? AND role = 'assistant'",
984: )
985: .get(stateFor(alias).sessionID),
986: ).toEqual({ count: 0 });
987: }
988: },
989: );
990: },
991: );
992: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
1000: detailOffsetValue !== undefined &&
1001: (!Number.isSafeInteger(detailOffsetValue) ||
1002: (detailOffsetValue as number) < 0)
1003: ) {
1004: throw new Error("Recall detailOffset must be a non-negative integer");
1005: }
1006: if (
1007: detailLimitValue !== undefined &&
1008: (!Number.isSafeInteger(detailLimitValue) ||
1009: (detailLimitValue as number) < 1 ||
1010: (detailLimitValue as number) > 16_000)
1011: ) {
1012: throw new Error("Recall detailLimit must be an integer from 1 to 16000");
1013: }
1014: const query = queryValue ?? "";
1015: if (!query.trim() && !idValue && !idsValue) {
1016: throw new Error("Recall query, id, or ids is required");
1017: }
1018: if (
1019: (detailOffsetValue !== undefined || detailLimitValue !== undefined) &&
1020: typeof idValue !== "string"
1021: ) ...
/home/byk/Code/opencode-lore-recall-recovery/packages/core/src/log.ts
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/core/src/log.ts</path>
<type>file</type>
<content>
1: /**
2: * Lightweight logger that suppresses informational messages by default.
3: *
4: * In TUI mode, all stderr output renders as red "error" text — confusing
5: * for routine status messages like "incremental distillation" or "pruned
6: * temporal messages". Only actual errors should be visible by default.
7: *
8: * Set LORE_DEBUG=1 to see informational messages (useful when debugging
9: * the plugin itself).
10: *
11: * ## Sink registration
12: *
13: * An optional {@link LogSink} can be registered via {@link registerSink}.
14: * When registered, every log call (regardless of `isDebug`) also forwards
15: * to the sink. This is used by the gateway to bridge logs → Sentry without
16: * adding a Sentry dependency to `@loreai/core`.
17: *
18: * ## File logging
19: *
20: * All log calls (info, warn, error) are written to a persistent log file
21: * at ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/core/src/log.ts</path>
<type>file</type>
<content>
300: constants.O_CREAT |
301: constants.O_NONBLOCK |
302: NO_FOLLOW,
303: LOG_FILE_MODE,
304: );
305: try {
306: const info = fstatSync(fd);
307: if (!info.isFile())
308: throw new Error(`Refusing non-regular log file: ${path}`);
309: assertCurrentOwner(info, path);
310: validateLogDirectory(dataDir());
311: assertSameFile(lstatSync(path), info, path);
312: if (existing) assertSameFile(existing, info, path);
313: if (process.platform !== "win32") fchmodSync(fd, LOG_FILE_MODE);
314: return fd;
315: } catch (error) {
316: closeSync(fd);
317: throw error;
318: }
319: }
320:
321: function tightenExistingLogFile(path: string): void {
322: const existing = lstatSync(path);
323: if (!existing.isFile() || existing.isSymbolicLink()) {
324: throw new Error(`Refusing non-regular log file: ...
No files found
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/llm-adapter.ts:
Line 3953: log.error(
Line 4902: log.error(
Line 4997: log.error(exhaustionMsg);
Line 5101: log.error(
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts:
Line 1120: log.error("gateway recall execution failed:", e);
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/worker-health.ts:
Line 669: log.error(
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/vertex-auth.ts:
Line 90: log.error("Vertex ADC token mint failed:", (err as Error).message);
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 942: log.error(
Line 1125: log.error("streaming post-response drop cleanup failed:", error);
Line 1175: log.error("streaming post-response processing failed:", ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path> <type>file</type> <content> 1: /** 2: * Gateway recall interception — transparent memory search for any client. 3: * 4: * Uses a unified "Marker and Expand" strategy: 5: * 6: * 1. **On response (to client):** The recall `tool_use` block is replaced 7: * with a text marker. Responses clients receive an invisible unique anchor; 8: * other clients receive status text plus the same anchor. The recall result 9: * is stored in session state under that unique key. 10: * 11: * 2. **On request (from client):** Marker text blocks in the conversation 12: * are expanded back into the original `tool_use` + `tool_result` pairs 13: * before forwarding upstream. 14: * 15: * For recall-only responses, a follow-up call is still made internally 16: * so the model can continue in the same HTTP response (seamless UX). ...
Found 8 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall-already-in-ltm.test.ts: Line 48: await executeRecall(block, "/tmp/proj", "sess", undefined, ids); Line 54: await executeRecall(block, "/tmp/proj", "sess", undefined, ids); Line 69: await executeRecall(block, "/tmp/proj", "sess"); Line 137: const result = await executeRecall( /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall.test.ts: Line 231: const result = await executeRecall( Line 242: "Recall search failed. The memory system encountered an error.", Line 266: const result = await executeRecall( Line 272: "Recall search failed. The memory system encountered an error.",
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/recall.test.ts</path>
<type>file</type>
<content>
1: /**
2: * Unit tests for gateway recall interception helpers.
3: *
4: * Tests the pure functions in recall.ts:
5: * - Tool definition
6: * - Detection helpers (findRecallToolUse, hasRecallToolUse, hasOtherToolUse)
7: * - Follow-up request builder
8: * - Pending recall injection
9: * - Response stripping
10: */
11: import { describe, test, expect, vi } from "vitest";
12: import { log } from "@loreai/core";
13: import {
14: LORE_COMMIT_REMINDER,
15: accumulateOpenAINonStreamJSON,
16: accumulateResponsesNonStreamJSON,
17: loreMessagesToGateway,
18: responsesProvenanceContent,
19: responsesProvenanceByMessageId,
20: responsesAnchorContext,
21: } from "../src/pipeline";
22: import {
23: isUsableRecallContinuation,
24: RECALL_GATEWAY_TOOL,
25: RECALL_TOOL_NAME,
26: MAX_RECALL_DEPTH,
27: findRecallToolUse,
28: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
885: activeKeys.add(match.key);
886: }
887: }
888: }
889:
890: // Remove entries not referenced by any current marker
891: let changed = false;
892: for (const key of store.keys()) {
893: if (!activeKeys.has(key)) {
894: store.delete(key);
895: changed = true;
896: }
897: }
898: return changed;
899: }
900:
901: // ---------------------------------------------------------------------------
902: // Detection helpers
903: // ---------------------------------------------------------------------------
904:
905: /** Find the recall tool_use block in a GatewayResponse, if any. */
906: export function findRecallToolUse(
907: resp: GatewayResponse,
908: ): GatewayToolUseBlock | undefined {
909: return resp.content.find(
910: (b): b is GatewayToolUseBlock =>
911: b.type === "tool_use" && b.name === ...
/home/byk/Code/opencode-lore-recall-recovery/packages/core/test/log.test.ts
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/core/test/log.test.ts</path>
<type>file</type>
<content>
1: import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
2: import {
3: chmodSync,
4: lstatSync,
5: mkdirSync,
6: mkdtempSync,
7: readFileSync,
8: rmSync,
9: symlinkSync,
10: writeFileSync,
11: } from "node:fs";
12: import { tmpdir } from "node:os";
13: import { join } from "node:path";
14:
15: /**
16: * Import a fresh copy of the log module with a controlled `LORE_DEBUG` value.
17: *
18: * `isDebug` (and the `stderrSilenced` flag) are module-level state captured at
19: * import time, so each test resets the module registry to get a clean,
20: * deterministic instance regardless of the ambient environment.
21: */
22: async function freshLog(debug: string | undefined) {
23: if (debug === undefined) delete process.env.LORE_DEBUG;
24: else process.env.LORE_DEBUG = debug;
25: vi.resetModules();
26: return ...
Found 14 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 964: lastStreamingPostResponseResetLog = 0;
Line 1075: let lastStreamingPostResponseResetLog = 0;
Line 1133: if (now - lastStreamingPostResponseResetLog >= 30_000) {
Line 1134: lastStreamingPostResponseResetLog = now;
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cli-logs-contract.test.ts:
Line 31: // Mutable state for the mocked log.logFilePath.
Line 39: logFilePath: () => fakeState.path,
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/cli/logs.ts:
Line 30: const path = log.logFilePath();
/home/byk/Code/opencode-lore-recall-recovery/packages/core/src/log.ts:
Line 399: export function logFilePath(): string | undefined {
Line 433: function writeToFile(level: string, message: string): void {
Line 434: const path = logFilePath();
Line 469: writeToFile("info", msg);
Line 478: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/codex-usage-provisional.test.ts</path>
<type>file</type>
<content>
1: import { dirname } from "node:path";
2: import { afterEach, expect, it } from "vitest";
3: import { createHarness, type Harness } from "./helpers/harness";
4: import { DEFAULT_SYSTEM } from "./helpers/fixtures";
5: import { getActiveSessions, setUpstreamInterceptor } from "../src/pipeline";
6: import { buildOpenAIResponsesResponse } from "../src/translate/openai-responses";
7:
8: let harness: Harness | undefined;
9: afterEach(async () => {
10: await harness?.teardown();
11: harness = undefined;
12: });
13:
14: for (const incomplete of [false, true]) {
15: it(`preserves current Codex quota during session header migration (incomplete=${incomplete})`, async () => {
16: harness = await createHarness({ fixtures: [] });
17: let calls = 0;
18: const quotaEvents: Record<string, unknown>[] = [];
19: setUpstreamInterceptor(async ...
Found 14 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cache-warmer.test.ts:
Line 447: { role: "user", content: [{ type: "text", text: "q1" }] },
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/cache-analytics.test.ts:
Line 971: '{"role":"user","content":[{"type":"text","text":"q1"}]},' +
Line 978: '{"role":"user","content":[{"type":"text","text":"q1"}]},' +
Line 980: '{"role":"user","content":[{"type":"text","text":"q2","cache_control":{"type":"ephemeral"}}]}' +
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/delta-compress-reanchor.test.ts:
Line 716: // B=seq1. Ascending-seq order (A before B) must hold every turn. ...
Found 48 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/gemini.ts:
Line 31: DEFAULT_MAX_SSE_FRAMES,
Line 50: stopAtTerminal?: boolean;
Line 53: maxFrames?: number;
Line 79: maxFrames: opts.strict
Line 80: ? (opts.maxFrames ?? DEFAULT_MAX_SSE_FRAMES)
Line 81: : opts.maxFrames,
Line 259: // legal usage-only frame after that terminal, so stopAtTerminal
Line 269: opts.stopAtTerminal &&
Line 282: if (opts.stopAtTerminal && !terminalSeen) {
Line 363: stopAtTerminal: opts.strict,
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/anthropic.ts:
Line 58: export const DEFAULT_MAX_SSE_FRAMES = 100_000;
Line 154: maxFrames?: number;
Line 155: frameCounter?: { count: number };
Line 175: const maxFrames = opts.maxFrames ?? DEFAULT_MAX_SSE_FRAMES;
Line 176: const frameCounter = opts.frameCounter ?? ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
40: /** Format a single named SSE event for sending to the client. */
41: export function formatSSEEvent(eventType: string, data: string): string {
42: return `event: ${eventType}\ndata: ${data}\n\n`;
43: }
44:
45: // ---------------------------------------------------------------------------
46: // SSE parsing
47: // ---------------------------------------------------------------------------
48:
49: type StreamChunkRead = Awaited<
50: ReturnType<ReadableStreamDefaultReader<Uint8Array>["read"]>
51: >;
52:
53: /**
54: * Foreground and worker SSE streams share this finite frame ceiling. The byte
55: * ceilings bound retained data, while this independently bounds parser work for
56: * tiny frames (including blank and comment-only frames). ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1850: return status;
1851: }
1852:
1853: function validateFailureTerminal(parsed: Record<string, unknown>): void {
1854: if (!isRecord(parsed.response) || parsed.response.status !== "failed") {
1855: throw new Error("malformed Responses terminal event");
1856: }
1857: const error = parsed.response.error;
1858: if (error !== undefined && error !== null) {
1859: if (!isRecord(error)) throw new Error("malformed Responses terminal event");
1860: for (const field of ["type", "code", "message"] as const) {
1861: if (error[field] !== undefined && typeof error[field] !== "string") {
1862: throw new Error("malformed Responses terminal event");
1863: }
1864: }
1865: }
1866: }
1867:
1868: /**
1869: * Accumulate an OpenAI Responses API SSE stream into a GatewayResponse. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1950: }
1951: if (
1952: opts.onSemanticContent &&
1953: responsesEventHasSemanticContent(event, parsed)
1954: ) {
1955: opts.onSemanticContent();
1956: }
1957: if (
1958: opts.validation &&
1959: event === "response.failed" &&
1960: !opts.allowFailureTerminal &&
1961: !opts.requireCompletedTerminal
1962: ) {
1963: throw new Error("response.failed terminal");
1964: }
1965: if (opts.validation === "public") {
1966: validatePublicResponsesEvent(state, event, parsed, maxSparseIndex);
1967: } else if (opts.validation === "codex") {
1968: validateCodexResponsesEvent(state, event, parsed, maxSparseIndex);
1969: }
1970: if (opts.validation && event === "response.failed") {
1971: ...
Found 3 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
Line 588: case "codex.rate_limits": {
Line 592: const quota: Record<string, unknown> = { type: "codex.rate_limits" };
Line 1625: function validateCodexResponsesEvent(
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1570: const unbound = soleCodexItem(codexItemSet(state, kind, true));
1571: if (unbound !== undefined) {
1572: outputIndex = unbound;
1573: bindCodexItemId(state, outputIndex, itemId);
1574: } else if (codexItemSet(state, kind).size > 0) {
1575: malformedResponsesEvent();
1576: }
1577: }
1578: }
1579: outputIndex ??= nextResponsesOutputIndex(state, maxSparseIndex);
1580:
1581: const existing = state.rawItems.get(outputIndex);
1582: if (event === "response.output_item.added" && existing) {
1583: malformedResponsesEvent();
1584: }
1585: if (event === "response.output_item.done" && existing) {
1586: if (
1587: existing.type !== item.type ||
1588: (isNonEmptyString(existing.id) &&
1589: isNonEmptyString(item.id) &&
1590: existing.id !== item.id)
1591: ) ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1700: event === "response.in_progress" &&
1701: response.status !== undefined &&
1702: response.status !== "in_progress"
1703: ) {
1704: malformedResponsesEvent();
1705: }
1706: }
1707:
1708: switch (event) {
1709: case "response.output_item.added":
1710: case "response.output_item.done":
1711: normalizeCodexItemEvent(state, event, parsed, maxSparseIndex);
1712: break;
1713: case "response.content_part.added":
1714: case "response.content_part.done":
1715: if (!isRecord(parsed.part)) malformedResponsesEvent();
1716: normalizeCodexDataEvent(state, event, parsed, maxSparseIndex);
1717: break;
1718: case "response.output_text.delta":
1719: if (typeof parsed.delta !== "string") malformedResponsesEvent();
1720: normalizeCodexDataEvent(state, event, parsed, ...
Found 59 matches /home/byk/Code/opencode-lore-recall-recovery/.lore.md: Line 41: * **embedding-units 64-chunk cap**: Chose structural \`"\n\x1f"\` boundaries and a 64-chunk temporal cap over splitting on tool-looking text, dropping overflow, or allowing unlimited vec0 rows because tool output may mimic headers and unbounded fan-out expands storage and KNN widening. Keep units dependency-free; preserve prose/reasoning verbatim and reduced tool envelopes. Units \`0..62\` stay separate, while index \`63+\` is joined into the final chunk so evidence is retained. Embed through token-area-bounded \`embedInTokenBatches(..., "document")\`, then atomically store the complete vector set. Line 297: * **LocalProvider cold-backlog pinning**: Trap: least-busy worker assignment looks self-balancing, but the pool starts with one slot and grows only after that slot completes a real embed and becomes healthy. ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/usage-limit-headers.ts</path>
<type>file</type>
<content>
1: /** Preserve account quota metadata independently of rewritten token usage. */
2: export function copyUsageLimitHeaders(source: Headers, target: Headers): void {
3: const connectionHeaders = new Set(
4: (source.get("connection") ?? "")
5: .split(",")
6: .map((name) => name.trim().toLowerCase()),
7: );
8: source.forEach((value, name) => {
9: // Preserve provider units and windows verbatim, even across wire formats.
10: // OpenAI-compatible APIs share x-ratelimit-*; gateways may use the
11: // unprefixed fields. Codex has quota windows, named buckets, and credits.
12: // Never copy arbitrary upstream headers (cookies, framing, credentials).
13: if (
14: (name.startsWith("anthropic-ratelimit-") ||
15: name.startsWith("x-ratelimit-") ||
16: name.startsWith("x-rate-limit-") ||
17: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall-budget.ts</path>
<type>file</type>
<content>
1: import type { RecallCoverage } from "@loreai/core";
2: import type { GatewayUsage } from "./translate/types";
3:
4: /** Finite backstop only; normal termination is time, tokens, bytes, items, or stall. */
5: export const MAX_RECALL_EXECUTIONS = 24;
6: export const MAX_RECALL_CHAIN_TOKENS = 128_000;
7: export const MAX_RECALL_CHAIN_RESULT_BYTES = 512 * 1024;
8: export const MAX_RECALL_CHAIN_ITEMS = 64;
9: /** The formatter's configured maximum for source previews in one search. ...
Found 2 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/anthropic.ts: Line 291: const blockBytes = Buffer.byteLength(block); /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts: Line 2553: retainedBytes += Buffer.byteLength(data);
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts</path> <type>file</type> <content> 2390: 2391: /** 2392: * Stream an OpenAI Responses API upstream straight through to a Responses-API 2393: * client, forwarding each SSE event as it arrives while accumulating a complete 2394: * `GatewayResponse` in parallel. 2395: * 2396: * True-streaming counterpart to `accumulateResponsesSSEStream` (which buffers 2397: * the ENTIRE upstream before the client sees a byte — the cause of the 2398: * codex/ChatGPT "waiting for response headers" hang, since ChatGPT's 2399: * `/backend-api/codex/responses` reasoning turns are slow-to-first-token). 2400: * 2401: * Safe ONLY when no `recall` tool_use can appear in the stream (the caller 2402: * gates on recall-tool absence): recall interception requires buffering so the 2403: * injected tool_use never leaks to the client. ...
Found 11 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:
Line 582: export function applyResponsesEvent(
Line 1393: applyResponsesEvent(state, "response.output_item.added", {
Line 1597: applyResponsesEvent(state, "response.output_item.added", {
Line 1767: applyResponsesEvent(state, event, parsed);
Line 2158: applyResponsesEvent(state, event, parsed);
Line 2250: applyResponsesEvent(state, "response.output_item.done", {
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 8382: applyResponsesEvent(state, "response.output_item.added", {
Line 9154: applyResponsesEvent(acc, "response.output_item.added", {
Line 9435: applyResponsesEvent(acc, "response.output_item.done", {
Line 10251: applyResponsesEvent(state, event, parsed);
Line 10846: applyResponsesEvent(contState, ce, cparsed);
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10165: throw new Error(`Responses payload type does not match ${event}`);
10166: }
10167: if (
10168: (event === "response.output_item.added" ||
10169: event === "response.output_item.done") &&
10170: (parsed.item as Record<string, unknown> | undefined)?.type ===
10171: "function_call" &&
10172: (parsed.item as Record<string, unknown>).name === RECALL_TOOL_NAME
10173: ) {
10174: recallDetected = true;
10175: }
10176: const normalizationState = normalizeCodexEvent(
10177: state,
10178: event,
10179: parsed,
10180: );
10181: validateResponseLifecycle(state, event, parsed);
10182: seedImplicitCodexItem(state, normalizationState, event, ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10050: error: unknown,
10051: ): PrincipalFailureCategory => {
10052: if (error instanceof SSEStreamTransportError) {
10053: return "principal_transport";
10054: }
10055: if (error instanceof SSEStreamLimitError) {
10056: return "principal_resource_limit";
10057: }
10058: return principalFailureCategory;
10059: };
10060: const principalTransportStage = () =>
10061: ordinaryToolEmitted
10062: ? ("post_tool" as const)
10063: : principalEventEmitted
10064: ? ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10340: // Don't forward recall-item events to the client.
10341: continue;
10342: }
10343:
10344: // Terminal events: handle recall interception before forwarding.
10345: if (
10346: event === "response.completed" ||
10347: event === "response.done" ||
10348: event === "response.incomplete" ||
10349: event === "response.failed"
10350: ) {
10351: principalReadFinished = true;
10352: const terminalParsed = stripHiddenReferenceOutput(parsed);
10353: const terminalResponse = terminalParsed.response as
10354: | Record<string, unknown>
10355: | undefined;
10356: if (
10357: Array.isArray(terminalResponse?.output) &&
10358: ...
Found 8 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts: Line 10131: formatResponsesEvent(event, data), Line 10149: const chunk = encoder.encode(formatResponsesEvent(event, data)); Line 10295: formatResponsesEvent(event, data), Line 10737: formatResponsesEvent(ce, cd), Line 10755: formatResponsesEvent(ce, cd), Line 11049: formatResponsesEvent(ce, cd), Line 11453: const chunk = encoder.encode(formatResponsesEvent(event, data)); /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts: Line 2563: encoder.encode(formatResponsesEvent(event, data)),
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11415: throw error;
11416: }
11417: },
11418: rollback: () => {
11419: if (transactionSettled) return;
11420: transactionSettled = true;
11421: pendingCommits.length = 0;
11422: rollbackTransaction();
11423: },
11424: };
11425: deferredTransaction = transaction;
11426: if (successful) opts.onTransactionReady?.(transaction);
11427: if (!finish(visibleResp, successful)) {
11428: transaction.rollback();
11429: throw new Error(
11430: "recall onComplete failed after delivery",
11431: );
11432: ...
Found 1 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts: Line 7947: const normalizeCodexEvent = (
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7900: const responseLifecycleFor = (
7901: acc: ResponsesAccState,
7902: ): { created: boolean; terminal: boolean } => {
7903: let lifecycle = responseLifecycles.get(acc);
7904: if (!lifecycle) {
7905: lifecycle = { created: false, terminal: false };
7906: responseLifecycles.set(acc, lifecycle);
7907: }
7908: return lifecycle;
7909: };
7910: type TextPartLifecycle = {
7911: kind: string;
7912: authoritativeValue: string;
7913: authoritativeValueSeen: boolean;
7914: deltaSeen: boolean;
7915: valueDone: boolean;
7916: finalValue?: string;
7917: partAdded: boolean;
7918: partDone: boolean;
7919: partFinalValue?: string;
7920: };
7921: type OutputLifecycle = {
7922: argumentDeltaSeen: boolean;
7923: argumentDeltas: string;
7924: argumentsDone: boolean;
7925: outputDone: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10695: deferredContinuationBytes = 0;
10696: };
10697: let continuationRecallBytes = 0;
10698: const promoteContinuationCandidate = (
10699: outputIndex: number,
10700: ): void => {
10701: const bytes =
10702: contUnresolvedToolBytes.get(outputIndex) ?? 0;
10703: contUnresolvedToolBytes.delete(outputIndex);
10704: continuationRecallBytes += bytes;
10705: hiddenRecallBytes += bytes;
10706: if (
10707: continuationRecallBytes > maxDeferredBytes ||
10708: hiddenRecallBytes > maxHiddenRecallBytes
10709: ) {
10710: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
1160: ) => Promise<GatewayResponse>;
1161: /**
1162: * Accumulate a streaming (SSE) upstream response into a GatewayResponse.
1163: * Required only by `runRecallFollowUpStreamAccumulated` (the `openai-codex`
1164: * path, whose ChatGPT backend mandates streaming).
1165: */
1166: parseSSE?: (
1167: response: Response,
1168: signal?: AbortSignal,
1169: ) => Promise<GatewayResponse>;
1170: }
1171:
1172: function hasResponsesRefusal(item: Record<string, unknown>): boolean {
1173: return (
1174: item.type === "message" &&
1175: Array.isArray(item.content) &&
1176: item.content.some((part: unknown) => {
1177: if (!part || typeof part !== "object") return false;
1178: const refusal = part as Record<string, unknown>;
1179: return (
1180: refusal.type === "refusal" &&
1181: typeof refusal.refusal === ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/recall.ts</path>
<type>file</type>
<content>
1630: * parsed via the injected `parseJSON`, so a flag/consumer mismatch is
1631: * structurally impossible and any divergence fails loud (see assertJSONResponse).
1632: */
1633: export async function runRecallFollowUpJSON(
1634: ctx: RecallFollowUpCtx,
1635: originalReq: GatewayRequest,
1636: resp: GatewayResponse,
1637: recallResult: string,
1638: recallToolUseBlock: GatewayToolUseBlock,
1639: signal?: AbortSignal,
1640: finalRecallRound = false,
1641: ): Promise<RecallFollowUpJSON | RecallFollowUpError> {
1642: const followUp = buildRecallFollowUpRequest(
1643: originalReq,
1644: resp,
1645: recallResult,
1646: recallToolUseBlock,
1647: /* stream */ false,
1648: finalRecallRound,
1649: );
1650: return runRecallJSONRequest(ctx, followUp, signal);
1651: }
1652:
1653: async function runRecallJSONRequest(
1654: ctx: ...
Found 2 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 7809: export function streamResponsesRecallAware(
Line 18746: streamResponsesRecallAware(upstreamResponse, {
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path> <type>file</type> <content> 7780: 7781: /** 7782: * True-streaming, recall-aware variant of `streamResponsesPassthrough` for the 7783: * OpenAI Responses API (codex/ChatGPT) — used when the request carries the 7784: * gateway-injected `recall` tool but the client speaks the Responses API. 7785: * 7786: * Unlike the buffered `accumulateResponsesSSEStream` path (which withholds ALL 7787: * client bytes until the entire slow reasoning-heavy upstream completes — the 7788: * cause of opencode's 10s `ProviderHeaderTimeoutError`), this function forwards 7789: * every upstream SSE event to the client AS IT ARRIVES, while transparently 7790: * intercepting a `recall` `function_call` output item: 7791: * 7792: * - **No recall**: forwards everything unchanged (identical to 7793: * `streamResponsesPassthrough`). ...
Found 97 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 9: * forwards events live while transparently intercepting a `recall`
Line 209: test("forwards events live with NO recall — no header hold-back", async () => {
Line 792: const privateCause = "private principal socket failure";
Line 796: controller.error(new Error(privateCause));
Line 802: sessionID: "private-session\nforged-log-line",
Line 832: expect(out).not.toContain(privateCause);
Line 833: expect(warnings.join("\n")).not.toContain("private-session");
Line 857: const privateCause = "private principal socket failure";
Line 861: controller.error(new Error(privateCause));
Line 872: controller.error(new Error("private retry socket failure"));
Line 886: expect(out).not.toContain(privateCause);
Line 887: expect(out).not.toContain("private retry socket ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1: /**
2: * Unit tests for `streamResponsesRecallAware` — the true-streaming,
3: * recall-aware OpenAI Responses (codex/ChatGPT) streamer.
4: *
5: * Regression for the "Provider response headers timed out after 10000ms" issue:
6: * the buffered `accumulateResponsesSSEStream` path withholds ALL client bytes
7: * until the entire (slow, reasoning-heavy) upstream completes, so opencode's
8: * 10s `ProviderHeaderTimeoutError` fired on ChatGPT sessions. This streamer
9: * forwards events live while transparently intercepting a `recall`
10: * function_call (emit marker, run follow-up, rebuild the terminal
11: * `response.completed`).
12: */
13: import { log } from "@loreai/core";
14: import { afterEach, describe, test, expect } from "vitest";
15: import { streamResponsesRecallAware } from "../src/pipeline";
16: import {
17: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 219: runFollowUp: async () => {
Line 261: runFollowUp: async () => {
Line 296: runFollowUp: async () => {
Line 325: runFollowUp: async () => {
Line 363: runFollowUp: async () => {
Line 392: runFollowUp: async () => {
Line 450: runFollowUp: async () => {
Line 508: runFollowUp: async () => {
Line 562: runFollowUp: async () => {
Line 613: runFollowUp: async () => {
Line 637: runFollowUp: async () => {
Line 671: runFollowUp: async () => {
Line 703: runFollowUp: async () => {
Line 730: runFollowUp: async () => {
Line 764: runFollowUp: async () => {
Line 821: runFollowUp: async () => {
Line 877: runFollowUp: async () => {
Line 938: runFollowUp: ...
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1010: { kind: "read", stage: "post_tool", outcome: "continue" },
1011: ]);
1012: });
1013:
1014: test("does not retry a pre-output principal inactivity failure", async () => {
1015: let retries = 0;
1016: const transport: PrincipalTransportFailureSample[] = [];
1017: setPrincipalTransportFailureHook((sample) => transport.push(sample));
1018: const upstream = new Response(
1019: new ReadableStream<Uint8Array>({
1020: pull() {},
1021: }),
1022: );
1023: const client = streamResponsesRecallAware(upstream, {
1024: sseInactivityMs: 5,
1025: onComplete: () => {},
1026: retryPrincipal: async () => {
1027: retries++;
1028: return streamFrom([]);
1029: },
1030: onRecall: async () => ({ anchorText: "", resultText: "" }),
1031: ...
Found 3 matches /home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts: Line 123: } from "./translate/types"; Line 133: } from "./translate/types"; Line 218: } from "./stream/openai-responses";
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
90: resolveAgentsFileName,
91: latReader,
92: embedding,
93: temporalEmbeddingQueue,
94: saveSessionTracking,
95: loadSessionTracking,
96: appendSessionPromptDelta,
97: deleteSessionPromptDelta,
98: listSessionPromptDeltas,
99: updateSessionPromptDeltaSelector,
100: updateSessionPromptDeltaContent,
101: withSavepoint,
102: loadHeaderSessionIndex,
103: isHostedMode,
104: enableHostedMode,
105: importLoreFileAs,
106: resolveWorkspaces,
107: currentTenantId,
108: withTenant,
109: } from "@loreai/core";
110:
111: import type {
112: GatewayRequest,
113: GatewayResponse,
114: GatewayMessage,
115: GatewayContentBlock,
116: GatewayToolUseBlock,
117: GatewayToolResultBlock,
118: GatewayUsage,
119: StoredRecall,
120: SessionState,
121: UpstreamSnapshot,
122: WarmupState,
123: } from "./translate/types";
124: import ...
Found 12 matches
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:
Line 7826: maxStreamBytes?: number;
Line 7827: maxSSEFrames?: number;
Line 7962: Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES),
Line 8065: const maxTransactionalBytes = maxRetainedStateBytes;
Line 8066: const maxStreamBytes = opts.maxStreamBytes ?? 64 * 1024 * 1024;
Line 8070: const maxSSEFrames = opts.maxSSEFrames ?? 100_000;
Line 10122: maxFrames: maxSSEFrames,
Line 10133: if (streamBytes > maxStreamBytes) {
Line 10502: if (transactionalBytes > maxTransactionalBytes) {
Line 10729: maxFrames: maxSSEFrames,
Line 10739: if (streamBytes > maxStreamBytes) {
Line 11062: frameCounter.count > maxSSEFrames ||
<path>/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8030: | undefined;
8031: const restoreTransactionBaseline = (): void => {
8032: if (!transactionBaseline) return;
8033: state.id = transactionBaseline.id;
8034: state.model = transactionBaseline.model;
8035: state.stopReason = transactionBaseline.stopReason;
8036: state.terminalEvent = transactionBaseline.terminalEvent;
8037: state.terminalResponse = transactionBaseline.terminalResponse;
8038: state.usage = { ...transactionBaseline.usage };
8039: state.items = new Map(transactionBaseline.items);
8040: state.rawItems = new Map(transactionBaseline.rawItems);
8041: transactionBaseline = undefined;
8042: };
8043: const rollbackTransaction = (): void => {
8044: restoreTransactionBaseline();
8045: for (const rollback of transactionRollbacks.splice(0).reverse()) {
8046: try {
8047: rollback();
8048: ...
No files, VCS state, servers, or databases were touched. I did not run tests. Because VCS access was prohibited, I treated this checkout as candidate b61b0861 but did not independently verify its identity.
The required repo-setup skill was unavailable. I instead read AGENTS.md, quality/REVIEW.md, and package.json. No CONTRIBUTING.md exists.
codex.rate_limits privacy and bounds/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/types.ts:347-349applyResponsesEvent() only allowlists five top-level names, then copies each value unchanged. Nested objects, strings, arrays, and private fields remain unrestricted. Every event is appended without a metadata-specific cap:
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:588-603/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:1924-1932
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:18153-18154
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:18329-18343
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:18396-18402
/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:18511-18520/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/translate/openai-responses.ts:1279-1283/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/stream/openai-responses.ts:2551-2565/home/byk/Code/opencode-lore-recall-recovery/packages/gateway/src/pipeline.ts:10250-10251, ...