openai 7.5.0 → 7.6.0

package/src/lib/AssistantStream.ts

@@ -99,19 +99,69 @@ export type RunSubmitToolOutputsParamsStream = Omit<RunSubmitToolOutputsParamsBa
   stream?: true;
 };
 
+function stabilizeAssistantStreamEvent(event: AssistantStreamEvent): {
+  event: AssistantStreamEvent;
+  exposedEvent: AssistantStreamEvent;
+} {
+  const eventDescriptor = Object.getOwnPropertyDescriptor(event, 'event');
+  const dataDescriptor = Object.getOwnPropertyDescriptor(event, 'data');
+  const eventType = Reflect.get(event, 'event', event) as AssistantStreamEvent['event'];
+  const data = Reflect.get(event, 'data', event) as AssistantStreamEvent['data'];
+  let stableData = data;
+  if (
+    eventType === 'thread.message.created' ||
+    eventType === 'thread.message.in_progress' ||
+    eventType === 'thread.message.delta' ||
+    eventType === 'thread.message.completed' ||
+    eventType === 'thread.message.incomplete' ||
+    eventType === 'thread.run.step.created' ||
+    eventType === 'thread.run.step.in_progress' ||
+    eventType === 'thread.run.step.delta' ||
+    eventType === 'thread.run.step.completed' ||
+    eventType === 'thread.run.step.failed' ||
+    eventType === 'thread.run.step.cancelled' ||
+    eventType === 'thread.run.step.expired'
+  ) {
+    const messageID = Object.getOwnPropertyDescriptor(data, 'id');
+    if (messageID && 'value' in messageID && Reflect.get(data, 'id', data) !== messageID.value) {
+      const canonicalID = messageID.value as unknown;
+      stableData = new Proxy(data, {
+        get(target, property) {
+          return property === 'id' ? canonicalID : Reflect.get(target, property, target);
+        },
+      }) as AssistantStreamEvent['data'];
+    }
+  }
+  const stableEvent = Object.freeze({ event: eventType, data: stableData }) as AssistantStreamEvent;
+  const ordinaryEvent =
+    eventDescriptor !== undefined &&
+    'value' in eventDescriptor &&
+    eventDescriptor.value === eventType &&
+    dataDescriptor !== undefined &&
+    'value' in dataDescriptor &&
+    dataDescriptor.value === data &&
+    stableData === data;
+
+  return {
+    event: stableEvent,
+    exposedEvent: ordinaryEvent ? event : ({ event: eventType, data: stableData } as AssistantStreamEvent),
+  };
+}
+
 /** Streams assistant-run events while accumulating messages, run steps, and tool-call snapshots. */
 export class AssistantStream
   extends EventStream<AssistantStreamEvents>
   implements AsyncIterable<AssistantStreamEvent>
 {
-  //Track all events in a single list for reference
-  #events: AssistantStreamEvent[] = [];
-
   //Used to accumulate deltas
   //We are accumulating many types so the value here is not strict
   #runStepSnapshots: Record<string, Runs.RunStep> = Object.create(null);
+  #runStepIDOwners = new Map<string, string>();
+  #activeRunStepID: string | undefined;
   #messageSnapshots: Record<string, Message> = Object.create(null);
+  #messageIDOwners = new Map<string, string>();
   #messageSnapshot: Message | undefined;
+  #activeMessageID: string | undefined;
   #finalRun: Run | undefined;
   #currentContentIndex: number | undefined;
   #currentContent: MessageContent | undefined;
@@ -339,11 +389,49 @@ export class AssistantStream
       return;
     }
 
