@livekit/agents 0.7.8 → 1.0.0-next.0

package/src/llm/function_context.test.ts

@@ -1,248 +0,0 @@
-// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
-//
-// SPDX-License-Identifier: Apache-2.0
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import type { CallableFunction } from './function_context.js';
-import { oaiParams } from './function_context.js';
-
-describe('function_context', () => {
-  describe('oaiParams', () => {
-    it('should handle basic object schema', () => {
-      const schema = z.object({
-        name: z.string().describe('The user name'),
-        age: z.number().describe('The user age'),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'The user name',
-          },
-          age: {
-            type: 'number',
-            description: 'The user age',
-          },
-        },
-        required: ['name', 'age'],
-      });
-    });
-
-    it('should handle enum fields', () => {
-      const schema = z.object({
-        color: z.enum(['red', 'blue', 'green']).describe('Choose a color'),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          color: {
-            type: 'string',
-            description: 'Choose a color',
-            enum: ['red', 'blue', 'green'],
-          },
-        },
-        required: ['color'],
-      });
-    });
-
-    it('should handle array fields', () => {
-      const schema = z.object({
-        tags: z.array(z.string()).describe('List of tags'),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          tags: {
-            type: 'array',
-            description: 'List of tags',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        required: ['tags'],
-      });
-    });
-
-    it('should handle array of enums', () => {
-      const schema = z.object({
-        colors: z.array(z.enum(['red', 'blue', 'green'])).describe('List of colors'),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          colors: {
-            type: 'array',
-            description: 'List of colors',
-            items: {
-              type: 'string',
-              enum: ['red', 'blue', 'green'],
-            },
-          },
-        },
-        required: ['colors'],
-      });
-    });
-
-    it('should handle optional fields', () => {
-      const schema = z.object({
-        name: z.string().describe('The user name'),
-        age: z.number().optional().describe('The user age'),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'The user name',
-          },
-          age: {
-            type: 'number',
-            description: 'The user age',
-          },
-        },
-        required: ['name'], // age should not be required
-      });
-    });
-
-    it('should handle fields without descriptions', () => {
-      const schema = z.object({
-        name: z.string(),
-        age: z.number(),
-      });
-
-      const result = oaiParams(schema);
-
-      expect(result).toEqual({
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: undefined,
-          },
-          age: {
-            type: 'number',
-            description: undefined,
-          },
-        },
-        required: ['name', 'age'],
-      });
-    });
-  });
-
-  describe('CallableFunction type', () => {
-    it('should properly type a callable function', async () => {
-      const schema = z.object({
-        name: z.string().describe('The user name'),
-        age: z.number().describe('The user age'),
-      });
-
-      const testFunction: CallableFunction<typeof schema, string> = {
-        description: 'Test function',
-        parameters: schema,
-        execute: async (args: z.infer<typeof schema>) => {
-          // TypeScript should recognize args.name and args.age
-          return `${args.name} is ${args.age} years old`;
-        },
-      };
-
-      const result = await testFunction.execute({ name: 'John', age: 30 });
-      expect(result).toBe('John is 30 years old');
-    });
-
-    it('should handle async execution', async () => {
-      const schema = z.object({
-        delay: z.number().describe('Delay in milliseconds'),
-      });
-
-      const testFunction: CallableFunction<typeof schema, number> = {
-        description: 'Async test function',
-        parameters: schema,
-        execute: async (args: z.infer<typeof schema>) => {
-          await new Promise((resolve) => setTimeout(resolve, args.delay));
-          return args.delay;
-        },
-      };
-
-      const start = Date.now();
-      const result = await testFunction.execute({ delay: 100 });
-      const duration = Date.now() - start;
-
-      expect(result).toBe(100);
-      expect(duration).toBeGreaterThanOrEqual(95); // Allow for small timing variations
-    });
-
-    describe('nested array support', () => {
-      it('should handle nested array fields', () => {
-        const schema = z.object({
-          items: z.array(
-            z.object({
-              name: z.string().describe('the item name'),
-              modifiers: z
-                .array(
-                  z.object({
-                    modifier_name: z.string(),
-                    modifier_value: z.string(),
-                  }),
-                )
-                .describe('list of the modifiers applied on this item, such as size'),
-            }),
-          ),
-        });
-        const result = oaiParams(schema);
-        expect(result).toEqual({
-          type: 'object',
-          properties: {
-            items: {
-              type: 'array',
-              description: undefined,
-              items: {
-                type: 'object',
-                properties: {
-                  name: {
-                    type: 'string',
-                    description: 'the item name',
-                  },
-                  modifiers: {
-                    type: 'array',
-                    description: 'list of the modifiers applied on this item, such as size',
-                    items: {
-                      type: 'object',
-                      properties: {
-                        modifier_name: {
-                          type: 'string',
-                        },
-                        modifier_value: {
-                          type: 'string',
-                        },
-                      },
-                      required: ['modifier_name', 'modifier_value'],
-                    },
-                  },
-                },
-                required: ['name', 'modifiers'],
-              },
-            },
-          },
-          required: ['items'],
-        });
-      });
-    });
-  });
-});

