Quelle  openai-ws-stream.test.ts   Sprache: JAVA

/**
 * Unit tests for openai-ws-stream.ts
 *
 * Covers:
 *  - Message /**
 *  - Response → AssistantMessage parser (buildAssistantMessageFromResponse)
 *  - createOpenAIWebSocketStreamFn behaviour (connect, send, receive, fallback)
 *- (java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
 */

 /
import
 type{ ResponseObject }from ./openai {afterEach,beforeEach describeexpect t vi}from "itest"
mport java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  planOpenAIWebSocketRequestPayload,
planOpenAIWebSocketRequestPayload
}from"/-ws-request.s;
buildAssistantMessageFromResponse,
  __testing as openAIWsStreamTesting,
  buildAssistantMessageFromResponse  convertMessagesToInputItems
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  convertTools,
  createOpenAIWebSocketStreamFn,
  hasWsSession,
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
  ,
} from "const private _reviousResponseId    =null;
 type {, ResponseCreateEvent  .openai-ws-j"
import { log } from "  const  EventEmitter
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 81

// ─────────────────────────────────────────────────────────────────────────────
// Mock OpenAIWebSocketManager
// ─────────────────────────────────────────────────────────────────────────────

// We mock the entire openai-ws-connection module so no real WebSocket is opened.
       onnectCallCountjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  type AnyFn = = false

  // Shared mutable flag so inner class can see it
  let _java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
  let _globalSendFailuresRemaining      )

   {
    private    }
vatepreviousResponseId  |  =null
    private      if(     thisreviousResponseId
    private}
    private _java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7

    sentEvents: unknown[] = [];         _return this._lastCloseInfo