-    this.#currentEvent = event;
+    const { event: stableEvent, exposedEvent } = stabilizeAssistantStreamEvent(event);
+
+    let messageID: string | undefined;
+    let messageData: MessageStreamEvent['data'] | undefined;
+    let runStepID: string | undefined;
+    let runStepData: RunStepStreamEvent['data'] | undefined;
+    switch (stableEvent.event) {
+      case 'thread.message.created':
+      case 'thread.message.in_progress':
+      case 'thread.message.delta':
+      case 'thread.message.completed':
+      case 'thread.message.incomplete': {
+        messageID = this.#validateMessageEvent(stableEvent);
+        messageData = stableEvent.data;
+        break;
+      }
+      case 'thread.run.step.created':
+      case 'thread.run.step.in_progress':
+      case 'thread.run.step.delta':
+      case 'thread.run.step.completed':
+      case 'thread.run.step.failed':
+      case 'thread.run.step.cancelled':
+      case 'thread.run.step.expired': {
+        runStepID = this.#validateRunStepEvent(stableEvent);
+        runStepData = stableEvent.data;
+        break;
+      }
+    }
+
+    this.#currentEvent = exposedEvent;
 
-    this.#handleEvent(event);
+    this.#handleEvent(exposedEvent);
+    if (messageID !== undefined && messageData !== undefined) {
+      this.#reserveMessageAlias(messageData, messageID);
+    }
+    if (runStepID !== undefined && runStepData !== undefined) {
+      this.#reserveRunStepAlias(runStepData, runStepID);
+    }
+    if (runStepID === undefined && this.#activeRunStepID !== undefined && this.#currentRunStepSnapshot) {
+      this.#reserveRunStepAlias(this.#currentRunStepSnapshot, this.#activeRunStepID);
+    }
 
-    switch (event.event) {
+    switch (stableEvent.event) {
       case 'thread.created': {
         //No action on this event.
         break;
@@ -359,7 +447,7 @@ export class AssistantStream
       case 'thread.run.cancelling':
       case 'thread.run.cancelled':
       case 'thread.run.expired': {
-        this.#handleRun(event);
+        this.#handleRun(stableEvent);
         break;
       }
 
@@ -370,7 +458,19 @@ export class AssistantStream
       case 'thread.run.step.failed':
       case 'thread.run.step.cancelled':
       case 'thread.run.step.expired': {
-        this.#handleRunStep(event);
+        if (runStepID === undefined) {
+          throw new OpenAIError('Received assistant run-step event without a canonical run-step ID');
+        }
+        const activeRunStep = this.#runStepSnapshots[runStepID];
+        if (activeRunStep) {
+          this.#reserveRunStepAlias(activeRunStep, runStepID);
+        }
+        this.#handleRunStep(stableEvent, runStepID);
+        this.#reserveRunStepAlias(stableEvent.data, runStepID);
+        const retainedRunStep = this.#runStepSnapshots[runStepID];
+        if (retainedRunStep) {
+          this.#reserveRunStepAlias(retainedRunStep, runStepID);
+        }
         break;
       }
 
@@ -379,7 +479,14 @@ export class AssistantStream
       case 'thread.message.delta':
       case 'thread.message.completed':
       case 'thread.message.incomplete': {
-        this.#handleMessage(event);
+        this.#handleMessage(stableEvent);
+        if (messageID !== undefined) {
+          this.#reserveMessageAlias(stableEvent.data, messageID);
+          const retainedMessage = this.#messageSnapshots[messageID];
+          if (retainedMessage) {
+            this.#reserveMessageAlias(retainedMessage, messageID);
+          }
+        }
         break;
       }
 
@@ -390,7 +497,7 @@ export class AssistantStream
         );
       }
       default: {
-        assertNever(event);
+        assertNever(stableEvent);
       }
     }
   }
@@ -407,10 +514,142 @@ export class AssistantStream
     return this.#finalRun;
   }
 
