refactor: remove _tag wrapper and fix type safety in streaming events

- Import proper OpenResponsesStreamEvent type instead of using any
- Remove _tag wrapper from getFullResponsesStream events
- Emit events directly with clean discriminated union on type field
- Add ToolPreliminaryResultEvent type for generator tool results
- Add isToolPreliminaryResultEvent type guard helper
- Update tests to use clean API without internal _tag field
- Export new type and helper from main index

This provides a cleaner API surface without exposing internal
implementation details like _tag, while maintaining full type safety.

Author: mattapperson

src/index.ts

@@ -10,7 +10,7 @@ export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
 export { ResponseWrapper } from "./lib/response-wrapper.js";
 export type { GetResponseOptions } from "./lib/response-wrapper.js";
 export { ReusableReadableStream } from "./lib/reusable-stream.js";
-export { ToolType } from "./lib/tool-types.js";
+export { ToolType, isToolPreliminaryResultEvent } from "./lib/tool-types.js";
 export type {
   EnhancedTool,
   ToolWithExecute,
@@ -23,6 +23,7 @@ export type {
   EnhancedResponseStreamEvent,
   ToolStreamEvent,
   ChatStreamEvent,
+  ToolPreliminaryResultEvent,
 } from "./lib/tool-types.js";
 // #endregion
 export * from "./sdk/sdk.js";

src/lib/response-wrapper.ts

@@ -339,19 +339,18 @@ export class ResponseWrapper {
 
       const consumer = this.reusableStream.createConsumer();
 
-      // Yield original events wrapped
+      // Yield original events directly
       for await (const event of consumer) {
-        yield { _tag: "original" as const, event };
+        yield event;
       }
 
       // After stream completes, check if tools were executed and emit preliminary results
       await this.executeToolsIfNeeded();
 
-      // Emit all preliminary results
+      // Emit all preliminary results as new event types
       for (const [toolCallId, results] of this.preliminaryResults) {
         for (const result of results) {
           yield {
-            _tag: "tool_preliminary" as const,
             type: "tool.preliminary_result" as const,
             toolCallId,
             result,

src/lib/tool-types.ts

@@ -1,5 +1,6 @@
 import { z, type ZodType, type ZodObject, type ZodRawShape } from "zod/v4";
 import * as models from "../models/index.js";
+import type { OpenResponsesStreamEvent } from "../models/index.js";
 
 /**
  * Tool type enum for enhanced tools
@@ -210,19 +211,32 @@ export interface APITool {
   parameters: { [k: string]: any | null } | null;
 }
 
+/**
+ * Tool preliminary result event emitted during generator tool execution
+ */
+export type ToolPreliminaryResultEvent = {
+  type: "tool.preliminary_result";
+  toolCallId: string;
+  result: unknown;
+  timestamp: number;
+};
+
 /**
  * Enhanced stream event types for getFullResponsesStream
  * Extends OpenResponsesStreamEvent with tool preliminary results
  */
 export type EnhancedResponseStreamEvent =
-  | { _tag: "original"; event: any } // Original OpenResponsesStreamEvent
-  | {
-      _tag: "tool_preliminary";
-      type: "tool.preliminary_result";
-      toolCallId: string;
-      result: unknown;
-      timestamp: number;
-    };
+  | OpenResponsesStreamEvent
+  | ToolPreliminaryResultEvent;
+
+/**
+ * Type guard to check if an event is a tool preliminary result event
+ */
+export function isToolPreliminaryResultEvent(
+  event: EnhancedResponseStreamEvent
+): event is ToolPreliminaryResultEvent {
+  return event.type === "tool.preliminary_result";
+}
 
 /**
  * Tool stream event types for getToolStream

tests/e2e/getResponse.test.ts

@@ -306,23 +306,19 @@ describe("getResponse E2E Tests", () => {
 
       for await (const event of response.getFullResponsesStream()) {
         expect(event).toBeDefined();
-        expect("_tag" in event).toBe(true);
+        expect("type" in event).toBe(true);
         events.push(event);
       }
 
       expect(events.length).toBeGreaterThan(0);
 
-      // Get original events only
-      const originalEvents = events.filter((e) => e._tag === "original");
-      expect(originalEvents.length).toBeGreaterThan(0);
-
-      // Verify we have different event types in original events
-      const eventTypes = new Set(originalEvents.map((e) => e.event?.type).filter(Boolean));
+      // Verify we have different event types
+      const eventTypes = new Set(events.map((e) => e.type));
       expect(eventTypes.size).toBeGreaterThan(1);
 
       // Should have completion event
-      const hasCompletionEvent = originalEvents.some(
-        (e) => e.event?.type === "response.completed" || e.event?.type === "response.incomplete"
+      const hasCompletionEvent = events.some(
+        (e) => e.type === "response.completed" || e.type === "response.incomplete"
       );
       expect(hasCompletionEvent).toBe(true);
     }, 15000);
@@ -340,9 +336,9 @@ describe("getResponse E2E Tests", () => {
 
       const textDeltaEvents: any[] = [];
 
-      for await (const wrappedEvent of response.getFullResponsesStream()) {
-        if (wrappedEvent._tag === "original" && wrappedEvent.event?.type === "response.output_text.delta") {
-          textDeltaEvents.push(wrappedEvent.event);
+      for await (const event of response.getFullResponsesStream()) {
+        if (event.type === "response.output_text.delta") {
+          textDeltaEvents.push(event);
         }
       }