Merge remote-tracking branch 'origin/v2' into responses-item-replay

packages/ai/src/protocols/open-responses.ts

@@ -70,10 +70,14 @@ const OpenResponsesReasoningItem = Schema.Struct({
   encrypted_content: optionalNull(Schema.String),
 })
 
-const OpenResponsesItemReference = Schema.Struct({
-  type: Schema.tag("item_reference"),
-  id: Schema.String,
-})
+export const ProviderItem = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.String,
+    id: Schema.String,
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
+type OpenResponsesProviderItem = Schema.Schema.Type<typeof ProviderItem>
 
 // `function_call_output.output` accepts either a plain string or an ordered
 // array of content items so tools can return images and files in addition to text.
@@ -91,29 +95,42 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
 
 export const InputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
-  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
+    type: Schema.optionalKey(Schema.tag("message")),
+    id: Schema.optionalKey(Schema.String),
+    role: Schema.tag("user"),
+    content: Schema.Array(OpenResponsesInputContent),
+    status: Schema.optionalKey(Schema.Literals(["in_progress", "completed", "incomplete"])),
+  }),
+  Schema.Struct({
+    type: Schema.optionalKey(Schema.tag("message")),
+    id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(OpenResponsesOutputText),
+    status: Schema.optionalKey(Schema.Literals(["in_progress", "completed", "incomplete"])),
     phase: Schema.optionalKey(MessagePhase),
   }),
   OpenResponsesReasoningItem,
-  OpenResponsesItemReference,
   Schema.Struct({
     type: Schema.tag("function_call"),
+    id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
     arguments: Schema.String,
+    status: Schema.optionalKey(Schema.Literals(["in_progress", "completed", "incomplete"])),
   }),
   Schema.Struct({
     type: Schema.tag("function_call_output"),
+    id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     output: OpenResponsesFunctionCallOutput,
+    status: Schema.optionalKey(Schema.Literals(["in_progress", "completed", "incomplete"])),
   }),
 ])
 type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
 type LoweredInputItem =
   | OpenResponsesInputItem
+  | OpenResponsesProviderItem
   | {
       readonly role: "assistant"
       readonly content: ReadonlyArray<{ readonly type: "output_text"; readonly text: string }>
@@ -128,7 +145,7 @@ type OpenResponsesReasoningInput = {
   summary: Array<{ type: "summary_text"; text: string }>
   encrypted_content?: string | null
 }
-type OpenResponsesReasoningReplay = Omit<OpenResponsesReasoningInput, "id">
+type OpenResponsesReasoningReplay = OpenResponsesReasoningInput
 
 export const Tool = Schema.Struct({
   type: Schema.tag("function"),
@@ -269,10 +286,9 @@ export interface ParserState {
   readonly messagePhase: (value: unknown) => MessagePhase | null | undefined
   readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
-  readonly store: boolean | undefined
 }
 
-type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
+type ReasoningSummaryStatus = "active" | "can-conclude"
 
 interface ReasoningStreamItem {
   readonly encryptedContent: string | null | undefined
@@ -310,34 +326,82 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
     tool: (toolName) => ({ type: "function" as const, name: toolName }),
   })
 
-const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
-  type: "function_call",
-  call_id: part.id,
-  name: part.name,
-  arguments: ProviderShared.encodeJson(part.input),
-})
+const responseItemID = (prefix: string, id: string) => {
+  const value = id.startsWith("call_") ? id.slice(5) : id
+  const sanitized = value.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") || "item"
+  const direct = `${prefix}_${sanitized}`
+  if (value === sanitized && direct.length <= 64) return direct
+  const hash = Array.from(id).reduce(
+    (hash, character) => BigInt.asUintN(64, (hash ^ BigInt(character.codePointAt(0) ?? 0)) * 1099511628211n),
+    14695981039346656037n,
+  )
+  const suffix = hash.toString(36)
+  return `${prefix}_${sanitized.slice(0, 62 - prefix.length - suffix.length)}_${suffix}`
+}
+
+const validResponseItemID = (value: unknown): value is string =>
+  typeof value === "string" && value.length <= 64 && /^[a-zA-Z0-9]+_.+$/.test(value)
+
+const responseItemMetadata = (part: { readonly providerMetadata?: ProviderMetadata }, providerMetadataKey: string) => {
+  const metadata = part.providerMetadata?.[providerMetadataKey]
+  return ProviderShared.isRecord(metadata) ? metadata : undefined
+}
+
+const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
+  const metadata = responseItemMetadata(part, providerMetadataKey)
+  return {
+    type: "function_call",
+    id: validResponseItemID(metadata?.itemId) ? metadata.itemId : responseItemID("fc", part.id),
+    call_id: part.id,
+    name: part.name,
+    arguments: ProviderShared.encodeJson(part.input),
+    status: "completed",
+  }
+}
 
 const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
   const metadata = part.providerMetadata?.[providerMetadataKey]
-  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
-    return undefined
+  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string") return undefined
   const encryptedContent =
     typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
       ? metadata.reasoningEncryptedContent
       : undefined
   return {
     type: "reasoning",
-    id: metadata.itemId,
+    id: validResponseItemID(metadata.itemId) ? metadata.itemId : responseItemID("rs", metadata.itemId),
     summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
     encrypted_content: encryptedContent,
   }
 }
 
-const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-    ? metadata.itemId
-    : undefined
+const hostedToolItem = (part: ToolResultPart, providerMetadataKey: string): OpenResponsesProviderItem | undefined => {
+  const metadata = responseItemMetadata(part, providerMetadataKey)
+  if (
+    ProviderShared.isRecord(metadata?.responseItem) &&
+    typeof metadata.responseItem.id === "string" &&
+    typeof metadata.responseItem.type === "string"
+  )
+    return {
+      ...metadata.responseItem,
+      type: metadata.responseItem.type,
+      id: validResponseItemID(metadata.responseItem.id)
+        ? metadata.responseItem.id
+        : responseItemID("item", metadata.responseItem.id),
+    }
+  if (
+    part.result.type === "json" &&
+    ProviderShared.isRecord(part.result.value) &&
+    typeof part.result.value.id === "string" &&
+    typeof part.result.value.type === "string"
+  )
+    return {
+      ...part.result.value,
+      type: part.result.value.type,
+      id: validResponseItemID(part.result.value.id)
+        ? part.result.value.id
+        : responseItemID("item", part.result.value.id),
+    }
+  return undefined
 }
 
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
@@ -400,14 +464,15 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
   const system: LoweredInputItem[] =
     request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
   const input: LoweredInputItem[] = [...system]
-  const store = OpenResponsesOptions.resolve(request).store
   const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
