🤖 Remove OpenAI reasoning workarounds - use previousResponseId properly (#300)

## Summary

Removes all OpenAI-specific workarounds for reasoning + web_search bugs
by properly using `previousResponseId` for conversation state
management.

## Problem

The codebase had 266 lines of workarounds to handle OpenAI itemId
errors:
- `openaiReasoningMiddleware.ts` - filtered reasoning parts from
messages
- `openaiReasoningFetch.ts` - intercepted HTTP requests to strip itemIds
- Both files implemented complex logic to work around state management
issues

The original itemId errors occurred because we were **filtering
reasoning parts** while still sending `previousResponseId`, causing
OpenAI to reference missing items.

## Solution

**Use OpenAI's Responses API as designed**: Send `previousResponseId`
WITHOUT filtering anything. OpenAI manages reasoning state internally.

### Changes

- ✅ Enable `previousResponseId` in providerOptions (was disabled)
- ✅ Delete `openaiReasoningMiddleware.ts` (128 lines)
- ✅ Delete `openaiReasoningFetch.ts` (138 lines)  
- ✅ Remove middleware wrappers from providerFactory and aiService
- ✅ **Keep reasoning parts in transformModelMessages** - OpenAI needs
them for `previousResponseId` to work
- ✅ Simplify OpenAI provider initialization
- ✅ Update tests to expect reasoning parts preserved

### Root Cause

The bug was **always fixable** with proper use of `previousResponseId`.
The fix works with both:
- Old SDK versions (ai@5.0.56, @ai-sdk/openai@2.0.40) ✅ tested
- New SDK versions (ai@5.0.72, @ai-sdk/openai@2.0.52) ✅ tested

The workarounds were unnecessary - we just needed to use the API
correctly.

### Key Insight (Credit: Codex)

Codex correctly identified that `transformModelMessages` was still
stripping reasoning parts, which would defeat the purpose of using
`previousResponseId`. The complete fix required:
- Enabling `previousResponseId` in provider options
- Keeping reasoning parts in messages sent to OpenAI
- Removing all workaround code

## Testing

```bash
TEST_INTEGRATION=1 bun x jest tests/ipcMain/openai-web-search.test.ts
```

- ✅ Test passes consistently in ~50-90 seconds
- ✅ No itemId errors  
- ✅ Reasoning + web_search works correctly
- ✅ All type checks pass
- ✅ Tested with both old and new SDK versions

## Impact

- **-266 lines** of workaround code deleted
- **-59 lines** total net change
- **0 lines** of new complexity added
- Zero jank 🎉

_Generated with `cmux`_

Author: ammar-agent

src/services/aiService.ts

@@ -2,7 +2,7 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
 import { EventEmitter } from "events";
-import { convertToModelMessages, wrapLanguageModel, type LanguageModel } from "ai";
+import { convertToModelMessages, type LanguageModel } from "ai";
 import { applyToolOutputRedaction } from "@/utils/messages/applyToolOutputRedaction";
 import type { Result } from "@/types/result";
 import { Ok, Err } from "@/types/result";
@@ -38,8 +38,6 @@ import type {
   StreamStartEvent,
 } from "@/types/stream";
 import { applyToolPolicy, type ToolPolicy } from "@/utils/tools/toolPolicy";
-import { openaiReasoningFixMiddleware } from "@/utils/ai/openaiReasoningMiddleware";
-import { createOpenAIReasoningFetch } from "@/utils/ai/openaiReasoningFetch";
 import { MockScenarioPlayer } from "./mock/mockScenarioPlayer";
 import { Agent } from "undici";
 
@@ -283,13 +281,11 @@ export class AIService extends EventEmitter {
             provider: providerName,
           });
         }
-        // Create custom fetch that strips itemIds to fix reasoning + web_search bugs
-        // Wraps user's custom fetch if provided, otherwise wraps default fetch
+        // Use custom fetch if provided, otherwise default with unlimited timeout
         const baseFetch =
           typeof providerConfig.fetch === "function"
             ? (providerConfig.fetch as typeof fetch)
             : defaultFetchWithUnlimitedTimeout;
-        const fetchWithReasoningFix = createOpenAIReasoningFetch(baseFetch);
 
         // Wrap fetch to force truncation: "auto" for OpenAI Responses API calls.
         // This is a temporary override until @ai-sdk/openai supports passing
@@ -342,26 +338,23 @@ export class AIService extends EventEmitter {
                   }
                   const newBody = JSON.stringify(json);
                   const newInit: RequestInit = { ...init, headers, body: newBody };
-                  return fetchWithReasoningFix(input, newInit);
+                  return baseFetch(input, newInit);
                 } catch {
                   // If body isn't JSON, fall through to normal fetch
-                  return fetchWithReasoningFix(input, init);
+                  return baseFetch(input, init);
                 }
               }
 
               // Default passthrough
-              return fetchWithReasoningFix(input, init);
+              return baseFetch(input, init);
             } catch {
               // On any unexpected error, fall back to original fetch
-              return fetchWithReasoningFix(input, init);
+              return baseFetch(input, init);
             }
           },
-          "preconnect" in fetchWithReasoningFix &&
-            typeof (fetchWithReasoningFix as typeof fetch).preconnect === "function"
+          "preconnect" in baseFetch && typeof baseFetch.preconnect === "function"
             ? {
-                preconnect: (fetchWithReasoningFix as typeof fetch).preconnect.bind(
-                  fetchWithReasoningFix
-                ),
+                preconnect: baseFetch.preconnect.bind(baseFetch),
               }
             : {}
         );
@@ -370,19 +363,13 @@ export class AIService extends EventEmitter {
         const { createOpenAI } = await import("@ai-sdk/openai");
         const provider = createOpenAI({
           ...providerConfig,
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
           fetch: fetchWithOpenAITruncation as any,
         });
         // Use Responses API for persistence and built-in tools
-        const baseModel = provider.responses(modelId);
-
-        // Wrap with middleware to strip stale OpenAI reasoning item IDs
-        const wrappedModel = wrapLanguageModel({
-          model: baseModel,
-          middleware: openaiReasoningFixMiddleware,
-        });
-
-        return Ok(wrappedModel);
+        // OpenAI manages reasoning state via previousResponseId - no middleware needed
+        const model = provider.responses(modelId);
+        return Ok(model);
       }
 
       return Err({
@@ -462,11 +449,10 @@ export class AIService extends EventEmitter {
       log.debug(`Filtered ${messages.length - filteredMessages.length} empty assistant messages`);
       log.debug_obj(`${workspaceId}/1a_filtered_messages.json`, filteredMessages);
 
-      // OpenAI-specific: DON'T strip reasoning - keep all content
-      // The custom fetch wrapper strips item_reference objects to prevent dangling references
+      // OpenAI-specific: Keep reasoning parts in history
       // OpenAI manages conversation state via previousResponseId
       if (providerName === "openai") {
-        log.debug("Keeping reasoning parts for OpenAI (fetch wrapper handles item_references)");
+        log.debug("Keeping reasoning parts for OpenAI (managed via previousResponseId)");
       }
 
       // Add [CONTINUE] sentinel to partial messages (for model context)