fix(llm): replay OpenAI reasoning continuation state

rekram1-node · rekram1-node · commit d91e5e2f1ea4 · 2026-05-23T11:55:37.000-05:00
diff --git a/packages/llm/src/protocols/openai-responses.ts b/packages/llm/src/protocols/openai-responses.ts
@@ -52,11 +52,16 @@ const OpenAIResponsesReasoningSummaryText = Schema.Struct({
 
 const OpenAIResponsesReasoningItem = Schema.Struct({
   type: Schema.tag("reasoning"),
-  id: Schema.String,
+  id: Schema.optional(Schema.String),
   summary: Schema.Array(OpenAIResponsesReasoningSummaryText),
   encrypted_content: optionalNull(Schema.String),
 })
 
+const OpenAIResponsesItemReference = Schema.Struct({
+  type: Schema.tag("item_reference"),
+  id: Schema.String,
+})
+
 // `function_call_output.output` accepts either a plain string or an ordered
 // array of content items so tools can return images in addition to text.
 // https://platform.openai.com/docs/api-reference/responses/object
@@ -72,6 +77,7 @@ const OpenAIResponsesInputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenAIResponsesInputContent) }),
   Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenAIResponsesOutputText) }),
   OpenAIResponsesReasoningItem,
+  OpenAIResponsesItemReference,
   Schema.Struct({
     type: Schema.tag("function_call"),
     call_id: Schema.String,
@@ -88,7 +94,7 @@ type OpenAIResponsesInputItem = Schema.Schema.Type<typeof OpenAIResponsesInputIt
 
 type OpenAIResponsesReasoningInput = {
   type: "reasoning"
-  id: string
+  id?: string
   summary: Array<{ type: "summary_text"; text: string }>
   encrypted_content?: string | null
 }
@@ -264,17 +270,20 @@ const lowerToolCall = (part: ToolCallPart): OpenAIResponsesInputItem => ({
 
 const lowerReasoning = (part: ReasoningPart): OpenAIResponsesReasoningInput | undefined => {
   const openai = part.providerMetadata?.openai
-  if (!ProviderShared.isRecord(openai) || typeof openai.itemId !== "string") return undefined
+  if (!ProviderShared.isRecord(openai)) return undefined
+  const id = typeof openai.itemId === "string" ? openai.itemId : undefined
+  const encryptedContent =
+    typeof openai.reasoningEncryptedContent === "string"
+      ? openai.reasoningEncryptedContent
+      : openai.reasoningEncryptedContent === null
+        ? null
+        : undefined
+  if (!id && typeof encryptedContent !== "string") return undefined
   return {
     type: "reasoning",
-    id: openai.itemId,
+    id,
     summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
-    encrypted_content:
-      typeof openai.reasoningEncryptedContent === "string"
-        ? openai.reasoningEncryptedContent
-        : openai.reasoningEncryptedContent === null
-          ? null
-          : undefined,
+    encrypted_content: encryptedContent,
   }
 }
 
@@ -325,6 +334,7 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
     if (message.role === "assistant") {
       const content: TextPart[] = []
       const reasoningItems: Record<string, OpenAIResponsesReasoningInput> = {}
+      const reasoningReferences = new Set<string>()
       const flushText = () => {
         if (content.length === 0) return
         input.push({ role: "assistant", content: content.map((part) => ({ type: "output_text", text: part.text })) })
@@ -339,6 +349,15 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
           flushText()
           const reasoning = lowerReasoning(part)
           if (!reasoning) continue
+          if (store !== false && reasoning.id) {
+            if (!reasoningReferences.has(reasoning.id)) input.push({ type: "item_reference", id: reasoning.id })
+            reasoningReferences.add(reasoning.id)
+            continue
+          }
+          if (!reasoning.id) {
+            input.push(reasoning)
+            continue
+          }
           const existing = reasoningItems[reasoning.id]
           if (existing) {
             existing.summary.push(...reasoning.summary)
@@ -393,13 +412,14 @@ const lowerOptions = Effect.fn("OpenAIResponses.lowerOptions")(function* (reques
     return yield* invalid(`OpenAI Responses does not support reasoning effort ${effort}`)
   const summary = OpenAIOptions.reasoningSummary(request)
   const encryptedState = OpenAIOptions.encryptedReasoning(request)
+  const includeEncryptedReasoning = encryptedState || (store === false && OpenAIOptions.isReasoningModel(request))
   const verbosity = OpenAIOptions.textVerbosity(request)
   const instructions = OpenAIOptions.instructions(request)
   return {
     ...(instructions ? { instructions } : {}),
     ...(store !== undefined ? { store } : {}),
     ...(promptCacheKey ? { prompt_cache_key: promptCacheKey } : {}),
-    ...(encryptedState ? { include: ["reasoning.encrypted_content"] as const } : {}),
+    ...(includeEncryptedReasoning ? { include: ["reasoning.encrypted_content"] as const } : {}),
     ...(effort || summary ? { reasoning: { effort, summary } } : {}),
     ...(verbosity ? { text: { verbosity } } : {}),
   }
diff --git a/packages/llm/src/protocols/utils/openai-options.ts b/packages/llm/src/protocols/utils/openai-options.ts
@@ -42,6 +42,16 @@ export const reasoningSummary = (request: LLMRequest): "auto" | undefined => {
 export const encryptedReasoning = (request: LLMRequest) =>
   options(request)?.includeEncryptedReasoning === true ? true : undefined
 
+export const isReasoningModel = (request: LLMRequest) => {
+  const id = request.model.id.toLowerCase()
+  return (
+    id.startsWith("o1") ||
+    id.startsWith("o3") ||
+    id.startsWith("o4-mini") ||
+    (id.startsWith("gpt-5") && !id.startsWith("gpt-5-chat"))
+  )
+}
+
 export const promptCacheKey = (request: LLMRequest) => {
   const value = options(request)?.promptCacheKey
   return typeof value === "string" ? value : undefined
diff --git a/packages/llm/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-image-tool-result.json b/packages/llm/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-image-tool-result.json
diff --git a/packages/llm/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-reasoning.json b/packages/llm/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-reasoning.json
@@ -18,7 +18,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Show concise reasoning when the provider supports visible reasoning summaries.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"store\":false,\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":120,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Show concise reasoning when the provider supports visible reasoning summaries.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":120,\"stream\":true}"
       },
       "response": {
         "status": 200,
diff --git a/packages/llm/test/provider/openai-responses.test.ts b/packages/llm/test/provider/openai-responses.test.ts
@@ -660,6 +660,7 @@ describe("OpenAI Responses route", () => {
             ]),
             Message.user("Summarize it."),
           ],
+          providerOptions: { openai: { store: false } },
         }),
       ).pipe(
         Effect.provide(
@@ -717,6 +718,7 @@ describe("OpenAI Responses route", () => {
               { type: "text", text: "After." },
             ]),
           ],
+          providerOptions: { openai: { store: false } },
         }),
       )
 
@@ -733,6 +735,56 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("references stored reasoning items by id", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+        LLM.request({
+          model,
+          messages: [
+            Message.assistant([
+              {
+                type: "reasoning",
+                text: "Checked the previous diff.",
+                providerMetadata: { openai: { itemId: "rs_1" } },
+              },
+            ]),
+          ],
+          providerOptions: { openai: { store: true } },
+        }),
+      )
+
+      expect(prepared.body.input).toEqual([{ type: "item_reference", id: "rs_1" }])
+    }),
+  )
+
+  it.effect("continues stateless reasoning from encrypted content without an item id", () =>
+    Effect.gen(function* () {
+      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+        LLM.request({
+          model,
+          messages: [
+            Message.assistant([
+              {
+                type: "reasoning",
+                text: "Checked the previous diff.",
+                providerMetadata: { openai: { reasoningEncryptedContent: "encrypted-state" } },
+              },
+            ]),
+          ],
+          providerOptions: { openai: { store: false } },
+        }),
+      )
+
+      expect(prepared.body.input).toEqual([
+        {
+          type: "reasoning",
+          encrypted_content: "encrypted-state",
+          summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+        },
+      ])
+    }),
+  )
+
   it.effect("joins streamed summary blocks into one continuation reasoning item", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
diff --git a/packages/opencode/test/session/llm-native.test.ts b/packages/opencode/test/session/llm-native.test.ts
@@ -89,12 +89,12 @@ const sessionOpenAIReasoning = (
   text: string,
   options: {
     readonly storedAs: "providerMetadata" | "providerOptions"
-    readonly itemId: string
+    readonly itemId?: string
     readonly encryptedContent: string | null
   },
 ) => {
   const metadata = {
-    openai: { itemId: options.itemId, reasoningEncryptedContent: options.encryptedContent },
+    openai: { ...(options.itemId ? { itemId: options.itemId } : {}), reasoningEncryptedContent: options.encryptedContent },
   }
   if (options.storedAs === "providerMetadata")
     return Object.assign({ type: "reasoning" as const, text }, { providerMetadata: metadata })
@@ -544,13 +544,26 @@ describe("session.llm-native.request", () => {
         model: "gpt-5-mini",
         instructions: "You are concise.",
         input: [openAIResponses.user("hello")],
+        include: ["reasoning.encrypted_content"],
         max_output_tokens: 512,
         store: false,
         stream: true,
       },
     }),
   )
 
+  it.effect("requests encrypted OpenAI reasoning state for stateless reasoning models", () =>
+    expectOpenAIResponsesRequest({
+      history: [storedSession.user("hello")],
+      providerOptions: { openai: { store: false, reasoningSummary: "auto" } },
+      expectedBody: {
+        input: [openAIResponses.user("hello")],
+        include: ["reasoning.encrypted_content"],
+        store: false,
+      },
+    }),
+  )
+
   it.effect("omits non-persisted OpenAI reasoning ids without encrypted state", () =>
     expectOpenAIResponsesRequest({
       history: [
@@ -572,6 +585,7 @@ describe("session.llm-native.request", () => {
           openAIResponses.assistant("The parser changed."),
           openAIResponses.user("Summarize it."),
         ],
+        include: ["reasoning.encrypted_content"],
         store: false,
       },
     }),
@@ -608,6 +622,50 @@ describe("session.llm-native.request", () => {
     }),
   )
 
+  it.effect("preserves encrypted OpenAI reasoning state without a stored item id", () =>
+    expectOpenAIResponsesRequest({
+      history: [
+        storedSession.assistant([
+          storedSession.openaiReasoning("Checked the previous diff.", {
+            storedAs: "providerMetadata",
+            encryptedContent: "encrypted-state",
+          }),
+        ]),
+      ],
+      providerOptions: { openai: { store: false } },
+      expectedBody: {
+        input: [
+          {
+            type: "reasoning",
+            encrypted_content: "encrypted-state",
+            summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+          },
+        ],
+        include: ["reasoning.encrypted_content"],
+        store: false,
+      },
+    }),
+  )
+
+  it.effect("references stored OpenAI reasoning items by id", () =>
+    expectOpenAIResponsesRequest({
+      history: [
+        storedSession.assistant([
+          storedSession.openaiReasoning("Checked the previous diff.", {
+            storedAs: "providerMetadata",
+            itemId: "rs_1",
+            encryptedContent: null,
+          }),
+        ]),
+      ],
+      providerOptions: { openai: { store: true } },
+      expectedBody: {
+        input: [{ type: "item_reference", id: "rs_1" }],
+        store: true,
+      },
+    }),
+  )
+
   it.effect("uses provider fetch override for native OpenAI OAuth requests", () =>
     Effect.gen(function* () {
       const captures: Array<{ url: string; body: unknown }> = []
