privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-HIKTO6P7.mjs

@@ -0,0 +1,275 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  import_websocket
+} from "./c-CU4NGAUO.mjs";
+import {
+  AzureOpenAI,
+  OpenAI,
+  OpenAIError,
+  __classPrivateFieldGet
+} from "./c-L26VOJX4.mjs";
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/tinfoil/node_modules/openai/lib/EventEmitter.mjs
+var _EventEmitter_listeners;
+var EventEmitter = class {
+  static {
+    __name(this, "EventEmitter");
+  }
+  constructor() {
+    _EventEmitter_listeners.set(this, {});
+  }
+  /**
+   * Adds the listener function to the end of the listeners array for the event.
+   * No checks are made to see if the listener has already been added. Multiple calls passing
+   * the same combination of event and listener will result in the listener being added, and
+   * called, multiple times.
+   * @returns this, so that calls can be chained
+   */
+  on(event, listener) {
+    const listeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+  /**
+   * Removes the specified listener from the listener array for the event.
+   * off() will remove, at most, one instance of a listener from the listener array. If any single
+   * listener has been added multiple times to the listener array for the specified event, then
+   * off() must be called multiple times to remove each instance.
+   * @returns this, so that calls can be chained
+   */
+  off(event, listener) {
+    const listeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+    if (!listeners)
+      return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0)
+      listeners.splice(index, 1);
+    return this;
+  }
+  /**
+   * Adds a one-time listener function for the event. The next time the event is triggered,
+   * this listener is removed and then invoked.
+   * @returns this, so that calls can be chained
+   */
+  once(event, listener) {
+    const listeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+  /**
+   * This is similar to `.once()`, but returns a Promise that resolves the next time
+   * the event is triggered, instead of calling a listener callback.
+   * @returns a Promise that resolves the next time given event is triggered,
+   * or rejects if an error is emitted.  (If you request the 'error' event,
+   * returns a promise that resolves with the error).
+   *
+   * Example:
+   *
+   *   const message = await stream.emitted('message') // rejects if the stream errors
+   */
+  emitted(event) {
+    return new Promise((resolve, reject) => {
+      const onError = /* @__PURE__ */ __name((error) => {
+        this.off(event, onEvent);
+        reject(error);
+      }, "onError");
+      const onEvent = /* @__PURE__ */ __name((value) => {
+        if (event !== "error")
+          this.off("error", onError);
+        resolve(value);
+      }, "onEvent");
+      if (event !== "error")
+        this.once("error", onError);
+      this.once(event, onEvent);
+    });
+  }
+  _emit(event, ...args) {
+    const listeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+    if (listeners) {
+      __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event] = listeners.filter((l) => !l.once);
+      listeners.forEach(({ listener }) => listener(...args));
+    }
+  }
+  _hasListener(event) {
+    const listeners = __classPrivateFieldGet(this, _EventEmitter_listeners, "f")[event];
+    return listeners && listeners.length > 0;
+  }
+};
+_EventEmitter_listeners = /* @__PURE__ */ new WeakMap();
+
+// node_modules/tinfoil/node_modules/openai/realtime/internal-base.mjs
+var OpenAIRealtimeError = class extends OpenAIError {
+  static {
+    __name(this, "OpenAIRealtimeError");
+  }
+  constructor(message, event) {
+    super(message);
+    this.error = event?.error;
+    this.event_id = event?.event_id;
+  }
+};
+var OpenAIRealtimeEmitter = class extends EventEmitter {
+  static {
+    __name(this, "OpenAIRealtimeEmitter");
+  }
+  _onError(event, message, cause) {
+    message = event?.error ? `${event.error.message} code=${event.error.code} param=${event.error.param} type=${event.error.type} event_id=${event.error.event_id}` : message ?? "unknown error";
+    if (!this._hasListener("error")) {
+      const error2 = new OpenAIRealtimeError(message + `
+
+To resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`rt.on('error', (error) => ...)\` `, event);
+      error2.cause = cause;
+      Promise.reject(error2);
+      return;
+    }
+    const error = new OpenAIRealtimeError(message, event);
+    error.cause = cause;
+    this._emit("error", error);
+  }
+};
+function isAzure(client) {
+  return client instanceof AzureOpenAI;
+}
+__name(isAzure, "isAzure");
+function buildRealtimeURL(client, connection) {
+  const config = typeof connection === "string" ? { model: connection } : connection;
+  const baseURL = client.baseURL;
+  const azure = isAzure(client);
+  const hasModel = !!config.model;
+  const hasCallID = !!config.callID;
+  if (hasModel === hasCallID) {
+    throw new Error("Pass exactly one of `model` or `callID` when opening a Realtime WebSocket.");
+  }
+  let url;
+  if (azure && hasCallID) {
+    url = new URL(baseURL);
+    const basePath = url.pathname.replace(/\/+/g, "/").replace(/\/+$/, "");
+    const versionedPath = basePath.endsWith("/v1") ? basePath : `${basePath}/v1`;
+    url.pathname = `${versionedPath}/realtime`;
+    url.search = "";
+    url.hash = "";
+  } else {
+    const path = "/realtime";
+    url = new URL(baseURL + (baseURL.endsWith("/") ? path.slice(1) : path));
+  }
+  url.protocol = "wss";
+  if (azure) {
+    if (hasCallID) {
+      url.searchParams.set("call_id", config.callID);
+    } else {
+      url.searchParams.set("api-version", client.apiVersion);
+      url.searchParams.set("deployment", config.model);
+    }
+  } else {
+    if (hasCallID) {
+      url.searchParams.set("call_id", config.callID);
+    } else {
+      url.searchParams.set("model", config.model);
+    }
+  }
+  return url;
+}
+__name(buildRealtimeURL, "buildRealtimeURL");
+function getAzureRealtimeConnection(client, connection) {
+  if (connection.callID !== void 0) {
+    if (connection.deploymentName !== void 0) {
+      throw new Error("Pass either `deploymentName` or `callID`, but not both.");
+    }
+    return { callID: connection.callID };
+  }
+  const model = connection.deploymentName ?? client.deploymentName;
+  if (!model) {
+    throw new Error("No deployment name provided");
+  }
+  return { model };
+}
+__name(getAzureRealtimeConnection, "getAzureRealtimeConnection");
+
+// node_modules/tinfoil/node_modules/openai/realtime/ws.mjs
+var OpenAIRealtimeWS = class _OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
+  static {
+    __name(this, "OpenAIRealtimeWS");
+  }
+  constructor(props, client) {
+    super();
+    client ?? (client = new OpenAI());
+    const hasProvider = typeof client?._options?.apiKey === "function";
+    if (hasProvider && !props.__resolvedApiKey) {
+      throw new Error([
+        "Cannot open Realtime WebSocket with a function-based apiKey.",
+        "Use the .create() method so that the key is resolved before connecting."
+      ].join("\n"));
+    }
+    this.url = buildRealtimeURL(client, props);
+    this.socket = new import_websocket.default(this.url, {
+      ...props.options,
+      headers: {
+        ...props.options?.headers,
+        ...isAzure(client) && !props.__resolvedApiKey ? {} : { Authorization: `Bearer ${client.apiKey}` }
+      }
+    });
+    this.socket.on("message", (wsEvent) => {
+      const event = (() => {
+        try {
+          return JSON.parse(wsEvent.toString());
+        } catch (err) {
+          this._onError(null, "could not parse websocket event", err);
+          return null;
+        }
+      })();
+      if (event) {
+        this._emit("event", event);
+        if (event.type === "error") {
+          this._onError(event);
+        } else {
+          this._emit(event.type, event);
+        }
+      }
+    });
+    this.socket.on("error", (err) => {
+      this._onError(null, err.message, err);
+    });
+  }
+  static async create(client, props) {
+    return new _OpenAIRealtimeWS({ ...props, __resolvedApiKey: await client._callApiKey() }, client);
+  }
+  static async azure(client, props = {}) {
+    const connection = getAzureRealtimeConnection(client, props);
+    const isApiKeyProvider = await client._callApiKey();
+    const apiKey = client.apiKey;
+    if (!apiKey) {
+      throw new Error("Azure OpenAI Realtime requires an API key");
+    }
+    return new _OpenAIRealtimeWS({
+      ...connection,
+      options: {
+        ...props.options,
+        headers: {
+          ...props.options?.headers,
+          ...isApiKeyProvider ? {} : { "api-key": apiKey }
+        }
+      },
+      __resolvedApiKey: isApiKeyProvider
+    }, client);
+  }
+  send(event) {
+    try {
+      this.socket.send(JSON.stringify(event));
+    } catch (err) {
+      this._onError(null, "could not send data", err);
+    }
+  }
+  close(props) {
+    try {
+      this.socket.close(props?.code ?? 1e3, props?.reason ?? "OK");
+    } catch (err) {
+      this._onError(null, "could not close the connection", err);
+    }
+  }
+};
+export {
+  OpenAIRealtimeWS
+};