Dashboard › opencode-lore › Session 1RZ6UYfFz5rZ
1RZ6UYfFz5rZwd3o1Independent read-only adversarial correctness review of immutable candidate /home/byk/Code/opencode-lore-codex-reasoning stable change wlpsntppxyyxpvwnnywkpvkskzvtktvp, commit b588d81bfd33e0b30e5040c694c893b3a116e363, parent rtwyxzrr/b9feb17a1feb58a72a080cca0e493130427c506f, expected child diff SHA 8553e8714cf769789ec17e29f4ae2d3ade02d5cbd8662e1ef33981871dcd15a7, exactly pipeline.ts + openai-responses-recall-aware-stream.test.ts. Read AGENTS.md, quality/REVIEW.md, scripts. repo-setup unavailable: note and proceed. No edits/format/install/VCS/network/server/production DB. Verify identity/hash/status/conflicts/files at start/end; stop on mismatch. Inspect all changed lines and relevant strict accumulator/normalizer/callers/tests. Audit lifecycle-backed Codex reasoning reconciliation, exact summary/reasoning part validation, shifted continuation coordinates, omitted/done/terminal variants, sparse ceilings, bounded complexity/operation-count guards, accumulation-before-rejection, recall side effects, cancellation/failure callbacks. Confirm tests fail first/guard removal evidence is discriminating. Supplied exact evidence: 250/250 repeated, 482/482 strict suites, static and bundle green. Focused tests only if useful, no exhaustive. Findings severity with exact HEAD file:line, PASS/CONCERN/MUST-FIX, residual risks, substantive verdict. Never warning-only; use lore recall/local UI fallback. 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-codex-reasoning</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-codex-reasoning/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-codex-reasoning/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-codex-reasoning/scripts</path> <type>directory</type> <entries> bump-version.sh cch-scan.c check-cc-version.ts check-docs-links.mjs check-patches.ts check-preview-links.mjs check-social-meta.mjs extract-cch-seed.ts generate-config-docs.ts generate-env-docs.ts generate-release-checksums.mjs smoke-install.mjs (12 entries) </entries>
/home/byk/Code/opencode-lore-codex-reasoning /home/byk/Code/opencode-lore-codex-reasoning Working copy changes: M packages/gateway/src/pipeline.ts M packages/gateway/test/openai-responses-recall-aware-stream.test.ts Working copy (@) : wlpsntpp b588d81b fix(responses): bound Codex reasoning state Parent commit (@-): rtwyxzrr b9feb17a fix/codex-sparse-reasoning | fix(responses): reject untracked Codex reasoning 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. wlpsntppxyyxpvwnnywkpvkskzvtktvp b588d81bfd33e0b30e5040c694c893b3a116e363 parents=rtwyxzrrqnqspzypxtymnolzwmpnnumv/b9feb17a1feb58a72a080cca0e493130427c506f conflict=false rtwyxzrrqnqspzypxtymnolzwmpnnumv b9feb17a1feb58a72a080cca0e493130427c506f parents=uyznyvwtuxrkvnppulnwlpryssrywsrt/1ff66d14757b98d3ec7bdb8012104d1f10b292b8 ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/package.json</path>
<type>file</type>
<content>
1: {
2: "name": "lore-monorepo",
3: "private": true,
4: "type": "module",
5: "license": "FSL-1.1-Apache-2.0",
6: "description": "Monorepo root for Lore — three-tier memory architecture",
7: "main": "./packages/opencode/src/index.ts",
8: "exports": {
9: ".": "./packages/opencode/src/index.ts"
10: },
11: "packageManager": "pnpm@10.28.0",
12: "volta": {
13: "node": "24.16.0",
14: "pnpm": "10.28.0"
15: },
16: "pnpm": {
17: "onlyBuiltDependencies": [
18: "esbuild",
19: "onnxruntime-node",
20: "sharp"
21: ],
22: "overrides": {
23: "basic-ftp": "5.3.1",
24: "ip-address": "10.2.0",
25: "fast-xml-parser": "5.7.3",
26: "@huggingface/hub": "2.11.0",
27: "onnxruntime-node": "1.27.0",
28: "yaml": ">=2.8.3",
29: "esbuild": ">=0.28.1",
30: "@opentelemetry/core": ">=2.8.0",
31: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/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": ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/script</path> <type>directory</type> <entries> build-binary-sea.ts build.ts bundle.ts debug-id.ts import-meta-url.js jsonc-parser-plugin.ts native-loader.cjs ort-native-plugin.ts ort-npm-plugin.ts ort-platform-package.ts ort-web-plugin.ts pack-ort-npm.ts record-session.ts smoke-test.ts vendor-embeddings.ts vendor-ort-native.ts vendor-paths.ts vendor-sqlite-vec.ts (18 entries) </entries>
The server restarted. Resume the same immutable Codex correctness review with prior state preserved. Complete a substantive evidence-based review and exact MERGE/DO-NOT-MERGE verdict. Use local lore recall/UI if needed; never warning-only. Remain read-only: no edits, VCS/server/network except local recall fallback, production DB, or exhaustive rerun.
...output truncated...
Full output saved to: /home/byk/.local/share/opencode/tool-output/tool_0ac5ba4530011hcOlRrIHCtfKL
8873: summaryState.authoritativeValueSeen &&
8874: summaryState.authoritativeValue !== initialValue
8875: ) {
8876: throw new Error(
8877: `Responses reasoning summary part changed initial content for index ${outputIndex}:${summaryIndex}`,
8788 8878: );
8789 : if (
8790 : summaryState.authoritativeValueSeen &&
8791 : summaryState.authoritativeValue !== initialValue
8792 : ) {
8793 : throw new Error(
8794 : `Responses reasoning summary part changed initial content for index ${outputIndex}:${summaryIndex}`,
8795 : );
8796 : }
8797 : summaryState.authoritativeValue = initialValue;
8798 : ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0ac5ba4530011hcOlRrIHCtfKL</path>
<type>file</type>
<content>
1: packages/gateway/src/pipeline.ts | 385 +++++++-------
2: ...est/openai-responses-recall-aware-stream.test.ts | 599 ++++++++++++++++++++++
3: 2 files changed, 812 insertions(+), 172 deletions(-)
4: Modified regular file packages/gateway/src/pipeline.ts:
5: ...
6: 7970 7970: }
7: 7971 7971: return value;
8: 7972 7972: };
9: 7973: const assertExactReasoningPart: (
10: 7974: rawPart: unknown,
11: 7975: kind: "summary_text" | "reasoning_text",
12: 7976: description: string,
13: 7977: ) => asserts rawPart is {
14: 7978: type: "summary_text" | "reasoning_text";
15: 7979: text: string;
16: 7980: } = (rawPart, kind, description) => {
17: 7981: if (!rawPart || typeof rawPart !== "object" || Array.isArray(rawPart)) {
18: 7982: throw new Error(`invalid Responses ...
<path>/home/byk/.local/share/opencode/tool-output/tool_0ac5ba4530011hcOlRrIHCtfKL</path>
<type>file</type>
<content>
1057: 2993: build: (reasoningId: string, marker: string) => [
1058: 2994: sseEvent("response.output_item.added", {
1059: 2995: output_index: 0,
1060: 2996: item: {
1061: 2997: type: "reasoning",
1062: 2998: id: reasoningId,
1063: 2999: summary: [{ type: "summary_text", text: "tracked summary" }],
1064: 3000: },
1065: 3001: }),
1066: 3002: sseEvent("response.output_item.done", {
1067: 3003: output_index: 0,
1068: 3004: item: {
1069: 3005: type: "reasoning",
1070: 3006: id: reasoningId,
1071: 3007: status: "completed",
1072: 3008: summary: [
1073: 3009: {
1074: 3010: type: ...
Found 28 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 217: type ResponsesAccState,
Line 7794: export function streamResponsesRecallAware(
Line 7879: const maxSparseIndex = Math.min(maxSSEFrames, DEFAULT_MAX_SSE_FRAMES);
Line 7882: const outputIdentities = new Set<string>();
Line 7934: const normalizeCodexEvent = (
Line 7949: maxSparseIndex,
Line 8004: if (rawParts.length > maxSparseIndex) {
Line 8006: `Responses ${description} exceeded ${maxSparseIndex} item limit`,
Line 8047: if (parts.length > maxSparseIndex) {
Line 8049: `Responses ${description} exceeded ${maxSparseIndex} item limit`,
Line 8413: (index as number) >= maxSparseIndex
Line 8538: outputIdentities.has(identity) ||
Line 8545: for (const identity of identities) outputIdentities.add(identity);
Line 8648: (outputIdentities.has(finalCallId) ||
Line 8673: ...
Found 49 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 205: applyResponsesEvent,
Line 206: finalizeResponsesAcc,
Line 208: makeResponsesAccState,
Line 217: type ResponsesAccState,
Line 7877: let state = makeResponsesAccState();
Line 7884: ResponsesAccState,
Line 7888: acc: ResponsesAccState,
Line 7917: ResponsesAccState,
Line 7921: acc: ResponsesAccState,
Line 7931: ResponsesAccState,
Line 7932: ResponsesAccState
Line 7934: const normalizeCodexEvent = (
Line 7935: acc: ResponsesAccState,
Line 7938: ): ResponsesAccState | undefined => {
Line 7942: normalizationState = makeResponsesAccState();
Line 8073: let transactionBaseline: ResponsesAccState | undefined;
Line 8275: acc: ResponsesAccState,
Line 8386: state: ResponsesAccState,
Line 8451: applyResponsesEvent(state, "response.output_item.added", {
Line 9166: const ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
180: buildAnthropicRequest,
181: buildAnthropicNonStreamResponse,
182: parseAnthropicResponseJSON,
183: type AnthropicCacheOptions,
184: } from "./translate/anthropic";
185: import {
186: bedrockMantleUrl,
187: isBedrockMantleDispatch,
188: toMantleModelId,
189: } from "./translate/bedrock";
190: import { buildVertexUpstream, vertexHost } from "./translate/vertex";
191: import { getVertexAccessToken, resolveVertexProject } from "./vertex-auth";
192: import {
193: buildOpenAIUpstreamRequest,
194: buildOpenAIResponse,
195: } from "./translate/openai";
196: import {
197: buildOpenAIResponsesUpstreamRequest,
198: buildOpenAIResponsesResponse,
199: parseOpenAIResponsesRequest,
200: } from "./translate/openai-responses";
201: import {
202: accumulateResponsesSSEStream,
203: streamResponsesPassthrough,
204: ...
Found 5 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts:
Line 48: export interface ResponsesAccState {
Line 556: export function makeResponsesAccState(): ResponsesAccState {
Line 582: export function applyResponsesEvent(
Line 815: export function finalizeResponsesAcc(
Line 1750: export function normalizeCodexResponsesEvent(
<path>/home/byk/Code/opencode-lore-codex-reasoning/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-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
520:
521: function completeCodexMessageSnapshot(
522: snapshot: Record<string, unknown>,
523: outputIndex: number,
524: terminalContentParts: ReadonlyMap<
525: string,
526: { kind: "text" | "refusal"; value: string }
527: >,
528: ): Record<string, unknown> {
529: if (snapshot.type !== "message" || snapshot.content !== undefined) {
530: return snapshot;
531: }
532: const finalizedContent = finalizedResponsesMessageContent(
533: outputIndex,
534: terminalContentParts,
535: ).map((part) =>
536: part.kind === "text"
537: ? { type: "output_text", text: part.value }
538: : { type: "refusal", refusal: part.value },
539: );
540: return finalizedContent.length > 0
541: ? { ...snapshot, content: finalizedContent }
542: : snapshot;
543: }
544:
545: /** Validated unsuccessful terminal, carrying usage ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1680: }
1681: if (state.id && response.id !== undefined && response.id !== state.id) {
1682: throw new Error("malformed Responses terminal event");
1683: }
1684: if (
1685: state.model &&
1686: response.model !== undefined &&
1687: response.model !== state.model
1688: ) {
1689: throw new Error("malformed Responses terminal event");
1690: }
1691: if (
1692: event === "response.created" &&
1693: response.status !== undefined &&
1694: response.status !== "in_progress" &&
1695: response.status !== "queued"
1696: ) {
1697: malformedResponsesEvent();
1698: }
1699: if (
1700: event === "response.in_progress" &&
1701: response.status !== undefined &&
1702: response.status !== "in_progress"
1703: ) {
1704: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1280: previousIdentity?: string,
1281: ): void {
1282: const normalized = state.items.get(outputIndex);
1283: if (normalized?.type !== "tool_use" || !identity) {
1284: malformedResponsesEvent();
1285: }
1286: const previous = previousIdentity ?? (normalized.callId || normalized.id);
1287: if (
1288: previous &&
1289: previous !== identity &&
1290: state.effectiveToolIndexById.get(previous) === outputIndex
1291: ) {
1292: state.effectiveToolIndexById.delete(previous);
1293: }
1294: bindResponsesIdentity(
1295: state,
1296: state.effectiveToolIndexById,
1297: identity,
1298: outputIndex,
1299: );
1300: }
1301:
1302: function validateCodexOutputItem(
1303: event: "response.output_item.added" | "response.output_item.done",
1304: item: unknown,
1305: ): asserts item is Record<string, unknown> ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
7750: return;
7751: }
7752: try {
7753: withTenant(recallContext?.sessionState.storageTenantId ?? "", () =>
7754: withSavepoint("native_recall_delivery", recallPersistence.commit),
7755: );
7756: } catch (error) {
7757: recallPersistence.rollback();
7758: throw error;
7759: }
7760: },
7761: streamSignal,
7762: recallPersistence.rollback,
7763: );
7764: }
7765:
7766: /**
7767: * True-streaming, recall-aware variant of `streamResponsesPassthrough` for the
7768: * OpenAI Responses API (codex/ChatGPT) — used when the request carries the
7769: * gateway-injected `recall` tool but the client speaks the Responses API. ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
8650: syntheticIdentities.has(finalCallId))
8651: ) {
8652: throw new Error("duplicate Responses item identity");
8653: }
8654: finalFunctionIdentity = { callId: finalCallId, name: finalName };
8655: }
8656: const declaredType = declared?.type;
8657: const itemId = parsed.item_id;
8658: if (
8659: event !== "response.output_item.done" &&
8660: (typeof itemId !== "string" || itemId !== declared?.id)
8661: ) {
8662: throw new Error(
8663: `Responses ${event} changed item_id for index ${outputIndex}`,
8664: );
8665: }
8666: if (
8667: (event.startsWith("response.output_text") ||
8668: event.startsWith("response.content_part") ||
8669: event.startsWith("response.reasoning_text") ||
8670: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
9650: ) {
9651: throw new Error("invalid Responses output item reference");
9652: }
9653: if (
9654: references.has(outputIndex) ||
9655: acc.rawItems.has(outputIndex) ||
9656: syntheticIdentities.has(item.id) ||
9657: outputIdentities.has(item.id) ||
9658: referenceIdentities.has(item.id)
9659: ) {
9660: throw new Error("duplicate Responses item reference");
9661: }
9662: references.set(outputIndex, { id: item.id, done: false });
9663: referenceIdentities.add(item.id);
9664: return true;
9665: }
9666: if (!Number.isSafeInteger(rawIndex)) return false;
9667: const outputIndex = rawIndex as number;
9668: const reference = references.get(outputIndex);
9669: if (!reference) return false;
9670: if (
9671: event !== ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
10450: // Suppress all events belonging to a recall item, but still count
10451: // them so malformed argument streams cannot grow without bound.
10452: if (
10453: (isRecallEvent || isUnresolvedToolEvent) &&
10454: outputIndex !== undefined
10455: ) {
10456: const hiddenChunk = encoder.encode(
10457: formatResponsesEvent(event, data),
10458: );
10459: const hiddenBytes = hiddenChunk.byteLength;
10460: deferredBytes += hiddenBytes;
10461: if (isRecallEvent) {
10462: hiddenRecallBytes += hiddenBytes;
10463: } else {
10464: unresolvedToolBytes.set(
10465: outputIndex,
10466: (unresolvedToolBytes.get(outputIndex) ?? ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
11350: continuationFollowUpInput.finalRecallRound &&
11351: contPending.length === 0 &&
11352: !isUsableRecallContinuation(
11353: finalizeResponsesAcc(contState),
11354: )
11355: ) {
11356: throw new RecallContinuationFailure(
11357: "follow_up_missing_output",
11358: );
11359: }
11360: if (contRecallIndices.size !== contPending.length) {
11361: throw new RecallContinuationFailure(
11362: "follow_up_incomplete_arguments",
11363: );
11364: }
11365: if (contPending.length > 1) {
11366: ...
Found 100 matches (more matches available)
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 7: * until the entire (slow, reasoning-heavy) upstream completes, so opencode's
Line 127: const sparseVisibleFunctionCall = (
Line 130: itemId = `fc_sparse_${outputIndex}`,
Line 131: callId = `call_sparse_${outputIndex}`,
Line 232: const reasoningSummaryEvents = (
Line 241: sseEvent("response.reasoning_summary_part.added", {
Line 247: sseEvent("response.reasoning_summary_text.delta", {
Line 253: sseEvent("response.reasoning_summary_text.done", {
Line 259: sseEvent("response.reasoning_summary_part.done", {
Line 268: const reasoningSummaryParts = (summaries: readonly string[]) =>
Line 404: textItem(0, "omitted from terminal", "msg_omitted"),
Line 1043: sparseVisibleFunctionCall(0, '{"path":"README.md"}'),
Line 2107: test("accepts ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/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, vi } from "vitest";
15: import { streamResponsesRecallAware } from "../src/pipeline";
16: import {
17: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
2020: model: "gpt-5.6-terra",
2021: status: "completed",
2022: output: [terminalItem],
2023: },
2024: }),
2025: ]),
2026: {
2027: onComplete: (response) => {
2028: completedResponse = response;
2029: },
2030: onRecall: async () => ({ anchorText: "", resultText: "" }),
2031: runFollowUp: async () => {
2032: throw new Error("should not run");
2033: },
2034: },
2035: );
2036:
2037: expect(await drain(client)).toContain("response.failed");
2038: expect(completedResponse?.rawOutputItems).toEqual([item]);
2039: });
2040:
2041: test("never forwards response-side item_reference lifecycle events", async () => {
2042: let completedResponse: GatewayResponse | undefined;
2043: const client = ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
3220: expect(completedResponse?.rawOutputItems?.[0]?.content).toEqual(
3221: item.content,
3222: );
3223: });
3224:
3225: test("rejects an oversized output_item.added reasoning summary before seeding lifecycle state", async () => {
3226: const summary = reasoningSummaryParts(
3227: Array.from(
3228: { length: 17 },
3229: (_, index) => `oversized added summary ${index}`,
3230: ),
3231: );
3232: const client = streamResponsesRecallAware(
3233: streamFrom([
3234: created("resp_oversized_added_summary", "gpt-5.6-terra"),
3235: sseEvent("response.output_item.added", {
3236: output_index: 0,
3237: item: {
3238: type: "reasoning",
3239: id: "rs_oversized_added_summary",
3240: summary,
3241: ...
Found 46 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 6: * the buffered `accumulateResponsesSSEStream` path withholds ALL client bytes
Line 584: test("rejects repeated call IDs before recall execution", async () => {
Line 743: test("bounds retained output before recall detection", async () => {
Line 2426: test("rejects a terminal-only principal reasoning summary before recall execution", async () => {
Line 2493: test("rejects a terminal-only continuation reasoning summary before nested recall execution", async () => {
Line 2780: test("rejects a continuation coordinate at the sparse ceiling before nested recall", async () => {
Line 2785: const nestedQuery = "private ceiling nested recall";
Line 2789: created("resp_sparse_ceiling_continuation", "gpt-5.6-terra"),
Line 2793: "fc_ceiling_nested",
Line 2794: "call_ceiling_nested",
Line ...
Found 18 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 2884: { type: "reasoning_text", text: "tracked content", private: marker },
Line 3027: content: [{ type: "reasoning_text", text: "tracked content" }],
Line 3038: type: "reasoning_text",
Line 3060: content: [{ type: "reasoning_text", text: marker }],
Line 3079: { type: "reasoning_text", text: "before gap" },
Line 3081: { type: "reasoning_text", text: marker },
Line 3101: type: "reasoning_text",
Line 5633: created("resp_reasoning_text", "gpt-5.6-terra"),
Line 5642: part: { type: "reasoning_text", text: "pre" },
Line 5644: sseEvent("response.reasoning_text.delta", {
Line 5650: sseEvent("response.reasoning_text.done", {
Line 5660: part: { type: "reasoning_text", text: "prefix" },
Line ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
5480: item: {
5481: type: "message",
5482: id: "msg_part_prefix",
5483: role: "assistant",
5484: content: [{ type: "output_text", text: "prefix" }],
5485: },
5486: }),
5487: completed("resp_part_prefix"),
5488: ]),
5489: {
5490: onComplete: () => {},
5491: onRecall: async () => ({ anchorText: "", resultText: "" }),
5492: runFollowUp: async () => {
5493: throw new Error("should not run");
5494: },
5495: },
5496: );
5497:
5498: expect(await drain(client)).not.toContain("response.failed");
5499: });
5500:
5501: test.each([
5502: {
5503: name: "part completion changing initial content",
5504: events:
5505: sseEvent("response.content_part.added", {
5506: ...
Found 12 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts: Line 759: maxRetainedStateBytes: 1, Line 3909: maxRetainedStateBytes: 64 * 1024, Line 7350: maxRetainedStateBytes: 8 * 1024 * 1024, Line 7384: maxRetainedStateBytes: 1024 * 1024, Line 7429: maxRetainedStateBytes: 1024 * 1024, Line 7482: maxRetainedStateBytes: 800 * 1024, Line 7548: const maxRetainedStateBytes = Line 7560: maxRetainedStateBytes, Line 7614: maxRetainedStateBytes: 8 * 1024 * 1024, Line 7645: maxRetainedStateBytes: 32 * 1024, Line 7676: maxRetainedStateBytes: 48 * 1024, Line 7819: maxRetainedStateBytes: retainedPrincipalBytes + 1,
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
700: runFollowUp: async () => {
701: throw new Error("should fail before follow-up");
702: },
703: },
704: );
705:
706: expect(await drain(client)).toContain(PUBLIC_RECALL_ERROR);
707: });
708:
709: test("bounds suppressed recall argument events", async () => {
710: const added = sseEvent("response.output_item.added", {
711: output_index: 0,
712: item: {
713: type: "function_call",
714: id: "fc_args",
715: call_id: "call_args",
716: name: "recall",
717: },
718: });
719: const client = streamResponsesRecallAware(
720: streamFrom([
721: created("resp_args", "gpt-5.6-terra"),
722: added,
723: sseEvent("response.function_call_arguments.done", {
724: output_index: 0,
725: item_id: ...
fix(responses): bound Codex reasoning state
Commit ID: b588d81bfd33e0b30e5040c694c893b3a116e363
Change ID: wlpsntppxyyxpvwnnywkpvkskzvtktvp
Author : Burak Yigit Kaya <ben@byk.im> (2026-09-16 20:08:38)
Committer: Burak Yigit Kaya <ben@byk.im> (2026-09-16 21:11:43)
fix(responses): bound Codex reasoning state
packages/gateway/src/pipeline.ts | 385 +++++++-------
...est/openai-responses-recall-aware-stream.test.ts | 599 ++++++++++++++++++++++
2 files changed, 812 insertions(+), 172 deletions(-)
wlpsntppxyyx b588d81bfd33 fix(responses): bound Codex reasoning state
rtwyxzrrqnqs b9feb17a1feb fix(responses): reject untracked Codex reasoning
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
7300: );
7301: const second = streamFrom([
7302: created("resp_bytes_second", "gpt-5.6-terra"),
7303: secondRecall,
7304: completed("resp_bytes_second"),
7305: ]);
7306: const oneRecallBytes = new TextEncoder().encode(firstRecall).byteLength;
7307: let recalls = 0;
7308: const client = streamResponsesRecallAware(
7309: streamFrom([
7310: created("resp_bytes_first", "gpt-5.6-terra"),
7311: firstRecall,
7312: completed("resp_bytes_first"),
7313: ]),
7314: {
7315: maxDeferredBytes: 1024 * 1024,
7316: maxHiddenRecallBytes: oneRecallBytes + 32,
7317: onComplete: () => {},
7318: onRecall: async ({ query }) => {
7319: recalls++;
7320: return {
7321: anchorText: buildAnchor(query),
7322: ...
Found 3 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/anthropic.ts: Line 58: export const DEFAULT_MAX_SSE_FRAMES = 100_000; Line 175: const maxFrames = opts.maxFrames ?? DEFAULT_MAX_SSE_FRAMES; Line 1993: ? (opts.maxFrames ?? DEFAULT_MAX_SSE_FRAMES)
Found 2 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts:
Line 7794: export function streamResponsesRecallAware(
Line 18788: streamResponsesRecallAware(upstreamResponse, {
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/pipeline.ts</path>
<type>file</type>
<content>
18690: suppressTemporalStorage,
18691: endGenAiSpan,
18692: );
18693: if (!persisted) throw postResponseFailed;
18694: recallPersistenceTransaction?.commit();
18695: }),
18696: );
18697: recallPersistenceTransaction = undefined;
18698: } catch (error) {
18699: rollbackRecallPersistence();
18700: if (error !== postResponseFailed) throw error;
18701: }
18702: } catch (error) {
18703: rollbackRecallPersistence();
18704: throw error;
18705: }
18706: },
18707: dropStreamingFinalizer,
18708: true,
18709: requestCredentialFingerprint(req.rawHeaders, config) ?? ...
diff --git a/packages/gateway/src/pipeline.ts b/packages/gateway/src/pipeline.ts
index 60b7e2621b..55dc6a98c4 100644
--- a/packages/gateway/src/pipeline.ts
+++ b/packages/gateway/src/pipeline.ts
@@ -7970,6 +7970,58 @@
}
return value;
};
+ const assertExactReasoningPart: (
+ rawPart: unknown,
+ kind: "summary_text" | "reasoning_text",
+ description: string,
+ ) => asserts rawPart is {
+ type: "summary_text" | "reasoning_text";
+ text: string;
+ } = (rawPart, kind, description) => {
+ if (!rawPart || typeof rawPart !== "object" || Array.isArray(rawPart)) {
+ throw new Error(`invalid Responses ${description} item`);
+ }
+ const part = rawPart as Record<string, unknown>;
+ const keys = Object.keys(part);
+ if (
+ keys.length !== 2 ||
+ !Object.hasOwn(part, "type") ||
+ !Object.hasOwn(part, "text") ||
+ part.type !== kind ||
+ typeof part.text !== "string"
+ ) {
+ throw new Error(`invalid Responses ...
Found 27 matches
/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts:
Line 3382: "preserves a completed %s reasoning summary when the terminal omits the whole item",
Line 3384: const summary = "whole-item omitted summary";
Line 3408: recallCall(0, { query: "whole item omitted summary" }),
Line 3667: encrypted_content: "provisional-ciphertext",
Line 3676: encrypted_content: "completed-ciphertext",
Line 3688: continuationCiphertext = acc.rawOutputItems?.[0]?.encrypted_content;
Line 3703: encrypted_content: "completed-ciphertext",
Line 3726: encrypted_content: "ciphertext-D",
Line 3756: encrypted_content: "ciphertext-B",
Line 3780: )?.encrypted_content,
Line 3809: typeof item.encrypted_content === "string",
Line 3811: .map((item) => item.encrypted_content),
Line 4598: ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/test/openai-responses-recall-aware-stream.test.ts</path>
<type>file</type>
<content>
4500: recallCalls++;
4501: return { anchorText: "", resultText: "" };
4502: },
4503: runFollowUp: async () => {
4504: throw new Error("should not run");
4505: },
4506: },
4507: );
4508:
4509: const output = await drain(client);
4510: const completedJSON = JSON.stringify(completedResponse);
4511: expect(output).toContain(PUBLIC_GATEWAY_ERROR);
4512: expect(output).not.toContain(PUBLIC_RECALL_ERROR);
4513: expect(output).not.toContain("private omitted query");
4514: expect(output).not.toContain("fc_terminal_sparse_omitted");
4515: expect(completedJSON).not.toContain("private omitted query");
4516: expect(completedJSON).not.toContain("fc_terminal_sparse_omitted");
4517: expect(recallCalls).toBe(0);
4518: });
4519:
4520: test("rejects ...
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
1180: }
1181: return null;
1182: }
1183:
1184: function responsesEventHasSemanticContent(
1185: event: string,
1186: parsed: Record<string, unknown>,
1187: ): boolean {
1188: if (
1189: event === "response.output_item.added" ||
1190: event === "response.output_item.done"
1191: ) {
1192: const item = isRecord(parsed.item) ? parsed.item : undefined;
1193: if (item?.type === "function_call") return true;
1194: if (item?.type === "message" && Array.isArray(item.content)) {
1195: return item.content.some(
1196: (part) =>
1197: isRecord(part) &&
1198: ((typeof part.text === "string" && part.text.length > 0) ||
1199: (typeof part.refusal === "string" && part.refusal.length > 0)),
1200: );
1201: }
1202: }
1203: if (
1204: event === "response.output_text.delta" ...
Found 2 matches /home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts: Line 349: export function responsesDoneItemMatchesAdded( Line 401: export function responsesTerminalItemMatches(
<path>/home/byk/Code/opencode-lore-codex-reasoning/packages/gateway/src/stream/openai-responses.ts</path>
<type>file</type>
<content>
300: sparseValueExtends(actual[field], value),
301: );
302: }
303: return isDeepStrictEqual(actual, established);
304: }
305:
306: function sparseTextPartsExtend(actual: unknown, established: unknown): boolean {
307: if (!Array.isArray(established)) return established === undefined;
308: if (!Array.isArray(actual) || actual.length < established.length)
309: return false;
310: return established.every((rawPart, index) => {
311: const actualPart = actual[index];
312: if (!isRecord(rawPart) || !isRecord(actualPart)) return false;
313: return Object.entries(rawPart).every(([field, value]) => {
314: if (
315: (field === "text" || field === "refusal") &&
316: typeof value === "string"
317: ) {
318: return (
319: typeof actualPart[field] === "string" &&
320: ...
No files found
Date: Sep 16, 2026 * 🟡 (22:45) User provided a TypeScript file excerpt spanning lines 8669–9630 that validates and reconciles streamed Responses API lifecycle events, including `response.reasoning_text`, `response.output_text`, `response.content_part.added`, `response.failed`, and terminal response data. * 🟡 (22:45) The supplied code tracks per-output lifecycle state via `lifecyclesFor(acc).get…
Date: Sep 16, 2026 * 🔴 (22:43) User stated source coverage is private and is never emitted to the client.
Date: Sep 16, 2026 * 🔴 (22:41) User stated sparse numeric identities never need more address space than the number of frames the accumulator is willing to process. * 🔴 (22:41) User stated the caller-supplied frame override must be capped at the production ceiling so arithmetic remains practical and `index + 1` always changes the value. * 🟡 (22:41) In `packages/gateway/src/stream/openai-respons…
Date: Sep 16, 2026 * 🟡 (22:37) `packages/gateway/src/stream/openai-responses.ts` documents the OpenAI Responses API SSE lifecycle as `response.created` → `response.in_progress` → `response.output_item.added` → repeated `response.output_text.delta` → `response.output_item.done` → `response.function_call_arguments.delta` → `response.function_call_arguments.done` → `response.completed`; it reuses `…
Date: Sep 16, 2026 * 🟡 (22:35) Additional test diff context covered reasoning-output validation cases named `"done content extra fields"`, strict reasoning streams, malformed summaries, sparse content, and oversized `response.output_item.added` reasoning summaries. * 🟡 (22:35) Test fixtures exercised reasoning content including `{ type: "reasoning_text", text: marker }`, arrays created with `Ar…
Date: Sep 16, 2026 * 🟡 (22:35) User supplied additional read-only diff context for the resumed correctness review, covering `packages/gateway/src/pipeline.ts` and related tests. * 🟡 (22:35) The `packages/gateway/src/pipeline.ts` context included Responses lifecycle validation and errors: `invalid Responses output_index for ${event}`, `"Responses output message must have assistant role"`, `missi…
Date: Sep 16, 2026 * 🔴 (22:34) User stated the server restarted. * 🔴 [requested-review] (22:34) User requested resuming the same immutable Codex correctness review with prior state preserved and completing a substantive, evidence-based review. * 🔴 (22:34) User required the resumed review to conclude with an exact `MERGE` or `DO-NOT-MERGE` verdict. * 🔴 (22:34) User permitted local lore recall/…
Date: Sep 16, 2026 * 🔴 [requested-review] (22:19) User requested an independent, read-only adversarial correctness review of immutable candidate `/home/byk/Code/opencode-lore-codex-reasoning`, stable change `wlpsntppxyyxpvwnnywkpvkskzvtktvp`, commit `b588d81bfd33e0b30e5040c694c893b3a116e363`, parent change/commit `rtwyxzrr` / `b9feb17a1feb58a72a080cca0e493130427c506f`, and expected child diff SH…