@livekit/agents 0.7.9 → 1.0.0-next.0

package/src/voice/transcription/synchronizer.ts

@@ -0,0 +1,478 @@
+// SPDX-FileCopyrightText: 2025 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import type { AudioFrame } from '@livekit/rtc-node';
+import { delay } from '@std/async';
+import type { ReadableStream, WritableStreamDefaultWriter } from 'node:stream/web';
+import { log } from '../../log.js';
+import { IdentityTransform } from '../../stream/identity_transform.js';
+import type { SentenceStream, SentenceTokenizer } from '../../tokenize/index.js';
+import { basic } from '../../tokenize/index.js';
+import { Future, Task } from '../../utils.js';
+import { AudioOutput, type PlaybackFinishedEvent, TextOutput } from '../io.js';
+
+const STANDARD_SPEECH_RATE = 3.83; // hyphens (syllables) per second
+
+interface TextSyncOptions {
+  speed: number;
+  hyphenateWord: (word: string) => string[];
+  splitWords: (words: string) => [string, number, number][];
+  sentenceTokenizer: SentenceTokenizer;
+}
+
+interface TextData {
+  sentenceStream: SentenceStream;
+  pushedText: string;
+  done: boolean;
+  forwardedHyphens: number;
+  forwardedText: string;
+}
+
+interface AudioData {
+  pushedDuration: number;
+  done: boolean;
+}
+
+class SegmentSynchronizerImpl {
+  private textData: TextData;
+  private audioData: AudioData;
+  private speed: number;
+  private outputStream: IdentityTransform<string>;
+  private outputStreamWriter: WritableStreamDefaultWriter<string>;
+  private captureTask: Promise<void>;
+  private startWallTime?: number;
+
+  private startFuture: Future = new Future();
+  private closedFuture: Future = new Future();
+  private playbackCompleted: boolean = false;
+
+  private logger = log();
+
+  constructor(
+    private readonly options: TextSyncOptions,
+    private readonly nextInChain: TextOutput,
+  ) {
+    this.speed = options.speed * STANDARD_SPEECH_RATE; // hyphens per second
+    this.textData = {
+      sentenceStream: options.sentenceTokenizer.stream(),
+      pushedText: '',
+      done: false,
+      forwardedHyphens: 0,
+      forwardedText: '',
+    };
+    this.audioData = {
+      pushedDuration: 0,
+      done: false,
+    };
+    this.outputStream = new IdentityTransform();
+    this.outputStreamWriter = this.outputStream.writable.getWriter();
+
+    this.mainTask()
+      .then(() => {
+        this.outputStreamWriter.close();
+      })
+      .catch((error) => {
+        this.logger.error({ error }, 'mainTask SegmentSynchronizerImpl');
+      });
+    this.captureTask = this.captureTaskImpl();
+  }
+
+  get closed() {
+    return this.closedFuture.done;
+  }
+
+  get audioInputEnded() {
+    return this.audioData.done;
+  }
+
+  get textInputEnded() {
+    return this.textData.done;
+  }
+
+  get readable(): ReadableStream<string> {
+    return this.outputStream.readable;
+  }
+
+  pushAudio(frame: AudioFrame) {
+    if (this.closed) {
+      this.logger.warn('SegmentSynchronizerImpl.pushAudio called after close');
+      return;
+    }
+    // TODO(AJS-102): use frame.durationMs once available in rtc-node
+    const frameDuration = frame.samplesPerChannel / frame.sampleRate;
+
+    if (!this.startWallTime && frameDuration > 0) {
+      this.startWallTime = Date.now();
+      this.startFuture.resolve();
+    }
+
+    this.audioData.pushedDuration += frameDuration;
+  }
+
+  endAudioInput() {
+    if (this.closed) {
+      this.logger.warn('SegmentSynchronizerImpl.endAudioInput called after close');
+      return;
+    }
+
+    this.audioData.done = true;
+  }
+
+  pushText(text: string) {
+    if (this.closed) {
+      this.logger.warn('SegmentSynchronizerImpl.pushText called after close');
+      return;
+    }
+
+    this.textData.sentenceStream.pushText(text);
+    this.textData.pushedText += text;
+  }
+
+  endTextInput() {
+    if (this.closed) {
+      this.logger.warn('SegmentSynchronizerImpl.endTextInput called after close');
+      return;
+    }
+
+    this.textData.done = true;
+    this.textData.sentenceStream.endInput();
+  }
+
+  markPlaybackFinished(_playbackPosition: number, interrupted: boolean) {
+    if (this.closed) {
+      this.logger.warn('SegmentSynchronizerImpl.markPlaybackFinished called after close');
+      return;
+    }
+
+    if (!this.textData.done || !this.audioData.done) {
+      this.logger.warn(
+        { textDone: this.textData.done, audioDone: this.audioData.done },
+        'SegmentSynchronizerImpl.markPlaybackFinished called before text/audio input is done',
+      );
+      return;
+    }
+
+    if (!interrupted) {
+      this.playbackCompleted = true;
+    }
+  }
+
+  get synchronizedTranscript(): string {
+    if (this.playbackCompleted) {
+      return this.textData.pushedText;
+    }
+    return this.textData.forwardedText;
+  }
+
+  private async captureTaskImpl() {
+    // Don't use a for-await loop here, because exiting the loop will close the writer in the
+    // outputStream, which will cause an error in the mainTask.then method.
+    const reader = this.outputStream.readable.getReader();
+    while (true) {
+      const { done, value: text } = await reader.read();
+      if (done) {
+        break;
+      }
+      this.textData.forwardedText += text;
+      await this.nextInChain.captureText(text);
+    }
+    reader.releaseLock();
+    this.nextInChain.flush();
+  }
+
+  private async mainTask(): Promise<void> {
+    await this.startFuture.await;
+
+    if (this.closed && !this.playbackCompleted) {
+      return;
+    }
+
+    if (!this.startWallTime) {
+      throw new Error('startWallTime is not set when starting SegmentSynchronizerImpl.mainTask');
+    }
+
+    for await (const textSegment of this.textData.sentenceStream) {
+      const sentence = textSegment.token;
+
+      let textCursor = 0;
+      if (this.closed && !this.playbackCompleted) {
+        return;
+      }
+
+      for (const [word, _, endPos] of this.options.splitWords(sentence)) {
+        if (this.closed && !this.playbackCompleted) {
+          return;
+        }
+
+        if (this.playbackCompleted) {
+          this.outputStreamWriter.write(sentence.slice(textCursor, endPos));
+          textCursor = endPos;
+          continue;
+        }
+
+        const wordHphens = this.options.hyphenateWord(word).length;
+        const elapsedSeconds = (Date.now() - this.startWallTime) / 1000;
+        const targetHyphens = elapsedSeconds * this.options.speed;
+        const hyphensBehind = Math.max(0, targetHyphens - this.textData.forwardedHyphens);
+        let delay = Math.max(0, wordHphens - hyphensBehind) / this.speed;
+
+        if (this.playbackCompleted) {
+          delay = 0;
+        }
+
+        await this.sleepIfNotClosed(delay / 2);
+        this.outputStreamWriter.write(sentence.slice(textCursor, endPos));
+        await this.sleepIfNotClosed(delay / 2);
+
+        this.textData.forwardedHyphens += wordHphens;
+        textCursor = endPos;
+      }
+
+      if (textCursor < sentence.length) {
+        const remaining = sentence.slice(textCursor);
+        this.outputStreamWriter.write(remaining);
+      }
+    }
+  }
+
+  private async sleepIfNotClosed(sleepTimeSeconds: number) {
+    if (this.closed) {
+      return;
+    }
+    await delay(sleepTimeSeconds * 1000);
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) {
+      return;
+    }
+    this.closedFuture.resolve();
+    this.startFuture.resolve(); // avoid deadlock of mainTaskImpl in case it never started
+    this.textData.sentenceStream.close();
+    await this.captureTask;
+  }
+}
+
+export interface TranscriptionSynchronizerOptions {
+  speed: number;
+  hyphenateWord: (word: string) => string[];
+  splitWords: (words: string) => [string, number, number][];
+  sentenceTokenizer: SentenceTokenizer;
+}
+
+export const defaultTextSyncOptions: TranscriptionSynchronizerOptions = {
+  speed: 1,
+  hyphenateWord: basic.hyphenateWord,
+  splitWords: basic.splitWords,
+  sentenceTokenizer: new basic.SentenceTokenizer({
+    retainFormat: true,
+  }),
+};
+
+export class TranscriptionSynchronizer {
+  readonly audioOutput: SyncedAudioOutput;
+  readonly textOutput: SyncedTextOutput;
+
+  private options: TextSyncOptions;
+  private rotateSegmentTask: Task<void>;
+  private _enabled: boolean = true;
+  private closed: boolean = false;
+
+  /* @internal */
+  _impl: SegmentSynchronizerImpl;
+
+  private logger = log();
+
+  constructor(
+    nextInChainAudio: AudioOutput,
+    nextInChainText: TextOutput,
+    options: TranscriptionSynchronizerOptions = defaultTextSyncOptions,
+  ) {
+    this.audioOutput = new SyncedAudioOutput(this, nextInChainAudio);
+    this.textOutput = new SyncedTextOutput(this, nextInChainText);
+    this.options = {
+      speed: options.speed,
+      hyphenateWord: options.hyphenateWord,
+      splitWords: options.splitWords,
+      sentenceTokenizer: options.sentenceTokenizer,
+    };
+
+    // initial segment/first segment, recreated for each new segment
+    this._impl = new SegmentSynchronizerImpl(this.options, nextInChainText);
+    this.rotateSegmentTask = Task.from((controller) =>
+      this.rotateSegmentTaskImpl(controller.signal),
+    );
+  }
+
+  get enabled(): boolean {
+    return this._enabled;
+  }
+
+  set enabled(enabled: boolean) {
+    if (this._enabled === enabled) {
+      return;
+    }
+
+    this._enabled = enabled;
+    this.rotateSegment();
+  }
+
+  rotateSegment() {
+    if (this.closed) {
+      return;
+    }
+
+    if (!this.rotateSegmentTask.done) {
+      this.logger.warn('rotateSegment called while previous segment is still being rotated');
+    }
+    this.rotateSegmentTask = Task.from((controller) =>
+      this.rotateSegmentTaskImpl(controller.signal, this.rotateSegmentTask),
+    );
+  }
+
+  async close(): Promise<void> {
+    this.closed = true;
+    await this.rotateSegmentTask.cancelAndWait();
+    await this._impl.close();
+  }
+
+  async barrier(): Promise<void> {
+    if (this.rotateSegmentTask.done) {
+      return;
+    }
+    await this.rotateSegmentTask.result;
+  }
+
+  private async rotateSegmentTaskImpl(abort: AbortSignal, oldTask?: Task<void>) {
+    if (oldTask) {
+      await oldTask.result;
+    }
+
+    if (abort.aborted) {
+      return;
+    }
+    await this._impl.close();
+    this._impl = new SegmentSynchronizerImpl(this.options, this.textOutput.nextInChain);
+  }
+}
+
+class SyncedAudioOutput extends AudioOutput {
+  private pushedDuration: number = 0.0;
+
+  constructor(
+    public synchronizer: TranscriptionSynchronizer,
+    private nextInChainAudio: AudioOutput,
+  ) {
+    super(nextInChainAudio.sampleRate, nextInChainAudio);
+  }
+
+  async captureFrame(frame: AudioFrame): Promise<void> {
+    // using barrier() on capture should be sufficient, flush() must not be called if
+    // capture_frame isn't completed
+    await this.synchronizer.barrier();
+
+    await super.captureFrame(frame);
+    await this.nextInChainAudio.captureFrame(frame); // passthrough audio
+
+    // TODO(AJS-102): use frame.durationMs once available in rtc-node
+    this.pushedDuration += frame.samplesPerChannel / frame.sampleRate;
+
+    if (!this.synchronizer.enabled) {
+      return;
+    }
+
+    if (this.synchronizer._impl.audioInputEnded) {
+      this.logger.warn(
+        'SegmentSynchronizerImpl audio marked as ended in capture audio, rotating segment',
+      );
+      this.synchronizer.rotateSegment();
+      await this.synchronizer.barrier();
+    }
+    this.synchronizer._impl.pushAudio(frame);
+  }
+
+  flush() {
+    super.flush();
+    this.nextInChainAudio.flush();
+
+    if (!this.synchronizer.enabled) {
+      return;
+    }
+
+    if (!this.pushedDuration) {
+      // in case there is no audio after the text was pushed, rotate the segment
+      this.synchronizer.rotateSegment();
+      return;
+    }
+
+    this.synchronizer._impl.endAudioInput();
+  }
+
+  clearBuffer() {
+    this.nextInChainAudio.clearBuffer();
+  }
+
+  // this is going to be automatically called by the next_in_chain
+  onPlaybackFinished(ev: PlaybackFinishedEvent) {
+    if (!this.synchronizer.enabled) {
+      super.onPlaybackFinished(ev);
+      return;
+    }
+
+    this.synchronizer._impl.markPlaybackFinished(ev.playbackPosition, ev.interrupted);
+    super.onPlaybackFinished({
+      playbackPosition: ev.playbackPosition,
+      interrupted: ev.interrupted,
+      synchronizedTranscript: this.synchronizer._impl.synchronizedTranscript,
+    });
+
+    this.synchronizer.rotateSegment();
+    this.pushedDuration = 0.0;
+  }
+}
+
+class SyncedTextOutput extends TextOutput {
+  private capturing: boolean = false;
+  private logger = log();
+
+  constructor(
+    private readonly synchronizer: TranscriptionSynchronizer,
+    public readonly nextInChain: TextOutput,
+  ) {
+    super(nextInChain);
+  }
+
+  async captureText(text: string): Promise<void> {
+    await this.synchronizer.barrier();
+
+    if (!this.synchronizer.enabled) {
+      // pass through to the next in chain
+      await this.nextInChain.captureText(text);
+      return;
+    }
+
+    this.capturing = true;
+    if (this.synchronizer._impl.textInputEnded) {
+      this.logger.warn(
+        'SegmentSynchronizerImpl text marked as ended in capture text, rotating segment',
+      );
+      this.synchronizer.rotateSegment();
+      await this.synchronizer.barrier();
+    }
+    this.synchronizer._impl.pushText(text);
+  }
+
+  flush() {
+    if (!this.synchronizer.enabled) {
+      this.nextInChain.flush(); // passthrough text if the synchronizer is disabled
+      return;
+    }
+
+    if (!this.capturing) {
+      return;
+    }
+
+    this.capturing = false;
+    this.synchronizer._impl.endTextInput();
+  }
+}

