Dashboard › opencode-lore › Session 07lvpyMSoBEF
07lvpyMSoBEFH5KGwPerform independent read-only security/privacy/pentest review of exact provider-failure candidate in /home/byk/Code/opencode-lore-provider-error. No edits/format/VCS mutations/server/network/production DB/exhaustive reruns. Candidate change wswlsmrn commit 24880457763b (resolve full), base main@origin 2cbf40060c67df229731cf1b9e34d5bf22ec2145, expected plain diff SHA-256 c79cc2ec010e22f01961d8eec7bce3a60b8dfcb02c12b9ce4c0de9c5e173cb4d, exactly six known files. Read AGENTS.md, quality/REVIEW.md, scripts, every changed line plus parsing/routing/logging/telemetry/accounting/persistence/cancellation callers/tests. Attack provider diagnostic leakage through SSE, callbacks, persistence, logs, Sentry, usage/cost metrics, identities/model/time/extensions, failed output; forged response.in_progress before/after created; failure/diagnostic aliases before creation; contradictory statuses; duplicate/decreasing/invalid sequence numbers; recall-bearing failure arguments/results; terminal backpressure cancellation; rollback and state restoration; malformed output/reference/tool identities; usage overflow; Codex rate limits; request-wide limits. Provider terminal sequence must never control outbound sequence. Confirm source-order rejection occurs before usage/state mutation in principal and continuation and synthetic public envelope remains fixed/contiguous. Evaluate fail-first/mutation evidence and missing cross-products. Supplied evidence: 615/615 affected, 200/200 repeated sequence battery, static/bundle green. Run focused tests only if useful. Verify identity/status/conflicts/hash start/end. Report PASS/CONCERN/MUST-FIX with exact file:line evidence and residual risk, never empty, end exactly MERGE or DO-NOT-MERGE.
<skill_content name="jj-guide"> # Skill: jj-guide # jj Guide for AI Agents Jujutsu (jj) is a Git-compatible VCS with mutable commits, automatic snapshotting, no staging area, and first-class conflicts. This skill teaches you how to use it safely from a non-interactive agent environment. If `.jj/` exists in the repo root, this is a jj repo. **Use `jj` commands, not `git`.** In a colocated repo (`.jj/` *and* `.git/`), git tools can read the state, but mutations should go through `jj` so the operation log stays consistent. ## Critical Rules - **NEVER** use interactive flags (`-i`, `--interactive`). TUI prompts hang in agent environments. This applies to `jj split -i`, `jj squash -i`, `jj commit -i`, `jj resolve`, `jj diffedit`, etc. - **ALWAYS** pass `-m "msg"` when describing/committing. Without `-m`, an editor opens and hangs. - **VERIFY** mutations with `jj st` and `jj log` after `squash`, `abandon`, `rebase`, `restore`, `commit`. ...
<path>/home/byk/Code/opencode-lore-provider-error</path> <type>directory</type> <entries> .craft.yml .git .github/ .gitignore .jj/ .lore.md .oxfmtrc.json .oxlintrc.json AGENTS.md CHANGELOG.md codecov.yml LICENSE node_modules/ package.json packages/ patches/ pnpm-lock.yaml pnpm-workspace.yaml quality/ README.md scripts/ stryker.config.mjs supabase/ tsconfig.base.json tsconfig.json vitest.config.ts vitest.evals.config.ts vitest.mutation.config.ts (28 entries) </entries>
<path>/home/byk/Code/opencode-lore-provider-error/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-provider-error/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. ...
<path>/home/byk/Code/opencode-lore-provider-error/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: ...
No files found
○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 parents=a1020a45be1382893a183e2ff39506e78a08fb76 description=fix(responses): reject non-monotonic provider failures ○ plzxzousrzuvukvvtzlvvynqpokuptqu a1020a45be1382893a183e2ff39506e78a08fb76 parents=01a6e06b08ba1b54f42c5b4c757ec449eb8e8490 description=fix(responses): preserve trusted failure metadata ~ (elided revisions) ◆ pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 description=feat(cch): add seeds for Claude Code up to 2.1.272 (#1780) │ ~
The working copy has no changes. Working copy (@) : lpmvqrur e19ee1c7 (empty) (no description set) Parent commit (@-): wswlsmrn 24880457 fix/responses-provider-failures | fix(responses): reject non-monotonic provider failures Warning: These bookmarks have conflicts: fix/responses-private-references Hint: Use `jj bookmark list` to see details. Use `jj bookmark set <name> -r <rev>` to resolve. @ lpmvqrurxwlmrmwnyllmxlvkmplvwnlz e19ee1c704ed9f24432cb7d88c6e45af03d35d67 parents=24880457763b6f10831856d01c41bd72d62ddc28 description= ○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 parents=a1020a45be1382893a183e2ff39506e78a08fb76 description=fix(responses): reject non-monotonic provider failures │ ~
M packages/gateway/src/pipeline.ts M packages/gateway/src/stream/openai-responses.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts M packages/gateway/test/openai-responses-stream.test.ts M packages/gateway/test/pipeline-streaming.test.ts M packages/gateway/test/recall-codex-stream.test.ts c79cc2ec010e22f01961d8eec7bce3a60b8dfcb02c12b9ce4c0de9c5e173cb4d -
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0a9d3acc4001d2ZooRz0djIsSl
740 857: event === "response.failed" ||
741 858: status === "failed" ||
...
745 862: ? "response.incomplete"
746 863: : "response.completed";
747 864: if (resp) {
748 : state.terminalResponse = { ...resp };
749 : if (typeof resp.id === "string") state.id = resp.id;
750 : if (typeof resp.model === "string") state.model = resp.model;
865: state.terminalResponse = sanitizedFailure
866: ? {
867: ...(sanitizedFailure.parsed.response as Record<string, unknown>),
868: }
869: : { ...resp };
870: if (!sanitizedFailure) {
871: if (typeof resp.id === "string") state.id = resp.id;
872: if (typeof resp.model === "string") state.model = resp.model;
...
packages/gateway/src/pipeline.ts | 343 +++++- packages/gateway/src/stream/openai-responses.ts | 1024 +++++++++++-------- ...st/openai-responses-recall-aware-stream.test.ts | 1152 +++++++++++++++++++++- ...es/gateway/test/openai-responses-stream.test.ts | 882 +++++++++++++++- packages/gateway/test/pipeline-streaming.test.ts | 147 +- packages/gateway/test/recall-codex-stream.test.ts | 3 +- 6 files changed, 3056 insertions(+), 495 deletions(-)
Found 46 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts: Line 206: cloneResponsesAccState, Line 208: finalizeUnsuccessfulResponsesAcc, Line 217: restoreResponsesAccState, Line 219: sanitizeResponsesProviderFailureTerminal, Line 220: validateResponsesSourceSequence, Line 10161: const sourceSequenceNumber = validateResponsesSourceSequence( Line 10182: ? cloneResponsesAccState(state) Line 10195: ? ...
<path>/home/byk/Code/opencode-lore-provider-error/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-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1050:
1051: function validatePublicResponsesEvent(
1052: state: ResponsesAccState,
1053: event: string,
1054: parsed: Record<string, unknown>,
1055: maxSparseIndex: number,
1056: ): void {
1057: const outputIndex = parsed.output_index;
1058: const validOutputIndex =
1059: Number.isSafeInteger(outputIndex) &&
1060: (outputIndex as number) >= 0 &&
1061: (outputIndex as number) < maxSparseIndex;
1062: const item = validOutputIndex
1063: ? state.items.get(outputIndex as number)
1064: : undefined;
1065: const malformed = (): never => {
1066: throw new Error("malformed Responses stream event");
1067: };
1068:
1069: if (parsed.type !== undefined && parsed.type !== event) malformed();
1070: if (
1071: parsed.sequence_number !== undefined &&
1072: (!Number.isSafeInteger(parsed.sequence_number) ||
1073: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
2190: validateCodexResponsesEvent(state, event, parsed, maxSparseIndex);
2191: }
2192: const prevalidatedTerminalStatus =
2193: opts.validation &&
2194: !sanitizedFailure &&
2195: (event === "response.completed" ||
2196: event === "response.done" ||
2197: event === "response.incomplete")
2198: ? validatedTerminalStatus(
2199: event,
2200: parsed,
2201: opts.validation,
2202: opts.requireCompletedTerminal,
2203: )
2204: : undefined;
2205: if (opts.validation && event === "response.output_item.done") {
2206: const outputIndex = parsed.output_index as number;
2207: const doneItem =
2208: opts.validation === "codex"
2209: ? ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/usage-validation.ts</path>
<type>file</type>
<content>
1: /** Runtime validation for provider-reported token usage. */
2:
3: export function isRecord(value: unknown): value is Record<string, unknown> {
4: return !!value && typeof value === "object" && !Array.isArray(value);
5: }
6:
7: function invalid(message: string): never {
8: throw new Error(message);
9: }
10:
11: function tokenCount(
12: value: unknown,
13: message: string,
14: allowNull = false,
15: ): number | undefined {
16: if (value === undefined || (allowNull && value === null)) return undefined;
17: if (!Number.isSafeInteger(value) || (value as number) < 0) invalid(message);
18: return value as number;
19: }
20:
21: /** Add validated token counts without allowing a safe-integer overflow. ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10000: // Already closed/cancelled.
10001: }
10002: };
10003:
10004: const resetKeepalive = (): void => {
10005: if (keepaliveTimer) clearTimeout(keepaliveTimer);
10006: keepaliveTimer = setTimeout(function tick() {
10007: if (cancelled || signal.aborted) return;
10008: if ((controller.desiredSize ?? 1) > 0) {
10009: void safeEnqueue(keepaliveComment);
10010: }
10011: if (!signal.aborted) {
10012: keepaliveTimer = setTimeout(tick, KEEPALIVE_INACTIVITY_MS);
10013: }
10014: }, KEEPALIVE_INACTIVITY_MS);
10015: };
10016: const clearKeepalive = (): void => {
10017: if (keepaliveTimer) clearTimeout(keepaliveTimer);
10018: keepaliveTimer = null;
10019: };
10020: let ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10480: parseRecallArguments(parsed.arguments),
10481: );
10482: }
10483: if (isUnresolvedToolEvent && !isRecallEvent) {
10484: deferredEvents.push({
10485: chunk: hiddenChunk,
10486: candidateIndex: outputIndex,
10487: });
10488: }
10489: if (event === "response.output_item.done") {
10490: if (isRecallEvent) {
10491: collectCompletedRecall(
10492: state,
10493: outputIndex,
10494: parsedRecallInputs,
10495: pendingRecalls,
10496: );
10497: }
10498: }
10499: // Don't forward recall-item events to the client. ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11020: if (
11021: opts.validation === "codex" &&
11022: ce !== "response.output_item.added" &&
11023: ce !== "response.output_item.done" &&
11024: implicitItem?.type === "function_call" &&
11025: implicitItem.name === ""
11026: ) {
11027: contUnresolvedToolIndices.add(ci);
11028: }
11029: }
11030: let resolvingRecallTool = false;
11031: let resolvingVisibleTool = false;
11032: if (
11033: (ce === "response.output_item.added" ||
11034: ce === ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11700: !signal.aborted &&
11701: opts.retryPrincipal !== undefined &&
11702: principalTransportRetries < maxPrincipalTransportRetries;
11703: if (isPrincipalTransportFailure) {
11704: reportPrincipalTransportFailure({
11705: kind: error.kind,
11706: stage: principalTransportStage(),
11707: outcome: shouldRetryPrincipal
11708: ? "retry"
11709: : principalEventEmitted
11710: ? "continue"
11711: : principalTransportRetries > 0
11712: ? "retry_exhausted"
11713: : "failed",
11714: });
11715: }
11716: if (!shouldRetryPrincipal) throw error;
11717:
11718: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts:
Line 613: cached_tokens: Number.MAX_SAFE_INTEGER,
Line 626: output_tokens: Number.MAX_SAFE_INTEGER,
Line 628: reasoning_tokens: Number.MAX_SAFE_INTEGER,
Line 824: async (_case, events, diagnostic) => {
Line 830: ).rejects.toThrow(diagnostic);
Line 2571: "%s rejects MAX_SAFE_INTEGER sparse output and content indices",
Line 2575: ? { output_index: Number.MAX_SAFE_INTEGER }
Line 2576: : { output_index: Number.MAX_SAFE_INTEGER };
Line 2605: content_index: Number.MAX_SAFE_INTEGER,
Line 3711: async (_case, events, diagnostic) => {
Line 3717: ).rejects.toThrow(diagnostic);
Line 4123: "provider-diagnostics-secret",
Line 4135: sequence_number: 16,
Line 4149: sequence_number: 17,
Line 4164: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/gemini-stream.test.ts:
Line 123: let cancelled = false;
Line 140: cancelled = true;
Line 152: expect(cancelled).toBe(true);
Line 157: let cancelled = false;
Line 178: cancelled = true;
Line 187: expect(cancelled).toBe(true);
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/gemini-ingress.e2e.test.ts:
Line 212: // The @ai-sdk/google provider is tagged x-lore-provider: google by the
Line 213: // opencode/pi plugins. The google provider route is protocol "openai"
Line 220: { "x-lore-provider": "google" },
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/cli-bundle-smoke.test.ts:
Line 202: "`lore recall` runtime failures emit one JSON error envelope through the bundle with ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/test/pipeline-streaming.test.ts: Line 5233: // The third observation promotes only provisionally, and provider failure
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
4050: id: "item-one",
4051: call_id: "duplicate-call",
4052: name: "one",
4053: arguments: "{}",
4054: };
4055: const second = { ...first, id: "item-two", name: "two" };
4056: const upstream = buildSSEResponse([
4057: {
4058: event: "response.output_item.added",
4059: data: { output_index: 0, item: first },
4060: },
4061: {
4062: event: "response.output_item.added",
4063: data: { output_index: 1, item: second },
4064: },
4065: ]);
4066: const output = await streamResponsesPassthrough(
4067: upstream,
4068: () => {},
4069: undefined,
4070: "public",
4071: ).text();
4072: expect(output).toContain("item-one");
4073: expect(output).not.toContain("item-two");
4074: expect(output).toContain("response.failed");
4075: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts</path>
<type>file</type>
<content>
4890: });
4891:
4892: test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {
4893: const completions: Array<{
4894: response: GatewayResponse;
4895: successful: boolean;
4896: }> = [];
4897: const client = streamResponsesPassthrough(
4898: buildSSEResponse([
4899: {
4900: event: "response.created",
4901: data: {
4902: type: "response.created",
4903: response: {
4904: id: "resp_failure_backpressure",
4905: model: "gpt-5.6-sol",
4906: status: "in_progress",
4907: },
4908: },
4909: },
4910: {
4911: event: "response.failed",
4912: data: {
4913: type: "response.failed",
4914: response: {
4915: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
120: output_index: outputIndex,
121: item_id: itemId,
122: delta: argumentsText,
123: }) +
124: sseEvent("response.output_item.done", {
125: output_index: outputIndex,
126: item: {
127: type: "function_call",
128: id: itemId,
129: call_id: callId,
130: name: "read",
131: arguments: argumentsText,
132: status: "completed",
133: },
134: });
135:
136: const completed = (id: string, usage?: unknown) =>
137: sseEvent("response.completed", {
138: response: {
139: id,
140: model: "gpt-5.6-terra",
141: status: "completed",
142: ...(usage ? { usage } : {}),
143: },
144: });
145:
146: const incomplete = (id: string) =>
147: sseEvent("response.incomplete", {
148: response: {
149: id,
150: model: "gpt-5.6-terra",
151: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
1080: }),
1081: },
1082: ]);
1083: });
1084:
1085: test("restores principal state when terminal validation leaves a sparse tool unresolved", async () => {
1086: const privateArguments = '{"path":"private-unresolved-path"}';
1087: const completions: Array<{
1088: response: GatewayResponse;
1089: successful: boolean;
1090: }> = [];
1091: let recalls = 0;
1092: const client = streamResponsesRecallAware(
1093: streamFrom([
1094: created("resp_atomic_sparse", "gpt-5.6-terra"),
1095: textItem(0, "safe before unresolved tool", "msg_atomic_sparse"),
1096: sseEvent("response.output_item.added", {
1097: output_index: 7,
1098: item: {
1099: type: "function_call",
1100: id: "fc_atomic_sparse",
1101: call_id: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
8750: expect(errors).toEqual([
8751: "recall follow-up stream failed category=follow_up_setup",
8752: "openai-responses recall-aware stream failed category=follow_up_setup",
8753: ]);
8754: expect(errors.join("\n")).not.toContain("follow-up unavailable");
8755: });
8756:
8757: test("classifies recall execution failure without exposing callback details", async () => {
8758: const failures: RecallContinuationFailureCategory[] = [];
8759: setRecallContinuationFailureHook((category) => failures.push(category));
8760: const client = streamResponsesRecallAware(
8761: streamFrom([
8762: created("resp_recall_execution_failure", "gpt-5.6-terra"),
8763: recallCall(0, { query: "private query" }),
8764: completed("resp_recall_execution_failure"),
8765: ]),
8766: ...
Found 5 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts: Line 7886: const responseLifecycles = new WeakMap< Line 7893: let lifecycle = responseLifecycles.get(acc); Line 7896: responseLifecycles.set(acc, lifecycle); Line 9149: const validateResponseLifecycle = ( Line 10222: responseLifecycles.set(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7840: onRecall: (input: {
7841: query: string;
7842: scope?: string;
7843: id?: string;
7844: ids?: string[];
7845: detailOffset?: number;
7846: detailLimit?: number;
7847: outputIndex: number;
7848: toolUseId: string;
7849: /** Position in the normalized GatewayResponse content array. */
7850: contentPosition: number;
7851: /** The accumulated response INCLUDING the recall tool_use, so the caller
7852: * can build the follow-up request from the same accumulation the
7853: * streamer uses. */
7854: acc: GatewayResponse;
7855: signal: AbortSignal;
7856: }) => Promise<{
7857: anchorText: string;
7858: resultText: string;
7859: /** Private source coverage; never emitted to the client. */
7860: coverage?: readonly ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9080: if (!finalPart || finalPart.type !== contentState.kind) {
9081: throw new Error(
9082: `Responses output_item.done changed reasoning content type for index ${outputIndex}:${contentIndex}`,
9083: );
9084: }
9085: if (
9086: (contentState.deltaSeen && !contentState.valueDone) ||
9087: (contentState.partAdded && !contentState.partDone)
9088: ) {
9089: throw new Error(
9090: `Responses reasoning content ended before completion for index ${outputIndex}:${contentIndex}`,
9091: );
9092: }
9093: const finalValue = partValue(
9094: contentState.kind,
9095: finalPart,
9096: "reasoning output item content",
9097: ...
No files found
Found 32 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/codex-usage-provisional.test.ts:
Line 22: type: "codex.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-provider-error/packages/gateway/test/codex-usage-metadata.test.ts:
Line 11: type: "codex.rate_limits",
Line 58: .filter((frame) => frame.startsWith("event: codex.rate_limits\n"))
Line 64: const events = [limits, { ...limits, metered_limit_name: "codex_spark" }];
Line 72: expect(body.indexOf("codex.rate_limits")).toBeLessThan(
Line 130: `${await upstream([]).text()}event: codex.rate_limits\ndata: ${JSON.stringify(limits)}\n\n`,
Line 160: metered_limit_name: fc.string({ maxLength: 30 }),
Line 168: ({ metered_limit_name, ...primary }) => ...
Found 5 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
Line 7799: export function streamResponsesRecallAware(
Line 15453: return streamResponsesPassthrough(
Line 18871: streamResponsesRecallAware(upstreamResponse, {
Line 19079: streamResponsesPassthrough(
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts:
Line 2649: export function streamResponsesPassthrough(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18600: return nonStreamHttpResponse(
18601: shouldInjectWarning
18602: ? injectContextWarning(markerResp, warningText)
18603: : markerResp,
18604: req.protocol,
18605: req.stream,
18606: { "x-lore-recall-invoked": "true" },
18607: longContext,
18608: );
18609: }
18610:
18611: if (!jsonFollowUp.ok) {
18612: log.error(
18613: `recall follow-up upstream error: ${jsonFollowUp.status ?? "?"}`,
18614: new Error(`recall follow-up upstream ${jsonFollowUp.status ?? "?"}`),
18615: );
18616: captureToolPairing400({
18617: status: jsonFollowUp.status ?? 0,
18618: errorBody: jsonFollowUp.detail,
18619: messages: currentModifiedReq.messages,
18620: // `result` here is the recall string (shadowed); ...
Found 5 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts: Line 13458: function accountUnsuccessfulResponse( Line 15879: accountUnsuccessfulResponse( Line 16142: accountUnsuccessfulResponse( Line 18746: accountUnsuccessfulResponse( Line 18812: accountUnsuccessfulResponse(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path> <type>file</type> <content> 13380: sessionState.warmup.warmupCount = 0; 13381: } 13382: } 13383: 13384: // --- Shadow context tracking for counterfactual compaction estimation --- 13385: // Track how large the context *would* be without Lore's distillation 13386: // compressing it. When the shadow counter crosses the auto-compact 13387: // threshold, record a counterfactual compaction event. 13388: updateShadowContext( 13389: sessionID, 13390: actualInput, 13391: usage.outputTokens ?? 0, 13392: getWorkerModel(sessionState.lastUpstream)?.modelID ?? "unknown", 13393: req.model, 13394: sessionState.resolvedConversationTTL, 13395: requestEnablesLongContext(req), 13396: ); 13397: 13398: // Mark session dirty for periodic flush (gradient + warming + costs). ...
Modified regular file packages/gateway/src/pipeline.ts:
...
203 203: streamResponsesPassthrough,
204 204: translateAnthropicStreamToResponses,
205 205: applyResponsesEvent,
206: cloneResponsesAccState,
206 207: finalizeResponsesAcc,
208: finalizeUnsuccessfulResponsesAcc,
207 209: formatResponsesEvent,
208 210: makeResponsesAccState,
209 211: mapStatusFromStopReason,
...
212 214: isValidResponsesReasoningEncryptedContent,
213 215: responsesDoneItemMatchesAdded,
214 216: responsesTerminalItemMatches,
217: restoreResponsesAccState,
215 218: normalizeCodexResponsesEvent,
219: sanitizeResponsesProviderFailureTerminal,
220: validateResponsesSourceSequence,
216 221: ResponsesTerminalError,
217 222: type ResponsesAccState,
218 223: } from "./stream/openai-responses";
... ...
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0a9e5ba23001R2VhyyJCHCmPQO
586: }
587:
588: export function restoreResponsesAccState(
589: state: ResponsesAccState,
590: snapshot: ResponsesAccState,
591: ): void {
592: for (const key of Object.keys(state) as Array<keyof ResponsesAccState>) {
593: if (!Object.hasOwn(snapshot, key)) delete state[key];
594: }
595: Object.assign(state, snapshot);
596: }
597:
598: const PUBLIC_GATEWAY_ERROR = "Gateway request failed";
599:
600: /**
601: * Build the only provider-failure payload that may cross the gateway boundary.
602: * Provider diagnostics and failed output stay private; stable protocol fields
603: * remain available so clients can close the existing response lifecycle. ...
○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 │ fix(responses): reject non-monotonic provider failures │ ○ plzxzousrzuvukvvtzlvvynqpokuptqu a1020a45be1382893a183e2ff39506e78a08fb76 │ fix(responses): preserve trusted failure metadata │ ○ skwrwnvkvulpwztqsvprtnrozswvtptx 01a6e06b08ba1b54f42c5b4c757ec449eb8e8490 │ fix(responses): make provider failure settlement atomic │ ○ xqmskzvmnqkrnvmyrznrxkxsxtwyurvu b1bc7cd46c4eb09f23a7a5c6db257c380401ca02 │ fix(responses): complete provider failure sanitization │ ○ qnlnmzlxyynvkvssnkusztrzyxzylkzo 29dee093d7ceed38b0ed823c9d5b26f8c1ba3d7c │ fix(responses): bind sanitized failures to trusted state │ ○ prpmozzzqvktqmyxkmyprklpmqxwktkv d385b39653b0085833e281b6347b15071cee6801 │ fix(responses): sanitize provider failures │ ◆ pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 │ feat(cch): add seeds for Claude Code up to 2.1.272 (#1780) ~ ## Summary Automated cch seed extraction ...
Commit ID: d385b39653b0085833e281b6347b15071cee6801
Change ID: prpmozzzqvktqmyxkmyprklpmqxwktkv
Author : Burak Yigit Kaya <ben@byk.im> (2026-09-12 22:23:01)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 10:18:43)
fix(responses): sanitize provider failures
packages/gateway/src/pipeline.ts | 19 ++-
packages/gateway/src/stream/openai-responses.ts | 100 ++++++++++++++--
...est/openai-responses-recall-aware-stream.test.ts | 130 +++++++++++++++++-----
...ges/gateway/test/openai-responses-stream.test.ts | 106 +++++++++++++----
packages/gateway/test/pipeline-streaming.test.ts | 18 ++-
packages/gateway/test/recall-codex-stream.test.ts | 3 +-
6 files changed, 313 insertions(+), 63 deletions(-)
Commit ID: 29dee093d7ceed38b0ed823c9d5b26f8c1ba3d7c
Change ID: qnlnmzlxyynvkvssnkusztrzyxzylkzo
Author : Burak Yigit Kaya <ben@byk.im> (2026-09-14 08:34:22)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 10:18:43)
fix(responses): bind sanitized ...
Found 13 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
Line 7884: const referenceIdentities = new Set<string>();
Line 8459: referenceIdentities.has(identity) ||
Line 8582: referenceIdentities.has(finalCallId) ||
Line 9483: referenceIdentities.has(item.id)
Line 9488: referenceIdentities.add(item.id);
Line 9547: referenceIdentities.has(
Line 9561: referenceIdentities.has(syntheticId) ||
Line 10785: referenceIdentities: new Set(referenceIdentities),
Line 11301: referenceIdentities.clear();
Line 11302: for (const identity of continuationRetryBaseline.referenceIdentities) {
Line 11303: referenceIdentities.add(identity);
Line 11548: referenceIdentities: new Set(referenceIdentities),
Line 11761: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9400: opts.validation === "codex" &&
9401: !lifecyclesFor(acc).get(outputIndex)?.outputDone
9402: );
9403: },
9404: );
9405: if (matchIndex < 0) {
9406: throw new Error("Responses terminal output changed streamed item");
9407: }
9408: if (opts.validation === "public" && matchIndex !== expectedIndex) {
9409: throw new Error("Responses terminal output changed streamed item");
9410: }
9411: const [outputIndex, streamed] = expected[matchIndex];
9412: const lifecycle = lifecyclesFor(acc).get(outputIndex);
9413: onMatched?.(outputIndex, actual);
9414: if (
9415: !isReference &&
9416: opts.validation === "codex" &&
9417: lifecycle &&
9418: !lifecycle.outputDone
9419: ) {
9420: outputIndexForEvent(
9421: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9580: // --- Keepalive (same as streamResponsesPassthrough) ---
9581: const KEEPALIVE_INACTIVITY_MS = 30_000;
9582: const keepaliveComment = encoder.encode(`: keepalive\n\n`);
9583: let keepaliveTimer: ReturnType<typeof setTimeout> | null = null;
9584: let completed = false;
9585: let completionAttempted = false;
9586: let nextSequenceNumber = 0;
9587:
9588: const sequenceChunk = (chunk: Uint8Array): Uint8Array => {
9589: const text = new TextDecoder().decode(chunk);
9590: if (!text.startsWith("event: ")) return chunk;
9591: let output = "";
9592: for (const frame of text.split("\n\n")) {
9593: if (!frame) continue;
9594: const lines = frame.split("\n");
9595: const eventLine = lines.find((line) => line.startsWith("event: "));
9596: const dataLines = lines.filter((line) => line.startsWith("data: "));
9597: ...
Found 5 matches
/home/byk/Code/opencode-lore-provider-error/packages/core/src/log.ts:
Line 13: * An optional {@link LogSink} can be registered via {@link registerSink}.
Line 66: export function registerSink(s: LogSink): void {
Line 218: function sanitizedError(error: Error): Error {
Line 497: export function error(...args: unknown[]): void {
Line 504: if (err) sink?.captureException(sanitizedError(err));
<path>/home/byk/Code/opencode-lore-provider-error/packages/core/src/log.ts</path>
<type>file</type>
<content>
190: .replace(
191: new RegExp(
192: String.raw`(^|[\r\n])([\t ]*(?:${LOG_SENSITIVE_KEY})[\t ]*:[\t ]*)[^\r\n]*`,
193: "gi",
194: ),
195: `$1$2${LOG_FILTERED}`,
196: )
197: .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, LOG_FILTERED)
198: .replace(/\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, LOG_FILTERED)
199: .replace(/\bAKIA[A-Z0-9]{16}\b/g, LOG_FILTERED)
200: .replace(
201: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g,
202: LOG_FILTERED,
203: );
204: }
205:
206: function safeArgs(args: unknown[]): string[] {
207: return args.map((arg) =>
208: redactSensitiveLogText(
209: typeof arg === "string"
210: ? arg
211: : arg instanceof Error
212: ? (arg.stack ?? arg.message)
213: : String(arg),
214: ),
215: );
216: }
217:
218: function sanitizedError(error: ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
5600: part: { type: "summary_text", text: "summary" },
5601: }),
5602: sseEvent("response.reasoning_summary_text.done", {
5603: output_index: 0,
5604: item_id: "rs_late_part",
5605: summary_index: 0,
5606: text: "summary",
5607: }),
5608: sseEvent("response.reasoning_summary_part.done", {
5609: output_index: 0,
5610: item_id: "rs_late_part",
5611: summary_index: 0,
5612: part: { type: "summary_text", text: "summary" },
5613: }),
5614: sseEvent("response.output_item.done", {
5615: output_index: 0,
5616: item: {
5617: type: "reasoning",
5618: id: "rs_late_part",
5619: summary: [{ type: "summary_text", text: "summary" }],
5620: },
5621: ...
Modified regular file packages/gateway/test/pipeline-streaming.test.ts:
...
86 86: import { translateAnthropicStreamToResponses } from "../src/stream/openai-responses";
87 87: import { translateAnthropicStreamToGemini } from "../src/stream/gemini";
88: import { setRecallContinuationFailureHook } from "../src/recall-continuation-failure";
88 89: import {
89 90: makeConversationFixtures,
...
727 728: afterEach(() => vi.mocked(getDegradationWarning).mockReset());
728 729: afterEach(() => vi.mocked(Sentry.startInactiveSpan).mockReset());
730: afterEach(() => setRecallContinuationFailureHook(undefined));
729 731:
730 732: it("does not deadlock when an OpenAI translator drops Anthropic lifecycle frames", async () => {
... ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0a9e5ba23001R2VhyyJCHCmPQO</path>
<type>file</type>
<content>
1: Modified regular file packages/gateway/src/stream/openai-responses.ts:
2: ...
3: 51: created: boolean;
4: 52: createdAt?: number;
5: 53: lastAcceptedSequenceNumber?: number;
6: ...
7: 563: created: false,
8: ...
9: 582: export function cloneResponsesAccState(
10: 583: state: ResponsesAccState,
11: 584: ): ResponsesAccState {
12: 585: return structuredClone(state);
13: 586: }
14: 587:
15: 588: export function restoreResponsesAccState(
16: 589: state: ResponsesAccState,
17: 590: snapshot: ResponsesAccState,
18: 591: ): void {
19: 592: for (const key of Object.keys(state) as Array<keyof ResponsesAccState>) {
20: 593: if (!Object.hasOwn(snapshot, key)) delete state[key];
21: 594: }
22: 595: Object.assign(state, ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0a9e5ba23001R2VhyyJCHCmPQO</path> <type>file</type> <content> 1048: 2628 : created_at: Math.floor(Date.now() / 1000), 1049: 2876: created_at: state.createdAt ?? 0, 1050: ... 1051: 2635 : message: "Upstream response stream failed", 1052: 2883: message: PUBLIC_GATEWAY_ERROR, 1053: ... 1054: 2642 : finish(false); 1055: 2890: finish(false, finalizeUnsuccessfulResponsesAcc(state)); 1056: ... (End of file - total 1056 lines) </content>
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0a9ea4e4f001IAajUsmOXoMZ5j
291 : }),
292 : ]),
293 : {
294 : onComplete: () => {},
295 : onRecall: async () => ({ anchorText: "", resultText: "" }),
296 : runFollowUp: async () => {
297 : throw new Error("should not be called");
298 : },
299 : },
300 : );
301 :
302 : const out = await drain(client);
303 : expect(out.match(/^event: response\.failed$/gm)).toHaveLength(1);
304 : expect(out).toContain("provider failed");
305 : expect(out).not.toContain("ended without a terminal event");
294: test.each([
295: ["response.failed", "failed"],
296: ["response.failed", "cancelled"],
297: ["response.done", "failed"],
298: ["response.done", "cancelled"],
299: ] as const)(
300: ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0a9ea4e4f001IAajUsmOXoMZ5j</path>
<type>file</type>
<content>
1: Modified regular file packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
2: ...
3: 176: const nonMonotonicProviderFailures = (
4: 177: [
5: 178: ["response.failed", "response.failed", "failed"],
6: 179: ["failed response.done", "response.done", "failed"],
7: 180: ["cancelled response.done", "response.done", "cancelled"],
8: 181: ["error", "error", undefined],
9: 182: ["response.error", "response.error", undefined],
10: 183: ] as const
11: 184: ).flatMap(([alias, event, status]) =>
12: 185: ([10, 9] as const).map(
13: 186: (sequence) => [alias, sequence, event, status] as const,
14: 187: ),
15: 188: );
16: 189:
17: ...
18: 280 : test("forwards a principal response.failed exactly once when no recall occurs", async () => ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0a9ea4e4f001IAajUsmOXoMZ5j</path>
<type>file</type>
<content>
1130: 8990: rollback: () => rollbacks++,
1131: 8991: }),
1132: 8992: runFollowUp: async () => ({
1133: 8993: reader: failedFollowUp.body!.getReader(),
1134: 8994: }),
1135: 8995: },
1136: 8996: );
1137: 8997: if (!client.body) throw new Error("test response has no body");
1138: 8998:
1139: 8999: await failureReported;
1140: 9000: await client.body.cancel();
1141: 9001: await new Promise((resolve) => setImmediate(resolve));
1142: 9002:
1143: 9003: expect(failures).toEqual(["follow_up_failed"]);
1144: 9004: expect([commits, rollbacks, rollbacksAtComplete]).toEqual([0, 1, [1]]);
1145: 9005: expect(completions).toEqual([
1146: 9006: {
1147: 9007: successful: false,
1148: 9008: ...
Modified regular file packages/gateway/test/openai-responses-stream.test.ts:
...
16: makeResponsesAccState,
...
4110 : test("validates and forwards a provider failure terminal", async () => {
4111 : const outcomes: boolean[] = [];
4112 : const output = await streamResponsesPassthrough(
4113 : buildSSEResponse([
4114 : {
4115 : event: "response.failed",
4116 : data: {
4117 : type: "response.failed",
4118 : response: {
4119 : status: "failed",
4120 : error: { type: "server_error", message: "provider failed" },
4121 : },
4122 : },
4123 : },
4124 : ]),
4125 : (_response, successful) => outcomes.push(successful),
4126 : undefined,
4127 : "public",
4128 : ).text();
4129 : expect(output.match(/event: ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts: Line 12665: export function accumulateResponsesNonStreamJSON(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
12590: if (message) {
12591: const textContent = message.content as string | undefined;
12592: if (textContent) {
12593: content.push({ type: "text", text: textContent });
12594: }
12595: const toolCalls = message.tool_calls as
12596: | Array<Record<string, unknown>>
12597: | undefined;
12598: if (toolCalls) {
12599: const toolIdentities = new Set<string>();
12600: for (const tc of toolCalls) {
12601: const fn = tc.function as Record<string, unknown> | undefined;
12602: let input: unknown = {};
12603: if (typeof fn?.arguments === "string") {
12604: try {
12605: input = JSON.parse(fn.arguments);
12606: } catch {
12607: input = fn.arguments;
12608: }
12609: }
12610: const id = asString(tc.id);
12611: if (!id || ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts: Line 13115: function accountConversationUsage(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
13070: writeTokens: usage.cacheCreationInputTokens ?? 0,
13071: });
13072: sessionState.lastTurnWasIdle = false; // consumed
13073:
13074: // Track cold-cache turns for auto-TTL upgrade (rolling 20-turn window)
13075: const cacheRead = usage.cacheReadInputTokens ?? 0;
13076: const cacheCreation = usage.cacheCreationInputTokens ?? 0;
13077: const isColdTurn = cacheRead === 0 && cacheCreation > 0;
13078: if (!sessionState.coldCacheWindow) sessionState.coldCacheWindow = [];
13079: sessionState.coldCacheWindow.push(isColdTurn);
13080: if (sessionState.coldCacheWindow.length > 20) {
13081: sessionState.coldCacheWindow.shift();
13082: }
13083: }
13084:
13085: // --- Finalize gen_ai.chat span (after cache analytics enrichment) ---
13086: // Ended here (before recordCacheUsage, matching the original inlined ...
Found 5 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
Line 12047: function sanitizedUpstreamErrorResponse(response: Response): Response {
Line 12121: async function preserveUpstreamErrorResponse(
Line 15631: return preserveUpstreamErrorResponse(upstreamResponse, abortScope.signal);
Line 15816: return sanitizedUpstreamErrorResponse(upstreamResponse);
Line 18318: return finishForeground(sanitizedUpstreamErrorResponse(upstreamResponse));
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
15530: const reader = response.body.getReader();
15531: const validator = new AnthropicSSEValidator();
15532: try {
15533: for await (const { event, data } of parseSSEStream(reader, {
15534: signal: abort.signal,
15535: requireEventTerminator: true,
15536: fatalUtf8: true,
15537: maxFrames: DEFAULT_MAX_SSE_FRAMES,
15538: maxTotalBytes: MAX_FOREGROUND_RESPONSE_BYTES,
15539: })) {
15540: validator.process(event, data);
15541: await forward(event, data);
15542: if (validator.isDone()) break;
15543: }
15544: validator.assertDone();
15545: } finally {
15546: cancelAndReleaseReader(reader);
15547: }
15548: } ...
Found 41 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses.test.ts:
Line 7: * - Response conversion (non-streaming and streaming)
Line 1365: test("non-streaming: builds correct Responses API JSON", async () => {
Line 1391: test("non-streaming: tool_use maps to function_call output", async () => {
Line 1422: test("non-streaming: preserves validated native output items", async () => {
Line 1440: test("non-streaming: max_tokens maps to incomplete status", async () => {
Line 1454: test("non-streaming: id gets resp_ prefix if missing", async () => {
Line 1538: test("non-streaming: emits input_tokens_details.cached_tokens when present", async () => {
Line 1557: test("non-streaming: omits input_tokens_details when no cached tokens", async () => {
Line 1585: test("non-streaming: emits prompt_tokens_details.cached_tokens when present", async () => {
Line 1607: test("non-streaming: omits ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/sentry.ts: Line 150: export function setGenAiUsageAttributes(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/sentry.ts</path>
<type>file</type>
<content>
130: }
131:
132: // ---------------------------------------------------------------------------
133: // gen_ai.chat span helpers
134: // ---------------------------------------------------------------------------
135:
136: /** Usage fields from an Anthropic API response. */
137: export type AnthropicUsage = {
138: input_tokens?: number;
139: output_tokens?: number;
140: cache_read_input_tokens?: number;
141: cache_creation_input_tokens?: number;
142: };
143:
144: /**
145: * Set gen_ai.* usage attributes on a span from Anthropic API usage data.
146: *
147: * Shared by conversation turn spans, worker direct spans, and batch result
148: * spans. Does NOT set input/output message content — privacy boundary.
149: */
150: export function setGenAiUsageAttributes(
151: span: Sentry.Span,
152: usage: AnthropicUsage,
153: responseModel?: string,
154: ): void ...
Found 33 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/budget-throttle.test.ts:
Line 9: recordConversationCost,
Line 214: // updateCostRate (tested via recordConversationCost + getCostRate)
Line 226: recordConversationCost(
Line 236: recordConversationCost(
Line 260: recordConversationCost("session-1", "claude-sonnet-4-20250514", {
Line 281: test("recordConversationCost writes to the ledger for today", () => {
Line 283: recordConversationCost("ledger-session", "claude-sonnet-4-20250514", {
Line 316: recordConversationCost("ledger-session-2", "claude-sonnet-4-20250514", {
Line 329: recordConversationCost("ledger-session-3", "claude-sonnet-4-20250514", {
Line 365: recordConversationCost("session-1", "claude-sonnet-4-20250514", {
Line 383: recordConversationCost("new-session", "claude-sonnet-4-20250514", ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/cost-tracker.ts</path>
<type>file</type>
<content>
640: cacheWriteRate *
641: batchMultiplier;
642: const outputCost =
643: ((usage.output_tokens ?? 0) / 1_000_000) * pricing.output * batchMultiplier;
644:
645: return {
646: total: inputCost + cacheReadCost + cacheWriteCost + outputCost,
647: inputCost,
648: cacheReadCost,
649: cacheWriteCost,
650: outputCost,
651: };
652: }
653:
654: // ---------------------------------------------------------------------------
655: // Accumulation — called from pipeline, LLM adapter, batch queue, warmup
656: // ---------------------------------------------------------------------------
657:
658: /**
659: * Record a conversation turn's cost (called from postResponse).
660: *
661: * @param ttl - Cache TTL for this session. Anthropic charges 2× cache_write
662: * for 1h TTL; without this the cost uses the base (5m) rate. ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/sentry.ts: Line 408: export function emitCostMetric(
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/sentry.ts</path>
<type>file</type>
<content>
390: if (!Sentry.isInitialized()) return;
391: Sentry.metrics.count("lore.cache_warmup.hit", 1, {
392: attributes: { model, ttl },
393: });
394: }
395:
396: /**
397: * Emit a metric when the circuit breaker trips.
398: */
399: export function emitWarmupCircuitBreakerMetric(): void {
400: if (!Sentry.isInitialized()) return;
401: Sentry.metrics.count("lore.cache_warmup.circuit_breaker_tripped", 1, {});
402: }
403:
404: // ---------------------------------------------------------------------------
405: // LLM cost estimation
406: // ---------------------------------------------------------------------------
407:
408: export function emitCostMetric(
409: model: string,
410: usage: AnthropicUsage,
411: callType: "conversation" | "direct" | "batch",
412: ttl?: "5m" | "1h",
413: ): void {
414: if (!Sentry.isInitialized()) return;
415:
416: // ...
<path>/home/byk/Code/opencode-lore-provider-error/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: ...
node:internal/process/promises:394
triggerUncaughtException(err, true /* fromPromise */);
^
Error: Transform failed with 1 error:
/eval.ts:1:994: ERROR: Top-level await is currently not supported with the "cjs" output format
at failureErrorWithLog (/home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/esbuild@0.28.1/node_modules/esbuild/lib/main.js:1748:15)
at /home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/esbuild@0.28.1/node_modules/esbuild/lib/main.js:1017:50
at responseCallbacks.<computed> (/home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/esbuild@0.28.1/node_modules/esbuild/lib/main.js:884:9)
at handleIncomingPacket (/home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/esbuild@0.28.1/node_modules/esbuild/lib/main.js:939:12)
at Socket.readFromStdout (/home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/esbuild@0.28.1/node_modules/esbuild/lib/main.js:862:7)
at Socket.emit (node:events:509:28)
...
/home/byk/Code/opencode-lore-provider-error/node_modules/.pnpm/tsx@4.22.4/node_modules/tsx/dist/register-BOkp8V6j.cjs:9
`)},"createLog"),G=ut(W.bgLightYellow(W.black(" CJS "))),Tn=ut(W.bgBlue(" ESM ")),R=new Map,Sn=u(async e=>{if(R.has(e))return R.get(e);if(!await D.promises.access(e).then(()=>!0,()=>!1)){R.set(e,void 0);return}const r=await D.promises.readFile(e,"utf8");try{const n=JSON.parse(r);return R.set(e,n),n}catch{throw new Error(`Error parsing: ${e}`)}},"readPackageJson"),On=u(e=>{if(R.has(e))return R.get(e);if(!D.existsSync(e)){R.set(e,void 0);return}const t=D.readFileSync(e,"utf8");try{const r=JSON.parse(t);return R.set(e,r),r}catch{throw new Error(`Error parsing: ${e}`)}},"readPackageJsonSync"),Pn=u(async e=>{let t=new URL("package.json",e);for(;!t.pathname.endsWith("/node_modules/package.json");){const r=Q.fileURLToPath(t),n=await Sn(r);if(n)return n;const s=t;if(t=new URL("../package.json",t),t.pathname===s.pathname)break}},"findPackageJson"),ft=u(e=>{let t=new ...
No files found
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/package.json</path>
<type>file</type>
<content>
1: {
2: "name": "@loreai/gateway",
3: "version": "0.40.0",
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: "types": "./dist/index.d.cts",
12: "bun": "./dist/index.bun.js",
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": "tsx script/build-binary-sea.ts",
27: "start": "tsx ...
Found 5 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/server.ts: Line 494: const result = await handleRequest(gatewayReq, config); Line 617: return withoutCors(await handleRequest(gatewayReq, config)); Line 671: return withoutCors(await handleRequest(gatewayReq, config)); Line 704: return withoutCors(await handleRequest(gatewayReq, config)); Line 739: return withoutCors(await handleRequest(gatewayReq, config));
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
450:
451: /**
452: * Reject a WebSocket upgrade cleanly so the client falls back to HTTP on the
453: * first attempt. `426 Upgrade Required` is the closest semantic fit ("this
454: * resource is served over a different protocol"); `Connection: close` tells the
455: * client not to keep retrying on the same socket.
456: */
457: function rejectWebSocketUpgrade(pathname: string): Response {
458: const resp = errorResponseWithoutCors(
459: 426,
460: "websocket_not_supported",
461: `WebSocket transport is not supported for ${pathname}; use HTTP.`,
462: );
463: resp.headers.set("Connection", "close");
464: return resp;
465: }
466:
467: // ---------------------------------------------------------------------------
468: // Route handlers
469: // ---------------------------------------------------------------------------
470:
471: async function ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/server.ts</path>
<type>file</type>
<content>
580: const authorization = req.headers.get("authorization") ?? "";
581: const expected = `Bearer ${token}`;
582: const actualBytes = Buffer.from(authorization);
583: const expectedBytes = Buffer.from(expected);
584: return (
585: actualBytes.length === expectedBytes.length &&
586: timingSafeEqual(actualBytes, expectedBytes)
587: );
588: }
589:
590: async function handleOpenAIChatCompletions(
591: req: Request,
592: config: GatewayConfig,
593: ): Promise<Response> {
594: let body: unknown;
595: try {
596: // Transparently decode any Content-Encoding (Codex sends zstd by default)
597: // before JSON-parsing — raw compressed bytes would otherwise fail to parse.
598: body = JSON.parse(await decodeRequestBody(req));
599: } catch {
600: return errorResponse(400, "invalid_request_error", "Invalid JSON body");
601: }
602:
603: ...
<path>/home/byk/Code/opencode-lore-provider-error/vitest.config.ts</path>
<type>file</type>
<content>
1: import { defineConfig } from "vitest/config";
2: import path from "node:path";
3:
4: export default defineConfig({
5: // Alias @loreai/core and @loreai/gateway for test imports.
6: // MUST be at the top level of the vite config — putting this under
7: // `test.resolve.alias` does NOT work (vite's resolver is a top-level
8: // option, not a test.* option). The previous placement silently
9: // resolved to the stale dist build, masking real test failures.
10: resolve: {
11: alias: {
12: "@loreai/core": path.resolve(__dirname, "packages/core/src"),
13: "@loreai/gateway": path.resolve(__dirname, "packages/gateway/src"),
14: },
15: },
16: test: {
17: // Run all packages' tests
18: include: [
19: "packages/core/test/**/*.test.ts",
20: // Fast, pure unit tests for the eval suite's own logic (scorers,
21: // analysis). ...
<path>/home/byk/Code/opencode-lore-provider-error/tsconfig.json</path>
<type>file</type>
<content>
1: {
2: "extends": "./tsconfig.base.json",
3: "compilerOptions": {
4: "noEmit": true
5: },
6: "include": [
7: "packages/*/src",
8: "packages/*/test",
9: "packages/*/script",
10: "packages/*/scripts",
11: "packages/*/eval"
12: ],
13: "exclude": ["node_modules", "**/dist"]
14: }
(End of file - total 14 lines)
</content>
Found 4 matches
/home/byk/Code/opencode-lore-provider-error/packages/core/test/setup.ts:
Line 1: import { mkdtempSync, rmSync } from "node:fs";
Line 3: import { tmpdir } from "node:os";
Line 11: const tmp = mkdtempSync(join(tmpdir(), "lore-test-"));
Line 12: process.env.LORE_DB_PATH = join(tmp, "test.db");
<path>/home/byk/Code/opencode-lore-provider-error/packages/core/test/setup.ts</path>
<type>file</type>
<content>
1: import { mkdtempSync, rmSync } from "node:fs";
2: import { join } from "node:path";
3: import { tmpdir } from "node:os";
4: import { afterAll, afterEach } from "vitest";
5: import { close, invalidateProjectIdCache } from "../src/db";
6: import { silenceStderr } from "../src/log";
7:
8: // Create an isolated temporary database for the entire test run.
9: // This prevents test fixtures from leaking into the live lore DB
10: // at ~/.local/share/lore/lore.db.
11: const tmp = mkdtempSync(join(tmpdir(), "lore-test-"));
12: process.env.LORE_DB_PATH = join(tmp, "test.db");
13:
14: // ---------------------------------------------------------------------------
15: // Block live network to models.dev during tests.
16: //
17: // `fetchModelData()` (gateway/src/worker-model.ts) hits
18: // https://models.dev/api.json to pull pricing/limits, and the gateway
19: // pre-warms it on ...
Found 6 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts: Line 5643: const maxIndex = Number.MAX_SAFE_INTEGER; Line 5679: input_tokens: Number.MAX_SAFE_INTEGER, Line 5705: input_tokens: Number.MAX_SAFE_INTEGER, Line 5735: cached_tokens: Number.MAX_SAFE_INTEGER, Line 5764: cached_tokens: Number.MAX_SAFE_INTEGER, Line 5799: input_tokens: Number.MAX_SAFE_INTEGER,
Found 20 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-stream.test.ts: Line 4135: sequence_number: 16, Line 4149: sequence_number: 17, Line 4193: sequence_number: 17, Line 4233: sequence_number: 10, Line 4247: sequence_number: terminalSequence, Line 4288: sequence_number: 4, Line 4301: sequence_number: 99, Line 4341: sequence_number: 1, Line 4354: sequence_number: 2, Line 4574: sequence_number: 10, Line 4587: sequence_number: 11, Line 4600: sequence_number: 12, Line 4610: sequence_number: 13, Line 4625: sequence_number: 99, Line 4662: sequence_number: 14, Line 4710: sequence_number: 1, Line 4723: sequence_number: 2, Line 4736: sequence_number: 3, Line 4746: ...
Found 100 matches (more matches available) /home/byk/Code/opencode-lore-provider-error/package.json: Line 66: "premutation": "pnpm --filter @loreai/gateway run bundle", Line 67: "mutation": "stryker run", /home/byk/Code/opencode-lore-provider-error/.oxlintrc.json: Line 23: "typescript/no-base-to-string": "error", /home/byk/Code/opencode-lore-provider-error/README.md: Line 23: it stores your team's decisions inside a proprietary vector database. Line 32: - **A local SQLite database** at `~/.local/share/lore/lore.db` with an open Line 50: Built-in memory features go a step further — they store facts about your codebase. But storing facts isn't memory architecture: without compression, context management, active recall, or portability, it's a clipboard that expires. Facts accumulate. Knowledge compounds. Only one scales. ...
No files found
Found 13 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 822: const hostileModel = "private-in-progress-model";
Line 848: model: hostileModel,
Line 879: expect(out).not.toContain(hostileModel);
Line 880: expect(JSON.stringify(completions)).not.toContain(hostileModel);
Line 881: expect(capturedLogs.join("\n")).not.toContain(hostileModel);
Line 897: test("projects trusted in-progress metadata before a provider failure", async () => {
Line 898: const hostileModel = "private-visible-in-progress-model";
Line 923: model: hostileModel,
Line 951: expect(out).not.toContain(hostileModel);
Line 952: expect(JSON.stringify(completions)).not.toContain(hostileModel);
Line 2114: test("rejects response.in_progress changing the created response identity", async () => ...
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
880: expect(JSON.stringify(completions)).not.toContain(hostileModel);
881: expect(capturedLogs.join("\n")).not.toContain(hostileModel);
882: expect(recalls).toBe(0);
883: expect(completions).toEqual([
884: {
885: successful: false,
886: response: expect.objectContaining({
887: id: "resp_trusted_in_progress_failure",
888: model: "gpt-5.6-terra",
889: content: [],
890: rawOutputItems: [],
891: usage: { inputTokens: 7, outputTokens: 3 },
892: }),
893: },
894: ]);
895: });
896:
897: test("projects trusted in-progress metadata before a provider failure", async () => {
898: const hostileModel = "private-visible-in-progress-model";
899: const capturedLogs: string[] = [];
900: log.registerSink({
901: info: (message) ...
The working copy has no changes. Working copy (@) : lpmvqrur 1512d486 (empty) fix(responses): unify provider failure handling Parent commit (@-): wswlsmrn 24880457 fix/responses-provider-failures | fix(responses): reject non-monotonic provider failures Warning: These bookmarks have conflicts: fix/responses-private-references Hint: Use `jj bookmark list` to see details. Use `jj bookmark set <name> -r <rev>` to resolve. @ lpmvqrurxwlmrmwnyllmxlvkmplvwnlz 1512d486a34f36accc9a6d522247a75c9a52fffe parents=24880457763b6f10831856d01c41bd72d62ddc28 description=fix(responses): unify provider failure handling ○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 parents=a1020a45be1382893a183e2ff39506e78a08fb76 description=fix(responses): reject non-monotonic provider failures ~ (elided revisions) ◆ pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 description=feat(cch): add seeds for Claude ...
Found 1 matches /home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts: Line 600: "openai-responses provider failure";
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
590: snapshot: ResponsesAccState,
591: ): void {
592: for (const key of Object.keys(state) as Array<keyof ResponsesAccState>) {
593: if (!Object.hasOwn(snapshot, key)) delete state[key];
594: }
595: Object.assign(state, snapshot);
596: }
597:
598: const PUBLIC_GATEWAY_ERROR = "Gateway request failed";
599: export const RESPONSES_PROVIDER_FAILURE_LOG =
600: "openai-responses provider failure";
601:
602: /**
603: * Build the only provider-failure payload that may cross the gateway boundary.
604: * Provider diagnostics and failed output stay private; stable protocol fields
605: * remain available so clients can close the existing response lifecycle. ...
M packages/gateway/src/pipeline.ts M packages/gateway/src/stream/openai-responses.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts M packages/gateway/test/openai-responses-stream.test.ts 24880457763b6f10831856d01c41bd72d62ddc28 packages/gateway/src/pipeline.ts packages/gateway/src/stream/openai-responses.ts packages/gateway/test/openai-responses-recall-aware-stream.test.ts packages/gateway/test/openai-responses-stream.test.ts packages/gateway/src/pipeline.ts | 15 +++- packages/gateway/src/stream/openai-responses.ts | 90 ++++++++++++++++++---- .../openai-responses-recall-aware-stream.test.ts | 72 +++++++++++++++++ .../gateway/test/openai-responses-stream.test.ts | 87 ++++++++++++++++++++- 4 files changed, 244 insertions(+), 20 deletions(-) 00c6939912f4f3d79457872d427b47eccc0f60bb917d4ea6aa7cde512e6af260 packages/gateway/src/pipeline.ts 47f5c9c6ba1a43316698356d0d1e99412a57618434ae351e999260bc313bd808 ...
/usr/bin/bash: line 1: python: command not found
--- 598-690 ---
598: const PUBLIC_GATEWAY_ERROR = "Gateway request failed";
599:
600: /**
601: * Build the only provider-failure payload that may cross the gateway boundary.
602: * Provider diagnostics and failed output stay private; stable protocol fields
603: * remain available so clients can close the existing response lifecycle.
604: */
605: export function sanitizeResponsesProviderFailureTerminal(
606: event: string,
607: parsed: Record<string, unknown>,
608: state: Pick<
609: ResponsesAccState,
610: "id" | "model" | "createdAt" | "lastAcceptedSequenceNumber"
611: >,
612: ): { event: "response.failed"; parsed: Record<string, unknown> } | undefined {
613: const response = isRecord(parsed.response) ? parsed.response : undefined;
614: const diagnostic = event === "error" || event === "response.error";
615: if (
616: !diagnostic &&
617: !(
618: event === "response.failed" &&
619: (response?.status === "failed" || response?.status === ...
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0aa2a5441001KH4kpSmMpq12ID
10316: encoder.encode(
10317: formatResponsesEvent(
10318: providerFailureTerminal.event,
10319: JSON.stringify(providerFailureTerminal.parsed),
10320: ),
10321: ),
10322: () => {
10323: terminalDelivered = true;
10324: },
10325: ))
10326: ) {
10327: break;
10328: }
10329: cancelAndReleaseReader(reader, signal.reason);
10330: principalReader = null;
10331: clearKeepalive();
10332: safeClose();
10333: return;
10334: }
--- 10480-10655 ---
10480: parseRecallArguments(parsed.arguments),
10481: );
10482: ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0aa2a5441001KH4kpSmMpq12ID</path>
<type>file</type>
<content>
1: --- 9580-9629 ---
2: 9580: // --- Keepalive (same as streamResponsesPassthrough) ---
3: 9581: const KEEPALIVE_INACTIVITY_MS = 30_000;
4: 9582: const keepaliveComment = encoder.encode(`: keepalive\n\n`);
5: 9583: let keepaliveTimer: ReturnType<typeof setTimeout> | null = null;
6: 9584: let completed = false;
7: 9585: let completionAttempted = false;
8: 9586: let nextSequenceNumber = 0;
9: 9587:
10: 9588: const sequenceChunk = (chunk: Uint8Array): Uint8Array => {
11: 9589: const text = new TextDecoder().decode(chunk);
12: 9590: if (!text.startsWith("event: ")) return chunk;
13: 9591: let output = "";
14: 9592: for (const frame of text.split("\n\n")) {
15: 9593: if (!frame) continue;
16: 9594: const lines = frame.split("\n");
17: 9595: const eventLine = lines.find((line) => line.startsWith("event: "));
18: 9596: ...
0 files changed, 0 insertions(+), 0 deletions(-) e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 -
Error: Failed to parse template: Keyword `commit_id` doesn't exist Caused by: --> 1:1 | 1 | commit_id ++ " " ++ description.first_line() ++ "\n" | ^-------^ | = Keyword `commit_id` doesn't exist Hint: Did you mean `commit`?
@ lpmvqrur ben@byk.im 2026-09-16 11:49:37 provider-error@ 1512d486 │ (empty) fix(responses): unify provider failure handling │ -- operation 58a2b9a6dcc9 describe commit e19ee1c704ed9f24432cb7d88c6e45af03d35d67 ○ lpmvqrur/1 ben@byk.im 2026-09-16 10:39:21 e19ee1c7 (hidden) (empty) (no description set) -- operation 9c44ffd239ad commit 3e07e684e4ada41df3418a66e85c3aa4780a74bf
--- 12230-12276 ---
12230: const json = JSON.parse(body) as Record<string, unknown>;
12231: const parseResponse =
12232: protocol === "openai-responses"
12233: ? accumulateResponsesNonStreamJSON
12234: : protocol === "openai"
12235: ? accumulateOpenAINonStreamJSON
12236: : protocol === "gemini"
12237: ? parseGeminiResponseJSON
12238: : accumulateAnthropicNonStreamJSON;
12239: let response: GatewayResponse | undefined;
12240: try {
12241: if (protocol === "openai-responses") {
12242: const parsed = parseResponsesNonStreamEnvelope(json);
12243: response = parsed.response;
12244: if (parsed.status !== "completed")
12245: throw new ResponsesTerminalError(response, parsed.status);
12246: } else {
12247: response = parseResponse(json);
12248: if (requireValidCompletion)
12249: assertValidNonStreamCompletion(json, protocol);
12250: }
12251: return response;
12252: } ...
--- 15420-15480 ---
15420: settled,
15421: sessionIDs: new Set(),
15422: };
15423: activePipelineRequests.add(active);
15424: signal.addEventListener("abort", onAbort, { once: true });
15425:
15426: try {
15427: const response = await operation(signal, trackOperation, (sessionID) =>
15428: claimPipelineSession(active, sessionID, signal),
15429: );
15430: responseReturned = true;
15431: if (signal.aborted) {
15432: if (callerSignal?.aborted) markResponseCancelled();
15433: settleResponse();
15434: }
15435: return wrapBodyWithCleanup(response, settleResponse, undefined, () => {
15436: markResponseCancelled();
15437: settleResponse();
15438: });
15439: } catch (error) {
15440: onResponseBodySettled?.();
15441: void finish();
15442: throw error;
15443: }
15444: }
15445:
15446: export function validatedMetaStream(
15447: response: Response,
15448: protocol: "anthropic" | "openai" | ...
diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 3a5a89dd..a03a58d8 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -216,7 +216,10 @@ import {
responsesTerminalItemMatches,
restoreResponsesAccState,
normalizeCodexResponsesEvent,
+ projectResponsesInProgressEvent,
+ RESPONSES_PROVIDER_FAILURE_LOG,
sanitizeResponsesProviderFailureTerminal,
+ validateResponsesProviderFailureTerminal,
validateResponsesSourceSequence,
ResponsesTerminalError,
type ResponsesAccState,
@@ -10287,12 +10290,14 @@ export function streamResponsesRecallAware(
throw new Error("malformed Responses terminal event");
}
if (providerFailureTerminal) {
- if (
- (event === "error" || event === "response.error") &&
- !responseLifecycleFor(state).created
- ) {
- throw new Error("Responses event before ...
○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 parents=a1020a45be1382893a183e2ff39506e78a08fb76 description=fix(responses): reject non-monotonic provider failures ○ plzxzousrzuvukvvtzlvvynqpokuptqu a1020a45be1382893a183e2ff39506e78a08fb76 parents=01a6e06b08ba1b54f42c5b4c757ec449eb8e8490 description=fix(responses): preserve trusted failure metadata ~ (elided revisions) ◆ pxrvwsvvkmpoxnsqmrkwrnlqvvkoltwz 2cbf40060c67df229731cf1b9e34d5bf22ec2145 parents=e977b4b1da8f8197c3238466d41de0bccd8eb054 description=feat(cch): add seeds for Claude Code up to 2.1.272 (#1780) │ ~ M packages/gateway/src/pipeline.ts M packages/gateway/src/stream/openai-responses.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts M packages/gateway/test/openai-responses-stream.test.ts M packages/gateway/test/pipeline-streaming.test.ts M packages/gateway/test/recall-codex-stream.test.ts c79cc2ec010e22f01961d8eec7bce3a60b8dfcb02c12b9ce4c0de9c5e173cb4d - M ...
300: "sanitizes a principal provider failure received as %s with status %s",
466: "rejects a principal %s with non-monotonic source sequence %s before accepting failure usage",
509: status: "in_progress",
654: status: "in_progress",
730: test("sanitizes a recall-bearing provider failure before later lifecycle checks", async () => {
820: test("keeps created metadata authoritative through a hidden recall and provider failure", async () => {
838: id: "resp_trusted_in_progress_failure",
844: sseEvent("response.in_progress", {
846: id: "resp_trusted_in_progress_failure",
848: status: "in_progress",
854: id: "resp_trusted_in_progress_failure",
886: id: "resp_trusted_in_progress_failure",
1167: test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {
1174: created("resp_failure_backpressure", "gpt-5.6-terra"),
1177: id: ...
--- 2020-2075 ---
2020: error: (message) => errors.push(message),
2021: captureException: () => {},
2022: });
2023: const client = streamResponsesRecallAware(new Response(null), {
2024: onComplete: () => {},
2025: onRecall: async () => ({ anchorText: "", resultText: "" }),
2026: runFollowUp: async () => {
2027: throw new Error("should not run");
2028: },
2029: });
2030:
2031: const out = await drain(client);
2032: expect(out.match(/^event: response\.failed$/gm)).toHaveLength(1);
2033: expect(out).toContain(PUBLIC_GATEWAY_ERROR);
2034: expect(out).not.toContain(PUBLIC_RECALL_ERROR);
2035: expect(out).not.toContain("Upstream response has no body");
2036: expect(failures).toEqual([]);
2037: expect(errors).toEqual([
2038: "openai-responses recall-aware stream failed category=principal_unexpected",
2039: ]);
2040: });
2041:
2042: test("rejects response.in_progress changing the created ...
e02913cfe3f7507cae8a358dab68d27a5960b1fe6eedc5386345cbcc053da488 - f596a3263bf661df8884702b00e550d9187f3b369a662ddd989e7ac28540178d - 5b6b8dc43aae88fc56daad97d7ab55da8ed57ce873d8d0cf347f3eb4e4bed21c -
3722: test("Anthropic translator emits inclusive Responses cache usage", async () => {
4225: "rejects a %s terminal with non-monotonic source sequence %s before accepting usage",
4892: test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {
466: "rejects a principal %s with non-monotonic source sequence %s before accepting failure usage",
1167: test("finalizes validated failure usage when cancellation wins terminal backpressure", async () => {
5665: test("rejects usage overflow while merging a continuation", async () => {
5698: test("rejects per-response usage overflow before recall side effects", async () => {
5725: test("rejects impossible cache usage before recall side effects", async () => {
5755: test("rejects cache usage without input_tokens before recall", async () => {
8839: "rejects a continuation %s with non-monotonic source sequence %s before accepting failure usage",
9139: test("merges continuation ...
5b6b8dc43aae88fc56daad97d7ab55da8ed57ce873d8d0cf347f3eb4e4bed21c - f596a3263bf661df8884702b00e550d9187f3b369a662ddd989e7ac28540178d - e02913cfe3f7507cae8a358dab68d27a5960b1fe6eedc5386345cbcc053da488 - 2f13d034476b26316abff935a26a74b8e1c516a152e85952daa80aecc50405f3 - d9f6777bd96c6fe0b9f1cf028b5f82843284bcc08c492130c96d9bd82c894ba8 - fc65ee28f054d358a744ab8a62ac22001fa7fb03f8971816cb83998995541d6d -
15819: let accumulated: GatewayResponse;
15820: try {
15821: accumulated = req.stream
15822: ? forwarded.effectiveProtocol === "openai-responses"
15823: ? await accumulateResponsesSSEStream(upstreamResponse, {
15824: signal: abortScope.signal,
15825: validation: req.codex ? "codex" : "public",
15826: stopAtTerminal: true,
15827: requireCompletedTerminal: true,
15828: })
15829: : forwarded.effectiveProtocol === "openai"
15830: ? await accumulateOpenAISSEStream(upstreamResponse, {
15831: signal: abortScope.signal,
15832: strict: true,
15833: stopAtTerminal: true,
15834: consumeUntilDone: true,
15835: })
15836: : forwarded.effectiveProtocol === "gemini"
15837: ? await accumulateGeminiSSEStream(upstreamResponse, {
15838: signal: abortScope.signal,
15839: strict: ...
<path>/home/byk/Code/opencode-lore-provider-error/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 () ...
18225: }
18226: const upstreamResponse = wrapBodyWithCleanup(
18227: upstreamResult.response,
18228: () => {},
18229: foregroundAbort.signal,
18230: );
18231: let foregroundOwnershipTransferred = false;
18232: const finishForeground = (response: Response): Response => {
18233: if (foregroundOwnershipTransferred) return response;
18234: foregroundOwnershipTransferred = true;
18235: copyUsageLimitHeaders(upstreamResponse.headers, response.headers);
18236: return wrapBodyWithCleanup(
18237: response,
18238: releaseForeground,
18239: foregroundAbort.signal,
18240: rollbackRecallPersistence,
18241: );
18242: };
18243: const awaitForeground = async <T>(operation: Promise<T>): Promise<T> => {
18244: try {
18245: return await operation;
18246: } catch (error) {
18247: if (!foregroundOwnershipTransferred) releaseForeground();
18248: throw error;
18249: }
18250: };
18251: const { ...
Found 1 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts:
Line 2575: export function captureToolPairing400(input: {
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
2540: // become the literal last message of the request, so (1) agent harnesses
2541: // (Claude Code REPL, OpenCode) render it as a stray turn ("Understood.") and
2542: // (2) the model sees the conversation ending on its OWN turn and ends the
2543: // agent loop early (the wedge). Cap at messages.length - 1 so at least one
2544: // real message (a user turn / tool_result) always follows the pair and closes
2545: // the request. (Only reachable when messages.length >= 1; an empty array has
2546: // no delta to place.)
2547: let idx = Math.max(0, Math.min(desired, Math.max(0, messages.length - 1)));
2548: // Walk backward while the immediately-preceding message is an assistant
2549: // carrying a tool_use. ...
c79cc2ec010e22f01961d8eec7bce3a60b8dfcb02c12b9ce4c0de9c5e173cb4d - M packages/gateway/src/pipeline.ts M packages/gateway/src/stream/openai-responses.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts M packages/gateway/test/openai-responses-stream.test.ts M packages/gateway/test/pipeline-streaming.test.ts M packages/gateway/test/recall-codex-stream.test.ts ○ wswlsmrnuzlqtxyskqotksrlqtzplrkl 24880457763b6f10831856d01c41bd72d62ddc28 parents=a1020a45be1382893a183e2ff39506e78a08fb76 │ ~
Found 5 matches
/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/anthropic.ts:
Line 61: export class SSEStreamTransportError extends Error {
Line 79: export async function readStreamChunk(
Line 88: throw new SSEStreamTransportError("read", "SSE stream read failed", {
Line 119: inactivityError = new SSEStreamTransportError(
Line 246: const { done, value } = await readStreamChunk(reader, {
<path>/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/stream/anthropic.ts</path>
<type>file</type>
<content>
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).
57: */
58: export const DEFAULT_MAX_SSE_FRAMES = 100_000;
59:
60: /** A post-header transport failure while reading an SSE response body. */
61: export class SSEStreamTransportError extends Error {
62: readonly kind: "inactivity" | "read";
63:
64: constructor(
65: kind: "inactivity" | "read",
66: message: string,
67: options?: ErrorOptions,
68: ) {
69: super(message, options);
70: this.name = "SSEStreamTransportError";
71: this.kind = kind;
72: }
73: }
74:
75: /** Deterministic local stream limits must never be ...
11993: const parsed = parseResponsesNonStreamEnvelope(json);
12017: function parseResponsesNonStreamEnvelope(json: Record<string, unknown>): {
13209: function accountUnsuccessfulResponse(
15417: parseResponsesNonStreamEnvelope(
15630: accountUnsuccessfulResponse(
15893: accountUnsuccessfulResponse(
18497: accountUnsuccessfulResponse(
18563: accountUnsuccessfulResponse(
18579: async function captureUnsuccessfulResponses(
18845: captureUnsuccessfulResponses(
18967: captureUnsuccessfulResponses(
546: export class ResponsesTerminalError extends Error {
552: this.name = "ResponsesTerminalError";
2364: throw new ResponsesTerminalError(
--- 11975-12030 ---
11975: strict: true,
11976: stopAtTerminal: true,
11977: });
11978: }
11979: }
11980:
11981: const json = JSON.parse(body) as Record<string, unknown>;
11982: const parseResponse =
11983: protocol === "openai-responses"
11984: ? accumulateResponsesNonStreamJSON
11985: : protocol === "openai"
11986: ? accumulateOpenAINonStreamJSON
11987: : protocol === "gemini"
11988: ? parseGeminiResponseJSON
11989: : accumulateAnthropicNonStreamJSON;
11990: let response: GatewayResponse | undefined;
11991: try {
11992: if (protocol === "openai-responses") {
11993: const parsed = parseResponsesNonStreamEnvelope(json);
11994: response = parsed.response;
11995: if (parsed.status !== "completed")
11996: throw new ResponsesTerminalError(response, parsed.status);
11997: } else {
11998: response = parseResponse(json);
11999: if ...
7790: * terminal `response.completed` reflecting marker + continuation.
7791: *
7792: * `onComplete` mirrors `streamResponsesPassthrough` (invoked exactly once with
7793: * the accumulated internal response for `postResponse`/calibration).
7794: *
7795: * The recall execution callback abstracts the pipeline-scope dependencies
7796: * (`executeRecall` + follow-up forwarding + recall store), so this function
7797: * stays a self-contained streamer in the Responses module.
7798: */
7799: export function streamResponsesRecallAware(
7800: upstreamResponse: Response,
7801: opts: {
7802: onComplete: (response: GatewayResponse, successful: boolean) => void;
7803: onTransactionReady?: (transaction: {
7804: commit: () => void;
7805: rollback: () => void;
7806: }) => void;
7807: sessionID?: string;
7808: /** Emergency ceiling for the request-owned recall chain. */
7809: maxRecallExecutions?: number;
7810: /** @deprecated Use ...
608: validation: "codex", 770: validation: "codex", 1056: validation: "codex", 1132: validation: "codex", 1892: validation: "codex", 2524: validation: "public", 2557: validation: "codex", 2622: validation: "codex", 3029: validation: "codex", 3118: validation: "codex", 3183: validation: "codex", 3252: validation: "codex", 3346: validation: "codex", 3399: validation: "codex", 3451: validation: "codex", 3513: validation: "codex", 3580: validation: "codex", 3651: validation: "codex", 3720: validation: "codex", 3788: validation: "codex", 3841: validation: "codex", 3904: validation: "codex", 4015: validation: "codex", 4127: validation: "codex", 4153: validation: "codex", 4188: validation: "public", 4243: validation: "codex", 4286: validation: "codex", 6907: ...
--- 2470-2585 ---
2470: }),
2471: ]),
2472: {
2473: onComplete: () => {},
2474: onRecall: async () => ({ anchorText: "", resultText: "" }),
2475: runFollowUp: async () => {
2476: throw new Error("should not run");
2477: },
2478: },
2479: );
2480: expect(await drain(client)).toContain("response.failed");
2481: });
2482:
2483: test("rejects an unknown public incomplete reason", async () => {
2484: const client = streamResponsesRecallAware(
2485: streamFrom([
2486: created("resp_unknown_incomplete", "gpt-5.6-terra"),
2487: sseEvent("response.incomplete", {
2488: response: {
2489: id: "resp_unknown_incomplete",
2490: model: "gpt-5.6-terra",
2491: status: "incomplete",
2492: incomplete_details: { reason: "provider_specific" },
2493: output: [],
2494: },
2495: }),
2496: ]),
2497: {
2498: ...
wswlsmrn, commit 24880457763b6f10831856d01c41bd72d62ddc28.main@origin at 2cbf40060c67df229731cf1b9e34d5bf22ec2145; the candidate descends from it through the provider-failure stack.c79cc2ec010e22f01961d8eec7bce3a60b8dfcb02c12b9ce4c0de9c5e173cb4d.jj file show -r wswlsmrn evidence. The candidate revision and patch hash did not change. All line references below refer to that immutable revision.error events bypass sanitization and leak provider textAfter response.created, this frame leaks verbatim:
event: error
data: private-provider-diagnostic
The principal parser forwards non-JSON events unless their event name starts with response. or equals message (packages/gateway/src/pipeline.ts:10135-10156). Sanitization only runs after successful JSON parsing at pipeline.ts:10284-10320.
The continuation parser has the same flaw: pipeline.ts:10921-10944 retains the raw frame, and pipeline.ts:11259-11268 can queue it for later client delivery.
This bypasses the fixed Gateway request failed envelope and exposes arbitrary provider diagnostics. Add principal and continuation regressions for non-JSON error, including recall pending, backpressure, EOF, and later successful/failing terminals.
response.in_progress can leak untrusted metadata before the sanitized failureRecall-aware lifecycle validation checks identity, status, and empty output but does not validate or project model, timestamp, or extensions ...
Date: Sep 16, 2026 * 🔴 (13:18) User stated knowledge-delta insertion is capped at `messages.length - 1` so at least one real message—user turn or `tool_result`—always follows the injected pair and closes the request. * 🔴 (13:18) User stated the knowledge delta must be inserted before an assistant message carrying `tool_use`, never after its `tool_use`, including both completed pairs and pending…
Date: Sep 16, 2026 * 🔴 (12:40) Changes in `packages/gateway/src/pipeline.ts` added imports for `projectResponsesInProgressEvent` and `RESPONSES_PROVIDER_FAILURE_LOG` and introduced additional Responses lifecycle/failure handling, including preservation of `sequence_number` and a `sanitizedFailure` structure. * 🔴 (12:43) Repository history showed commit `24880457763b6f10831856d01c41bd72d62ddc28`…
Date: Sep 16, 2026 * 🟡 (12:26) Tool result reported a clean/empty diff: `0 files changed, 0 insertions(+), 0 deletions(-)` with SHA-256 `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855`. * 🟡 (12:29) A template parse failed because keyword `commit_id` does not exist in `commit_id ++ " " ++ description.first_line() ++ "\n"`; the tool suggested `commit`. * 🟡 (12:32) Repository hi…
Date: Sep 16, 2026 * 🔴 (12:21) User-provided sparse-index invariant in `packages/gateway/src/stream/openai-responses.ts` around lines 2066-2069: sparse numeric identities “can never need more address space than the” established bound, and `index + 1` “always changes the value.” * 🔴 (12:21) User-provided accounting invariant in `packages/gateway/src/stream/openai-responses.ts` around line 2802: …
Date: Sep 16, 2026 * 🟡 (11:56) `packages/core/test/setup.ts` installs a baseline `globalThis.fetch` guard that intercepts only `https://models.dev/api.json`, returns canned HTTP 200 JSON, and delegates every other request to the captured real fetch. This prevents gateway startup/pre-warm calls from depending on models.dev or polluting fetch-mock assertions across test files. * 🟡 (11:56) Canned …
Date: Sep 16, 2026 * 🟡 (11:27) `handlePassthrough()` in `packages/gateway/src/pipeline.ts:15595` creates a foreground abort scope, calls `forwardToUpstream()`, and wraps the body with `wrapBodyWithCleanup()`. At lines 15627-15631, non-2xx upstream responses bypass SSE validation and return through `preserveUpstreamErrorResponse()` so provider 4xx/429 errors remain ordinary HTTP responses instead…
Date: Sep 16, 2026 * 🟡 (11:18) `packages/gateway/test/openai-responses-stream.test.ts` was modified to import `makeResponsesAccState` and add extensive Responses streaming terminal/error-path coverage. * 🟡 (11:18) Added test `"validates and forwards a provider failure terminal"` invokes `streamResponsesPassthrough()` with a `response.failed` SSE terminal whose response has `status: "failed"` an…
Date: Sep 16, 2026 * 🟡 (11:14) Additional gateway streaming test artifacts reference response fixtures `resp_sparse_provider_failure` and `resp_trusted_in_progress_failure`, alongside model `gpt-5.6-terra`. * 🟡 (11:14) A sparse provider-failure fixture uses usage `{ input_tokens: 19, output_tokens: 7 }`; terminal completion ordering is asserted as `[0, 1]`. * 🟡 (11:14) Failure-path privacy ass…
Date: Sep 16, 2026 * 🟡 (11:13) Gateway streaming tests were expanded with `test.each` coverage for 4 principal-provider failure combinations: 1. `response.failed` with status `failed`, 2. `response.failed` with status `cancelled`, 3. `response.done` with status `failed`, 4. `response.done` with status `cancelled`. * 🟡 (11:13) The new failure-sanitization tests use `PUBLIC_GATEWAY_ERROR`, includ…
Date: Sep 16, 2026 * 🔴 (11:11) User asserted that failed output is never authoritative and must not reach accounting hooks. * 🔴 (11:11) User asserted that failed usage/accounting never depends on client demand. * 🟡 (11:11) In `packages/gateway/src/pipeline.ts`, unsuccessful Responses stream finalization changed from `finish(false)` to `finish(false, finalizeUnsuccessfulResponsesAcc(state))`, a…
Date: Sep 16, 2026 * 🔴 (11:09) In `packages/gateway/src/pipeline.ts`, `consumeReferenceEvent(...)` accepts `response.output_item.added` items of type `item_reference` only when `output_index` is a nonnegative safe integer, `id` is a nonempty string, and the item has no keys other than `type` and `id`; duplicate identities across `references`, `acc.rawItems`, `syntheticIdentities`, `outputIdentit…
Date: Sep 16, 2026 * 🔴 (11:07) User’s Responses failure-handling invariant: failed output is never authoritative and must not reach accounting hooks. * 🔴 (11:07) User’s Responses accounting invariant: failed usage/accounting never depends on client demand. * 🔴 (11:07) In `packages/gateway/src/stream/openai-responses.ts`, `restoreResponsesAccState(state, snapshot)` deletes state keys absent fro…
Date: Sep 16, 2026 * 🔴 (11:06) User modified `packages/gateway/src/pipeline.ts`, adding imports for `cloneResponsesAccState` and `validateResponsesSourceSequence`. * 🔴 (11:06) The modified Responses pipeline introduces `rollbackPendingPrincipalTerminal`, snapshots terminal-state data through `terminalRecallSnapshot`, and can restore `recallDetected`, unresolved tool-byte state, and related life…
Date: Sep 16, 2026 * 🔴 (11:04) User supplied `/home/byk/Code/opencode-lore-provider-error/packages/gateway/src/pipeline.ts` lines 9080–9329. Reasoning output completion rejects changed content type/value, incomplete delta or part lifecycles, and disagreement among `authoritativeValue`, `finalValue`, `partFinalValue`, and the final output item; successful validation sets `lifecycle.outputDone = t…
Date: Sep 16, 2026 * 🔴 (11:01) User established the recall-streaming invariant: `"recall-only: never converts a failed continuation into completed"`; private recall input such as `"private query"` must not appear in drained client output. * 🔴 (11:01) User established that recall continuation diagnostics must `"never alter the fixed public failure"`. * 🔴 (11:01) User established that the pipeli…
Date: Sep 16, 2026 * 🔴 (10:59) User supplied a test-file excerpt covering approximately lines 137–1108 for Responses recall-aware streaming. The code includes SSE construction for `response.completed`; assistant `message` output items; terminal-event/status parameterization; replacement of principal provider diagnostics with a fixed public failure envelope; provider diagnostic aliases `"error"` …
Date: Sep 16, 2026 * 🔴 (10:58) User supplied a continuation of `packages/gateway/test/openai-responses-stream.test.ts`, approximately lines 4064–4890. The tests cover principal Responses streaming behavior including single emission of `response.created`, replacement of provider failure diagnostics with a fixed public failure envelope, rejection of non-monotonic failure sequences, handling diagno…
Date: Sep 16, 2026 * 🔴 (10:55) User supplied the next continuation of `packages/gateway/src/stream/openai-responses.ts`, approximately lines 11712–12335. The code handles principal Responses-stream retry exhaustion (`"retry_exhausted"`), logs `"retrying principal Responses stream after read transport failure"`, cancels `retryResponse.body`, clears `rollbackPendingPrincipalTerminal`, assigns cont…
Date: Sep 16, 2026 * 🔴 (10:52) User supplied the next continuation of `packages/gateway/src/stream/openai-responses.ts`, approximately lines 11030–11708. The code tracks `resolvingRecallTool`, `contRecallIndices`, hidden continuation chunks and `hiddenBytes`, throws `RecallContinuationFailure`, handles `response.output_item.done`, computes `incompleteRecallIndices`, detects whether `contState.te…
Date: Sep 16, 2026 * 🔴 (10:50) User supplied a continuation of `packages/gateway/src/stream/openai-responses.ts` covering approximately lines 10489–11020. The code handles `response.output_item.done`, calls `stripHiddenReferenceOutput(parsed)`, applies `opts.validation === "codex"` logic, tracks `recallDetected` and `recallIndices`, records outcome `"retry_succeeded"`, cancels via `cancelAndRele…
Date: Sep 16, 2026 * 🔴 (10:49) User asserted the directive “Always accumulate into the internal state for postResponse.” in `packages/gateway/src/stream/openai-responses.ts` near line 10409.
Date: Sep 16, 2026 * 🔴 (10:48) User asserted the directive “Always feed the accumulator” for streaming processing in `packages/gateway/src/stream/openai-responses.ts` near line 3074. * 🔴 (10:48) User asserted that the injected `tool_use` “never leaks to the client” in the true-streaming path of `packages/gateway/src/stream/openai-responses.ts` near lines 2635–2642. * 🔴 (10:48) User asserted th…
Date: Sep 16, 2026 * 🔴 (10:48) User stated the invariant near lines 2066–2069 of `packages/gateway/src/stream/openai-responses.ts`: sparse numeric identities “never need more address space than the” stated bound, and `index + 1` “always changes the value.”
Date: Sep 16, 2026 * 🔴 (10:47) User specified that accumulated text must be replaced with the final version because the final version is more reliable; this behavior is documented around line 790 of `packages/gateway/src/stream/openai-responses.ts`. * 🔴 (10:47) User reaffirmed the invariant documented at line 1030 of `packages/gateway/src/stream/openai-responses.ts`: failed output is never auth…
Date: Sep 16, 2026 * 🟡 (10:46) Candidate change identity resolved fully as change `wswlsmrnuzlqtxyskqotksrlqtzplrkl`, commit `24880457763b6f10831856d01c41bd72d62ddc28`, description `fix(responses): reject non-monotonic provider failures`, with parent `a1020a45be1382893a183e2ff39506e78a08fb76`. * 🟡 (10:46) Candidate parent `a1020a45be1382893a183e2ff39506e78a08fb76` is change `plzxzousrzuvukvvtzl…
Date: Sep 16, 2026 * 🔴 [requested-review] (10:42) User requested an independent, read-only security/privacy/pentest review of the exact provider-failure candidate in `/home/byk/Code/opencode-lore-provider-error`. * 🔴 (10:42) User prohibited edits, formatting, VCS mutations, server use, network use, production DB access, and exhaustive reruns during the review. * 🔴 (10:42) User identified candi…