+  // `store` controls server persistence, not client-managed history. Replay the
+  // same stable item identities for stored and stateless requests.
   for (const message of request.messages) {
     if (message.role === "system") {
       const part = yield* ProviderShared.wrappedSystemUpdate(extension.name, message)
       const previous = input.at(-1)
-      if (previous && "role" in previous && previous.role === "user")
+      if (previous && "role" in previous && previous.role === "user" && Array.isArray(previous.content))
         input[input.length - 1] = {
           role: "user",
           content: [...previous.content, { type: "input_text", text: part.text }],
@@ -427,8 +492,8 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
     if (message.role === "assistant") {
       const content: TextPart[] = []
       const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
-      const reasoningReferences = new Set<string>()
-      const hostedToolReferences = new Set<string>()
+      const hostedToolItems = new Set<string>()
+      let textItemIndex = 0
       const flushText = () => {
         if (content.length === 0) return
         const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
@@ -443,11 +508,26 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
           [],
         )
         input.push(
-          ...groups.map((group) => ({
-            role: "assistant" as const,
-            content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
-            ...(group.phase === undefined ? {} : { phase: group.phase }),
-          })),
+          ...groups.map((group) => {
+            const index = textItemIndex++
+            const first = group.parts[0]
+            const metadata = first ? responseItemMetadata(first, providerMetadataKey) : undefined
+            const id = validResponseItemID(metadata?.itemId)
+              ? metadata.itemId
+              : message.id === undefined && typeof metadata?.itemId !== "string"
+                ? undefined
+                : index === 0 && validResponseItemID(message.id)
+                  ? message.id
+                  : responseItemID("msg", `${message.id ?? metadata?.itemId}_${index}`)
+            return {
+              type: "message" as const,
+              ...(id === undefined ? {} : { id }),
+              role: "assistant" as const,
+              content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
+              status: "completed" as const,
+              ...(group.phase === undefined ? {} : { phase: group.phase }),
+            }
+          }),
         )
         content.splice(0, content.length)
       }
@@ -460,11 +540,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
           flushText()
           const reasoning = lowerReasoning(part, providerMetadataKey)
           if (!reasoning) continue
-          if (store !== false) {
-            if (!reasoningReferences.has(reasoning.id)) input.push({ type: "item_reference", id: reasoning.id })
-            reasoningReferences.add(reasoning.id)
-            continue
-          }
           const existing = reasoningItems[reasoning.id]
           if (existing) {
             existing.summary.push(...reasoning.summary)
@@ -472,11 +547,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
               existing.encrypted_content = reasoning.encrypted_content
             continue
           }
-          const replay = {
-            type: reasoning.type,
-            summary: reasoning.summary,
-            encrypted_content: reasoning.encrypted_content,
-          }
+          const replay = { ...reasoning }
           reasoningItems[reasoning.id] = replay
           input.push(replay)
           continue
@@ -484,22 +555,21 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         if (part.type === "tool-call") {
           flushText()
           if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part))
+          input.push(lowerToolCall(part, providerMetadataKey))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
           flushText()
-          const itemID = hostedToolItemID(part, providerMetadataKey)
-          if (store !== false && itemID && !hostedToolReferences.has(itemID))
-            input.push({ type: "item_reference", id: itemID })
-          if (store === false && part.result.type === "content") {
+          const item = hostedToolItem(part, providerMetadataKey)
+          if (item && !hostedToolItems.has(item.id)) input.push(item)
+          if (!item && part.result.type === "content") {
             const content: ReadonlyArray<Content> = part.result.value
             input.push({
               role: "user",
               content: yield* Effect.forEach(content, (item) => lowerToolResultContentItem(item, request, extension)),
             })
           }
-          if (itemID) hostedToolReferences.add(itemID)
+          if (item) hostedToolItems.add(item.id)
           continue
         }
         return yield* ProviderShared.unsupportedContent(extension.name, "assistant", [
@@ -518,20 +588,15 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
         return yield* ProviderShared.unsupportedContent(extension.name, "tool", ["tool-result"])
       input.push({
         type: "function_call_output",
+        id: responseItemID("fco", part.id),
         call_id: part.id,
         output: yield* lowerToolResultOutput(part, request, extension),
+        status: "completed",
       })
     }
   }
 
-  // With store:false, Responses APIs only accept previous reasoning items when the
-  // complete item has encrypted state. Summary blocks for one item may carry
-  // that state only on the last block, so filter after they have been joined.
-  return store === false
-    ? input.filter(
-        (item) => !("type" in item) || item.type !== "reasoning" || typeof item.encrypted_content === "string",
-      )
-    : input
+  return input
 })
 
 const lowerOptions = (request: LLMRequest) => {
@@ -641,7 +706,7 @@ const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepRe
   if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
   const phase = state.messagePhases[id]
-  const metadata = phase === undefined ? undefined : providerMetadata(state, { phase })
+  const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
   const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
@@ -652,7 +717,13 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
     return onOutputTextDelta(state, { ...event, delta: event.text }, id)
   }
   const events: LLMEvent[] = []
-  return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events]
+  return [
+    {
+      ...state,
+      lifecycle: Lifecycle.textEnd(state.lifecycle, events, id, providerMetadata(state, { itemId: id })),
+    },
+    events,
+  ]
 }
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
@@ -761,23 +832,11 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
   }
 
   const events: LLMEvent[] = []
-  const closed = Object.entries(item.summaryParts)
-    .filter((entry) => entry[1] === "can-conclude")
-    .reduce(
-      (lifecycle, entry) =>
-        Lifecycle.reasoningEnd(
-          lifecycle,
-          events,
-          `${event.item_id}:${entry[0]}`,
-          providerMetadata(state, { itemId: event.item_id }),
-        ),
-      state.lifecycle,
-    )
   return [
     {
       ...state,
       lifecycle: Lifecycle.reasoningStart(
-        closed,
+        state.lifecycle,
         events,
         `${event.item_id}:${event.summary_index}`,
         providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null }),
@@ -787,11 +846,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
         [event.item_id]: {
           ...item,
           summaryParts: {
-            ...Object.fromEntries(
-              Object.entries(item.summaryParts).map((entry) =>
-                entry[1] === "can-conclude" ? [entry[0], "concluded" as const] : entry,
-              ),
-            ),
+            ...item.summaryParts,
             [event.summary_index]: "active",
           },
         },
@@ -809,22 +864,13 @@ const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResul
   return [
     {
       ...state,
-      lifecycle:
-        state.store !== false
-          ? Lifecycle.reasoningEnd(
-              state.lifecycle,
-              events,
-              `${event.item_id}:${event.summary_index}`,
-              providerMetadata(state, { itemId: event.item_id }),
-            )
-          : state.lifecycle,
       reasoningItems: {
         ...state.reasoningItems,
         [event.item_id]: {
           ...item,
           summaryParts: {
             ...item.summaryParts,
-            [event.summary_index]: state.store !== false ? "concluded" : "can-conclude",
+            [event.summary_index]: "can-conclude",
           },
         },
       },
@@ -870,7 +916,10 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           state.lifecycle,
           events,
           item.id,
-          phase === undefined ? undefined : providerMetadata(state, { phase }),
+          providerMetadata(state, {
+            itemId: item.id,
+            ...(phase === undefined ? {} : { phase }),
+          }),
         ),
         messageItems,
         messagePhases,
@@ -1037,7 +1086,6 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
   messagePhase: (value) => messagePhase(value, extension),
   messagePhases: {},
   reasoningItems: {},
-  store: OpenResponsesOptions.resolve(request).store,
 })
 
 const messagePhase = (value: unknown, extension: Extension): MessagePhase | null | undefined => {

packages/ai/src/protocols/openai-compatible-responses.ts

@@ -17,6 +17,7 @@ export const route = Route.make({
   protocol: OpenResponses.protocol,
   endpoint: Endpoint.path(OpenResponses.PATH),
   transport: OpenResponses.httpTransport,
+  defaults: { providerOptions: { openresponses: { store: false } } },
 })
 
 export * as OpenAICompatibleResponses from "./openai-compatible-responses"

packages/ai/src/protocols/openai-responses.ts

@@ -37,10 +37,14 @@ const OpenAIResponsesToolChoice = Schema.Union([
 
 const OpenAIResponsesInputItem = Schema.Union([
   Schema.Struct({
+    type: Schema.optionalKey(Schema.tag("message")),
+    id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
+    status: Schema.optionalKey(Schema.Literals(["in_progress", "completed", "incomplete"])),
     phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
   }),
+  OpenResponses.ProviderItem,
   OpenResponses.InputItem,
 ])
 
@@ -195,7 +199,8 @@ const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function*
   item: HostedToolItem,
 ) {
   const tool = HOSTED_TOOLS[item.type]
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+  const callMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+  const resultMetadata = OpenResponses.providerMetadata(state, { itemId: item.id, responseItem: item })
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   events.push(
@@ -204,14 +209,14 @@ const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function*
       name: tool.name,
       input: tool.input(item),
       providerExecuted: true,
-      providerMetadata,
+      providerMetadata: callMetadata,
     }),
     LLMEvent.toolResult({
       id: item.id,
       name: tool.name,
       result: yield* hostedToolResult(item),
       providerExecuted: true,
-      providerMetadata,
+      providerMetadata: resultMetadata,
     }),
   )
   return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult

packages/ai/src/protocols/utils/lifecycle.ts

@@ -2,11 +2,11 @@ import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage }
 
 export interface State {
   readonly stepStarted: boolean
-  readonly text: ReadonlySet<string>
-  readonly reasoning: ReadonlySet<string>
+  readonly text: ReadonlyMap<string, ProviderMetadata | undefined>
+  readonly reasoning: ReadonlyMap<string, ProviderMetadata | undefined>
 }
 