package/src/worker.ts

@@ -32,11 +32,12 @@ import { version } from './version.js';
 const MAX_RECONNECT_ATTEMPTS = 10;
 const ASSIGNMENT_TIMEOUT = 7.5 * 1000;
 const UPDATE_LOAD_INTERVAL = 2.5 * 1000;
+const PROJECT_TYPE = 'nodejs';
 
 class Default {
   static loadThreshold(production: boolean): number {
     if (production) {
-      return 0.65;
+      return 0.7;
     } else {
       return Infinity;
     }
@@ -44,6 +45,7 @@ class Default {
 
   static numIdleProcesses(production: boolean): number {
     if (production) {
+      // TODO: use number of cores
       return 3;
     } else {
       return 0;
@@ -165,7 +167,7 @@ export class WorkerOptions {
   jobMemoryWarnMB: number;
   jobMemoryLimitMB: number;
 
-  /** @param options */
+  /** @param options - Worker options */
   constructor({
     agent,
     requestFunc = defaultRequestFunc,
@@ -299,6 +301,22 @@ export class Worker {
         'API Secret is required: Set LIVEKIT_API_SECRET, run with --api-secret, or pass apiSecret in WorkerOptions',
       );
 
+    if (opts.workerToken) {
+      if (opts.loadFunc !== defaultCpuLoad) {
+        this.#logger.warn(
+          'custom loadFunc is not supported when deploying to Cloud, using defaults',
+        );
+        opts.loadFunc = defaultCpuLoad;
+      }
+      const loadThreshold = Default.loadThreshold(opts.production);
+      if (opts.loadThreshold !== loadThreshold) {
+        this.#logger.warn(
+          'custom loadThreshold is not supported when deploying to Cloud, using defaults',
+        );
+        opts.loadThreshold = loadThreshold;
+      }
+    }
+
     if (Object.entries(InferenceRunner.registeredRunners).length) {
       this.#inferenceExecutor = new InferenceProcExecutor({
         runners: InferenceRunner.registeredRunners,
@@ -328,6 +346,7 @@ export class Worker {
       worker_type: JobType[opts.workerType],
       active_jobs: this.activeJobs.length,
       sdk_version: version,
+      project_type: PROJECT_TYPE,
     }));
   }
 
@@ -685,6 +704,7 @@ export class Worker {
           job: msg.job!,
           url: asgn.url || this.#opts.wsURL,
           token: asgn.token,
+          workerId: this.id,
         });
       } else {
         this.#logger.child({ requestId: req.id }).warn('pending assignment not found');

package/dist/llm/function_context.cjs

@@ -1,103 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var function_context_exports = {};
-__export(function_context_exports, {
-  oaiBuildFunctionInfo: () => oaiBuildFunctionInfo,
-  oaiParams: () => oaiParams
-});
-module.exports = __toCommonJS(function_context_exports);
-var import_zod = require("zod");
-const looksLikeInstanceof = (value, target) => {
-  let current = value == null ? void 0 : value.constructor;
-  do {
-    if ((current == null ? void 0 : current.name) === target.name) return true;
-    current = Object.getPrototypeOf(current);
-  } while (current == null ? void 0 : current.name);
-  return false;
-};
-const oaiParams = (p) => {
-  const properties = {};
-  const requiredProperties = [];
-  const processZodType = (field) => {
-    const isOptional = field instanceof import_zod.z.ZodOptional;
-    const nestedField = isOptional ? field._def.innerType : field;
-    const description = field._def.description;
-    if (looksLikeInstanceof(nestedField, import_zod.z.ZodEnum)) {
-      return {
-        type: typeof nestedField._def.values[0],
-        ...description && { description },
-        enum: nestedField._def.values
-      };
-    } else if (looksLikeInstanceof(nestedField, import_zod.z.ZodArray)) {
-      const elementType = nestedField._def.type;
-      return {
-        type: "array",
-        ...description && { description },
-        items: processZodType(elementType)
-      };
-    } else if (looksLikeInstanceof(nestedField, import_zod.z.ZodObject)) {
-      const { properties: properties2, required } = oaiParams(nestedField);
-      return {
-        type: "object",
-        ...description && { description },
-        properties: properties2,
-        required
-      };
-    } else {
-      let type2 = nestedField._def.typeName.toLowerCase();
-      type2 = type2.includes("zod") ? type2.substring(3) : type2;
-      return {
-        type: type2,
-        ...description && { description }
-      };
-    }
-  };
-  for (const key in p.shape) {
-    const field = p.shape[key];
-    properties[key] = processZodType(field);
-    if (!(field instanceof import_zod.z.ZodOptional)) {
-      requiredProperties.push(key);
-    }
-  }
-  const type = "object";
-  return {
-    type,
-    properties,
-    required: requiredProperties
-  };
-};
-const oaiBuildFunctionInfo = (fncCtx, toolCallId, fncName, rawArgs) => {
-  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)
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  oaiBuildFunctionInfo,
-  oaiParams
-});
-//# sourceMappingURL=function_context.cjs.map

package/dist/llm/function_context.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/llm/function_context.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { z } from 'zod';\n\n// heavily inspired by Vercel AI's `tool()`:\n// https://github.com/vercel/ai/blob/3b0983b/packages/ai/core/tool/tool.ts\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/** Type reinforcement for the callable function's execute parameters. */\nexport type inferParameters<P extends z.ZodTypeAny> = z.infer<P>;\n\n/** Raw OpenAI-adherent function parameters. */\nexport type OpenAIFunctionParameters = {\n  type: 'object';\n  properties: { [id: string]: any };\n  required: string[];\n  additionalProperties: boolean;\n};\n\n/** A definition for a function callable by the LLM. */\nexport interface CallableFunction<P extends z.ZodTypeAny = any, R = any> {\n  description: string;\n  parameters: OpenAIFunctionParameters | P;\n  execute: (args: inferParameters<P>) => PromiseLike<R>;\n}\n\n/** A function that has been called but is not yet running */\nexport interface FunctionCallInfo<P extends z.ZodTypeAny = any, R = any> {\n  name: string;\n  func: CallableFunction<P, R>;\n  toolCallId: string;\n  rawParams: string;\n  params: inferParameters<P>;\n  task?: PromiseLike<CallableFunctionResult>;\n}\n\n/** The result of a ran FunctionCallInfo. */\nexport interface CallableFunctionResult {\n  name: string;\n  toolCallId: string;\n  result?: any;\n  error?: any;\n}\n\n/** An object containing callable functions and their names */\nexport type FunctionContext = {\n  [name: string]: CallableFunction;\n};\n\n// XXX: Zod is victim to the dual-package hazard. this is a hacky sorta-fix\n// until Zod v4.0.0 is released.\n// https://github.com/colinhacks/zod/issues/2241#issuecomment-2142688925\nconst looksLikeInstanceof = <T>(value: unknown, target: new (...args: any[]) => T): value is T => {\n  let current = value?.constructor;\n  do {\n    if (current?.name === target.name) return true;\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    current = Object.getPrototypeOf(current) as Function;\n  } while (current?.name);\n  return false;\n};\n\n/** @internal */\nexport const oaiParams = (p: z.AnyZodObject) => {\n  const properties: Record<string, any> = {};\n  const requiredProperties: string[] = [];\n\n  const processZodType = (field: z.ZodTypeAny): any => {\n    const isOptional = field instanceof z.ZodOptional;\n    const nestedField = isOptional ? field._def.innerType : field;\n    const description = field._def.description;\n\n    if (looksLikeInstanceof(nestedField, z.ZodEnum)) {\n      return {\n        type: typeof nestedField._def.values[0],\n        ...(description && { description }),\n        enum: nestedField._def.values,\n      };\n    } else if (looksLikeInstanceof(nestedField, z.ZodArray)) {\n      const elementType = nestedField._def.type;\n      return {\n        type: 'array',\n        ...(description && { description }),\n        items: processZodType(elementType),\n      };\n    } else if (looksLikeInstanceof(nestedField, z.ZodObject)) {\n      const { properties, required } = oaiParams(nestedField);\n      return {\n        type: 'object',\n        ...(description && { description }),\n        properties,\n        required,\n      };\n    } else {\n      let type = nestedField._def.typeName.toLowerCase();\n      type = type.includes('zod') ? type.substring(3) : type;\n      return {\n        type,\n        ...(description && { description }),\n      };\n    }\n  };\n\n  for (const key in p.shape) {\n    const field = p.shape[key];\n    properties[key] = processZodType(field);\n\n    if (!(field instanceof z.ZodOptional)) {\n      requiredProperties.push(key);\n    }\n  }\n\n  const type = 'object' as const;\n  return {\n    type,\n    properties,\n    required: requiredProperties,\n  };\n};\n\n/** @internal */\nexport const oaiBuildFunctionInfo = (\n  fncCtx: FunctionContext,\n  toolCallId: string,\n  fncName: string,\n  rawArgs: string,\n): FunctionCallInfo => {\n  const func = fncCtx[fncName];\n  if (!func) {\n    throw new Error(`AI function ${fncName} not found`);\n  }\n\n  return {\n    name: fncName,\n    func,\n    toolCallId,\n    rawParams: rawArgs,\n    params: JSON.parse(rawArgs),\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAkB;AAmDlB,MAAM,sBAAsB,CAAI,OAAgB,WAAkD;AAChG,MAAI,UAAU,+BAAO;AACrB,KAAG;AACD,SAAI,mCAAS,UAAS,OAAO,KAAM,QAAO;AAE1C,cAAU,OAAO,eAAe,OAAO;AAAA,EACzC,SAAS,mCAAS;AAClB,SAAO;AACT;AAGO,MAAM,YAAY,CAAC,MAAsB;AAC9C,QAAM,aAAkC,CAAC;AACzC,QAAM,qBAA+B,CAAC;AAEtC,QAAM,iBAAiB,CAAC,UAA6B;AACnD,UAAM,aAAa,iBAAiB,aAAE;AACtC,UAAM,cAAc,aAAa,MAAM,KAAK,YAAY;AACxD,UAAM,cAAc,MAAM,KAAK;AAE/B,QAAI,oBAAoB,aAAa,aAAE,OAAO,GAAG;AAC/C,aAAO;AAAA,QACL,MAAM,OAAO,YAAY,KAAK,OAAO,CAAC;AAAA,QACtC,GAAI,eAAe,EAAE,YAAY;AAAA,QACjC,MAAM,YAAY,KAAK;AAAA,MACzB;AAAA,IACF,WAAW,oBAAoB,aAAa,aAAE,QAAQ,GAAG;AACvD,YAAM,cAAc,YAAY,KAAK;AACrC,aAAO;AAAA,QACL,MAAM;AAAA,QACN,GAAI,eAAe,EAAE,YAAY;AAAA,QACjC,OAAO,eAAe,WAAW;AAAA,MACnC;AAAA,IACF,WAAW,oBAAoB,aAAa,aAAE,SAAS,GAAG;AACxD,YAAM,EAAE,YAAAA,aAAY,SAAS,IAAI,UAAU,WAAW;AACtD,aAAO;AAAA,QACL,MAAM;AAAA,QACN,GAAI,eAAe,EAAE,YAAY;AAAA,QACjC,YAAAA;AAAA,QACA;AAAA,MACF;AAAA,IACF,OAAO;AACL,UAAIC,QAAO,YAAY,KAAK,SAAS,YAAY;AACjD,MAAAA,QAAOA,MAAK,SAAS,KAAK,IAAIA,MAAK,UAAU,CAAC,IAAIA;AAClD,aAAO;AAAA,QACL,MAAAA;AAAA,QACA,GAAI,eAAe,EAAE,YAAY;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAEA,aAAW,OAAO,EAAE,OAAO;AACzB,UAAM,QAAQ,EAAE,MAAM,GAAG;AACzB,eAAW,GAAG,IAAI,eAAe,KAAK;AAEtC,QAAI,EAAE,iBAAiB,aAAE,cAAc;AACrC,yBAAmB,KAAK,GAAG;AAAA,IAC7B;AAAA,EACF;AAEA,QAAM,OAAO;AACb,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,UAAU;AAAA,EACZ;AACF;AAGO,MAAM,uBAAuB,CAClC,QACA,YACA,SACA,YACqB;AACrB,QAAM,OAAO,OAAO,OAAO;AAC3B,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,eAAe,OAAO,YAAY;AAAA,EACpD;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA;AAAA,IACA,WAAW;AAAA,IACX,QAAQ,KAAK,MAAM,OAAO;AAAA,EAC5B;AACF;","names":["properties","type"]}

package/dist/llm/function_context.d.cts

@@ -1,47 +0,0 @@
-import { z } from 'zod';
-/** 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;
-};
-/** @internal */
-export declare const oaiParams: (p: z.AnyZodObject) => {
-    type: "object";
-    properties: Record<string, any>;
-    required: string[];
-};
-/** @internal */
-export declare const oaiBuildFunctionInfo: (fncCtx: FunctionContext, toolCallId: string, fncName: string, rawArgs: string) => FunctionCallInfo;
-//# sourceMappingURL=function_context.d.ts.map