+  #validateRunStepEvent(event: RunStepStreamEvent): string {
+    const descriptor = Object.getOwnPropertyDescriptor(event.data, 'id');
+    const runStepID = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+
+    if (typeof runStepID !== 'string' || runStepID.length === 0) {
+      throw new OpenAIError('Received assistant run-step event with an invalid run-step ID');
+    }
+
+    if (event.event === 'thread.run.step.created') {
+      if (this.#activeRunStepID !== undefined) {
+        throw new OpenAIError(
+          `Received run-step creation for "${runStepID}" before the active run step "${this.#activeRunStepID}" reached a terminal state`,
+        );
+      }
+
+      if (hasOwn(this.#runStepSnapshots, runStepID) || this.#runStepIDOwners.has(runStepID)) {
+        throw new OpenAIError(
+          `Received run-step creation for run step "${runStepID}", which has already been created`,
+        );
+      }
+
+      this.#activeRunStepID = runStepID;
+      this.#runStepIDOwners.set(runStepID, runStepID);
+      return runStepID;
+    }
+
+    if (this.#activeRunStepID !== undefined) {
+      if (runStepID !== this.#activeRunStepID) {
+        throw new OpenAIError(
+          `Received ${event.event} for run step "${runStepID}", which does not match the active run step "${this.#activeRunStepID}"`,
+        );
+      }
+      return runStepID;
+    }
+
+    if (event.event === 'thread.run.step.delta') {
+      if (!hasOwn(this.#runStepSnapshots, runStepID)) {
+        throw new OpenAIError('Received a RunStepDelta before creation of a snapshot');
+      }
+      throw new OpenAIError(`Received run-step delta for "${runStepID}" with no active run step`);
+    }
+
+    if (hasOwn(this.#runStepSnapshots, runStepID) || this.#runStepIDOwners.has(runStepID)) {
+      throw new OpenAIError(
+        `Received run-step event for run step "${runStepID}", which has already been created`,
+      );
+    }
+
+    this.#runStepIDOwners.set(runStepID, runStepID);
+    if (event.event === 'thread.run.step.in_progress') {
+      this.#activeRunStepID = runStepID;
+    }
+    return runStepID;
+  }
+
+  #reserveRunStepAlias(data: RunStepStreamEvent['data'], canonicalID: string): void {
+    const descriptor = Object.getOwnPropertyDescriptor(data, 'id');
+    const runStepID = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+    if (typeof runStepID !== 'string' || runStepID.length === 0) {
+      throw new OpenAIError('Received assistant run-step event with an invalid run-step ID');
+    }
+    const owner = this.#runStepIDOwners.get(runStepID);
+    if (owner !== undefined && owner !== canonicalID) {
+      throw new OpenAIError(
+        `Received run-step creation for run step "${runStepID}", which has already been created`,
+      );
+    }
+    this.#runStepIDOwners.set(runStepID, canonicalID);
+  }
+
+  #validateMessageEvent(event: MessageStreamEvent): string {
+    const descriptor = Object.getOwnPropertyDescriptor(event.data, 'id');
+    const messageID = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+
+    if (typeof messageID !== 'string' || messageID.length === 0) {
+      throw new OpenAIError('Received assistant message event with an invalid message ID');
+    }
+
+    if (event.event === 'thread.message.created') {
+      if (this.#messageSnapshot) {
+        throw new OpenAIError(
+          `Received message creation for "${messageID}" before the active message "${this.#activeMessageID}" reached a terminal state`,
+        );
+      }
+
+      if (hasOwn(this.#messageSnapshots, messageID) || this.#messageIDOwners.has(messageID)) {
+        throw new OpenAIError(
+          `Received message creation for message "${messageID}", which has already been created`,
+        );
+      }
+
+      this.#activeMessageID = messageID;
+      this.#messageIDOwners.set(messageID, messageID);
+      return messageID;
+    }
+
+    if (!this.#messageSnapshot) {
+      if (event.event === 'thread.message.delta') {
+        throw new OpenAIError(
+          'Received a delta with no existing snapshot (there should be one from message creation)',
+        );
+      }
+
+      throw new OpenAIError('Received thread message event with no existing snapshot');
+    }
+
+    if (messageID !== this.#activeMessageID) {
+      throw new OpenAIError(
+        `Received ${event.event} for message "${messageID}", which does not match the active message "${this.#activeMessageID}"`,
+      );
+    }
+    return messageID;
+  }
+
+  #reserveMessageAlias(data: MessageStreamEvent['data'], canonicalID: string): void {
+    const descriptor = Object.getOwnPropertyDescriptor(data, 'id');
+    const messageID = descriptor && 'value' in descriptor ? descriptor.value : undefined;
+    if (typeof messageID !== 'string' || messageID.length === 0) {
+      throw new OpenAIError('Received assistant message event with an invalid message ID');
+    }
+    const owner = this.#messageIDOwners.get(messageID);
+    if (owner !== undefined && owner !== canonicalID) {
+      throw new OpenAIError(
+        `Received message creation for message "${messageID}", which has already been created`,
+      );
+    }
+    this.#messageIDOwners.set(messageID, canonicalID);
+  }
+
   #handleMessage(this: AssistantStream, event: MessageStreamEvent) {
     const [accumulatedMessage, newContent] = this.#accumulateMessage(event, this.#messageSnapshot);
     this.#messageSnapshot = accumulatedMessage;