-export const initial = (): State => ({ stepStarted: false, text: new Set(), reasoning: new Set() })
+export const initial = (): State => ({ stepStarted: false, text: new Map(), reasoning: new Map() })
 
 export const stepStart = (state: State, events: LLMEvent[]): State => {
   if (state.stepStarted) return state
@@ -18,7 +18,7 @@ export const textStart = (state: State, events: LLMEvent[], id: string, provider
   if (state.text.has(id)) return state
   const stepped = stepStart(state, events)
   events.push(LLMEvent.textStart({ id, providerMetadata }))
-  return { ...stepped, text: new Set([...stepped.text, id]) }
+  return { ...stepped, text: new Map([...stepped.text, [id, providerMetadata]]) }
 }
 
 export const textDelta = (state: State, events: LLMEvent[], id: string, text: string): State => {
@@ -36,7 +36,7 @@ export const reasoningStart = (
   if (state.reasoning.has(id)) return state
   const stepped = stepStart(state, events)
   events.push(LLMEvent.reasoningStart({ id, providerMetadata }))
-  return { ...stepped, reasoning: new Set([...stepped.reasoning, id]) }
+  return { ...stepped, reasoning: new Map([...stepped.reasoning, [id, providerMetadata]]) }
 }
 
 export const reasoningDelta = (
@@ -59,8 +59,10 @@ export const reasoningEnd = (
 ): State => {
   if (!state.reasoning.has(id)) return state
   const stepped = stepStart(state, events)
-  events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
-  const reasoning = new Set(stepped.reasoning)
+  events.push(
+    LLMEvent.reasoningEnd({ id, providerMetadata: mergeMetadata(stepped.reasoning.get(id), providerMetadata) }),
+  )
+  const reasoning = new Map(stepped.reasoning)
   reasoning.delete(id)
   return { ...stepped, reasoning }
 }
@@ -68,16 +70,24 @@ export const reasoningEnd = (
 export const textEnd = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
   if (!state.text.has(id)) return state
   const stepped = stepStart(state, events)
-  events.push(LLMEvent.textEnd({ id, providerMetadata }))
-  const text = new Set(stepped.text)
+  events.push(LLMEvent.textEnd({ id, providerMetadata: mergeMetadata(stepped.text.get(id), providerMetadata) }))
+  const text = new Map(stepped.text)
   text.delete(id)
   return { ...stepped, text }
 }
 
+const mergeMetadata = (left: ProviderMetadata | undefined, right: ProviderMetadata | undefined) => {
+  if (left === undefined) return right
+  if (right === undefined) return left
+  return Object.fromEntries(
+    Array.from(new Set([...Object.keys(left), ...Object.keys(right)]), (key) => [key, { ...left[key], ...right[key] }]),
+  )
+}
+
 const closeOpenBlocks = (state: State, events: LLMEvent[]): State => {
-  for (const id of state.reasoning) events.push(LLMEvent.reasoningEnd({ id }))
-  for (const id of state.text) events.push(LLMEvent.textEnd({ id }))
-  return { ...state, text: new Set(), reasoning: new Set() }
+  for (const [id, providerMetadata] of state.reasoning) events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
+  for (const [id, providerMetadata] of state.text) events.push(LLMEvent.textEnd({ id, providerMetadata }))
+  return { ...state, text: new Map(), reasoning: new Map() }
 }
 
 export const finish = (

packages/ai/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-reasoning-continuation.json

@@ -44,7 +44,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"summary\":[],\"encrypted_content\":\"gAAAAABqEjXoGMCw3WDXpoD9151PEr2Lt8raW7KBKefQhZJGWx5f8jy152bApO6oE-Mr1BhUtfZNq3OPBVfSL4ioQ9bHREfujIBXgk9LUDBAz2Sle7KjOr9HaUV16A4HBiaFIRFjsHPS9G8yEySp1m6F1CD_WR6apyUGgugRh_y39EcOJmxPOzmiac5DVM6fraA1VpcGbqrZ1x2ANHFDOfnYTycPtPNTgzE7LjkYjDDWbT03uN1YxfP4pqjDVRzY14pA8bSZ8ys-pDv5kUFCAsw-OlU4jYKUXp-M8_6KTaRQP71LPwppt__zG_NJPfy-qUil4pOU8_NoxtxerHgLLXbfExZdzfpoGinoEjn7nj7BJDEtl-LNeNEb5c-1ZymNfVMp-Cs3fLEPkAV8rtHFtZ0MhE_07GKbGo7hTrOmkM4DydxmHsdWGNbXAG35cprslEA5P7p3GHFKnRs5hGs2eq-XcZ3yki64ZBOU_Tv6UR7nUH09gF1rdrJo3dpre6M00COwwdZ02zUP5KxCuI8FKu2jsZu9zgMVXDALsdtM5orTCVLXsn4rddWd111zE-vMjNmMMmktW2cHMjH7j1ooA-9P083koNVYiLi4UhMA64gTqgyl8MxkZekl7eFSMa7qk295NaHOKtFxzYYcZ9jdioCwSPSZ0ZZWLoNgrK7SWfRh0uaTHNcMZ3wq8ae6CguktIeVTCPTQAqJLQqd7AU0oOCKCJ7BWnC-L8UC6m7Pm9ZS958uUVeWBhgKHzMAGq9UeQB7IEeAcbMn3EDgOSfd8qCb8iwU9iG9dcu9axQwWU7pd7kd-T-He61W7z5wWgpx1KehWCxrN6kuKSo6p-uUfwVnJukreOn8BJNAzADQgz68bhmN9VGih7YcKVnLgwDwKditrjSd6-tfE0Baarj3jWENvT6ohY17R9FDrKS-2v8IIX6tGjoKJw8SRhaWLNv4vWlmxRgR0gdac3qumd0GKqsWSveNz01naA==\"},{\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":40,\"stream\":true}"
+        "body": "{\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Think briefly, then reply exactly with: Hello!\"}]},{\"type\":\"reasoning\",\"summary\":[],\"encrypted_content\":\"gAAAAABqEjXoGMCw3WDXpoD9151PEr2Lt8raW7KBKefQhZJGWx5f8jy152bApO6oE-Mr1BhUtfZNq3OPBVfSL4ioQ9bHREfujIBXgk9LUDBAz2Sle7KjOr9HaUV16A4HBiaFIRFjsHPS9G8yEySp1m6F1CD_WR6apyUGgugRh_y39EcOJmxPOzmiac5DVM6fraA1VpcGbqrZ1x2ANHFDOfnYTycPtPNTgzE7LjkYjDDWbT03uN1YxfP4pqjDVRzY14pA8bSZ8ys-pDv5kUFCAsw-OlU4jYKUXp-M8_6KTaRQP71LPwppt__zG_NJPfy-qUil4pOU8_NoxtxerHgLLXbfExZdzfpoGinoEjn7nj7BJDEtl-LNeNEb5c-1ZymNfVMp-Cs3fLEPkAV8rtHFtZ0MhE_07GKbGo7hTrOmkM4DydxmHsdWGNbXAG35cprslEA5P7p3GHFKnRs5hGs2eq-XcZ3yki64ZBOU_Tv6UR7nUH09gF1rdrJo3dpre6M00COwwdZ02zUP5KxCuI8FKu2jsZu9zgMVXDALsdtM5orTCVLXsn4rddWd111zE-vMjNmMMmktW2cHMjH7j1ooA-9P083koNVYiLi4UhMA64gTqgyl8MxkZekl7eFSMa7qk295NaHOKtFxzYYcZ9jdioCwSPSZ0ZZWLoNgrK7SWfRh0uaTHNcMZ3wq8ae6CguktIeVTCPTQAqJLQqd7AU0oOCKCJ7BWnC-L8UC6m7Pm9ZS958uUVeWBhgKHzMAGq9UeQB7IEeAcbMn3EDgOSfd8qCb8iwU9iG9dcu9axQwWU7pd7kd-T-He61W7z5wWgpx1KehWCxrN6kuKSo6p-uUfwVnJukreOn8BJNAzADQgz68bhmN9VGih7YcKVnLgwDwKditrjSd6-tfE0Baarj3jWENvT6ohY17R9FDrKS-2v8IIX6tGjoKJw8SRhaWLNv4vWlmxRgR0gdac3qumd0GKqsWSveNz01naA==\",\"id\":\"rs_0a0794dab3b8ec7d016a1235e7ce3881958a5eca32a36a14c5\"},{\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Hello!\"}],\"type\":\"message\",\"status\":\"completed\",\"id\":\"msg_0a0794dab3b8ec7d016a1235e8d64c81959a41f8db3ea7b66c\",\"phase\":\"final_answer\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Now reply exactly with: Done.\"}]}],\"store\":false,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"low\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"},\"max_output_tokens\":40,\"stream\":true}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/pdf/openai-tool-result.json

@@ -21,7 +21,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"gpt-4o-mini\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\",\"id\":\"fc_pdf_1\",\"status\":\"completed\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"data:application/pdf;base64,JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}],\"id\":\"fco_pdf_1\",\"status\":\"completed\"}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/pdf/xai-tool-result.json

@@ -21,7 +21,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\",\"mime_type\":\"application/pdf\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
+        "body": "{\"model\":\"grok-4.5\",\"input\":[{\"role\":\"system\",\"content\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"type\":\"function_call\",\"call_id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"arguments\":\"{}\",\"id\":\"fc_pdf_1\",\"status\":\"completed\"},{\"type\":\"function_call_output\",\"call_id\":\"call_pdf_1\",\"output\":[{\"type\":\"input_text\",\"text\":\"PDF read successfully\"},{\"type\":\"input_file\",\"filename\":\"verification.pdf\",\"file_data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\",\"mime_type\":\"application/pdf\"}],\"id\":\"fco_pdf_1\",\"status\":\"completed\"}],\"tools\":[{\"type\":\"function\",\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"parameters\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":40,\"temperature\":0,\"stream\":true}"
       },
       "response": {
         "status": 200,

packages/ai/test/provider/openai-compatible-responses.test.ts

@@ -51,7 +51,13 @@ describe("Open Responses-compatible route", () => {
           { role: "system", content: "You are concise." },
           { role: "user", content: [{ type: "input_text", text: "Say hello." }] },
         ],
+        store: false,
         stream: true,
+        max_output_tokens: undefined,
+        temperature: undefined,
+        tool_choice: undefined,
+        tools: undefined,
+        top_p: undefined,
       })
     }),
   )
