openai 7.24.0 → 7.26.0

package/src/lib/beta/agents/result-collection.ts

@@ -0,0 +1,115 @@
+import { OpenAIError } from '../../../core/error';
+import type { AgentSessionEvent } from '../../../resources/beta/agents/agents';
+import type { AgentTurnResult } from './agent-turn-result';
+import { AgentTurnResultCollector } from './agent-turn-result-collector';
+import { AgentTurnResultError } from './agent-turn-result-error';
+
+/** Shares collection between a raw creation stream and the follow-up helper.
+ * @internal
+ */
+export class ResultCollection {
+  #iterator: AsyncGenerator<AgentSessionEvent, void> | undefined;
+  #ended = false;
+  #enabled = false;
+  #uncollectedEvents = false;
+  #error: unknown;
+  #result: Promise<AgentTurnResult> | undefined;
+  readonly collector: AgentTurnResultCollector;
+
+  readonly #source: () => AsyncIterator<AgentSessionEvent>;
+  readonly #signal: AbortSignal | undefined;
+  readonly #canHandle: (name: string) => boolean;
+
+  constructor(
+    source: () => AsyncIterator<AgentSessionEvent>,
+    canHandle: (name: string) => boolean = () => false,
+    sessionID?: string,
+    signal?: AbortSignal,
+  ) {
+    this.#source = source;
+    this.#signal = signal;
+    this.#canHandle = canHandle;
+    this.collector = new AgentTurnResultCollector(sessionID);
+  }
+
+  enable(): void {
+    if (!this.#enabled && this.#uncollectedEvents) {
+      throw new OpenAIError(
+        'Call withResultCollection() before consuming events, or call finalResult() on a fresh stream.',
+      );
+    }
+    this.#enabled = true;
+  }
+
+  iterate(): AsyncIterator<AgentSessionEvent> {
+    if (this.#iterator) {
+      throw new OpenAIError('An agent result stream can only be consumed once');
+    }
+    return (this.#iterator = this.#observe());
+  }
+
+  async *#observe(): AsyncGenerator<AgentSessionEvent, void> {
+    const iterator = this.#source();
+    let done = false;
+    try {
+      while (true) {
+        // oxlint-disable-next-line no-await-in-loop -- Pull the single-use stream sequentially.
+        const next = await iterator.next();
+        if (next.done) {
+          done = true;
+          return;
+        }
+        if (this.#enabled) {
+          this.collector.accept(next.value);
+        } else {
+          this.#uncollectedEvents = true;
+        }
+        yield next.value;
+      }
+    } catch (error) {
+      if (this.#enabled) {
+        this.#error = error;
+      }
+      throw error;
+    } finally {
+      this.#ended = true;
+      if (!done) {
+        await iterator.return?.();
+      }
+    }
+  }
+
+  finalResult(): Promise<AgentTurnResult> {
+    return (this.#result ??= this.#collect());
+  }
+
+  async #collect(): Promise<AgentTurnResult> {
+    this.enable();
+    try {
+      const iterator = this.#iterator ?? this.iterate();
+      while (!this.#ended && !this.collector.ready) {
+        this.collector.checkAction(this.#canHandle);
+        // oxlint-disable-next-line no-await-in-loop -- Each event can dispatch tools before the next pull.
+        const next = await iterator.next();
+        if (next.done) {
+          break;
+        }
+      }
+      if (this.#error !== undefined && !this.collector.ready) {
+        throw this.#error;
+      }
+      if (!this.collector.ready && this.#signal?.aborted) {
+        throw this.collector.error('observation', this.#signal.reason);
+      }
+      return this.collector.finish();
+    } catch (error) {
+      throw error instanceof AgentTurnResultError ? error : this.collector.error('observation', error);
+    } finally {
+      try {
+        await this.#iterator?.return();
+      } finally {
+        this.collector.release();
+      }
+    }
+  }
+}

package/src/lib/beta/agents/tool-output.ts

@@ -0,0 +1,22 @@
+import { hasOwn, isObj } from '../../../internal/utils/values';
+import type { InputContentParam } from '../../../resources/beta/agents/agents';
+
+/**
+ * Recognizes supported content blocks without confusing JSON business data with content.
+ * @internal
+ */
+export function isInputContent(value: unknown): value is InputContentParam {
+  if (!isObj(value)) {
+    return false;
+  }
+  const content = value;
+  let field: string;
+  if (content['type'] === 'input_text') {
+    field = 'text';
+  } else if (content['type'] === 'input_image') {
+    field = 'image_url';
+  } else {
+    return false;
+  }
+  return hasOwn(content, 'type') && hasOwn(content, field) && typeof content[field] === 'string';
+}

package/src/lib/responses/responses-websocket-session.ts

@@ -22,9 +22,13 @@ interface LaneState {
   bytes: number;
 }
 
+// A disposed helper cannot distinguish a delayed terminal from a later request
+// on the same socket. Retain only IDs (never lane buffers) until that socket is gone.
+const reservedLanes = new WeakMap<WebSocketLike, Set<string | undefined>>();
+
 /** Limits for this optional helper. They do not change the underlying socket's limits. */
 export interface ResponsesWebSocketSessionOptions {
-  /** Maximum lane IDs registered until the next reconnect, including detached lanes. */
+  /** Maximum lane IDs registered on the socket until the next reconnect, including detached lanes. */
   maxLanes: number;
   /** Maximum queued events across all lanes. */
   maxBufferedEvents: number;
@@ -129,10 +133,16 @@ export class ResponsesWebSocketSession {
     ) {
       throw new OpenAIError('Invalid Responses WebSocket stream ID');
     }
-    if (this.#lanes.has(streamID)) {
+    const { socket: physicalSocket } = this.#connection;
+    let reservations = reservedLanes.get(physicalSocket);
+    if (!reservations) {
+      reservations = new Set();
+      reservedLanes.set(physicalSocket, reservations);
+    }
+    if (reservations.has(streamID)) {
       throw new OpenAIError('Responses WebSocket lane is already registered');
     }
-    if (this.#lanes.size >= this.#maxLanes) {
+    if (reservations.size >= this.#maxLanes) {
       throw new OpenAIError('Responses WebSocket lane limit exceeded');
     }
     const entry: LaneState = {
@@ -160,6 +170,7 @@ export class ResponsesWebSocketSession {
         positiveInteger(limits.maxBufferedBytes ?? this.#maxBytes),
       ),
     };
+    reservations.add(streamID);
     this.#lanes.set(streamID, entry);
     return entry.lane;
   }

package/src/resources/audio/speech.ts

@@ -26,7 +26,7 @@ export class Speech extends APIResource {
    * const speech = await client.audio.speech.create({
    *   input: 'input',
    *   model: 'tts-1',
-   *   voice: 'alloy',
+   *   voice: 'ash',
    * });
    *
    * const content = await speech.blob();