-    this.#messageSnapshots[accumulatedMessage.id] = accumulatedMessage;
+    if (!this.#activeMessageID) {
+      throw new OpenAIError('Received thread message event with no active message ID');
+    }
+    this.#messageSnapshots[this.#activeMessageID] = accumulatedMessage;
 
     for (const content of newContent) {
       const snapshotContent = accumulatedMessage.content[content.index];
@@ -502,12 +741,13 @@ export class AssistantStream
         this.#currentContentIndex = undefined;
         this.#currentContent = undefined;
         this.#messageSnapshot = undefined;
+        this.#activeMessageID = undefined;
       }
     }
   }
 
-  #handleRunStep(this: AssistantStream, event: RunStepStreamEvent) {
-    const accumulatedRunStep = this.#accumulateRunStep(event);
+  #handleRunStep(this: AssistantStream, event: RunStepStreamEvent, runStepID: string) {
+    const accumulatedRunStep = this.#accumulateRunStep(event, runStepID);
     this.#currentRunStepSnapshot = accumulatedRunStep;
 
     switch (event.event) {
@@ -554,6 +794,7 @@ export class AssistantStream
       case 'thread.run.step.cancelled':
       case 'thread.run.step.expired': {
         this.#currentRunStepSnapshot = undefined;
+        this.#activeRunStepID = undefined;
         const details = event.data.step_details;
         if (details.type === 'tool_calls' && this.#currentToolCall) {
           this.#emitExposed('toolCallDone', this.#currentToolCall as ToolCall);
@@ -582,19 +823,18 @@ export class AssistantStream
   }
 
   #handleEvent(this: AssistantStream, event: AssistantStreamEvent) {
-    this.#events.push(event);
     this.#emitExposed('event', event);
   }
 
-  #accumulateRunStep(event: RunStepStreamEvent): Runs.RunStep {
+  #accumulateRunStep(event: RunStepStreamEvent, runStepID: string): Runs.RunStep {
     switch (event.event) {
       case 'thread.run.step.created': {
-        this.#runStepSnapshots[event.data.id] = event.data;
+        this.#runStepSnapshots[runStepID] = event.data;
         return event.data;
       }
 
       case 'thread.run.step.delta': {
-        const snapshot = this.#runStepSnapshots[event.data.id] as Runs.RunStep;
+        const snapshot = this.#runStepSnapshots[runStepID] as Runs.RunStep;
         if (!snapshot) {
           throw new Error('Received a RunStepDelta before creation of a snapshot');
         }
@@ -603,10 +843,10 @@ export class AssistantStream
 
         if (data.delta) {
           const accumulated = accumulateAssistantStreamDelta(snapshot, data.delta, true) as Runs.RunStep;
-          this.#runStepSnapshots[event.data.id] = accumulated;
+          this.#runStepSnapshots[runStepID] = accumulated;
         }
 
-        return this.#runStepSnapshots[event.data.id] as Runs.RunStep;
+        return this.#runStepSnapshots[runStepID] as Runs.RunStep;
       }
 
       case 'thread.run.step.completed':
@@ -614,13 +854,13 @@ export class AssistantStream
       case 'thread.run.step.cancelled':
       case 'thread.run.step.expired':
       case 'thread.run.step.in_progress': {
-        this.#runStepSnapshots[event.data.id] = event.data;
+        this.#runStepSnapshots[runStepID] = event.data;
         break;
       }
     }
 
-    if (this.#runStepSnapshots[event.data.id]) {
-      return this.#runStepSnapshots[event.data.id] as Runs.RunStep;
+    if (this.#runStepSnapshots[runStepID]) {
+      return this.#runStepSnapshots[runStepID] as Runs.RunStep;
     }
     throw new Error('No snapshot available');
   }