@@ -112,6 +118,40 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
+  it.effect("keeps response item replay independent of store", () =>
+    Effect.gen(function* () {
+      const model = configure({
+        apiKey: "test-key",
+        baseURL: "https://responses.example.test/v1",
+      }).model("example-model")
+      const messages = [
+        Message.assistant({
+          type: "reasoning",
+          text: "Checked the previous diff.",
+          providerMetadata: {
+            openresponses: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
+          },
+        }),
+      ]
+      const stored = yield* compileRequest(
+        LLM.request({ model, messages, providerOptions: { openresponses: { store: true } } }),
+      )
+      const stateless = yield* compileRequest(
+        LLM.request({ model, messages, providerOptions: { openresponses: { store: false } } }),
+      )
+
+      expect(stored.body.input).toEqual(stateless.body.input)
+      expect(stored.body.input).toEqual([
+        {
+          type: "reasoning",
+          id: "rs_1",
+          summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+          encrypted_content: "encrypted-state",
+        },
+      ])
+    }),
+  )
+
   it.effect("does not interpret OpenAI hosted-tool items", () =>
     Effect.gen(function* () {
       const model = configure({

packages/ai/test/provider/openai-responses.test.ts

@@ -211,7 +211,12 @@ describe("OpenAI Responses route", () => {
             { type: "input_text", text: "<system-update>\nTreat &lt;/system-update&gt; literally.\n</system-update>" },
           ],
         },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        {
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: "After." }],
+          status: "completed",
+        },
       ])
     }),
   )