package/src/llm/function_context.ts

@@ -1,142 +0,0 @@
-// SPDX-FileCopyrightText: 2024 LiveKit, Inc.
-//
-// SPDX-License-Identifier: Apache-2.0
-import { z } from 'zod';
-
-// heavily inspired by Vercel AI's `tool()`:
-// https://github.com/vercel/ai/blob/3b0983b/packages/ai/core/tool/tool.ts
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/** Type reinforcement for the callable function's execute parameters. */
-export type inferParameters<P extends z.ZodTypeAny> = z.infer<P>;
-
-/** Raw OpenAI-adherent function parameters. */
-export type OpenAIFunctionParameters = {
-  type: 'object';
-  properties: { [id: string]: any };
-  required: string[];
-  additionalProperties: boolean;
-};
-
-/** A definition for a function callable by the LLM. */
-export interface CallableFunction<P extends z.ZodTypeAny = any, R = any> {
-  description: string;
-  parameters: OpenAIFunctionParameters | P;
-  execute: (args: inferParameters<P>) => PromiseLike<R>;
-}
-
-/** A function that has been called but is not yet running */
-export interface FunctionCallInfo<P extends z.ZodTypeAny = any, R = any> {
-  name: string;
-  func: CallableFunction<P, R>;
-  toolCallId: string;
-  rawParams: string;
-  params: inferParameters<P>;
-  task?: PromiseLike<CallableFunctionResult>;
-}
-
-/** The result of a ran FunctionCallInfo. */
-export interface CallableFunctionResult {
-  name: string;
-  toolCallId: string;
-  result?: any;
-  error?: any;
-}
-
-/** An object containing callable functions and their names */
-export type FunctionContext = {
-  [name: string]: CallableFunction;
-};
-
-// XXX: Zod is victim to the dual-package hazard. this is a hacky sorta-fix
-// until Zod v4.0.0 is released.
-// https://github.com/colinhacks/zod/issues/2241#issuecomment-2142688925
-const looksLikeInstanceof = <T>(value: unknown, target: new (...args: any[]) => T): value is T => {
-  let current = value?.constructor;
-  do {
-    if (current?.name === target.name) return true;
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    current = Object.getPrototypeOf(current) as Function;
-  } while (current?.name);
-  return false;
-};
-
-/** @internal */
-export const oaiParams = (p: z.AnyZodObject) => {
-  const properties: Record<string, any> = {};
-  const requiredProperties: string[] = [];
-
-  const processZodType = (field: z.ZodTypeAny): any => {
-    const isOptional = field instanceof z.ZodOptional;
-    const nestedField = isOptional ? field._def.innerType : field;
-    const description = field._def.description;
-
-    if (looksLikeInstanceof(nestedField, z.ZodEnum)) {
-      return {
-        type: typeof nestedField._def.values[0],
-        ...(description && { description }),
-        enum: nestedField._def.values,
-      };
-    } else if (looksLikeInstanceof(nestedField, z.ZodArray)) {
-      const elementType = nestedField._def.type;
-      return {
-        type: 'array',
-        ...(description && { description }),
-        items: processZodType(elementType),
-      };
-    } else if (looksLikeInstanceof(nestedField, z.ZodObject)) {
-      const { properties, required } = oaiParams(nestedField);
-      return {
-        type: 'object',
-        ...(description && { description }),
-        properties,
-        required,
-      };
-    } else {
-      let type = nestedField._def.typeName.toLowerCase();
-      type = type.includes('zod') ? type.substring(3) : type;
-      return {
-        type,
-        ...(description && { description }),
-      };
-    }
-  };
-
-  for (const key in p.shape) {
-    const field = p.shape[key];
-    properties[key] = processZodType(field);
-
-    if (!(field instanceof z.ZodOptional)) {
-      requiredProperties.push(key);
-    }
-  }
-
-  const type = 'object' as const;
-  return {
-    type,
-    properties,
-    required: requiredProperties,
-  };
-};
-
-/** @internal */
-export const oaiBuildFunctionInfo = (
-  fncCtx: FunctionContext,
-  toolCallId: string,
-  fncName: string,
-  rawArgs: string,
-): FunctionCallInfo => {
-  const func = fncCtx[fncName];
-  if (!func) {
-    throw new Error(`AI function ${fncName} not found`);
-  }
-
-  return {
-    name: fncName,
-    func,
-    toolCallId,
-    rawParams: rawArgs,
-    params: JSON.parse(rawArgs),
-  };
-};