tests passing

Author: 404Wolf

src/helpers/beta/zod.ts

@@ -1,47 +1,7 @@
-import { transformJSONSchema } from '../..//lib/transform-json-schema';
 import type { infer as zodInfer, ZodType } from 'zod';
 import * as z from 'zod';
-import { OpenAIError } from '../../core/error';
 import type { BetaRunnableTool, Promisable } from '../../lib/beta/BetaRunnableTool';
-import type { AutoParseableBetaOutputFormat } from '../../lib/beta-parser';
-import { FunctionTool } from '../../resources/beta';
-// import { AutoParseableBetaOutputFormat } from '../../lib/beta-parser';
-// import { BetaRunnableTool, Promisable } from '../../lib/tools/BetaRunnableTool';
-// import { BetaToolResultContentBlockParam } from '../../resources/beta';
-/**
- * Creates a JSON schema output format object from the given Zod schema.
- *
- * If this is passed to the `.parse()` method then the response message will contain a
- * `.parsed` property that is the result of parsing the content with the given Zod object.
- *
- * This can be passed directly to the `.create()` method but will not
- * result in any automatic parsing, you'll have to parse the response yourself.
- */
-export function betaZodOutputFormat<ZodInput extends ZodType>(
-  zodObject: ZodInput,
-): AutoParseableBetaOutputFormat<zodInfer<ZodInput>> {
-  let jsonSchema = z.toJSONSchema(zodObject, { reused: 'ref' });
-
-  jsonSchema = transformJSONSchema(jsonSchema);
-
-  return {
-    type: 'json_schema',
-    schema: {
-      ...jsonSchema,
-    },
-    parse: (content) => {
-      const output = zodObject.safeParse(JSON.parse(content));
-
-      if (!output.success) {
-        throw new OpenAIError(
-          `Failed to parse structured output: ${output.error.message} cause: ${output.error.issues}`,
-        );
-      }
-
-      return output.data;
-    },
-  };
-}
+import type { FunctionTool } from '../../resources/beta';
 
 /**
  * Creates a tool using the provided Zod schema that can be passed
@@ -78,34 +38,3 @@ export function betaZodTool<InputSchema extends ZodType>(options: {
     parse: (args: unknown) => options.inputSchema.parse(args) as zodInfer<InputSchema>,
   };
 }
-
-// /**
-//  * Creates a tool using the provided Zod schema that can be passed
-//  * into the `.toolRunner()` method. The Zod schema will automatically be
-//  * converted into JSON Schema when passed to the API. The provided function's
-//  * input arguments will also be validated against the provided schema.
-//  */
-// export function betaZodTool<InputSchema extends ZodType>(options: {
-//   name: string;
-//   inputSchema: InputSchema;
-//   description: string;
-//   run: (args: zodInfer<InputSchema>) => Promisable<string | Array<BetaToolResultContentBlockParam>>;
-// }): BetaRunnableTool<zodInfer<InputSchema>> {
-//   const jsonSchema = z.toJSONSchema(options.inputSchema, { reused: 'ref' });
-
-//   if (jsonSchema.type !== 'object') {
-//     throw new Error(`Zod schema for tool "${options.name}" must be an object, but got ${jsonSchema.type}`);
-//   }
-
-//   // TypeScript doesn't narrow the type after the runtime check, so we need to assert it
-//   const objectSchema = jsonSchema as typeof jsonSchema & { type: 'object' };
-
-//   return {
-//     type: 'custom',
-//     name: options.name,
-//     input_schema: objectSchema,
-//     description: options.description,
-//     run: options.run,
-//     parse: (args: unknown) => options.inputSchema.parse(args) as zodInfer<InputSchema>,
-//   };
-// }

tests/utils/mock-fetch.ts

@@ -1,47 +1,70 @@
-import { Fetch, RequestInfo, RequestInit } from 'openai/internal/builtin-types';
+import { type Fetch, type RequestInfo, type RequestInit, type Response } from 'openai/internal/builtin-types';
 import { PassThrough } from 'stream';
 
+/**
+ * Creates a mock `fetch` function and a `handleRequest` function for intercepting `fetch` calls.
+ *
+ * You call `handleRequest` with a callback function that handles the next `fetch` call.
+ * It returns a Promise that:
+ * - waits for the next call to `fetch`
+ * - calls the callback with the `fetch` arguments
+ * - resolves `fetch` with the callback output
+ */
 export function mockFetch(): {
   fetch: Fetch;
   handleRequest: (handle: Fetch) => void;
   handleStreamEvents: (events: any[]) => void;
   handleMessageStreamEvents: (iter: AsyncIterable<any>) => void;
 } {
-  const queue: Promise<typeof fetch>[] = [];
-  const readResolvers: ((handler: typeof fetch) => void)[] = [];
+  const fetchQueue: ((handler: typeof fetch) => void)[] = [];
+  const handlerQueue: Promise<typeof fetch>[] = [];
 
-  let index = 0;
+  const enqueueHandler = () => {
+    handlerQueue.push(
+      new Promise<typeof fetch>((resolve) => {
+        fetchQueue.push((handle: typeof fetch) => {
+          enqueueHandler();
+          resolve(handle);
+        });
+      }),
+    );
+  };
+  enqueueHandler();
 
   async function fetch(req: string | RequestInfo, init?: RequestInit): Promise<Response> {
-    const idx = index++;
-    if (!queue[idx]) {
-      queue.push(new Promise((resolve) => readResolvers.push(resolve)));
-    }
-
-    const handler = await queue[idx]!;
+    const handler = await handlerQueue.shift();
+    if (!handler) throw new Error('expected handler to be defined');
+    const signal = init?.signal;
+    if (!signal) return await handler(req, init);
     return await Promise.race([
       handler(req, init),
-      new Promise<Response>((_resolve, reject) => {
-        if (init?.signal?.aborted) {
-          // @ts-ignore
+      new Promise<Response>((resolve, reject) => {
+        if (signal.aborted) {
+          // @ts-ignore does exist in Node
           reject(new DOMException('The user aborted a request.', 'AbortError'));
           return;
         }
-        init?.signal?.addEventListener('abort', (_e) => {
-          // @ts-ignore
+        signal.addEventListener('abort', (e) => {
+          // @ts-ignore does exist in Node
           reject(new DOMException('The user aborted a request.', 'AbortError'));
         });
       }),
     ]);
   }
 
-  function handleRequest(handler: typeof fetch): void {
-    if (readResolvers.length) {
-      const resolver = readResolvers.shift()!;
-      resolver(handler);
-      return;
-    }
-    queue.push(Promise.resolve(handler));
+  function handleRequest(handle: typeof fetch): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      fetchQueue.shift()?.(async (req, init) => {
+        try {
+          return await handle(req, init);
+        } catch (err) {
+          reject(err);
+          return err as any;
+        } finally {
+          resolve();
+        }
+      });
+    });
   }
 
   function handleStreamEvents(events: any[]) {