@@ -329,7 +334,7 @@ describe("OpenAI Responses route", () => {
       yield* LLMClient.generate(
         LLMRequest.update(request, {
           model: Azure.configure({
-            baseURL: "https://opencode-test.openai.azure.com/openai/v1/",
+            resourceName: "opencode-test",
             apiKey: "azure-key",
             headers: { authorization: "Bearer stale" },
           }).responses("gpt-4.1-mini"),
@@ -414,8 +419,21 @@ describe("OpenAI Responses route", () => {
         model: "gpt-4.1-mini",
         input: [
           { role: "user", content: [{ type: "input_text", text: "What is the weather?" }] },
-          { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
-          { type: "function_call_output", call_id: "call_1", output: '{"forecast":"sunny"}' },
+          {
+            type: "function_call",
+            id: "fc_1",
+            call_id: "call_1",
+            name: "lookup",
+            arguments: '{"query":"weather"}',
+            status: "completed",
+          },
+          {
+            type: "function_call_output",
+            id: "fco_1",
+            call_id: "call_1",
+            output: '{"forecast":"sunny"}',
+            status: "completed",
+          },
         ],
         store: false,
         stream: true,
@@ -864,10 +882,10 @@ describe("OpenAI Responses route", () => {
       expect(response.text).toBe("Hello!")
       expect(response.events).toEqual([
         { type: "step-start", index: 0 },
-        { type: "text-start", id: "msg_1" },
+        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         { type: "text-delta", id: "msg_1", text: "Hello" },
         { type: "text-delta", id: "msg_1", text: "!" },
-        { type: "text-end", id: "msg_1" },
+        { type: "text-end", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         {
           type: "step-finish",
           index: 0,
@@ -923,35 +941,44 @@ describe("OpenAI Responses route", () => {
         {
           type: "text",
           text: "Checking.",
-          providerMetadata: { openai: { phase: "commentary" } },
+          providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
         },
         {
           type: "text",
           text: "Finished.",
-          providerMetadata: { openai: { phase: "final_answer" } },
+          providerMetadata: { openai: { itemId: "msg_final", phase: "final_answer" } },
         },
         {
           type: "text",
           text: "Unclassified.",
-          providerMetadata: { openai: { phase: null } },
+          providerMetadata: { openai: { itemId: "msg_null", phase: null } },
         },
       ])
 
       const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
       expect(prepared.body.input).toEqual([
         {
+          type: "message",
+          id: "msg_commentary",
           role: "assistant",
           content: [{ type: "output_text", text: "Checking." }],
+          status: "completed",
           phase: "commentary",
         },
         {
+          type: "message",
+          id: "msg_final",
           role: "assistant",
           content: [{ type: "output_text", text: "Finished." }],
+          status: "completed",
           phase: "final_answer",
         },
         {
+          type: "message",
+          id: "msg_null",
           role: "assistant",
           content: [{ type: "output_text", text: "Unclassified." }],
+          status: "completed",
           phase: null,
         },
       ])
@@ -1043,12 +1070,12 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(response.events.filter((event) => event.type.startsWith("text-"))).toEqual([
-        { type: "text-start", id: "msg_1" },
+        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         { type: "text-delta", id: "msg_1", text: "First" },
-        { type: "text-end", id: "msg_1" },
-        { type: "text-start", id: "msg_2" },
+        { type: "text-end", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-start", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
         { type: "text-delta", id: "msg_2", text: "Second" },
-        { type: "text-end", id: "msg_2" },
+        { type: "text-end", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
       ])
     }),
   )
@@ -1070,7 +1097,7 @@ describe("OpenAI Responses route", () => {
         { type: "step-start", index: 0 },
         { type: "reasoning-start", id: "rs_1" },
         { type: "reasoning-delta", id: "rs_1", text: "thinking" },
-        { type: "text-start", id: "msg_1" },
+        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         { type: "text-delta", id: "msg_1", text: "Hello" },
         { type: "reasoning-end", id: "rs_1" },
         { type: "text-end", id: "msg_1" },
@@ -1080,7 +1107,7 @@ describe("OpenAI Responses route", () => {
       expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
       expect(response.message.content).toEqual([
         { type: "reasoning", text: "thinking" },
-        { type: "text", text: "Hello" },
+        { type: "text", text: "Hello", providerMetadata: { openai: { itemId: "msg_1" } } },
       ])
     }),
   )
@@ -1146,33 +1173,34 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(response.reasoning).toBe("FirstSecond")
-      expect(response.events).toMatchObject([
-        { type: "step-start", index: 0 },
+      expect(response.events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
         {
           type: "reasoning-start",
           id: "rs_1:0",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
         },
-        { type: "reasoning-delta", id: "rs_1:0", text: "First" },
-        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { openai: { itemId: "rs_1" } } },
+        { type: "reasoning-delta", id: "rs_1:0", text: "First", providerMetadata: undefined },
         {
           type: "reasoning-start",
           id: "rs_1:1",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
         },
-        { type: "reasoning-delta", id: "rs_1:1", text: "Second" },
+        { type: "reasoning-delta", id: "rs_1:1", text: "Second", providerMetadata: undefined },
+        {
+          type: "reasoning-end",
+          id: "rs_1:0",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
         {
           type: "reasoning-end",
           id: "rs_1:1",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
         },
-        { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
-        { type: "finish", reason: { normalized: "stop", raw: undefined } },
       ])
     }),
   )
 
-  it.effect("closes reasoning summary parts when storage is not disabled", () =>
+  it.effect("preserves complete reasoning metadata when storage is enabled", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(
         LLMRequest.update(request, { providerOptions: { openai: { store: true } } }),
@@ -1192,7 +1220,7 @@ describe("OpenAI Responses route", () => {
               { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 1 },
               {
                 type: "response.output_item.done",
-                item: { type: "reasoning", id: "rs_1", encrypted_content: null },
+                item: { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" },
               },
               { type: "response.completed", response: { id: "resp_1" } },
             ),
@@ -1201,8 +1229,16 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(response.events.filter((event) => event.type === "reasoning-end")).toEqual([
-        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { openai: { itemId: "rs_1" } } },
-        { type: "reasoning-end", id: "rs_1:1", providerMetadata: { openai: { itemId: "rs_1" } } },
+        {
+          type: "reasoning-end",
+          id: "rs_1:0",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
+        {
+          type: "reasoning-end",
+          id: "rs_1:1",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
       ])
     }),
   )
@@ -1250,7 +1286,7 @@ describe("OpenAI Responses route", () => {
                   { role: "user", content: [{ type: "input_text", text: "Summarize it." }] },
                 ],
               })
-              expect(body.input[1]).not.toHaveProperty("id")
+              expect(body.input[1]).toHaveProperty("id", "rs_1")
               return input.respond(
                 sseEvents(
                   { type: "response.output_text.delta", item_id: "msg_1", delta: "Parser now round-trips reasoning." },
@@ -1267,6 +1303,98 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("keeps OpenAI and Azure response item replay independent of store", () =>
+    Effect.gen(function* () {
+      const models = [
+        model,
+        Azure.configure({ resourceName: "opencode-test", apiKey: "azure-key" }).responses("gpt-4.1-mini"),
+      ]
+      const messages = [
+        Message.assistant([
+          {
+            type: "reasoning" as const,
+            text: "Checked the previous diff.",
+            providerMetadata: {
+              openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
+            },
+          },
+          ToolCallPart.make({
+            id: "call_1",
+            name: "lookup",
+            input: { query: "weather" },
+            providerMetadata: { openai: { itemId: "fc_1" } },
+          }),
+        ]),
+        Message.tool({ id: "call_1", name: "lookup", result: { forecast: "sunny" } }),
+      ]
+
+      for (const current of models) {
+        const stored = yield* compileRequest(
+          LLM.request({ model: current, messages, providerOptions: { openai: { store: true } } }),
+        )
+        const stateless = yield* compileRequest(
+          LLM.request({ model: current, messages, providerOptions: { openai: { store: false } } }),
+        )
+
+        expect(stored.body.input).toEqual(stateless.body.input)
+        expect(stored.body.input).toEqual([
+          {
+            type: "reasoning",
+            id: "rs_1",
+            summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+            encrypted_content: "encrypted-state",
+          },
+          {
+            type: "function_call",
+            id: "fc_1",
+            call_id: "call_1",
+            name: "lookup",
+            arguments: '{"query":"weather"}',
+            status: "completed",
+          },
+          {
+            type: "function_call_output",
+            id: "fco_1",
+            call_id: "call_1",
+            output: '{"forecast":"sunny"}',
+            status: "completed",
+          },
+        ])
+      }
+    }),
+  )
+
+  it.effect("replaces invalid item ids without creating collisions", () =>
+    Effect.gen(function* () {
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          messages: [
+            Message.make({
+              id: "msg_text",
+              role: "assistant",
+              content: [
+                { type: "text", text: "Ready.", providerMetadata: { openai: { itemId: "" } } },
+                {
+                  type: "reasoning",
+                  text: "Think.",
+                  providerMetadata: { openai: { itemId: "", reasoningEncryptedContent: "encrypted" } },
+                },
+                ToolCallPart.make({ id: "call_a/b", name: "one", input: {} }),
+                ToolCallPart.make({ id: "call_a?b", name: "two", input: {} }),
+              ],
+            }),
+          ],
+        }),
+      )
+      const ids = prepared.body.input.flatMap((item) => ("id" in item && typeof item.id === "string" ? [item.id] : []))
+
+      expect(ids).toHaveLength(4)
+      expect(new Set(ids).size).toBe(ids.length)
+      expect(ids.every((id) => /^[a-zA-Z0-9]+_.+$/.test(id) && id.length <= 64)).toBe(true)
+    }),
+  )
+
   it.effect("preserves assistant content order around reasoning items", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -1274,38 +1402,55 @@ describe("OpenAI Responses route", () => {
           id: "req_reasoning_order",
           model,
           messages: [
-            Message.assistant([
-              { type: "text", text: "Before." },
-              {
-                type: "reasoning",
-                text: "Checked order.",
-                providerMetadata: {
-                  openai: {
-                    itemId: "rs_1",
-                    reasoningEncryptedContent: "encrypted-state",
+            Message.make({
+              id: "msg_assistant",
+              role: "assistant",
+              content: [
+                { type: "text", text: "Before." },
+                {
+                  type: "reasoning",
+                  text: "Checked order.",
+                  providerMetadata: {
+                    openai: {
+                      itemId: "rs_1",
+                      reasoningEncryptedContent: "encrypted-state",
+                    },
                   },
                 },
-              },
-              { type: "text", text: "After." },
-            ]),
+                { type: "text", text: "After." },
+              ],
+            }),
           ],
           providerOptions: { openai: { store: false } },
         }),
       )
 
       expect(prepared.body.input).toEqual([
-        { role: "assistant", content: [{ type: "output_text", text: "Before." }] },
+        {
+          type: "message",
+          id: "msg_assistant",
+          role: "assistant",
+          content: [{ type: "output_text", text: "Before." }],
+          status: "completed",
+        },
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [{ type: "summary_text", text: "Checked order." }],
         },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        {
+          type: "message",
+          id: "msg_msg_assistant_1",
+          role: "assistant",
+          content: [{ type: "output_text", text: "After." }],
+          status: "completed",
+        },
       ])
     }),
   )
 
-  it.effect("references stored reasoning items by id", () =>
+  it.effect("replays stored reasoning items with their id", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
@@ -1323,11 +1468,18 @@ describe("OpenAI Responses route", () => {
         }),
       )
 
-      expect(prepared.body.input).toEqual([{ type: "item_reference", id: "rs_1" }])
+      expect(prepared.body.input).toEqual([
+        {
+          type: "reasoning",
+          id: "rs_1",
+          summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+          encrypted_content: undefined,
+        },
+      ])
     }),
   )
 
-  it.effect("references stored provider-executed hosted tool results by id", () =>
+  it.effect("replays stored provider-executed hosted tool results", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
@@ -1357,7 +1509,7 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(prepared.body.input).toEqual([
-        { type: "item_reference", id: "ws_1" },
+        { type: "web_search_call", id: "ws_1", status: "completed" },
         { role: "user", content: [{ type: "input_text", text: "Continue." }] },
       ])
     }),
@@ -1432,6 +1584,7 @@ describe("OpenAI Responses route", () => {
       expect(prepared.body.input).toEqual([
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [
             { type: "summary_text", text: "First" },
@@ -1442,7 +1595,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("skips non-persisted reasoning ids without encrypted state", () =>
+  it.effect("replays reasoning ids without encrypted state", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
         LLM.request({
@@ -1472,6 +1625,12 @@ describe("OpenAI Responses route", () => {
       expect(prepared.body).toMatchObject({
         input: [
           { role: "user", content: [{ type: "input_text", text: "What changed?" }] },
+          {
+            type: "reasoning",
+            id: "rs_1",
+            summary: [{ type: "summary_text", text: "Checked the previous diff." }],
+            encrypted_content: null,
+          },
           { role: "assistant", content: [{ type: "output_text", text: "The parser changed." }] },
           { role: "user", content: [{ type: "input_text", text: "Summarize it." }] },
         ],
@@ -1663,7 +1822,8 @@ describe("OpenAI Responses route", () => {
           name: "web_search",
           result: { type: "json", value: item },
           providerExecuted: true,
-          providerMetadata: { openai: { itemId: "ws_1" } },
+          output: undefined,
+          providerMetadata: { openai: { itemId: "ws_1", responseItem: item } },
         },
       ])
     }),
@@ -1754,7 +1914,8 @@ describe("OpenAI Responses route", () => {
         name: "code_interpreter",
         result: { type: "json", value: item },
         providerExecuted: true,
-        providerMetadata: { openai: { itemId: "ci_1" } },
+        output: undefined,
+        providerMetadata: { openai: { itemId: "ci_1", responseItem: item } },
       })
     }),
   )

packages/ai/test/recorded-scenarios.ts

@@ -261,7 +261,7 @@ const assistantMessageFromResponse = (response: LLMResponse, step: AssistantStep
     content.push({ type: "reasoning", text: response.reasoning, providerMetadata: reasoning.providerMetadata })
   }
 
-  if (response.text.length > 0) content.push({ type: "text", text: response.text })
+  content.push(...response.message.content.filter((part) => part.type === "text"))
   content.push(...response.toolCalls)
   return Message.assistant(content)
 }

packages/core/package.json

@@ -17,7 +17,6 @@
     "opencode": "./bin/opencode"
   },
   "exports": {
-    "./environment": "./src/environment/index.ts",
     "./session/runner": "./src/session/runner/index.ts",
     "./instructions": "./src/instructions/index.ts",
     "./*": "./src/*.ts"

packages/core/src/environment/driver.ts

@@ -1,9 +0,0 @@
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import type { FilesImpl } from "./files"
-
-export interface Driver {
-  readonly spawner: ChildProcessSpawner["Service"]
-  readonly overrides?: Partial<FilesImpl>
-}
-
-export * as EnvironmentDriver from "./driver"

packages/core/src/environment/exec-defaults.ts

@@ -1,185 +0,0 @@
-import { Effect, Stream } from "effect"
-import { ChildProcess } from "effect/unstable/process"
-import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
-import { collectStream } from "@opencode-ai/util/process"
-import { Failed, NotFound, WrongKind, type FileInfo, type FileType, type FilesImpl } from "./files"
-
-const MAX_DATA_BYTES = 64 * 1024 * 1024
-const MAX_ERROR_BYTES = 64 * 1024
-const NOT_FOUND = 44
-const WRONG_KIND = 45
-const FAILED = 46
-
-const loadMetadata = (flags = "") => `
-metadata=$(stat ${flags} -c '%F\t%s\t%Y' -- "$1" 2>&1) || {
-  case "$metadata" in
-    *'No such file or directory'*|*'Not a directory'*) exit ${NOT_FOUND} ;;
-    *) printf '%s' "$metadata" >&2; exit ${FAILED} ;;
-  esac
-}
-`
-
-const statScript = `
-${loadMetadata()}
-printf '%s\n' "$metadata"
-`
-
-const readScript = `
-${loadMetadata("-L")}
-kind=\${metadata%%	*}
-if [ "$kind" != 'regular file' ] && [ "$kind" != 'regular empty file' ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-printf '%s\n' "$metadata"
-if [ "$2" = range ]; then
-  dd if="$1" iflag=skip_bytes,count_bytes skip="$3" count="$4" status=none
-else
-  cat -- "$1"
-fi
-`
-
-const listScript = `
-${loadMetadata()}
-kind=\${metadata%%	*}
-if [ "$kind" != directory ]; then
-  printf '%s' "$kind" >&2
-  exit ${WRONG_KIND}
-fi
-find "$1" -mindepth 1 -maxdepth 1 -printf '%y\\0%f\\0'
-`
-
-interface Result {
-  readonly exitCode: number
-  readonly stdout: Uint8Array
-  readonly stderr: Uint8Array
-}
-
-export const execDefaults = (spawner: ChildProcessSpawner["Service"]): FilesImpl => {
-  const run = (
-    path: string,
-    script: string,
-    args: ReadonlyArray<string> = [],
-    stdin?: Uint8Array,
-  ): Effect.Effect<Result, Failed> =>
-    Effect.scoped(
-      Effect.gen(function* () {
-        const command = ChildProcess.make("sh", ["-c", script, "sh", path, ...args], {
-          env: { LC_ALL: "C" },
-          extendEnv: true,
-          stdin: stdin === undefined ? undefined : Stream.make(stdin),
-        })
-        const handle = yield* spawner.spawn(command).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        const [stdout, stderr, exitCode] = yield* Effect.all(
-          [
-            collectStream(handle.stdout, MAX_DATA_BYTES),
-            collectStream(handle.stderr, MAX_ERROR_BYTES),
-            handle.exitCode,
-          ],
-          { concurrency: "unbounded" },
-        ).pipe(Effect.mapError((cause) => new Failed({ path, cause })))
-        if (stdout.truncated || stderr.truncated) {
-          return yield* new Failed({ path, cause: new Error("Process output exceeded its collection limit") })
-        }
-        return { exitCode, stdout: stdout.buffer, stderr: stderr.buffer }
-      }),
-    )
-
-  const classify = <A>(
-    path: string,
-    result: Result,
-    success: (stdout: Uint8Array) => A,
-  ): Effect.Effect<A, NotFound | WrongKind | Failed> => {
-    if (result.exitCode === 0) return Effect.sync(() => success(result.stdout))
-    if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-    if (result.exitCode === WRONG_KIND) {
-      return Effect.fail(new WrongKind({ path, actual: parseType(new TextDecoder().decode(result.stderr)) }))
-    }
-    return Effect.fail(processFailure(path, result))
-  }
-
-  const stat: FilesImpl["stat"] = (path) =>
-    run(path, statScript).pipe(Effect.flatMap((result) => classifyStat(path, result)))
-
-  const complete = (path: string, result: Result) =>
-    result.exitCode === 0 ? Effect.void : Effect.fail(processFailure(path, result))
-
-  return {
-    stat,
-    read: (path, range) =>
-      run(
-        path,
-        readScript,
-        range === undefined ? ["whole"] : ["range", String(range.offset), String(range.length)],
-      ).pipe(
-        Effect.flatMap((result) =>
-          classify(path, result, (stdout) => {
-            const newline = stdout.indexOf(10)
-            if (newline < 0) throw new Error("Missing read metadata header")
-            return {
-              info: parseInfo(stdout.slice(0, newline)),
-              bytes: stdout.slice(newline + 1),
-            }
-          }),
-        ),
-      ),
-    write: (path, bytes) =>
-      run(path, `mkdir -p "$(dirname "$1")" && cat > "$1"`, [], bytes).pipe(
-        Effect.flatMap((result) => complete(path, result)),
-      ),
-    list: (path) => run(path, listScript).pipe(Effect.flatMap((result) => classify(path, result, parseList))),
-    remove: (path) => run(path, `rm -rf -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-    move: (from, to) =>
-      run(
-        from,
-        `${loadMetadata()}
-mv -- "$1" "$2"`,
-        [to],
-      ).pipe(Effect.flatMap((result) => classifyMove(from, result))),
-    mkdir: (path) => run(path, `mkdir -p -- "$1"`).pipe(Effect.flatMap((result) => complete(path, result))),
-  }
-}
-
-const classifyStat = (path: string, result: Result): Effect.Effect<FileInfo, NotFound | Failed> => {
-  if (result.exitCode === 0) return Effect.sync(() => parseInfo(result.stdout))
-  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-  return Effect.fail(processFailure(path, result))
-}
-
-const classifyMove = (path: string, result: Result): Effect.Effect<void, NotFound | Failed> => {
-  if (result.exitCode === 0) return Effect.void
-  if (result.exitCode === NOT_FOUND) return Effect.fail(new NotFound({ path }))
-  return Effect.fail(processFailure(path, result))
-}
-
-const processFailure = (path: string, result: Result) =>
-  new Failed({
-    path,
-    cause: new Error(new TextDecoder().decode(result.stderr).trim() || `Process exited with code ${result.exitCode}`),
-  })
-
-const parseInfo = (bytes: Uint8Array): FileInfo => {
-  const [rawType, rawSize, rawMtime] = new TextDecoder().decode(bytes).trim().split("\t")
-  const size = Number(rawSize)
-  const mtimeMs = Number(rawMtime) * 1_000
-  if (!rawType || !Number.isFinite(size) || !Number.isFinite(mtimeMs)) throw new Error("Invalid stat output")
-  return { type: parseType(rawType), size, mtimeMs }
-}
-
-const parseType = (value: string): FileType => {
-  if (value === "regular file" || value === "regular empty file" || value === "f") return "file"
-  if (value === "directory" || value === "d") return "directory"
-  if (value === "symbolic link" || value === "l") return "symlink"
-  return "other"
-}
-
-const parseList = (bytes: Uint8Array) => {
-  const fields = new TextDecoder().decode(bytes).split("\0")
-  fields.pop()
-  if (fields.length % 2 !== 0) throw new Error("Invalid find output")
-  return fields
-    .filter((_, index) => index % 2 === 0)
-    .map((type, index) => ({ name: fields[index * 2 + 1], type: parseType(type) }))
-}
-
-export * as EnvironmentExecDefaults from "./exec-defaults"

packages/core/src/environment/files.ts

@@ -1,53 +0,0 @@
-import { Effect, Schema } from "effect"
-
-export const FileType = Schema.Literals(["file", "directory", "symlink", "other"])
-export type FileType = typeof FileType.Type
-
-export interface FileInfo {
-  readonly type: FileType
-  readonly size: number
-  readonly mtimeMs: number
-}
-
-export interface DirEntry {
-  readonly name: string
-  readonly type: FileType
-}
-
-export class NotFound extends Schema.TaggedErrorClass<NotFound>()("Environment.NotFound", {
-  path: Schema.String,
-}) {}
-
-export class WrongKind extends Schema.TaggedErrorClass<WrongKind>()("Environment.WrongKind", {
-  path: Schema.String,
-  actual: FileType,
-}) {}
-
-export class Failed extends Schema.TaggedErrorClass<Failed>()("Environment.Failed", {
-  path: Schema.String,
-  cause: Schema.Defect(),
-}) {}
-
-export interface FilesImpl {
-  /**
-   * Reads a file, following a final symlink so `info` describes the target whose bytes are returned.
-   * The process-backed default caps collected output at 64 MiB; larger whole-file reads fail with
-   * `Failed`, so callers must use ranges for larger files.
-   */
-  readonly read: (
-    path: string,
-    range?: { readonly offset: number; readonly length: number },
-  ) => Effect.Effect<{ readonly info: FileInfo; readonly bytes: Uint8Array }, NotFound | WrongKind | Failed>
-  readonly write: (path: string, bytes: Uint8Array) => Effect.Effect<void, Failed>
-  /** Describes the path entry itself, so a final symlink is reported as `symlink` rather than followed. */
-  readonly stat: (path: string) => Effect.Effect<FileInfo, NotFound | Failed>
-  /** Lists a directory entry without following a final symlink; intermediate symlinks are traversed. */
-  readonly list: (path: string) => Effect.Effect<ReadonlyArray<DirEntry>, NotFound | WrongKind | Failed>
-  readonly remove: (path: string) => Effect.Effect<void, Failed>
-  readonly move: (from: string, to: string) => Effect.Effect<void, NotFound | Failed>
-  readonly mkdir: (path: string) => Effect.Effect<void, Failed>
-}
-
-export interface Files extends FilesImpl {}
-
-export * as EnvironmentFiles from "./files"

packages/core/src/environment/index.ts

@@ -1,24 +0,0 @@
-export * as Environment from "./index"
-
-export { type Driver } from "./driver"
-export {
-  type DirEntry,
-  Failed,
-  type FileInfo,
-  type Files,
-  type FilesImpl,
-  type FileType,
-  NotFound,
-  WrongKind,
-} from "./files"
-export { execDefaults } from "./exec-defaults"
-export { makeMemoryDriver, type MemoryDriver } from "./memory"
-
-import type { Driver } from "./driver"
-import { execDefaults } from "./exec-defaults"
-import type { Files } from "./files"
-
-export const makeFiles = (driver: Driver): Files => ({
-  ...execDefaults(driver.spawner),
-  ...driver.overrides,
-})

packages/core/src/environment/memory.ts

@@ -1,168 +0,0 @@
-import path from "node:path"
-import { Effect, PlatformError } from "effect"
-import { make } from "effect/unstable/process/ChildProcessSpawner"
-import type { Driver } from "./driver"
-import { Failed, NotFound, WrongKind, type FileInfo, type FilesImpl, type FileType } from "./files"
-
-type Node =
-  | { readonly type: "file"; readonly bytes: Uint8Array; readonly mtimeMs: number }
-  | { readonly type: "directory"; readonly mtimeMs: number }
-  | { readonly type: "symlink"; readonly target: string; readonly mtimeMs: number }
-
-export interface MemoryDriver extends Driver {
-  readonly symlink: (target: string, path: string) => Effect.Effect<void, Failed>
-}
-
-export const makeMemoryDriver = (): MemoryDriver => {
-  const nodes = new Map<string, Node>([["/", { type: "directory", mtimeMs: Date.now() }]])
-  const key = (value: string) => path.posix.resolve("/", value)
-  const info = (node: Node): FileInfo => ({
-    type: node.type,
-    size:
-      node.type === "file"
-        ? node.bytes.length
-        : node.type === "symlink"
-          ? new TextEncoder().encode(node.target).length
-          : 0,
-    mtimeMs: node.mtimeMs,
-  })
-  const resolveKey = (value: string, followFinal: boolean, seen = new Set<string>()): string | undefined => {
-    const normalized = key(value)
-    const parts = normalized.split("/").filter(Boolean)
-    const base = "/"
-    const walk = (current: string, index: number): string | undefined => {
-      if (index === parts.length) return current
-      const part = parts[index]
-      const candidate = path.posix.join(current, part)
-      const node = nodes.get(candidate)
-      if (node?.type !== "symlink" || (!followFinal && index === parts.length - 1)) return walk(candidate, index + 1)
-      if (seen.has(candidate)) return undefined
-      seen.add(candidate)
-      const target = path.posix.resolve(path.posix.dirname(candidate), node.target)
-      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen)
-    }
-    return walk(base, 0)
-  }
-  const lookup = (value: string) => nodes.get(resolveKey(value, false) ?? key(value))
-  const requireParent = (value: string) => {
-    const parentPath = path.posix.dirname(key(value))
-    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath)
-    if (!parent) throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`)
-    if (parent.type !== "directory") throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`)
-  }
-  const mkdirSync = (value: string) => {
-    const target = resolveKey(value, false) ?? key(value)
-    const existing = nodes.get(target)
-    if (existing?.type === "directory") return
-    if (existing) throw new Error(`Path is not a directory: ${value}`)
-    const parent = path.posix.dirname(target)
-    if (parent !== target) mkdirSync(parent)
-    nodes.set(target, { type: "directory", mtimeMs: Date.now() })
-  }
-  const failed = (value: string, cause: unknown) => new Failed({ path: value, cause })
-  const overrides: FilesImpl = {
-    stat: (value) => {
-      const node = lookup(value)
-      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound({ path: value }))
-    },
-    read: (value, range) => {
-      const original = lookup(value)
-      if (!original) return Effect.fail(new NotFound({ path: value }))
-      if (original.type === "directory") return Effect.fail(new WrongKind({ path: value, actual: "directory" }))
-      const resolved = resolveKey(value, true)
-      const node = resolved === undefined ? undefined : nodes.get(resolved)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "file") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length)
-      return Effect.succeed({ info: info(node), bytes: bytes.slice() })
-    },
-    write: (value, bytes) =>
-      Effect.try({
-        try: () => {
-          mkdirSync(path.posix.dirname(key(value)))
-          const existing = lookup(value)
-          if (existing?.type === "directory") throw new Error(`Path is a directory: ${value}`)
-          const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false)
-          if (!target) throw new Error(`Cannot resolve symlink: ${value}`)
-          requireParent(target)
-          nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-    list: (value) => {
-      const target = resolveKey(value, false) ?? key(value)
-      const node = nodes.get(target)
-      if (!node) return Effect.fail(new NotFound({ path: value }))
-      if (node.type !== "directory") return Effect.fail(new WrongKind({ path: value, actual: node.type }))
-      const entries = [...nodes.entries()]
-        .filter(([entry]) => entry !== target && path.posix.dirname(entry) === target)
-        .map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type satisfies FileType }))
-        .sort((a, b) => a.name.localeCompare(b.name))
-      return Effect.succeed(entries)
-    },
-    remove: (value) =>
-      Effect.sync(() => {
-        const target = resolveKey(value, false) ?? key(value)
-        for (const entry of nodes.keys()) {
-          if (entry === target || entry.startsWith(`${target}/`)) nodes.delete(entry)
-        }
-      }),
-    move: (from, to) => {
-      const source = resolveKey(from, false) ?? key(from)
-      const node = nodes.get(source)
-      if (!node) return Effect.fail(new NotFound({ path: from }))
-      return Effect.try({
-        try: () => {
-          const requested = resolveKey(to, false) ?? key(to)
-          const destination =
-            nodes.get(requested)?.type === "directory"
-              ? path.posix.join(requested, path.posix.basename(source))
-              : requested
-          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
-            throw new Error(`Cannot move a directory into itself: ${from}`)
-          }
-          const existing = nodes.get(destination)
-          if (node.type === "directory" && existing && existing.type !== "directory") {
-            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`)
-          }
-          requireParent(destination)
-          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`))
-          for (const [entry] of moved) nodes.delete(entry)
-          for (const [entry, child] of moved) nodes.set(`${destination}${entry.slice(source.length)}`, child)
-        },
-        catch: (cause) => failed(from, cause),
-      })
-    },
-    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) }),
-  }
-
-  const spawner = make((command) =>
-    Effect.suspend(() => {
-      const description = command._tag === "StandardCommand" ? command.command : "pipeline"
-      return Effect.fail(
-        PlatformError.systemError({
-          _tag: "Unknown",
-          module: "EnvironmentMemory",
-          method: "spawn",
-          pathOrDescriptor: description,
-          cause: failed(description, new Error("The memory driver cannot spawn processes")),
-        }),
-      )
-    }),
-  )
-
-  return {
-    spawner,
-    overrides,
-    symlink: (target, value) =>
-      Effect.try({
-        try: () => {
-          requireParent(value)
-          nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() })
-        },
-        catch: (cause) => failed(value, cause),
-      }),
-  }
-}
-
-export * as EnvironmentMemory from "./memory"

packages/core/test/environment.test.ts

@@ -1,39 +0,0 @@
-import fs from "node:fs/promises"
-import { Effect } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import { CrossSpawnSpawner } from "@opencode-ai/util/cross-spawn-spawner"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { execDefaults, Failed, makeFiles, makeMemoryDriver } from "../src/environment/index"
-import { tmpdir } from "./fixture/tmpdir"
-import { environmentConformance } from "./lib/environment-conformance"
-
-environmentConformance("memory environment", () =>
-  Effect.sync(() => {
-    const driver = makeMemoryDriver()
-    return {
-      files: makeFiles(driver),
-      root: `/workspace-${crypto.randomUUID()}`,
-      symlink: driver.symlink,
-    }
-  }),
-)
-
-environmentConformance(
-  "GNU exec environment",
-  () =>
-    Effect.gen(function* () {
-      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-      const tmp = yield* Effect.promise(() => tmpdir("opencode-environment-"))
-      return {
-        files: execDefaults(spawner),
-        root: tmp.path,
-        symlink: (target: string, link: string) =>
-          Effect.tryPromise({
-            try: () => fs.symlink(target, link),
-            catch: (cause) => new Failed({ path: link, cause }),
-          }),
-        dispose: Effect.promise(() => tmp[Symbol.asyncDispose]()),
-      }
-    }).pipe(Effect.provide(LayerNode.compile(CrossSpawnSpawner.node))),
-  process.platform !== "linux",
-)

packages/core/test/lib/environment-conformance.ts

@@ -1,159 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Failed, NotFound, WrongKind, type Files } from "../../src/environment/index"
-import { it } from "./effect"
-
-export interface EnvironmentHarness {
-  readonly files: Files
-  readonly root: string
-  readonly symlink?: (target: string, path: string) => Effect.Effect<void, Failed>
-  readonly dispose?: Effect.Effect<void>
-}
-
-export const environmentConformance = <E>(
-  name: string,
-  makeHarness: () => Effect.Effect<EnvironmentHarness, E>,
-  skip = false,
-) => {
-  const check = <A, E2>(title: string, body: (harness: EnvironmentHarness) => Effect.Effect<A, E2>) =>
-    it.live(title, () =>
-      Effect.gen(function* () {
-        const harness = yield* Effect.acquireRelease(makeHarness(), (harness) =>
-          Effect.gen(function* () {
-            yield* Effect.ignore(harness.files.remove(harness.root))
-            if (harness.dispose) yield* harness.dispose
-          }),
-        )
-        yield* harness.files.mkdir(harness.root)
-        return yield* body(harness)
-      }),
-    )
-
-  const bytes = (value: string) => new TextEncoder().encode(value)
-  const text = (value: Uint8Array) => new TextDecoder().decode(value)
-  const suite = skip ? describe.skip : describe
-
-  suite(name, () => {
-    check("writes, stats, and reads a file with its info", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/hello.txt`
-        yield* harness.files.write(target, bytes("hello"))
-        const result = yield* harness.files.read(target)
-        expect(text(result.bytes)).toBe("hello")
-        expect(result.info.type).toBe("file")
-        expect(result.info.size).toBe(5)
-        expect(yield* harness.files.stat(target)).toEqual(result.info)
-      }),
-    )
-
-    check("reports missing paths", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/missing`
-        expect(yield* Effect.flip(harness.files.read(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.stat(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.list(target))).toBeInstanceOf(NotFound)
-        expect(yield* Effect.flip(harness.files.move(target, `${harness.root}/other`))).toBeInstanceOf(NotFound)
-      }),
-    )
-
-    check("reports the actual kind", (harness) =>
-      Effect.gen(function* () {
-        const directory = `${harness.root}/directory`
-        const file = `${harness.root}/file`
-        yield* harness.files.mkdir(directory)
-        yield* harness.files.write(file, bytes("data"))
-        const readError = yield* Effect.flip(harness.files.read(directory))
-        const listError = yield* Effect.flip(harness.files.list(file))
-        expect(readError).toBeInstanceOf(WrongKind)
-        expect((readError as WrongKind).actual).toBe("directory")
-        expect(listError).toBeInstanceOf(WrongKind)
-        expect((listError as WrongKind).actual).toBe("file")
-      }),
-    )
-
-    check("write creates parent directories", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/one/two/file`
-        yield* harness.files.write(target, bytes("nested"))
-        yield* harness.files.write(`${harness.root}/empty`, new Uint8Array())
-        expect((yield* harness.files.stat(`${harness.root}/one/two`)).type).toBe("directory")
-        expect(yield* harness.files.stat(`${harness.root}/empty`)).toMatchObject({ type: "file", size: 0 })
-        expect(text((yield* harness.files.read(target)).bytes)).toBe("nested")
-      }),
-    )
-
-    check("reads byte ranges", (harness) =>
-      Effect.gen(function* () {
-        const target = `${harness.root}/range`
-        yield* harness.files.write(target, bytes("0123456789"))
-        expect(text((yield* harness.files.read(target, { offset: 2, length: 4 })).bytes)).toBe("2345")
-        expect(text((yield* harness.files.read(target, { offset: 8, length: 8 })).bytes)).toBe("89")
-        expect(text((yield* harness.files.read(target, { offset: 20, length: 4 })).bytes)).toBe("")
-      }),
-    )
-
-    check("lists immediate entries with their kinds", (harness) =>
-      Effect.gen(function* () {
-        yield* harness.files.write(`${harness.root}/file name`, bytes("data"))
-        yield* harness.files.mkdir(`${harness.root}/directory`)
-        yield* harness.files.write(`${harness.root}/directory/nested`, bytes("nested"))
-        const entries = yield* harness.files.list(harness.root)
-        expect(entries.toSorted((a, b) => a.name.localeCompare(b.name))).toEqual([
-          { name: "directory", type: "directory" },
-          { name: "file name", type: "file" },
-        ])
-      }),
-    )
-
-    check("reports symlinks without resolving them", (harness) =>
-      Effect.gen(function* () {
-        if (!harness.symlink) return
-        yield* harness.files.write(`${harness.root}/target`, bytes("target"))
-        yield* harness.files.write(`${harness.root}/target-dir/file`, bytes("through link"))
-        yield* harness.symlink("target", `${harness.root}/link`)
-        yield* harness.symlink("target-dir", `${harness.root}/link-dir`)
-        expect((yield* harness.files.stat(`${harness.root}/link`)).type).toBe("symlink")
-        expect(yield* harness.files.list(harness.root)).toContainEqual({ name: "link", type: "symlink" })
-        expect(text((yield* harness.files.read(`${harness.root}/link-dir/file`)).bytes)).toBe("through link")
-        const listError = yield* Effect.flip(harness.files.list(`${harness.root}/link-dir`))
-        expect(listError).toBeInstanceOf(WrongKind)
-        expect((listError as WrongKind).actual).toBe("symlink")
-      }),
-    )
-
-    check("follows symlinks when reading", (harness) =>
-      Effect.gen(function* () {
-        if (!harness.symlink) return
-        yield* harness.files.write(`${harness.root}/target`, bytes("target content"))
-        yield* harness.files.mkdir(`${harness.root}/directory`)
-        yield* harness.symlink("target", `${harness.root}/file-link`)
-        yield* harness.symlink("directory", `${harness.root}/directory-link`)
-        yield* harness.symlink("missing", `${harness.root}/dangling-link`)
-
-        const result = yield* harness.files.read(`${harness.root}/file-link`)
-        expect(text(result.bytes)).toBe("target content")
-        expect(result.info.type).toBe("file")
-        expect(result.info.size).toBe(bytes("target content").length)
-
-        const directoryError = yield* Effect.flip(harness.files.read(`${harness.root}/directory-link`))
-        expect(directoryError).toBeInstanceOf(WrongKind)
-        expect((directoryError as WrongKind).actual).toBe("directory")
-        expect(yield* Effect.flip(harness.files.read(`${harness.root}/dangling-link`))).toBeInstanceOf(NotFound)
-      }),
-    )
-
-    check("moves files and removes trees idempotently", (harness) =>
-      Effect.gen(function* () {
-        const source = `${harness.root}/source/file`
-        const destination = `${harness.root}/destination`
-        yield* harness.files.write(source, bytes("moved"))
-        yield* harness.files.move(source, destination)
-        expect(text((yield* harness.files.read(destination)).bytes)).toBe("moved")
-        expect(yield* Effect.flip(harness.files.stat(source))).toBeInstanceOf(NotFound)
-        yield* harness.files.remove(`${harness.root}/source`)
-        yield* harness.files.remove(`${harness.root}/source`)
-        expect(yield* Effect.flip(harness.files.stat(`${harness.root}/source`))).toBeInstanceOf(NotFound)
-      }),
-    )
-  })
-}