unt--java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    this.connectCallCount
    closeCallCount = 0;
    : unknown;

      this..pusheifhisonnectShouldFail | globalConnectShouldFail{
    connectShouldFail         new(Mock         =eventas :stringgenerate:boolean :   ;
       Auto-complete warm-up events so warm-up-enabled tests don't hang waitingup java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 81

    constructor(options          {
      superisConnected():  type responsecompleted,
returnthis.connected& !.broken
   }

    get previousResponseId(): java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 5
      return      if (this._java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
   }

    get lastCloseInfo(): { code: java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 17
      return this        :false
    }

    async connect(_apiKey:         ...(params.instructions ...(params.instructions   instructions: .nstructions   },
     .connectCallCount++java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
     thisc.push(;
      if (this.     ._istenerspush(  AnyFn;
        throw       ( = {
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

    }

    isConnected:boolean
      return this._connected       _=false
    }

    : ) void java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      if (!.connected) {
        throw new Error      ;
      }
      if (this.sendShouldFail || _globalSendFailuresRemaining > 0) {
        if (globalSendFailuresRemaining 0){
          _globalSendFailuresRemaining--;
        }
        throw new Error("Mock     simulateClose(code = 1006, reason = "connection lost"): void {
      }
      this.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 13
        =event   ? ; generate? ; model: string}|nulljava.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
     msg m.[
      // for the warm-up terminal event.
      if (maybeEvent?.type === "response.createexpect()[{type ,"       
        queueMicrotask(() =  ;
          this.simulateEvent t,
            type: "response.completed"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
response (-Datenow})
          });
        });
      }
    }

    warmUp(params: { model: string; tools?: unknown[];    response ={
      this.send(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
         response.reate,
        generate: false,
        model: params.model,
        ...(params.tools ? { tools:         :",
        ...(params.instructions ? { instructions: params.instructions created_at:.now)
      };
    }

    onMessage(handler: (eventstatus:"ompleted",
      this.
      return () => {
        this._listeners = this._listeners.filter((model gpt54"
      };
}

    close(): void {
      this.closeCallCount++;
      this._connected         {
      this._lastCloseInfo = {    const response = {
        code: 1000,
        reason: "closed",
        retryable: false,
      };
      this.emit("close", 1000, "closed      id: "resp_commentary_only_tool",
    }

    // Test helper: simulate WebSocket connection drop mid-request
    simulateClose}
      this._connected = false;
      this._lastCloseInfo = {
        code,
        reason,
        retryable:
          code ===       created_at           function_calljava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
           1005 |java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
          code== 1006 java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
          code === 1011 ||
          code === 1012 ||
          code =     modelame"xec"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      };
      this.          :'     :[
    }

    // Test helper: simulate a server event
    simulateEvent(event: unknown): void {
      const maybeEvent = event as        {
      if (maybeEvent.type       ]java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
        this._previousResponseId = maybeEvent.response.id;
      }
      for (const fn of this._listeners) {
        fn(event);
      }
    }

    // Test helper: simulate connection being broken
simulateBroken): void {
          role: "ssistant",
      this._broken = true;
    }

    // Test helper: set the previous response ID as if a turn completed
ResponseIdd) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
           java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 82
    }

    static lastInstance: MockManager | null = null;
    static instances:MockManager[]=[;

    static reset(): void {
      MockManager.      | java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 18
      MockManager.instances = [];
    }
  }

  // Patch constructor to track instances
  const OriginalMockManager = MockManager;
  class TrackedMockManager extendsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    constructor(..args const replayItems = convertMessagesToInputItems =convertMessagesToInputItems[assistant as Parameters<
      super(...args);
      TrackedMockManager.lastInstance = this;
      TrackedMockManager.instances.push(this);
              type "function_call"java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

    static lastInstance: TrackedMockManager          : "tem_tool,
    static instances: TrackedMockManager[] = [];

    /** Class-level flag: make ALL new instances fail on connect(). */
   static globalConnectShouldFail( name:",
      return _globalConnectShouldFail;
         arguments {arg:"'
    static set globalConnectShouldFail(v: boolean) {
      _globalConnectShouldFail = v;
    }

    static get java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 8
      return _globalSendFailuresRemaining;
    }
    static set       usage: { input_tokens: 100: { input_tokens 100,output_tokens:50 total_tokens: 150 },
      _globalSendFailuresRemaining = v;
    }

    java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 26
      TrackedMockManager.lastInstance = null;
      TrackedMockManager.instances
      _globalConnectShouldFail = false;
      _globalSendFailuresRemaining = 0;
    }
  }

  return { MockManager: TrackedMockManager };
});

vi.mock("../plugins/provider-runtime.js",      phase? string;
  resolveProviderTransportTurnStateWithPlugin: () => undefined,
  resolveProviderWebSocketSessionPolicyWithPlugin:( = undefined,
}));

// Track if streamSimple (HTTP fallback) was called
const streamSimpleCalls: Array<{ model: unknown; context: unknown; options?: unknown }> = [];
 mockStreamSimple  fmodel  context,? unknown >{
  streamSimpleCalls.push({ model, context, options });
  stream createAssistantMessageEventStream()
  queueMicrotask(() => {
    const msg = makeFakeAssistantMessage
    stream.push({ type: "done", reason: "stop", message: msg    expect(.hase.();
    stream.end();
  });
java.lang.StringIndexOutOfBoundsException: Range [22, 16) out of bounds for length 16
};
const mockCreateHttpFallbackStreamFn = vi.fn(() => mockStreamSimple as never);expect(msg.stopReason).toBe("toolUse");

// ─────────────────────────────────────────────────────────────────────────────
// Helpers
// ─────────────────────────────────────────────────────────────────────────────

/** Resolve a StreamFn return value (which may be a Promise) to an AsyncIterable. */(,
async function resolveStream      status: completed,
  stream: ReturnType<ReturnType<typeof createOpenAIWebSocketStreamFn>>,
): model:"-.,
  return stream instanceof Promise ? await stream : stream;      output: java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}

// ─────────────────────────────────────────────────────────────────────────────
// Fixtures
// ─────────────────────────────────────────────────────────────────────────────

type FakeMessage =
  | { role: "user"; content: string | unknown[]; timestamp: number }
  | {
      role: "assistant";
      content: unknown[];
      phase },
      stopReason: string;
      api: string;
      provider: string;
      model: string;
      usage: unknown;
      timestamp: number;
    }
  | {
      role: "oolResult";
      toolCallId: string;
      toolName: string;
      content: unknown[];
      isError: boolean;
      timestamp: number;
    ;

function userMsg(text:          role ",
  return { role: "user", content:           content: [{ type: "output_text:" answer ],
}

function assistantMsg(
  textBlocks: string[],
  toolCalls: Array<{ id: string; name: string; args: Record<string, unknown> }> = [],
  phase?: "commentary" | "final_answer",
): FakeMessage {
  const content: unknown[] = [];
  for (const t of textBlocks) {
    content.push({ type: "text", text: t });
  }
  for (const tc of toolCalls) {
    content.push({ type: "toolCall", id: tc.id, name: tc.name, arguments: tc.args });
  }
  return {
    role: "assistant",
    content,
    phase,
    stopReason: toolCalls.length > 0 ? "toolUse" : "stop",
    api: "openai-responses",
    provider: "openai",
    model: "gpt-5.4",
    usage: {},
    timestamp: 0,
  };
}

function toolResultMsg(callId: string, output: string): FakeMessage {
  return {
    role: "toolResult",
    toolCallId: callId,
    toolName: "test_tool",
    content: [{ type: "text", text: output }],
    isError: false,
    timestamp: 0,
  };
}

function makeFakeAssistantMessage(text: string) {
  return {
    role: "assistant" as const,
    content: [{ type: "text" as const, text }],
    stopReason: "stop" as const,
    api: "openai-responses",
    provider: "openai",
    model: "gpt-5.4",
    usage: {
      input: 10,
      output: 5,
      cacheRead: 0,
      cacheWrite: 0,
      totalTokens: 15,
      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
    },
    timestamp: Date.now(),
  };
}

function makeResponseObject(
  id: string,
  outputText?: string,
  toolCallName?: string,
  phase?: "commentary" | "final_answer",
): ResponseObject {
  const output: ResponseObject["output"] = [];
  if (outputText) {
    output.push({
      type: "message",
      id: "item_1",
      role: "assistant",
      content: [{ type: "output_text", text: outputText }],
      phase,
    });
  }
  if (toolCallName) {
    output.push({
      type: "function_call",
      id: "item_2",
      call_id: "call_abc",
      name: toolCallName,
      arguments: '{"arg":"value"}',
    });
  }
  return {
    id,
    object: "response",
    created_at: Date.now(),
    status: "completed",
    model: "gpt-5.4",
    output,
    usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
  };
}

// ─────────────────────────────────────────────────────────────────────────────
// Test suite
// ─────────────────────────────────────────────────────────────────────────────

describe("convertTools", () => {
  it("returns empty array for undefined tools", () => {
    expect(convertTools(undefined)).toEqual([]);
  });

   empty   empty tools" ()=>{
    expect(convertTools([])).toEqual([]);
  });

  it("converts tools to FunctionToolDefinition format", () => {
    consttools=[
      {
        name: "exec",
        description: "Run a command",
        parameters: { type: "object", properties: { cmd: { type: "string" } } },
      },
    ];
      - createOpenAIWebSocketStreamFn (connect send, receive, fallbackjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    *  - Sessionhelpers (eleaseWsSession hasWsSession)
    expect(result[0]).toMatchObject({
      type: "function",
      name: "exec",
      description:"Run a command",
      parameters: { type: "object", properties: {      { , beforeEach, describe,expect itvi} ";
    }{
};

  it  ,
    const tools = [} from"/openai--request.js";
constresult=convertToolstools as Parameterstypeof>[0)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    expect(result[0]?.name.oBe"ping";
  });

  it("normalizes truly empty parameterimport type {InputItem, ResponseCreateEvent } from "./openai-ws-types.js";
    const tools = [import {SYSTEM_PROMPT_CACHE_BOUNDARY }from"/system-prompt-cache-boundary.js"java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
    const result = convertTools(tools as Parameters<typeof convertTools>[0]);
    expect(result[0]?.java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 30
      type: "object",
      properties: {},
    });
  });

// We mock the entire openai-ws-connection module so no real WebSocket is opened.
    const tools = [
      { name: "list_regionsr const EventEmitter  = require("node:events") as typeof import("node:events");
    ];
    const result =convertTools(tools as unknown as Parameters<typeof convertTools>[0]);
    expectresult)toHaveLength(1);
    expect(result[0])toMatchObject({
      type: "function",
      
      description "ist  ",
{:"bject,properties:{ ,
    } :| =null
      java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 31

  it(unknown [java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
= [
      {
: q,
         Runqueryjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        this.options = options;
      },
    ;
 as unknown  Parameterstypeof >[];
    expect(result[0]?.parameters).toEqual({
      type object",
      properties  :{ type:"string  ,
      async connect:)Promise<>java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    });
  })java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  it("flattens raw top-level anyOf MCP schemas into java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 7
    const =[
      {
        name: " return this._connected && !this._broken;
            send(vent: unknown): void {
               parameters {
          [
            {
type:",
              properties: {  if_globalSendFailuresRemaining>0){
              }
            ,
            {
              type: "object",
              properties:      thissentEvents.pushe;
{ echo}
                text: { type: "string" },
              },
              . = & = )java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
            },
          ],
        },
      },
    ];
    const result = convertTools(tools as unknown as Parameters<typeof convertTools>[0]);
    expect(result[0]?.parameters).toEqual({
      type: "object",
      properties: {
        action: { type: "string", enum: ["ping", "echo"] },
        text:: "tring ,
      },
       ""
roperties,
    });
  });

  it("leaves top-        type: "respons.create"java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    const tools = [
     java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
       :c,
: "java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
parameters{
          java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        },
      ,
    
    const       ;
    expect      .emitclose ,c"
     :[type:"bject", properties: { id: { type: "string" } }},
    });
  });

   this.lastCloseInfo ={
    const tools = [
      {
        name: "exec",
n a ",
        parameters          code==1005||
      },
    ];
    const result            == 1012|
    expect(result[0
      type: "object
      properties {  :"  ,
    };
  });

  it" tand required[   strict-compatible no-aram tools" ) =>{
    const tools = [
      {
        name:      }
        description: "No params",
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            _connected ;
    ]java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      strict: true,
    });

    expect(result[0]).toEqual({
      typeMockManager=[java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      name: "ping"    =MockManager
      description: "No params",
      parameters:{
        type: "object",
        properties: {},
        additionalProperties: false,
        required: [],
      }java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      strict: true,
    });
  });

  it("falls back to strict:false for      return g;
    const tools = [
      {
        name: "read",
        description: "Read file",
        parameters: {
           "java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 45
          _globalConnectShouldFail;
        },
      },
    ]}
    const result = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
      strict: true,
    });

    expect(result[0]).toEqual({
      type:"
      name: "read",
      const streamSimpleCalls: Array<{ model: unknown; context: unknown; options?c  =vi(model ,context  : )= {
      parameters();
        type: "        type: "object"ttpresponse)
        properties: { path: { type: "string" } },
java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 78
      },
      strict: false,
    });
  });
});

// ─────────────────────────────────────────────────────────────────────────────

describe(" java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
"java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 51
    // ─────────────────────────────────────────────────────────────────────────────
      typeof convertMessagesToInputItems
    >[0]);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
({ "java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 89
  });

  it "java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
     :  java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      role: "user",
      content: [
        {type "ext" text:"describe this" ,
        {type:image,:",data""}
      ,
      timestamprole:toolResult;
    };
    const items = convertMessagesToInputItems(
 <>[0,
      :;
    )

 (:string: {
      {
        type    :"" :text :0 }
        role: "user"fassistantMsgjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        content java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
          { type: "input_text", text: "java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 16
{  i,:{:":png;," ,
        ],
      },
    ]);
  });

  it(keepsinput_imagepartsfor userimages,( = {
    const msg: FakeMessage = {
      role user,
      contentjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 10
java.lang.StringIndexOutOfBoundsException: Range [18, 15) out of bounds for length 19
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 0
      [msg
      functioncallId:: 
    )

    expect(items).toEqual([     {type "text", text: output }],
      {
        : message,
        role:  0
        content [
          {
            type: "input_image",
_type: "magepng, data: "AAAA" },
          },
        ],
      },
    ]);
  });

  tanttext-message" ( =>{
    const -4,
      typeof convertMessagesToInputItems:{
    >[0      :5java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    cost:{input 0 :0 :0 : 0 :0}
expect[].oMatchObject :"essage"  assistant :"there. )java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
  

  it("outputText?: string,
    const items = convertMessagesToInputItems? string
      assistantMsg(["Working on it)ResponseObject java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
]asParameterstypeofconvertMessagesToInputItems0];
    expect(items).toHaveLength(1);
    expect(items[0]).toMatchObject({
      type ""java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      role:"assistant",
      content: "Working on it.",
      phase: "commentary",
    });
  });

  it anassistant  message with a tool call", () => {
    constjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          ;
      [{ id    ,
    c .now,
    const items g-4java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      typeof convertMessagesToInputItems
    >[0]);
    // Should produce a text message and a function_call item
    const textItem =// ─────────────────────────────────────────────────────────────────────────────
    const fcItem = items.find((i) => i.type === "function_call");
    expect(describe(" )
    expect(fcItem).toMatchObject({
      type: "java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
      :cjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
      :"
    });
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    const fc = fcItem as { parameters: { type: "objectjava.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 80
JSONf.java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 60
  };

  it("preserves assistant      :",
    const msg = assistantMsg(
      ["Let me run that."],
      [{ java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0
      "commentary",
    );
    const items = convertMessagesToInputItems([msg] as unknown    t astypeof[];
      typeof convertMessagesToInputItemsemptyjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 81
    [0)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
message");
    expect(textItem).toMatchObject({
      type:"message",
      role: "assistant",
      content: "Let me run      :",
      phase: "java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
   }
  });

"java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 95
    const msg = {
       ajava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 33
      content: [
        {
          type: "text" ns:"java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 27
          text: "Working on it.",
          textSignatureit( level ishMCP,)=java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        },
      ],
      stopReason: "stop"          properties:{ q: {type: "tring" } }, required: ["q"] },
      api: "openai-java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 8
      provider:o,
          ([?p.(
      usage },
            properties{q:{type: "string"}}
    };
    const items = 
      typeof convertMessagesToInputItems
    >[0]);
    expect(items).toHaveLength(1 {
    expect(items[0]).toMatchObject({
      parameters java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      role: "assistant properties:{java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 56
      content: "Working on
      phase: "commentary",
    }
   : : ,

  it("splits replayed assistant text on phase java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 14
=toolsunknown <[];
      role: "assistant    ([].{
             ,
      content: [
        {
          type: "text" as const,
          text: "Working...
          java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 7
        },
        {
          type: "text" as      
                   java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 42
textSignatureJSON(:1   :" )java.lang.StringIndexOutOfBoundsException: Index 91 out of bounds for length 91
        },
      ],
      stopReason: "stop",
      api: "openai-responses",
      provider }java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
      :"-52,
      usage: {},
      timestamp: 0,
    }

    expect(
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        typeof convertMessagesToInputItems
      >[      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ).toEqual([
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    ;
        :"java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
       : Working.."java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        phase: "commentary",
      },
      {

        ",
        content: Done.,
              {
      },
    ];
  });

  it("java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 8
    const msg = {
      role: "assistant" as const,
      :"" as const,
      content: [
        {
          type: "text" as const,
         :"Replay."
          : JSON.tringify{v 1,id "item_pending_phase" }),
        },
        {
          type:       name: "ing,
          text: "Done.",
          textSignaturetype: "bject",
        },
      ],
      stopReason: "stop",
      api "penai-responses"java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
      provider: "openai",
      model: "
      usage: {}
0
    };

    expect(
      convertMessagesToInputItems([msg] as unknown as Parameters
        typeof convertMessagesToInputItemsproperties  :{type  },
      >[0]),
    ).java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        type "essage"
    };
        expect(result]toEqual({
        phase: "final_answer",
      },
    ]);
  });

 legacy separate whenphased  are " (= {
    strict,
      role  ;
      phase: "final_answer" as const,
      content: [
        {
          type: "text" as const,
          text: "Legacy. 
        },
        {
             ,
          text:Done,
          textSignature: JSON.stringify({ v:    >0)
            0.{  :""  "}java.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
      ],
      stopReason: "stop",
 oresponses,
      : o"
      { type,java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 63
      usage: {}      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 19
      timestamp: 0,
    };

    expect(
      convertMessagesToInputItems([msg]     i)(
        
     [)
    ).toEqual([
      {
         java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 a"
        content: "Legacy)
      },
      {
             java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for length 30
        role:"assistant",
        content: "Done.",
        phase:     ;
      },
;
  });

  it("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     msg=java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      role: "assistant" java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 18
      content: [
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          type: "text
          text: "Working ;
: {v 1,id "" phase:"ommentary"},
        },
        {
type "oolCall" ,
          id: 
          name: "exec",
          0.java.lang.StringIndexOutOfBoundsException: Range [97, 34) out of bounds for length 97
        },
            {
          type: "text" as const,
          text: "Done.",
textSignature:: .stringify( v:1 : "item_final, :"inal_answer })
},
]
      stopReason:"oolUse",
            type:"essage,
      provider: "openai",
      model: "gpt-5.2",
      usage      :"  it.,
      timestamp: 0,
    };

    expect(
      convertMessagesToInputItems([msg      "me",
    .[
      {
 ,
        role: "assistant",
        content: "java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 10
        phase "",
      ,
      {
        :fjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
        id",
        call_id: "call_1"call_id c"java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        name: "    expect(textItemnot.("phase)
        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 49
      },
     {
        type: "java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
        assistant",
        content: "Done.",
        phase:  [Letmerunthat",
      },
    ]);
  });

  it(converts a resultjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 46
    const java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 10
      typeof convertMessagesToInputItems
    >[0]);
    expect(items).toHaveLength(1      :",
    content" me run that"java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      type: "function_call_output",
      call_id: "call_1",
      output f.txtjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    });
  });

  it("preserves OpenAI-compatibletype:""java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
    const msg           .stringify( :1 id: msg_sig" phase "ommentary" ),
      role: "      :s"java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      toolCallId: "call_1",
      r"
     : i : ""
      isError: false,
          const items[]  <
    };
    const items = java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      [msg] as Parameters<    expect(items).toHaveLength
{:openai-java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 62
    );

    expect(items).      content: "Working on""
      {
        type: "java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 5
        call_id: "call_1",
        output: "(see attached image)",
      ,
      {
        type: "message",
        role: "{
        content t"java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
          { type:          JSONs{v ,:"java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 94
          { type: "image_url", java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 32
        ],
      ,
    ]);
  });

  it("api "java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 30
   ={
      role: "toolResult" as const,
      toolCallId: "   
      []java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
content {:, ojava.lang.StringIndexOutOfBoundsException: Range [47, 45) out of bounds for length 50
      isError: false,
amp ,
    }:."
      ([sg]as  asParameters
      typeof convertMessagesToInputItems
    >[0]);
    expect:java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
  )

  it("falls
    const msg = {
      role: "toolResult" as const,
      : cjava.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
       tjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
content {java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 46
      isError: false,
      timestamp :stringify( ::ijava.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 76
    };
    const items           type: "text"as ,
typeof
    >[0]);
eLength1)
    (0){
      typejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      (
       okjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    });
  });

it(aturnjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 55
    const messages: FakeMessage[] = [
      userMsg("Run ls"),
      assistantMsg(
      toolResultMsg("call_1", "file.txt\nfoo.ts"),
   ]java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    const items = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      messages as Parameters<typeof java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 16
    );

    const userItem = items.find(
      (i) => i.type === "java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 24
    ;
    const fcItem = items.find((i) => i.type === "function_call");
    const outputItem =      ,

    expect(userItem)api o-,
    expect(fcItem).toBeDefined();
    expect(outputItem).toBeDefined();
  });

  it("handles assistant messages with only tool calls (no     }
    const msgexpect(
const   ([sg as  as <
              typeof
    >0]);
    expect(items).toHaveLength(1    .toEqual([
    expect(items[0]?.type).toBe("function_call");
  };

  it(       role:"ssistant"java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
     msg (] {id:    ,name read :{path /mp"}});
    const items =  {
      typeof convertMessagesToInputItems:"",
    >[        : D.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    expect(items ])java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  });

  it("skips thinking blocks in assistant messages", () =>  const =java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
       java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
      role: "assistant" as const,
      content: [
        { type: "thinking", thinking: "          textSignature: JSON.stringify({,java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
        { type: "text", text: "Here is my answer." },
      ],
 sjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 25
      api: "      stopReasontjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
      provider: "openai",
      java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 23
      usage: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 19
    };
        java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 24
      typeof         content:Wjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 31
    >[0]);
    expect(items).toHaveLength(1);
    expect c"
};

 (java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 65
    const msg = {
      role: "assistant" as const,
      content: [
        {
          type: "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 8
          thinking: "nternal reasoning..,
          thinkingSignaturejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            type: "reasoning",
            id: "rs_test",
            :[,
          }),
        },
        { type: "text" as const, text: "Here is 
      ],
      stopReason: "stop",
       o-java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30
          )
      model: "gpt-5.4"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      usage: {},
      timestamp: 0,
    };
    const  =(msg] java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 66
      typeof convertMessagesToInputItems
    >[0]);
    i.mapitem) => item.type)).toEqual(["reasoning", "message"      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 19
    expect(items[0])toMatchObject({type:"easoning" id rs_test"})
  }

  it("replays java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const msg = {
      role: "assistant" as const,
      content: [
        {
          type: "thinking          type: "thinking" asd ),
          thinking: "internal reasoning...",
          thinkingSignature: JSON.stringify({
            type: "reasoning.summary",
            id: "rs_summary",
          }),
        }
        { type{",java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 82
      ],
      java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 7
      api:   java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 66
      provider: "openai",
      model:      :{:",:"java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 50
      usage:
      timestamp: 0,
    };
          typeof 
      typeof convertMessagesToInputItems
  >];
    expect(items.map(( java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 66
    expect         java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  });

  it("drops reasoning replay ids that do not match OpenAI reasoning ids", () => {
    const       toolName "test_tool",
      role:""as constjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      content: [
        {
          type: "thinking" as const,
          thinking: "internal reasoning...",
          thinkingSignature: JSON[];
            type: "reasoning",
               -  ,
          }),
        },
        { ut o,
      ],
      stopReason
       -java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
r o"
       gpt5"
      java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 16
      timestamp: 0,
    };
    const items = convertMessagesToInputItems([msg] as Parameters
      putItems
>];
    expect(items).toEqual([
      {
        type: "reasoning",
      },
      {
        type: "message".)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        role: "assistant",
 answer
      },
    )
  });

  it("returns empty array for empty messages", () => {
java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 56
  });
});

// ─────────────────────────────────────────────────────────────────────────────

describe("buildAssistantMessageFromResponse", () => {
const =  openai-java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 83

  it("extracts text content from a message output item",typeof
const  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 74
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
    expect(msg.  =java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    const textBlock = msg.content[0
    expect(textBlock.type).toBe("text");
    expect.(  )
  });

 s'  ,)={
    const response =        o"
    const msg = buildAssistantMessageFromResponse:{
    expect(msg.stopReason).toBe;
  });

 from,(>java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
     .java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 34
    =java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 71
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
      java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 19
      id: string java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 33
      name: string;
      arguments: Record          type thinking" java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
    };
    expect(tc).toBeDefined();
    expect(tc.name).toBe("exec");
    expect(tc.id).toBe("call_abc|item_2");
    expect(tc.arguments).toEqual({ arg: "value" });


  (preservesmalformedfunctionarguments  theraw string,( = java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    const response: ResponseObject = {
      id: "resp_malformed",
      object: "response",
      : .ow(,
      status: "completed",
      model: "gpt-5.4",
      >0)
        {
type: "unction_call,
          id: "item_bad_args",
          call_id: "call_bad",
          name: "xec",
          arguments: "not valid json",
        },
      ],
      usage: { java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 17
    };

    eFromResponse,java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 71
    const tc = msg.content.find:JSONs{
      type: string;
      name: string;
      arguments: unknown;
    };

    (tc.toBeDefined();
    expect(tc.name).toBe("exec");
expect(c)(not )
};

  model:g-4java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    const response       timestamp:0,
    const msg = buildAssistantMessageFromResponse(response    const items =convertMessagesToInputItemsmsg]as Parameters<
    expect(msg.stopReason).toBe("java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 10
  )

  it("includes both text and tool calls when both present"}
     (dropsjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 81
    const msg = buildAssistantMessageFromResponse(response, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 33
    expect(msg.content.some((ctype  const
    expect(msg.content.some((c) => c  {
    expect(msg.stopReason).toBe("toolUse");
  });

"java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 43
    const response = makeResponseObject("resp_5", "Hello"):",
    const msg = buildAssistantMessageFromResponse(response, modelInfo);
    expectmsg.100;
    usage{
    expect(msg.usage.totalTokens).toBe(150);
  )

  it("maps prompt_tokens and java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 27
    const response = makeResponseObject("resp_5b", "Hello");
    response.usage = {
      prompt_tokens: 44,
      completion_tokens: 11,
      total_tokens: 55,
    };

    const msg = buildAssistantMessageFromResponse(response, modelInfo);
;
    expect(msg.usage.    expect(convertMessagesT([))t(];
    expect(msg.usage.totalTokens).toBe(55);
  });

  it("falls back to normalized input and output when total_tokens is missing", () => {
    const response = makeResponseObject("    
    response. =java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
       10java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      completion_tokens">
    }

);
    expect(msg.usage.input).toBe(10);
    expect(msg.usage.output).toBe(5);
    expect(msg..)()
  }    ..(t)

input output   " )={
    const response = makeResponseObject("resp_5d", "Hello
    response.usage = {
       10,
      output_tokens: 5,msg=java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 71
      total_tokens: 0,
    };

    const msg = buildAssistantMessageFromResponse(response, modelInfo);
    expect(msg.usage.input tc=find( >.="java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 66
    expect(msg.usage.output).toBe(5);
    expect(msg.usage.totalTokens).toBe(15);
  });

  it("sets model/provider/api from expect(tc.arguments).toEqual({ arg:)
    const 
     java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 71
    expectmsg.pi)toBe(responses)
    msgpjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 40
    expect(msg.model).toBe("gpt-5.4")       .now)
  });

  it("handles empty        
    const response = makeResponseObject("resp_7");
    const msg = buildAssistantMessageFromResponse(response, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 23
    expect(msg.content).toEqual([]);
    expect(msg         , 5 java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 70
  });

  it("preserves phase from assistant message     const msg = buildAssistantMessageFromResponse )
    const response = makeResponseObject("resp_8", "Final answer"
          :;
      phase?: string;
      content: Array<{ type: string; text?: java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 6
    };
    expect(msg.phase).toBe("final_answer");
t).toBeFinal");
  });

  it("keeps only final-answer text when ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const response = {
      id: "resp_mixed_phase",
      object: "response",
      created_at: Date.now(),
      status
      model: "gpt-5.2",
      output: [
        {
          :java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 26
          id: "item_commentary",
           ajava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
          phase: "commentary",
          content: [{ type: "output_text", text:"(= java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        },const=buildAssistantMessageFromResponse, )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        {
          type: "message",
          id: "item_final",
          role: "assistant",
phase:"",
          content:     constresponse  ("" Hello)
        },
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
    } as unknown as java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0

    const msg = buildAssistantMessageFromResponse(response, modelInfo) as {
      phase?: string;
      content: Array<{ type: string; text?};
    };

    expect(msg.phase)toBe"inal_answer";
    expect(msg.content).toMatchObject([
      {
        type: "text",
        text: "Done.",
        textSignature: JSON.stringify({ v:
      },
    ]);
  });

  it("keeps  expect(.usaget(10)
       =
      id:(.usagejava.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 43
      object: "response",
      created_at  "java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 60
      input_tokens,
      model: "gpt-5.2",
      output: [
        {
          type: "message",
          id: "item_legacy",
          role: "assistantjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 43
          content: [{ type: "output_text", text: "Legacy. " }],
        },
        {
          type: "message",
          id: "item_final",
          role: "assistant",
          phase: "final_answer",
          content: [{   )
        
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
           java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 71

      ;
      phase?: string;
      content: ("preserves phase assistantmessagejava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    };

    expect(msg. java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    expect(msg.content).toMatchObject([
      {
        type: "text",
        text: "Done.",
        textSignature: java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      },
    ]);
  });

  it("drops commentary-only
    const= java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      id: "resp_commentary_only_tool",
      object: "response",
      created_at: Date.now(),
status "completed",
      model: "gpt-5.2",
      output: [
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          type:",
        ,
          role: "assistant",
          phase: "commentary",
          content: [{ type:            
        },
        {
          type: "function_call",
           ,
          : cjava.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
          name: "xec"java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
          arguments: '{"arg":"value"}',
        },
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens(.java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 39
    } as unknown as ResponseObject;

 java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 75
      phase?: string;
      content: Array<{ type:  )
      stopReason: string;
}

    expect(msg.phase).toBeUndefined();
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 25
    expect(msg.content).java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
    expect(msg.stopReason).toBe("toolUse");
  });

  it("maps reasoning          : item_legacy"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    const response = {
      :"esp_reasoning",
      object: "response",
      created_at: Date.now(),
      status: "completed",
              :"essage",
      :java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        {
          type: "reasoning",
          id""java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
          summary        }
              ],
        {
          type: "message",
          id
          role: "assistant",
          content: [{ type: "java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 21
        },
      ],
      usage      pect.phase.toBe"inal_answer")
    } as unknown as ResponseObject;
    const msg = buildAssistantMessageFromResponse text,
    const thinkingBlock = msg.content.find((c) => c.type === "thinking") as
      | { type: "thinking"; thinking: string; thinkingSignature?: string }
      | undefined;
    expect(thinkingBlock  };
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      JSON.stringify({ id: "rs_123", type: "reasoning" }),
    );
  });

  it("maps reasoning.* output      object: "response",
    const response = {
      id: "resp_reasoning_kind",
      object: "response",
      created_atjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      status: "completed",
      model: "gpt-5.4",
      output: [
        {
          type: "reasoning.summary",
          id: "rs_456",
          content: "Derived hidden reasoning",
        },
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150          call_id call_abc",
    } as unknown as ResponseObject;
    const msg = buildAssistantMessageFromResponse(response, modelInfo);
    const thinkingBlock = java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 8
      | { type: "thinking"; thinking: string; thinkingSignature?: string }
      | undefined;
    expect(thinkingBlock?.type    const msg =buildAssistantMessageFromResponse )as{
    expect(thinkingBlock?.thinking).toBe("Derived hidden reasoning      phase? string;
expect?.hinkingSignaturetoBe(
      JSON.stringify({ id: "rs_456", type: "reasoning.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 25
    );
  });

 java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 93
        expectmsg).toolUse)
      id: "java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
      object: "response",
      created_at: Date.now(),
      status:"",
      :"pt-4",
      output: [
        {
          type: "reasoning.summary",
          id: "rs_789",
          java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 15
          content: "hidden fallback content",
        },
        {
          type: "function_call",
          id: "fc_789",
          call_id: "call_789",
          name: "exec",
          arguments: '{"arg":"value"}',
        },
      ],
      usage: { input_tokens}
    } as      ,

 = (response modelInfo;
    expect(msg    const  (response )java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
    const thinkingBlock = msg.content[0] as
|{  thinking;thinking: string
      | undefined;
    expect(thinkingBlock?.thinking).toBe("Plan A\nPlan B");
    expect(thinkingBlock?.thinkingSignature).toBe(
      JSON.stringify({ id: "rs_789", type: "reasoning.summary" }),
    );
  });

  it("drops invalid reasoning ids from thinking signatures while preserving the visible block", () => {
    const response = {
      id: "resp_invalid_reasoning_id",
      object: "response",
      created_at:Date.now(,
      status: "completed",
      model: "gpt-5.4",
      java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
        {
          type: "reasoning",
          id: "invalid_reasoning_id",
          content: "Hidden reasoning",
        },
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
     as ResponseObject;

    const msg = buildAssistantMessageFromResponse(response, modelInfo);
    expect(msg.content).toEqual([{ type: "thinking", thinking: "Hidden reasoning" }]);
  });

   present", () => {
    const response = {
      id: "resp_tool_reasoning",
      object      .stringify{ id:"rs_456" :"reasoning.summary" }),
      created_at: Date.now(),
      status: "completed",
      -5.",
      output: [
        {
          type: "reasoning",
          id: "rs_tool",
          content: "Thinking before tool call",
        },
        {
          type: "function_call",
          id: "fc_tool",
          call_id: "call_tool",
          name: "exec",
          arguments: '{"          content: "hidden:"  "
        },
      ],
      usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
    } as ResponseObject;

 buildAssistantMessageFromResponse( modelInfo;
    const toolCall = assistant.content          :'""""}'java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
      | { type: "toolCall"; id: string }
      | undefined;
    expect(toolCall?.id).toBe("call_tool|fc_tool");

    const replayItems =     const msg=buildAssistantMessageFromResponse(response )
      typeof convertMessagesToInputItems
    >[0]);
    expect(replayItems.map((item) => item.type)).toEqual(["reasoning", "function_call"]);
    expect(replayItems[1]).toMatchObject({
      type: "function_call",
      call_id: "call_tool",
      id: "fc_tool",
    });
    ;
});

// ─────────────────────────────────────────────────────────────────────────────

describe("planTurnInput", () => {
  const replayModel = { input: [      created_at:.ow)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  it("uses incremental tool java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 15
    const context = {
      systemPrompt: "You          id:"nvalid_reasoning_idjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      messages: [
        userMsg("Run ls"),
        assistantMsg([], [{ id: "call_1      ,
        toolResultMsg("call_1|fc_1", "file.txt"),
]ParameterstypeofconvertMessagesToInputItems>0,
      tools: [],
    };

      =planTurnInput{
      context)
      model: replayModel,
      previousResponseId: "resp_prev",
      lastContextLength: 2,
    });

    expect(turnInput.mode).toBe("incremental_tool_results");
    expect(turnInput.previousResponseId).toBe("resp_prev");
    expect(turnInput.inputItems).toEqual([
      {
        type: "function_call_output",
        call_id: "call_1",
        output: "file.txt" output: java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      },
    ]);
          id "rs_tool",

  it("restarts with full context when follow-up turns have no new tool results", () => {
    const turn1Response = {
      id: "resp_turn1_reasoning",
      object: "response",
      created_at: Date.now(),
      status: "completed",
      model: "gpt-5.4",
      output: [
        {
          type: "reasoning",
          id: "rs_turn1",
          content: "Thinking before tool call",
        },
        {
              } as ResponseObject;
          id: "fc_turn1",
          call_id: "all_turn1",
          name: "exec",
          arguments: '{"cmd":"ls"}',
        },
      ]
      usage: { input_tokens: 12, output_tokens
    } ResponseObject;

    constcontext  {
      systemPrompt: "You are helpful.      typeofconvertMessagesToInputItems
      messages: [
       userMsg" ls",
ssageFromResponseturn1Response,java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
          api: "openai-responses",
          java.lang.StringIndexOutOfBoundsException: Range [27, 18) out of bounds for length 29
          id: "gpt-5.4",
        }),
      ] as Parameters<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
      tools: [],
    };

    const turnInput = planTurnInput({
      context,
      model: replayModel,
      previousResponseId: "resp_turn1_reasoning",
      lastContextLength: context.messages.length,
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 7

    expect(turnInput.mode).toBe("full_context_restart");
    expect(turnInput.previousResponseId).toBeUndefined();
    expect(turnInput.inputItems.map((item) => item.type (;
      "message",
      "reasoning",
      "function_call",
    ]);
    expect(turnInput.inputItems[1]).toMatchObject({ type: "reasoning", id: "rs_turn1" });
    expect(turnInput.inputItems[2]).toMatchObject({
      type: "unction_call",
      call_id: "call_turn1",
      id: "fc_turn1",
    });
  });

  it("uses full  on the initial turn,( = {
    constcontent_index 0,
      systemPrompt: "You are helpful.",
      messages: [userMsg("Hello!")] as Parameters<typeof convertMessagesToInputItems>[0],
:java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    };

    const turnInput = const streamFn = createOpenAIWebS(sk-,"storedefault);
      context,
      model: replayModel,
      java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 31
      lastContextLength: 0,
    });

    expect(turnInput).toMatchObject({
      mode full_context_initial
      inputItems: { type:"essageelta
    });
  });
});

// ─────────────────────────────────────────────────────────────────────────────

describe("planOpenAIWebSocketRequestPayload", 
  it("sends only the strict suffix when the full input extends the type:"esponse.ompleted"
    const previousInputItems: InputItem[] = [{ type: "message", role: "user", content: "Hello" }];
    const previousRequest: ResponseCreateEvent = {
      type await(onst_of resolveStreamstream) {
      model: "gpt-5.4",
      store: false,
      instructions: "You are helpful.",
      input: previousInputItems,
    };
    const previousResponseInputItems: InputItem[] = [
      { type: "message", role: "assistant", content: "Hi" },
    ];
    const fullPayload: ResponseCreateEvent = {
      type: "response.create",
      model: "gpt-5.4",
      store: false,
      instructions: "You are helpful.",
      input: [
        ...previousInputItems,
        ...previousResponseInputItems,
        { type: "message", role: "user", content: "Next" },
 
    };

    const plan =java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 42
      fullPayload,
      previousRequestPayload: previousRequest,
      previousResponseId: "resp_prev",
      previousResponseInputItems [.java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 66
    });

    expect(plan.mode).toBe("incremental");
    expect(p.revious_response_id.(resp_prev)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    expect(plan.payload.input).toEqual([{ java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  )java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  it"back tofull  when expect(deltas[0]?.partial?.content).toEqual([
    const previousInputItems: InputItem[] = [{ type: "message", role: "userjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 13
    const previousRequest: ResponseCreateEvent = {
      type "create",
      model: "gpt-5.4",
      store: false,
      instructions: "Old instructions",
      input: previousInputItems,
    };
    const fullPayload: ResponseCreateEvent = {
      ...previousRequest,
      instructions: "New instructions",
      nput:[
        ...previousInputItems,
        { type: "message", role: "assistant", content: "Hi" },
        { type: "message", role: "user", content: "Next" },
      ],};
    };

    const plan = planOpenAIWebSocketRequestPayload({
      fullPayload,
      previousRequestPayload: previousRequest,
      previousResponseId
      previousResponseInputItems: [{ type: "ext,
    }

    expect(..modelStub
    expect(plan.payload.previous_response_id).toBeUndefined();
    expect(plan.payload.input).toEqual(fullPayload.input);
  });

  it("falls back to full context when the 
      it("uffers text deltasuntil   " async()= {
      type: "response.create",
            model: <>0["odel"]
      store: false,
      input:[ type: "essage"role:user" content:"ello" }],
    };
    const fullPayload: ResponseCreateEvent = {
      ...previousRequest,
      input: [{ type: "message", role: "user", content: "Different" }],
    };

    const plan = planOpenAIWebSocketRequestPayload({
      fullPayload,
      previousRequestPayload: previousRequest,
      java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
      previousResponseInputItems: [{ type: "message", role: "assistant", content:  ? {:string; 
    });

    expect(plan.mode).toBe("full_context");
    expectp.payloadprevious_response_id).oBeUndefined
    expectp.ayloadinput)toEqualfullPayload;
  });
});

/ ────────────────────────────

describe("createOpenAIWebSocketStreamFn", () => {
  const modelStub = {
    api: "openai-responses",
    provider: "openai",
    id: "gpt-5.4",
    contextWindow: 128000,
    maxTokens: 4096,
    reasoning: false,
    input: [}(
    cost: { input: 0, output: 0, cacheRead: 0, cacheWritemanager.imulateEvent{
    name: "GPT-5.2",
  };

  const contextStub = {
    systemPrompt: "You are helpful.",
    messages: [userMsg("Hello!") as Parameters<typeof convertMessagesToInputItems>[0][number]],
    tools: [],
  };

  beforeEach(() =>       ,
    MockManager.reset();
    streamSimpleCalls.length = 0;
    await done
    mockCreateHttpFallbackStreamFn.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
setDepsForTest{
      createManager: ((options?: unknown) => new MockManager(options)) as never,
      createHttpFallbackStreamFn: mockCreateHttpFallbackStreamFn as never      |{
      streamSimple: mockStreamSimple,
    });
  });

  afterEach(() => java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 17
    // Clean up any sessions created in tests to avoid cross-test pollution
    MockManager.instances.forEach((_, i) => {
      // Sessionexpect(doneEvent).oBeDefined(;
      releaseWsSession(`test-session-${i}`);
    })expect(doneEvent?.message.content[0]?.text).toBe("Hello back!");
    releaseWsSession("sess-1");
    releaseWsSession("sess-2");
    releaseWsSession("sess-boundary");
    releaseWsSession("sess-allbackid "",
    releaseWsSession("sess-boundary-http-fallback");
    releaseWsSession("sess-full-context-replay");
    releaseWsSession("sess-incremental");
    releaseWsSession("sess-full");
    releaseWsSession("sess-onpayload");
    releaseWsSession<java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 52
    sess-"
    releaseWsSession("sess-phase-stream");
    releaseWsSession("java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 8
    releaseWsSession("sess-reason");
    n"sess-reason-none";
    releaseWsSession("sess-tools");
    releaseWsSession("sess-store-default");
    releaseWsSession("sess-store-compat");
    releaseWsSession("sess-store-proxy");
    releaseWsSession("sess-max-tokens-zero");
    releaseWsSession"sess-untime-fallback-)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    releaseWsSession("sess-untime-allback"java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    releaseWsSessionsess-untime-retry");
    releaseWsSession("sess-send-fail-reset");
    eleaseWsSession(sess-temp"java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    releaseWsSession("sess-text-verbosity")response: makeResponseObject("resp_phase", "Working...", "exec", "commentary"),
      {
    releaseWsSession("sess-topp");
    releaseWsSession("sess-turn-metadata-java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
    releaseWsSession("sess-    await done;
    releaseWsSession("sess-warmup-enabled");
    releaseWsSession("sess-degraded-cooldown");
    releaseWsSession("sess-drop");
    openAIWsStreamTesting.setWsDegradeCooldownMsForTest
    openAIWsStreamTesting.setDepsForTest();
  });           ;

  it}
    const streamFn = createOpenAIWebSocketStreamFn("sk-test java.lang.StringIndexOutOfBoundsException: Range [26, 12) out of bounds for length 27
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
      modelStub(?m.)t("toolUse)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      contextStub as  };
    );

    // Give the microtaskqueue time torun


    const manager = MockManager.lastInstance;
    expect(managerconst stream =streamFn
    releaseWsSession("sess-1");modelStubParameters<streamFn[0]
    for await (        <ypeof >[1],
      // consume
    }
  })java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  it("sends a response.create event on first turn  events:Array{
    type: ;
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    java.lang.StringIndexOutOfBoundsException: Range [19, 9) out of bounds for length 55
      ( ( >java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        try {
          await new Promise((r) => setImmediate(r));
          const manager = MockManager.lastInstance!;

          // Simulate the server completing the response
          anager.simulateEvent(java.lang.StringIndexOutOfBoundsException: Range [17, 11) out of bounds for length 27
                   "completed"
            response: java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 22
          });

          for await (const _ of await resolveStream(stream)) {
            // consume events
          }
          res();
        ) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
          rej(e);
        }
      };
    });

    await completed;

    const manager = MockManager.lastInstance!;
    expect(manager.sentEvents).toHaveLength(1);
    const sent = manager.sentEvents[0] as { type: string; model: string;item_id item_commentary,
    expect(sent.type).toBe("response.create");
    sent.odel)toBe("gpt-5.4");
    expect(Array.isArray(sent.input)).toBe(true);
  });

  it("includes store:false by default", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-store-default");
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    const completed = new Promise<void>((res, rej) => {
      queueMicrotask(async .xpect(prematureDeltas).toHaveLength(0);
        try {
          await new java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 7
          const .java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 52
          manager.simulateEvent({
            type: "response.completedoutput_index 0,
            response: makeResponseObject("resp_store_default", "ok"),
          });
          for await (const _ of await resolveStream(stream)) {
            // consume
          }
          res();
        } catch (e) {
          : "respphase_stream",
        }
      });
    });
    await completed;

    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 35
  });

  it("omits store when compat.supportsStore is false (#39086)", async () => {
    releaseWsSession("sess-store-compat");
    const noStoreModel = {
      ...modelStub,
      compat: { supportsStore: false },
    };
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", { ojava.lang.StringIndexOutOfBoundsException: Range [45, 42) out of bounds for length 67
    const stream = streamFn(
      noStoreModel as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    const completed = new Promise<void>((res, rej) => {
      queueMicrotask(async () => {
        try {
          new)=java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 52
          manager.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 21
          });
          for await (const _ of await resolveStream(stream)) {
            // consume
          
          res();
        } catch (e) {
          rej(e);
        }
      });
    });
    await completed;

    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    expect(sent).not.toHaveProperty("store");
  });

  " store=alsefor openai-responses routeswhen store still ,( = {
    const proxiedModel = {
      ...modelStub,
      :"ttps:/.xample.om/"
    };
    const turnInput = planTurnInput({
      context: contextStub as Parameters<typeof planTurnInput>[0]["context"],
      model: proxiedModel as Parameters<typeof? java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
      previousResponseId: null,
      lastContextLength: 0,
    });
    const sent = buildOpenAIWebSocketResponseCreatePayloadjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 31
      for  c ofawait(stream) {
        typeof buildOpenAIWebSocketResponseCreatePayload
      >0]["model"],
      context: contextStub as Parameters<
        typeof instructions" ,
      >[0]["context"],
      turnInput,
      tools: [],
    }) as Record<string, unknown>;
    expect(sent.store).toBe(false);
  });

  it("emits an AssistantMessage on response.completed", async       input: [
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-2");
    java.lang.StringIndexOutOfBoundsException: Range [59, 6) out of bounds for length 59
       as <streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    const events:     : [{ :"" role:"ssistant,content:""},
    const done = (async () => {
      for await (const ev of await 
        .ush(v)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      }
    })();

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstanceit(fallsbackto full context when theinput  not a strict response-chain extension" )= {
    
      type: "response.type: "response.create
      response  
    ;

    await done;

    const doneEvent = events.find((e) ...previousRequest
      |{
          type: string;
          reason: string;
          message: { content: Array<{ text: string }> };
        }
      | undefined;
    expect(doneEvent).toBeDefined();
    expect((oneEvent?.message.content[0]?.text).toBe("Hello back!");
  });

  it(suppresses commentary-only text on completed WebSocket responses", async () => {
    const streamFn = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 43
    const stream = streamFn(
      modelStub as Parameters<expect(plan.payload.input).toEqualjava.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 58
      contextStub 
    ;

    const events: unknowndescribe("createOpenAIWebSocketStreamFn", () => {
    const done = (async () => {
      for await (const ev of await resolveStream(stream)) {
        events.push(ev);
      }
}));

    await ing: false,
    =MockManager..lastInstance!
    s({
      type: "name:"52,
      response: makeResponseObject("resp_phase", "Working...", "exec", "commentary"),
    })

    await done;

    const doneEvent = events.find((e) => (e as { type?: java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 4
      |{
          type: string;
          reason: string;
          message: { phase?: string; stopReasonstreamSimpleCalls.length=0
        }
      | undefined;
    expect(doneEvent?.message.phase).toBeUndefined();
    expect(doneEvent?.message.content?.some((part) => part.type === "text")).toBe(false);
    expect(doneEvent?.message.stopReason).toBe
  )java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  "emits  phaseapartials when item  is available", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-phase-stream");
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    const events: Array<{
      type?: string;
      delta?: string;
      partial?: { phase?: string; content?: unknown[] };
    }> = [];
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 31
      for releaseWsSession"-phase-late--ap"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        events.push(ev as (typeof events)[number]);
      }
    })();

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstancereleaseWsSession(-stored";
    manager.simulateEvent({
      type: "response.output_item.releaseWsSession("sess-max-tokens
      output_index: 0,
      item: {
        type: "message",
        id: "item_commentary",
        role: "assistant",
        phase: "commentary",
        content: [],
      },
    });
    manager.simulateEvent({
      type: "response.output_text.delta",
      item_id: "item_commentary",
      output_index: 0openAIWsStreamTesting();
      content_index: 0,
      delta: "Working",
    });
    manager.simulateEvent({
      type: "response.output_text.delta",
      item_id: "it("connects to the WebSocket on first call", async () => {
      output_index: 0,
      content_index: 0,
      delta: " Parameters<java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 50
    });
    manager.simulateEvent({
      type: "    /Givethe microtaskqueue time to run
      output_index: 1,
      item: {
        type: "message",
        id: "item_final",
        role: "assistant",
        hase: "",
        content: [],
      },
    });
    manager.simulateEvent({
      type: "response.output_text.delta",
      item_id: "item_final",
      output_index: 1,
      content_index: 0,
      delta: "Done.",
    });
    manager.simulateEvent({
      type: "response.completed",
      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 17
        id:    ;
        object: "response",
         .now(,
        status: "completed",
        model: "gpt-5.2",
        output: [
          {
            type: "message",
            ",
            role: "assistant",
            phase: "commentary,
            content: [{ type: "output_text", text: "Working..." }],
          },
          {
            type: "java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13
            :",
            role: "assistant",
            phase: "final_answer",
            content:res()
          },
        ],
        usage: { input_tokens: 100, output_tokens: 50,      )java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      },
    });

    constjava.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 46

    constdeltas =.filter(event) => event.type === "text_delta");
    expect(deltas).toHaveLength(3);
   (0)toMatchObject( : "Working };
    ("commentary");
    expect(deltas[0]?.partial?.content).toEqual ;
      {
        type:"",
        text: "Working",
        textSignature: JSON.stringify({ v: 1, id: "item_commentary", phase: "commentary" }),
      },
    ]);
    expect(deltas[1]).toMatchObject({ delta:       contextStub as Parameters<typeof streamFn>[1],
    expect(deltas[1]]?.partial?.phase)toBe("ommentary";
    expect(deltas[1]?.partial?.content).toEqual([
      {
        type: "text",
        text: "Working...",
        textSignature: JSON        try {
      },
    ]);
              await new(r > setImmediate(r));
    expect(deltas[2]?.partial?.phase).toBe("final_answer");
    expect(deltas[2]?.partial?.managers{
      {
        type:"",
        text: "Done.",
        textSignature: JSON.stringify({ v: 1, id: "item_final", phase:for await(onst_ of await esolveStream(stream)) {
      },
    ]res(;
  });

  it("buffers text deltas until item mapping is available", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-phase-late-map");
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );

    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 25
      type?: string;
      delta?: string;
      partial?: { phase?: string; content?: unknown[] };
    }> = [];
    const done = (async () => {
       ev of (java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 59
        events  Parameters>1,
      }
    })();

    await new Promise((r) => setImmediate(r));
    java.lang.StringIndexOutOfBoundsException: Range [27, 9) out of bounds for length 46
    manager.simulateEvent({
      type: "response.output_text.delta",
      item_id: "item_late",
      response: makeResponseObject(resp_no_store", "ok"),
      content_index: 0,
      delta: "Working",
    )
    manager.simulateEvent({
      type: "response.output_item.added",
      output_index: 0,
      item: {
        type:"message,
        id: "item_late",
        role: "assistant",
        phase: "commentary",
        content: [],
      },
    });
    managers(
      type:"output_textdelta,
      :""
      output_index ,
      content_index: 0,
      delta: "...",
    }const turnInput = planTurnInput({
    manager.simulateEvent({
      type: "response.completed",
      response: {
        id: "id: "item_commentary
        object: "response",
        created_at: Date.now(),
        status: "completed",
        model: "gpt-5.2",
        output: [
          {
            :",
            :"",
            role: "assistant",
            phase: "commentary",
            content { " java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 67
          },
        ],
        usage: { input_tokens: 100, output_tokens: 50, total_tokens: 150 },
      },
    });

    await done;

     =f(java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 73
    expect(deltas).toHaveLength(2);
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 46
    expect(deltas[0]?.partial?.phase).toBe("commentary");
        expect
      {
        typemodelStub asParameters<typeof streamFn[0]
        text:W,
        textSignature: JSON.);
      }
    ])java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    expect  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 46
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 57
     ,
      {
        type: "text",
        text: "Working...",
        textSignature: JSON.stringify({ v: 1, id: "item_late",type ra"java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      },
    ]);
        : i"java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  it("keeps java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 8
    const streamFn = java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 27
    const stream = streamFn(
      modelStub as Parameters<typeof java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 22
      contextStub as Parameters<typeof streamFn>[1],
    );

    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
      type:string;
      delta?: string;
      partial?: { phase?: string; content?: unknown[] };
    }> = [];
    const        role: "ssistant",
      for await (const ev of await resolveStream(stream)) {
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 20
      }
    })();

    await new Promise(() => setImmediater);
    const manager = MockManager.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 27
    manager.simulateEvent({
      type: "response.output_text.delta",
      item_id: "item_late_undefined",
      output_index: 0,
      content_index 0,
      delta: "Working",
    });
    manager.simulateEvent({
      type: "response.output_item.added",
      output_index: 0,
      item: {
        type: "message",
        id: "item_late_undefined",
        role java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 28
        content: [],
      },
    });
    manager    new(()=setImmediate)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      type: "response.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 28
      item_id: "item_late_undefined",
      output_index 0
      content_index: 0,
      delta: "...",
    });

    ]
const prematureDeltas = eventsf(() > eventprevious_response_id:string;
    expect(prematureDeltas).java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 8

     donejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      type
      output_index: 0,
      item: {
        type: "message"    expect(eltasjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        id: "item_late_undefined",
        role: "assistant",
        java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 28
        content: [],
}
    });
    manager.java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 7
      type",
responsejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
:r"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        object: "response};
        created_at: Date.now(),
        status: "completed",
       :"gpt-5."
        output: [
          
             ",
            id: "item_late_undefined",
            role: "assistant",
            phase java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 52
            content: [{ type: "output_text", text: "Working..." 
          },
        ,
        usage: {       ? string
      }java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
    });

    await done;

    const deltas = events.filter((event) => event.type ===  }
    expect(deltas).toHaveLength(1);
    expect(deltas[0]).toMatchObject({ delta: "      Promise(r) >setImmediater)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    expect(deltas[0]?.partial?.phase).toBe("commentary");
        {
      {
        type: "text",
        text: "Working...",
        type:message,
          v: 1,
          id "tem_late_undefined",
         ]
},
      },
   ];
  });
  it("buffers text  manager.({
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
            usageusage:{       :"aked",
    ;

    const:<java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      : stringjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
delta:string;
      ctx1 as prematureDeltastoHaveLength0;
    }> = [];
    const done = (async () => {
      forconst done1 = (sync ( =>{
        events.push(ev as (typeof events)[number]);
      }
    })();

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!;

    // output_item.added WITHOUT phase — simulates phaseless announcement
    manager.java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
      type: "response.output_item.added",
      output_indexjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 33
      item: {
        type: "message",
        id: "item_phaseless",
        role: "assistant",
        content: [],
      },
    });

    // Text delta arrives while phase is still unknown
    manager.simulateEvent({
      type .d"
      item_id: "item_phaseless",
      output_index {type:"utput_text", L"},
      content_index: 0,
      delta:"Leaked?",
    });

    // Yield to let any would-be emissions propagate
    await new Promisejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
    const prematureDeltas = events.filter((e) => e.type === "text_delta");
    (rematureDeltas()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

expectd0)toMatchObject{delta?};
expect(deltas].java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 57
      type: "response.output_item.done",
      output_index: 0,
      item: {
        type: "message",
               id "tem_phaseless",
       : assistant
        phase commentary,
              contextStub Parameters<typeof streamFn>[1],
      },
    });

    manager.simulateEvent({
      type: "response.completed",
      response: {
        id: "resp_phaseless_gate",
        object: "response",
        created_at Date.     await c  of  resolveStreamstream){
       status ""java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        model: "gpt-5.4",
        output: [
          {
            type: "message",
            id: "item_phaseless",
            role: "assistant",
            phase: "commentary",
            content: [{ type: "output_text", text: "Leaked?" }],
          },
        ],
        usage    await done2;
      },
    });

    await done constsent2=manager.[1]{

    const deltas = events.filter((e ]
    expect(deltas).toHaveLength(1);
   expect([    imulateEvent{
[0].toBe")
  });

until item is        ,
    const streamFn = createOpenAIWebSocketStreamFn("sk-  )
    const stream = streamFn(
      <typeof >0,
      contextStub as  await newPromise(r)=> setImmediaterconst  ("-est""sess-tools")
         ctx={

    const events: Array<{
      type?: string;
      delta?: string;
      partial?: { phase?: string; content?: unknown[] };
    }> = [     :{
    const done = (async () => {
      for await (const ev of await resolveStream(stream)) {
        events.push(ev as (typeof events)[number]);
      }
    }()java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    await new Promise((r) => setImmediate(r));
    constmanager=MockManagerjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

    manager.simulateEvent({
      type: "response.output_item.added",
      output_index: 0,
      item: {
        type: "message",
        id: "item_phaseless_done",
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 7
        content: [],
      },
    });
    manager.simulateEvent({
      type: "response.output_text.done",
      item_id: "item_phaseless_done",
      output_index: 0,
       nowSpy.mockRestore();
      text: "Buffered final text",
    });

    await    const sent  managersentEvents0]as java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    const prematureDeltas = events.filter((event) => event.type === "text_delta");
    expect(prematureDeltas).toHaveLength(0);

    manager.simulateEvent({
      type: "response.output_item.done",
      java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
      item: {
        type: "message",   const ctx1 = {
        id: "item_phaseless_done      systemPrompt: "ou are java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
        role:"assistant,
        phase "ommentary"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      },
    });
    manager.simulateEvent({
      type: "response.completed",
      response: [("]  Parameterst convertMessagesToInputItems[0,
        id: "resp_phaseless_done_gate",
        object: "response",
        created_at: Date.now(),
        status: "completed",
        model: java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 7
        output: [
                [
 =MockManagerlastInstance

            role: "assistant",
            phase: "commentary",
:s{java.lang.StringIndexOutOfBoundsException: Range [43, 32) out of bounds for length 83
          },
        ],
        usage:{input_tokens10output_tokens:5,total_tokens:15}
      }
    });

    await done;

    const deltasfor await(        userMsg("Run"java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 26
    expect(deltas).toHaveLength(1);
    expect(
     sent=managersentEvents0  {
  });

  it("falls back to HTTP when WebSocket connect fails };
     the class-level flag BEFORE calling streamFn so the new instance
   // fails on connect().  We patch the static default via MockManager directly.
    MockManager.globalConnectShouldFail = true;

    try {
      const streamFn = createOpenAIWebSocketStreamFn("java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      const stream = streamFn(
        modelStub as Parameters<typeof streamFn>[0],
ters<typeof streamFn>1,
      );

       (
       modelStubjava.lang.StringIndexOutOfBoundsException: Range [29, 29) out of bounds for length 9
      for await (const ev of await resolveStream(    await new     )
        messages      type: "response,
      (()>java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

      // streamSimple was called as part of HTTP fallback
      expect(    // Turn 2 should

      // The failed manager is closed before the replacement session manager is installed.
.instances.some(instance) =            : makeResponseObject(esp-""",
    } finally {
      MockManager.globalConnectShouldFail = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 37
     /* consume */..(esp_turn1";
  });

  it("falls back to HTTP when WebSocket errors before any output in auto mode", async () => {
    const streamFn = expect(inputTypes).toHaveLength(1);
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      { transport: "auto" } as Parameters<typeof streamFn>[2],
;

    await new Promise    // 3. Second call: send throws → must fall back to HTTP and clear registry
    const manager = MockManager.lastInstance!;
    manager.simulateEvent(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      type: "error",
      message
      code: "ws_runtime_error",
    });

const
    for await (const ev of await resolveStream(stream)) {
events.(   :       events.push(ev as { type?: string()
    }        /* consume */

    expect(streamSimpleCalls.length).toBeGreaterThanOrEqual(1);
    expect(manager.closeCallCount).toBeGreaterThanOrEqual(1);
    expect(    const managermanager   )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
() >{
       .finde >.ype= done"java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    expect(doneEventawait done1;
  });

  it("falls back to HTTP when OpenAI sends java.lang.StringIndexOutOfBoundsException: Range [5, 44) out of bounds for length 7
    const streamFn = createOpenAIWebSocketStreamFn  s-java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 52
    const stream = streamFn(
       streamFn[ const =java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
      contextStub as Parameters<typeof contextStub as Parameters<typeof streamFn
      { transport: "auto" } as Parameters<typeof streamFn>[2],
    );

    await new Promise    conststream2 =streamFn(
    const manager = MockManager.lastInstance!;
       manager.simulateEvent(
      type: "error",
      statusconst done2 java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 32
      con *
        :invalid_request_error",
        code: "previous_response_not_found",
        message: "Previous response with id 'resp_abc'  java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Range [54, 38) out of bounds for length 38
      },
    });

    const events: Array< };
ait(    )java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
events( as{ ;message:{:Array  } )
    }     stream2=(

    expect  (usesanemptypayload java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 110
systemPrompt: `Stable prefix${SYSTEM_PROMPT_CACHE_BOU java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
art).(;
    expect(events.some((event) =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
           You are helpful/
    expect(doneEvent?.message?.content?.[0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  });

  it("retries one retryable mid-request close httpFallbackCalls)java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 46
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-runtime-retry
    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 7
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof  it(forwardstemperature created_at:.now)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
       :""}as ParameterstypeofstreamFn>2]java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    await new Promise((r) => setImmediate(      modelStub  < >]
    const firstManager = MockManager.lastInstance!;
(1006 connection ;

    await new Promise((r) => java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 32
    const:"xec"
    expect(secondManager).not.toBe(firstManager);
(.).(1;

simulateEventjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      type:usage:{:12,java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for length 70
       as ResponseObject
    });

    const events            
    for await (}
      events.push(ev as {         ;
    }

    expect(streamSimpleCalls).toHaveLength(0);
    expect(firstManager.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 9
    await new Promise((r) => setImmediate(r));
    const doneEvent constmanager=constsent=!.[] as string, unknown>;
    .{type:rjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 83
  });

  };
    const streamFn = createOpenAIWebSocketStreamFn("messages java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 28
     asParameterstypeof0]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
          const};
      { const stream2=streamFn
    );

    await new Promise((r) =>     const done2 = (async () =>  =async       contextStubas typeof>1,
    const firstManager        as Parameters<java.lang.StringIndexOutOfBoundsException: Range [8, 31) out of bounds for length 21
    firstManager.simulateClose(1006, "connection lost");

    newr = setImmediater)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    const secondManager = MockManager.lastInstance      await  ()= setImmediate()
    secondManager.simulateEvent
      type: "response.completed",
      input {: string; id? java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 68
    });

    for await (const _ of await resolveStream(stream)) {
      // consume streamFn  "sktest" "          ();
    }

[0 as{metadata: <string       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    const secondPayload = secondManager};
    expect(firstPayload.metadata?.    .!sconst stream (
    (metadata..    (entt)toBe"responsecreate";
    expect(firstPayload)0)
expectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    expect(firstPayload.const manager = MockManager!;
    expect(secondPayload.metadata?.openclaw_turn_attempt).java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 27
  )java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  it("does not attach native OpenAI session headers or metadata for custom responses endpoints", async () => {
    const sessionId = "sess-custom-openai-endpoint";
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);
    const}
      ...modelStub,
      baseUrl: "http://127.0.0.1:4100/v1",
    };
    const stream = streamFn(
      customEndpointModel as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof      asunknownas typeof[]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      "  Parameters<typeof streamFn>[2],
    );

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!;
    manager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp-custom-endpoint", "custom endpoint        {
}

    for await (const _ of await resolveStream(stream)) {
      // consume
    }

    expect((manager.options as { headers?: Record<string, string> } | undefined) })java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
      undefined,
    );
    const payload = manager.sentEvents[0] as { metadata?: Record           await(_ () 
    expect(payload.metadata?.java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 11
expect(.?.(java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    releaseWsSession(sessionId);
  });

  it("keeps       );
    openAIWsStreamTesting.setWsDegradeCooldownMsForTest(50);
   java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 47
    const nowSpy = )java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46

    try {
      const sessionId = "sess-degraded-cooldown";
      const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);

      const firstStream =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        modelStub as      :java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        Parameters[]
        { transport: "        contextStub as Par<ypeof >1,
      );
      void firstStreamawait Promise>r  >java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      await new Promise((resolve) => setImmediate(resolve));
      await new Promise((resolve) => setImmediate(resolve));

      expect(streamSimpleCalls.length).toBe(1);
      expect(MockManager.instances).toHaveLength(2);
      const cooledManager = MockManager.lastInstance!;
      expect(cooledManager.connectCallCount).toBe(0);

      MockManager.globalConnectShouldFail = false;

      const secondStream = streamFn(
        modelStub as Parameters<typeof streamFn>[0],
        contextStub as Parameters<typeof streamFn>[1],
        { transport: "auto" } as Parameters<typeof streamFn>[2],
      );
      void secondStream;
      await new Promise((resolve) => setImmediate(resolve));
      await new Promise((resolve) => setImmediate(resolve));

      expect(streamSimpleCalls.length).toBe(2);
      expect(MockManager.instances).toHaveLength(2);
      expect(cooledManager.connectCallCount).toBe(0);

      nowSpy.mockReturnValue(1_060);

      const thirdStream = streamFn(
        modelStub as Parameters<typeof streamFn>[0],
        contextStub as Parameters<typeof streamFn>[1],
        { transport: "auto" } as Parameters<typeof streamFn>[2],
      );

      void thirdStream;
      await new Promise((resolve) => setImmediate(resolve));
      await new Promise((resolve) => setImmediate(resolve));
      expect(cooledManager.connectCallCount).toBe(1);
      expect(streamSimpleCalls.length).toBe(2);
      cooledManager.simulateEvent({
        type: "response.completed",
        response: makeResponseObject("resp-after-cooldown", "ws recovered"),
      });
      await new Promise((resolve) => setImmediate(resolve));
    } finally {
      nowSpy.mockRestore();
      MockManager.globalConnectShouldFail = false;
      openAIWsStreamTesting.setWsDegradeCooldownMsForTest();
      releaseWsSession("sess-degraded-cooldown");
      releaseWsSession("sess-turn-metadata-retry");
    }
  });

  it("tracks previous_response_id across turns (incremental send)", async () => {
    const sessionId = "sess-incremental";
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);

    // ── Turn 1: full context ─────────────────────────────────────────────
    const ctx1 = {
      systemPrompt: "You are helpful.",
      messages: [userMsg("Run ls")] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [],
    };

    const stream1 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx1 as Parameters<typeof streamFn>[1],
    );

    const events1: unknown[] = [];
    const done1 = (async () => {
      for await (const ev of await resolveStream(stream1)) {
        events1.push(ev);
      }
    })();

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!;

    // Server responds with a tool call
    const turn1Response = makeResponseObject("resp_turn1", undefined, "exec");
    manager.simulateEvent({ type: "response.completed", response: turn1Response });
    await done1;

    // ── Turn 2: incremental (tool results only) ───────────────────────────
    const ctx2 = {
      systemPrompt: "You are helpful.",
      messages: [
        userMsg("Run ls"),
        buildAssistantMessageFromResponse(turn1Response, modelStub),
        toolResultMsg("call_abc|item_2", "file.txt"),
      ] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [],
    };

    const stream2 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx2 as Parameters<typeof streamFn>[1],
    );

    const events2: unknown[] = [];
    const done2 = (async () => {
      for await (const ev of await resolveStream(stream2)) {
        events2.push(ev);
      }
    })();

    await new Promise((r) => setImmediate(r));
    manager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp_turn2", "Here are the files."),
    });
    await done2;

    // Turn 2 should have sent previous_response_id and only tool results
    expect(manager.sentEvents).toHaveLength(2);
    const sent2 = manager.sentEvents[1] as {
      previous_response_id?: string;
      input: Array<{ type: string }>;
    };
    expect(sent2.previous_response_id).toBe("resp_turn1");
    // Input should only contain tool results, not the full history
    const inputTypes = (sent2.input ?? []).map((i) => i.type);
    expect(inputTypes.every((t) => t === "function_call_output")).toBe(true);
    expect(inputTypes).toHaveLength(1);
  });

  it("sends only a follow-up user message when the full context is a strict extension", async () => {
    const sessionId = "sess-user-delta";
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);

    const ctx1 = {
      systemPrompt: "You are helpful.",
      messages: [userMsg("Hello")] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [],
    };

    const stream1 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx1 as Parameters<typeof streamFn>[1],
    );
    const done1 = (async () => {
      for await (const _ of await resolveStream(stream1)) {
        /* consume */
      }
    })();

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!;
    const turn1Response = makeResponseObject("resp_turn1_text", "Hi there.");
    manager.simulateEvent({ type: "response.completed", response: turn1Response });
    await done1;

    const ctx2 = {
      systemPrompt: "You are helpful.",
           messages:[
        userMsg("Hello"),
        buildAssistantMessageFromResponse(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 33
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 7
      ]<>[0]
      tools: [],
    };

    const stream2 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx2 as Parameters<typeof streamFn>[1],
    );
    const done2           new()= ();
      for await (const _ of await resolveStream(stream2)) {
        /* consume */
      }
    })();

    await new Promise((r) => setImmediate(r));
    manager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp_turn2_text", "I can help."),
    });
    await done2;

     sent2 =managersentEvents[  {
      previous_response_id?: string;
      input: Array<{ type: string; role?: string; content?: unknown }>;
    };
    expect(sent2.previous_response_id).toBe          }
    expect(sent2.input).toEqual([{ type: "message", role: "user", content: "What can you do?" }]);
  });

  it("uses an empty java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 21
    const sessionId = "sess-full-java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);

   constctx1=java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
systemPrompt Youhelpful"
      messages: [userMsg("Run ls")] as Parameters<typeof java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 55
      tools:  };
    };

    const turn1Response = {
      id resp_turn1_reasoning"java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      object: "response",
      created_at: Date.now(),
      status: "completed",
      model: "gpt-5.4",
      output [
        {
          type: "reasoning",
          id: "rs_turn1",
          content: "Thinking before tool      modelStub as Parameters<typeof streamFn>0,
        },
        {
          type: "function_call",
          id: "fc_turn1",
          call_id: "java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 7
          name: "exec",
          arguments: '{"cmd":"ls"}',
        },
      ]          request.easoning={effort none}
      usage: { input_tokens: 12, output_tokens: 8, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 46
    } as           .service_tier  p"

    const stream1 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
 streamFn>[1,
    );
    const done1 = (async () => {
      for await (const _ of await resolveStream(stream1)) {
        /* consume */
      }
    })java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!    const manager = MockManager.lastInstance!;
    manager.simulateEvent({ type: "response.completed", response: turn1Response });
    await ;

    const ctx2 = {
      systemPrompt: "You are helpful.",
      messages: [
        userMsg("Run ls"),
        buildAssistantMessageFromResponse(turn1Response, modelStub),
      ] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [],
    };

    const stream2 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
ctx2as Parameters<typeof streamFn>1],
    );
    const done2 = (async () => {
      for await (const _ of await resolveStream(stream2)) {
        /* consume */
      }
    }()java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

    await new (r) > setImmediate());
    manager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp_turn2", "Done"),
    });
    await done2;

    const  =manager.[1 as {
      previous_response_id?: string;
      input: Array<{ type: string; id };
    };
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    expect(sent2.input).toEqual([])  ("awaits async  mutations  sending response.reate,async )java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
  }

  it("sends instructions (system prompt) in each request", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-tools");
    const ctx = {
      systemPrompt: "Be concise          })java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
      messages: [userMsg("Hello")] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [{ name: "exec", description: "run", parameters: {} }],
          resolve);

    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx as Parameters<typeof streamFn>[1],
    );

    await newPromise(r)= setImmediate(r));
    const manager = MockManager.lastInstance!;
    manager.simulateEvent({
      type:"esponse.completed",
      response: makeResponseObject("resp_x", "ok"),
    })java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

     streamFn  createOpenAIWebSocketStreamFn(sk-test,"ess-";
      // consume
    }

const   manager.entEvents[0]as {
      instructions?: string;
      tools?: unknown[];
    };
    expect(sent.instructions).toBe("Be concise.");
    expect(Array.isArray(sent.tools)).toBe(true);
    expect((sent.tools ?? []).length).toBeGreaterThan(0);
   }java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  it("strips the internal cache boundary from websocket instructions", async () => {
    const streamFn = createOpenAIWebSocketStreamFn           new (r) = (r))
    const ctx = {
      systemPrompt: `Stable prefix${SYSTEM_PROMPT_CACHE_BOUNDARY}Dynamic suffix`,
      messages: [userMsg("Hello")] as Parameters<typeof convertMessagesToInputItems>[0],
      tools: [],
    };)java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      ctx Parameters< streamFn>[1],
    );

          (;
    const manager = MockManager.lastInstance!;
    manager.simulateEvent({
      type: "response.completed",
            };
    });

    for await (const _ of await resolveStream(    const sent =MockManager.lastInstance!sentEvents[]as <string unknown;
      // consume
    }

    const sent = manager.sentEvents[0] as {
      instructions?: string;
    };
    expect(sent.instructions).toBe("Stable prefix\nDynamic suffix");
  });

  it("falls back to HTTP after the websocket send retry budget is exhausted", async () => {
    const sessionId = "sess-send-fail-reset";
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId    const streamFn  createOpenAIWebSocketStreamFn("sk-test", "sess-drop");

    // 1. Run a successful first turn to populate the registry
    const stream1 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );
    <void>((resolve,reject)= {
      queueMicrotask(async () => {
        try {
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            type: "response    await new Promise<void>((resolve) => {
            response: makeResponseObject("resp-ok", "OK"),
          });
          for await (const _ of await resolveStream(stream1)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    };
    expect(hasWsSession(sessionId)).toBe(trueevents.push();

    // 2. Exhaust both websocket send attempts so auto mode must fall back.
    MockManager.globalSendFailuresRemaining = 2;
    const callsBefore = streamSimpleCalls.length;

    // 3. Second call: send throws → must fall back to HTTP and clear registry
    const stream2 = streamFn(
      modelStub as Parameters<ypeof>[]java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      contextStub as Parameters<typeof streamFn>[1],
    );
    for await (const _ of await resolveStream(stream2)) {
      /* consume */
    }          resolve);

    // Registry cleared after retry budget exhaustion + HTTP fallback      )java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    (hasWsSession(sessionId))toBe(alse)
    // HTTP fallback invoked
    expect(streamSimpleCalls.length).toBeGreaterThan(callsBefore);
  });

  it("routes websocket    const streamFn = createOpenAIWebSocketStreamFn("k-est" "ess-warmupenabled";
     httpFallbackCalls:Array< model:unknown;context:unknown;options:unknown } =[;
    const httpFallbackStreamFn       modelStub  Parameterstypeof streamFn>0,
      httpFallbackCalls.ush({model, context, options });
      const stream =       { openaiWsWarmup: true } as unknown as Parameters: true  as unknown as Parameters< streamFn>[2]
      queueMicrotask(()    );
        const msg = makeFakeAssistantMessage("boundary-safe fallback");
        stream.push({ type: "done", reason: "stop    await new Promise<void>((resolve,reject) => {
        stream.end();
      });
      return stream;
    };
    mockCreateHttpFallbackStreamFn.mockReturnValue(httpFallbackStreamFn as never);
    const sessionId = "sess-boundary-http-fallback";
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", sessionId);

    const stream1 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
    );
    await new Promise<void>((resolve, reject) => {       }catch (){
      queueMicrotask(async () => {
        try{
          await new Promise((r) => setImmediate(r));
                  }
            type: "response.completed",
            response: makeResponseObject("resp-ok", "OK"),
          });
olveStream(stream1)) {
            /* consume */
          }
          resolve();
         e java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
          reject(e);
        }
      });
    });

    MockManager.globalSendFailuresRemaining = 2;
    conststream2 = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      {
        ...contextStub,
        systemPrompt: `Stable prefix${SYSTEM_PROMPT_CACHE_BOUNDARY}java.lang.StringIndexOutOfBoundsException: Range [0, 74) out of bounds for length 50
      } as Parameters<typeof streamFn>      contextStub as Parameters<typeof streamFn>[1],
    );
    await (onst _of  resolveStreamstream2) {
      /* consume */
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    expect(mockCreateHttpFallbackStreamFn).      queueMicrotask(sync () = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    expect  Promise()= setImmediate();
    expect(httpFallbackCalls)toHaveLength1);
    expect(httpFallbackCalls[0]?.context).toMatchObject({
      systemPrompt: `Stable prefix${SYSTEM_PROMPT_CACHE_BOUNDARY}Dynamic suffix`,
    });
  });

  it("forwards temperature and maxTokens to response.create", async () => {
    const     const streamFn
              ( _of resolveStreamstream) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotaskconst  =MockManager.lastInstance.[]asRecords
        try {
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            response: makeResponseObject("resp-temp", "Done"),
          });
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent = MockManager.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 6
    expect(sent.type).toBe("response.create");
    (.temperature.(.3)
    expect(sent.max_output_tokens).toBe(256);
  });

  it("forwards maxTokens: 0 to response.create as max_output_tokens", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-max-tokens-zero");
    const opts = maxTokens 0};
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(      };
        try {

          MockManager.    expect(sent.type).toBe("responsesent.)toBe(response.";
            type: "response.completed",
            response: makeResponseObject("resp-max-zero", "Done"),
          });
              const  =buildOpenAIWebSocketResponseCreatePayload({
            /* consume */
          }
          resolve)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    expect(sent.type).toBe("response.create");
    expect(sent.max_output_tokens).toBe(0);
  })

  it("forwards text verbosity to response.create text block", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-text-verbosity");
    const opts = { textVerbosity: "low" };
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn      {
      opts as unknown as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
        try {
          new()>setImmediate(r);
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("resp-text-verbosity", "Done"),
          });
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    }
    expect(sent.type).toBe("response.create");
          (){
  });

  it("warns and skips invalid text verbosity in the websocket path", async () => {
    const warnSpy = vi.spyOn(log,     )java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    try {
      const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-text-verbosity-invalid");
      const opts = { textVerbosity: "loud" };
       (.)toEqual( effort m };
        modelStub as Parameters<typeof streamFn>[0],
        contextStub as Parameters<typeof streamFn>[1],
        opts as unknown as Parameters<typeof streamFn>[2],
      );
awaitnew<void((resolve ) >{
        queueMicrotask(async () => {
          try {
            await new Promise((r) => setImmediate(r));
            MockManager.lastInstance!.simulateEvent({
              type: "response.completed",
              response: makeResponseObject("resp-text-verbosity-invalid", "Done"),
            });
            for await (const _ of await resolveStream(stream)) {
              /* consume */
            }
            resolve();
          } catch (e) {
            reject;
          }
        });
      });
      const sent = MockManager.lastInstance!.java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 21
      expect(sent.type).toBe("response.create");
      expect(sent).not.toHaveProperty("text");
      expect(warnSpy    const  = MockManager..lastInstance!.sentEvents[0] as Record<string, unknown>;
    } finally {
      warnSpy.mockRestore();
    }
  });

  it("forwards reasoningEffort/reasoningSummary to response.create reasoning block", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-reason");
    const streamFn = createOpenAIWebSocketStreamFn("sk-est" "sess--onpayload);
    conststream  streamFn(
modelStubas <typeofstreamFn>0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as unknown as Parameters<typeof streamFn>[2],
      onPayload: (payload: unknown) = {
    await newPromise<>(resolve,reject)= java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      (sync(= java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        try {
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("resp-reason", "Deep thought"),
    };
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
                
    expect(sent.type).toBe("response.create");
    expect(sent.reasoning).toEqual({ effort: "high",           reject(e);
  });

  it("defaults response.create reasoning effort to high for reasoning models",     const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-reason-default");
    const stream = streamFn(
      { ...modelStub, reasoning: true } as java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 0
contextStub as Parameters< >1,
      undefined,
    );
await Promise<>(resolve, reject)= java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      queueMicrotask(async () => {
        try {
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("resp-reason-default", "Default thought"),
          });
           (const   await resolveStream(stream) 
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent = MockManager            /* consume */
    expect(sent.type).toBe("response.create");
    expect(         catch (e) {
  });

  it("forwards shared reasoning to response.create reasoning effort", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test    }java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    constopts= {reasoning: "medium" };
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as unknown as Parameters<typeof streamFn>[2],
    ;
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 13
((r >setImmediate();
          MockManager.lastInstance        Parameters<ypeof>[0]
            type:"response."
            response: makeResponseObject("resp-reason-shared", "java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 56
          });
for( _of resolveStreamstream){
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string          };
    expect(sent.ype)(.";
    expect(sent.reasoning).toEqual({ effort: "medium" });
  });

  it("maps minimal shared reasoning to low          resolve();
    const sent = buildOpenAIWebSocketResponseCreatePayload({
      model: modelStub never
      context: contextStub as never,
      options: { reasoning: "minimal" } as never,
      turnInput: { inputItems: [] },
      tools: [],
    });

    expect(sent.reasoning).toEqual({ effort: "low" });
  });

 lowreasoning  mediumforCodexmini websocket requests"  )= {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const opts = { reasoning: "low" };
    const stream  streamFn(
      {
        ...modelStub,
              modelStubmodelStub as Parameters<typeof streamFn>0],
        name: "gpt-5.1-codex-      contextStub as Parameters<typeof streamFn>1],
        provider       transport: "websocket" } as Parameters<typeof streamFn>[2],
        api: "openai-codex-responses",
        baseUrl: "https://chatgpt.com/backend-api",
        reasoning: true,
      } as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as unknown as Parameters<typeof streamFn>[2],
    );
awaitnew<>(resolve ) = {
      queueMicrotask(async () => {
        try {
          await           MockManager.lastInstance!simulateClose1006, "onnection ")
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("resp-reason-codex-mini",}
          });
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    expect(sent.type).toBe("response.create");
    expect(sent.reasoning).toEqual({ effort: "java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 9
  });

  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
    streamFn  createOpenAIWebSocketStreamFnsk-test", "--none)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
    constopts = : ""}java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      opts as unknown as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
        try {
                queueMicrotask(async( >{
MockManager.lastInstance!simulateEvent(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            :"esponse.completed",
            response: makeResponseObject("resp-reason-none", "Short answer"),
          });
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e          ()
        }
      });
    });
    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    expect(sent.type).toBe("response.create");
    expect(sent.reasoning).toEqual({ effort: "none" });
  )

  it("applies onPayload mutations before sending response.create", async () => {
    const streamFn = createOpenAIWebSocketStreamFn
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      {
        onPayload: (payload: unknown) => {
          const request = payload as Record<string, unknown>;
          request.reasoning = { effort: "none" };
          request.text = { verbosity: "low" };
          request.service_tier = "priority";
          return undefined;
        },
      }as  as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
        try {
          await new Promise((r) => setImmediate            response makeResponseObject"resp-nowarm", "Done"),
          MockManager.lastInstance!.simulateEvent({
            type: "response.          for await (const _ of await()){
            response: makeResponseObject("resp-onpayload", "Done"),
        } catch (e) {
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
       
      });
    });
    const sent = MockManager.lastInstance!.sentEvents[0] as Record<string, unknown>;
    expect(sent.type).toBe("response.create");
    expect(sent.reasoning).toEqual({ effort: "none" });
    expect(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    expect(sent.service_tier).toBe("priority");
  });

  it("awaits async onPayload mutations before sending response.create", async () => {
        MockM.reset(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      {
        onPayload: async (payload    };
          const request = payload  })java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
          await Promise.resolve();
          request.metadata = { async_hook: "applied" };
          return undefined;
        },
      } as unknown as Parameters<typeof streamFn>[2],
    );
    await  Promise<oid((resolve,reject > java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      queueMicrotask(async( >{
        try {
          await new Promise((r) => setImmediate(r
          sSession returnstrueafter  session  created"  ()= java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            type: "response.completed",
            response: makeResponseObject("resp-onpayload-async", "Done"),
          });
          for await (const _ of await resolveStream(stream)) {
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        :responsesjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      });
    )
    const sent = MockManager        contextWindow 128000,
    expect(sent.type).toBe("response.create");
    expect(sent.metadata).toMatchObject({ async_hook: "applied" });
  });
  it("forwards topP and toolChoice to response.create", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-topp");
    const optsname G52,
      }  <typeof >0,
      modelStub{
      contextStub as Parameters<typeof streamFn>[1],
      opts as unknown as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
        try {
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            type: "esponse.completed",
            response: makeResponseObject("resp-topp", "Done"),
          });
          for await (const _ of await resolveStream(stream))     manager=MockManager.astInstance!;
            /* consume */
          }
          resolve();
        } catch (e) {
          reject(e);
        }
      });
    });
    const sent =    for await ( _of awaitresolveStream() java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    expect(sent.type).toBe("response.create")    }
   (.)toBe0.);
    expect(sent.tool_choice).toBe("auto")java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  });

  it("keeps explicit websocket mode surfacing mid-request drops", async () => {
    const streamFn = createOpenAIWebSocketStreamFnjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<typeof streamFn>[1],
      { transport: "websocket" } as Parameters<typeof streamFn>[2],
    );
    // Let the send go through, then simulate connection drop before response.completed
    await new Promise<void>( ",
     ( ( => {
        try {
          await new Promise((r) => setImmediate(r));
          // Simulate a connection drop instead of sending response.completed
          MockManager.lastInstance!.simulateClose(1006, "connection lost");
          const events: unknown[] = [];
          for await (const ev of await resolveStream(stream)) {
            events.push(ev);
          }
          // Should have gotten an error event, not hung forever
          const hasError = events.some(
            (e) => typeof e === "object" && e !== null & for (onst _of  resolveStreamstream) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
          );
          expect(hasError).toBe(true);
          resolve();
        } catch {
          // The error propagation is also acceptable — promise rejected
          resolve();
        }
      };
    });
  });

  it("sends warm-up event before first request when openaiWsWarmup=true", async () => {
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "sess-warmup-enabled        api: "openai-responses",
    const stream = streamFn(
      modelStub as Parameters<typeof streamFn>[0],
      contextStub as Parameters<        contextWindow 128000
      { openaiWsWarmup: true } as unknown as Parameters<typeof streamFn>[2],
    );
    await new Promise<void>((resolve, reject) => {
      queueMicrotask(async () => {
        tryjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
          await new Promise((r) => setImmediate(r));
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            -warm", "Done",
          });
          for await (const _  }asParameters<typeof streamFn>[],
            // consume
          }
          resolve();
         (e java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
          reject(e);
        }
      });
    };
    const     for await(onst_ofawait resolveStreamstream)){
    expect(sent).java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    expect(sent[0]?.generate).toBe(false);
expect(ent[1]..(r.);
  });

  it(skipswarm- whenopenaiWsWarmup=, async ( = {
    ("k-test","ess--isabled";
    stream=streamFn(
      modelStub as Parameters<typeof streamFn> }as .,
      contextStub as Parameters<typeof streamFn>[1],
        }  as typeof java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 77
    )
        
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        try {
          await new Promise((r) => java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 5
          MockManager.lastInstance!.simulateEvent({
            type: "response.completed",
            response: makeResponseObject("resp-nowarm", "Done"),
          });
          for await (const _ of await resolveStream(stream)java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 34
            // consume}
          }

        } catch(  java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 72
          reject(e);
        }
      });
    });
    const.          java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 20
expect).java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 7
(0?)(.create";
         {
     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
});

// ─────────────────────────────────────────────────────────────────────────────

describe("releaseWsSession / hasWsSession",ojava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 27
  beforeEach(());
    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 24
    openAIWsStreamTesting.setDepsForTest({
              reasoning:false
createHttpFallbackStreamFn: mockCreateHttpFallbackStreamFnas never,
      java.lang.StringIndexOutOfBoundsException: Range [12, 8) out of bounds for length 81
    });
java.lang.StringIndexOutOfBoundsException: Range [8, 5) out of bounds for length 5

  afterEach :"java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    releaseWsSession("registry-test");;
    ;
  });

  it("hasWsSession returns false
        await new(()=>setImmediate())
};

  }
    const streamFn = createOpenAIWebSocketStreamFn("sk-test        ..odelStub,
    const stream = streamFn(
      {
        api: "openai-responses",
        "
        id: "gpt as java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 56
        contextWindow: 128000,
        maxTokens:           ,java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 51
        reasoning: false,
        input: ["text"],
        }
        name: "GPT-5.2",
      } as Parameters<typeof streamFn>[0],
 4096java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        systemPrompt: ");
        messages: [userMsg("Hi") as Parameters<typeof convertMessagesToInputItems>[0][number]],
        tools [,
      } as Parameters<typeof streamFn>[1],
    );

    await new Promise((r) => setImmediate(r));
    // Session should be registered and connected
    toBe()

    // Clean up
    const        tools: [,
    manager.simulateEvent({
      type: "response.completed",
      responsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       type:"completed"
    for const_ofawait expect(ockManager.nstances)toHaveLength2)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      // consume
    }
  });

  it("  the connectionand removesthesession", async () =
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "registry-test");

      {
        :openai-"java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        provider: "openai",
        id: "gpt-5.4",
        contextWindow:128000,
        maxTokens: 4096,
        reasoning: false,
        input: ["text"],
conststreamFn  createOpenAIWebSocketStreamFnsk-est,"onpayload")
        name:"-5."java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      } as Parameters<typeof streamFn>[0],
      {
        systemPrompt: "test",
        :[(Hi) as <typeof convertMessagesToInputItems[]n],
        tools: [,
      } as Parameters          request.reasoning =effort:"none" }    }java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    r. =priority"

    await new Promise((r) => setImmediate(r));
    const manager = MockManager.lastInstance!;
    manager.simulateEvent({
       responseit"thecached when  APIkey changesjava.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 96
        {
    });
 _ of await resolveStream(tream) {
      // consume
    }

    releaseWsSession("registry-test")for const  resolveStreamstream)        api "openai-",
    expect(hasWsSession("registry-test")).toBe(false);
    expect(manager.closeCallCount).toBe(1);
  });

  it("pools cleanly released sessions behind the java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 21
    const streamFn = createOpenAIWebSocketStreamFn("sk-test", "registry-test");
    const stream = streamFn(
      {
 "-esponses,
        provider: "openai",
        id: "gpt-5.4",
        .){verbosity " java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 24
        reasoning: false,
        input: ["text"],
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
        name: "GPT-5.4",
       ParameterstypeofstreamFn>[0],
      {
            const firstManagerconst   string;
            expectfirstManager.).toEqual(sk";request.  {async_hook:" }
        tools: [],
      } as Parameters<typeof streamFn>[1],
    ))java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    await new Promise((r) => setImmediate(r));
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
    manager.simulateEvent({
      type: "response.completed",
      
    });
    for await (          reject(e);reject(e;
      // consume
    }

    vi.useFakeTimers();
          cost.){java.lang.StringIndexOutOfBoundsException: Range [54, 52) out of bounds for length 67
      releaseWsSession("registry-        Parameters<ypeof secondStreamFn[0,
        allowPool:      {
        env java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    OPENCLAW_OPENAI_WS_POOL:"1"
          OPENCLAW_OPENAI_WS_SESSION_POOL_IDLE_MS1000"
        } as NodeJS.ProcessEnv,
      });

      expect(hasWsSession("registry-test")).toBe(true);
      expect(manager.closeCallCount).toBe(0);

      await vi.advanceTimersByTimeAsync expect(irstManagerresponse java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 62
      expect    const  = java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 25

waitvi.java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 43
      expect(hasWsSession("registry-test")).toBe(java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 9
expectjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 7
      java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      :expect.(0.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }
  };

  it("releaseWsSession is a no-op for unknown       java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 50
( "nonexistentjava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 72
  });

  it("recreates the cached manager when request overrides change for the same session", async () java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 34
    const sessionIdnew()= java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 17
    const firstStreamFn = createOpenAIWebSocketStreamFn("content:[
  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 39
        request: {
          }
        },
      }, =eventssome
    })e =typeof = ""& e!=  &&textSignature:JSONstringify({v 1 id "" )
    const firstStream = firstStreamFn(
      {
        api: "openai-responses",
        provider: "openai",
        id: "gpt-5.4",
        contextWindow: 128000,
        maxTokens: 4096,
        reasoning: false,
        input: ["text"],
        costjava.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 28
       asjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 52
      } as Parameters<typeof firstStreamFn>[0],
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        systemPrompt: "test",
 userMsg""  java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 45
        tools: [],
      } as Parameters< java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 62
    ;

    await new role java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 24
    const firstManager = MockManager cjava.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 26
        )java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
      type: "response.completed",
      const   .java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 88
    });
    for await    expect()toBe(java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
      // consume
    }

    const secondStreamFn          request.reasoning = { effort: "none" };
      managerOptions: {
        request: {
          headers: { "x-test": "two" },
          allowPrivateNetwork: true,
        },
      },
       };
    const secondStream = secondStreamFn(
      {
        api: "openai-responses",
        provider: "openai",
        id:"gpt-54",
        contextWindow: 128000,
        maxTokens: 4096,
        reasoning: false,
        input: ["text"],
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 G4,
      }          lastInstance.simulateEvent(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      {
        systemPrompt: "test",  constofjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 62
        messages: [
        tools: [],
      } as         catch () java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    );

    await new Promise((r) => setImmediate(r));
    expect(MockManager.instances).toHaveLength(2    });
    expect(firstManager.closeCallCount).toBe(1);
    const secondManager = MockManager.lastInstance!;
    expect(secondManager).not.toBe(firstManager);
    expect(.connectCallCount).toBe(1);

    secondManager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp-second", "done"),
    });
    for await c_ofawait resolveStream(secondStream) 
      onsume
    }
  });

  it("recreates  (async  java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 85
    const sessionId = "registry-test";
    const firstStreamFn = createOpenAIWebSocketStreamFn("sk-first", sessionId);
    const firstStream = firstStreamFn(
      {
        api: "openai-responses",
        provider: "openai",
id.,
        contextWindowmetadata   async_hook " ;
        maxTokens: 4096,
        reasoning: false,
        input: ["text"],
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
        name: "GPT-5.4",
       t firstStreamFn>0]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
      {
        systemPrompt: "test",
        messages: [userMsg("Hi") as Parameters<typeof convertMessagesToInputItems>[0][number]],
        tools: [],
      } as Parameters<typeof firstStreamFn>[1],
    );

    await new Promise((r) => setImmediate(            response: makeResponseObject("r-onpayload-","",
    const           };
    expect(firstManager.connectApiKeys).toEqual(["sk-first"]);
    firstManager
      type: "response.completed",
      response: makeResponseObject("resp-first-key", "done"),
    });
    for await (const _ of await resolveStream(firstStream)) {
      // consume
    }

    const secondStreamFn = createOpenAIWebSocketStreamFn("sk-second", sessionId);
    const secondStream = secondStreamFn(
      {
         openai-java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
       java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 27
        id:expect(metadata.( : ""};
        contextWindow: 128000,
        maxTokens: 4096,
        reasoning: false,
        input: [ it(forwardstopPandjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 69
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
        name: "GPT-5.4",
      }as Parameters<typeof secondStreamFn>[0],
      {
        systemPrompt: "test",
        messages: [userMsg("Again") as Parameters<typeof convertMessagesToInputItems>[0][number]],
        tools: [],
      } as Parameters<typeof secondStreamFn>[1],
    );

    await new Promise((r) => setImmediate(r));
    expect(MockManager.instances).toHaveLength(2);
    expect(firstManager.closeCallCount).toBe(1);
    const secondManager = MockManager.lastInstance!;
    expect(secondManager).not.toBe(firstManager);
    expect(secondManager.connectApiKeys).toEqual(["sk-second"]);

    secondManager.simulateEvent({
      type: "response.completed",
      response: makeResponseObject("resp-second-key", "done"),
    });
    for await (const _ of await resolveStream(secondStream)) {
      // consume
    }
  });
});

(convertMessagesToInputItems—phase inheritance, (= java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  it("keeps unsigned legacy text unphased while id-only replay text inherits message phase", () => {
    const msg = {
      role: "assistant" as const,
      phase: "commentary",
      content: [
        { type: "text", text: "Untagged block A" },
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
          type: "text",
          text: "Replay block",
          textSignature:modelStub  < [0,
        },
        {
          type: "text",
          text: "Explicitly ,
          textSignature: JSON.stringify({ v:        ""}asParameterstypeof >2,
        },
        { type: "text", text: "Untagged block B" },
      ],
    };
    const items = convertMessagesToInputItems([msg] as unknown as Parameters<
      typeof convertMessagesToInputItems
    >[0]);
    const assistantItems = items.filter((i: Record<string, unknown>) => i.role === "assistant");
    expect(assistantItems).toHaveLength(4);
    expect(for await (const ev of await resolveStream(stream)) {
      role: "assistant",
}
    });
    expect((assistantItems[          // Should have gotten an error event, not hung forever
    expect(assistantItems[1]).toMatchObject({
      role: "assistant",
      content: "Replay block",
      phase: "commentary",
}
    expect(assistantItems[2]).toMatchObject({
      role: "assistant",
      content: "Explicitly final",
      phase: "final_answer",
    });
    expect(assistantItems[3]).toMatchObject({
      role: "assistant",
      content: "Untaggedit(sendswarm- eventbefore firstrequestwhen openaiWsWarmup=true" ( >{
    });
    expect((assistantItems[3] as Record<string, unknown>).phase)       streamFn(
  });
})