@janole/ai-sdk-provider-codex-asp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1559 @@
+'use strict';
+
+var child_process = require('child_process');
+var provider = require('@ai-sdk/provider');
+
+// src/approvals.ts
+var ApprovalsDispatcher = class {
+  onCommandApproval;
+  onFileChangeApproval;
+  constructor(settings = {}) {
+    this.onCommandApproval = settings.onCommandApproval ?? (() => "accept");
+    this.onFileChangeApproval = settings.onFileChangeApproval ?? (() => "accept");
+  }
+  attach(client) {
+    const unsubCommand = client.onRequest(
+      "item/commandExecution/requestApproval",
+      async (params, _request) => {
+        const p = params;
+        const request = {
+          threadId: p.threadId,
+          turnId: p.turnId,
+          itemId: p.itemId,
+          ...p.approvalId !== void 0 ? { approvalId: p.approvalId } : {},
+          ...p.reason !== void 0 ? { reason: p.reason } : {},
+          ...p.command !== void 0 ? { command: p.command } : {},
+          ...p.cwd !== void 0 ? { cwd: p.cwd } : {}
+        };
+        const decision = await this.onCommandApproval(request);
+        return { decision };
+      }
+    );
+    const unsubFileChange = client.onRequest(
+      "item/fileChange/requestApproval",
+      async (params, _request) => {
+        const p = params;
+        const request = {
+          threadId: p.threadId,
+          turnId: p.turnId,
+          itemId: p.itemId,
+          ...p.reason !== void 0 ? { reason: p.reason } : {},
+          ...p.grantRoot !== void 0 ? { grantRoot: p.grantRoot } : {}
+        };
+        const decision = await this.onFileChangeApproval(request);
+        return { decision };
+      }
+    );
+    return () => {
+      unsubCommand();
+      unsubFileChange();
+    };
+  }
+};
+
+// src/errors.ts
+var CodexProviderError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodexProviderError";
+  }
+};
+var CodexNotImplementedError = class extends CodexProviderError {
+  constructor(method) {
+    super(`Codex provider method not implemented yet: ${method}`);
+    this.name = "CodexNotImplementedError";
+  }
+};
+
+// src/client/app-server-client.ts
+var JsonRpcError = class extends CodexProviderError {
+  code;
+  data;
+  constructor(error) {
+    super(error.message);
+    this.name = "JsonRpcError";
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+function isResponse(message) {
+  return "id" in message && message.id !== void 0 && ("result" in message || "error" in message) && !("method" in message);
+}
+function isRequestOrNotification(message) {
+  return "method" in message && typeof message.method === "string";
+}
+var AppServerClient = class {
+  transport;
+  requestTimeoutMs;
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  anyNotificationHandlers = /* @__PURE__ */ new Set();
+  requestHandlers = /* @__PURE__ */ new Map();
+  removeMessageListener = null;
+  removeErrorListener = null;
+  constructor(transport, settings = {}) {
+    this.transport = transport;
+    this.requestTimeoutMs = settings.requestTimeoutMs ?? 3e4;
+  }
+  async connect() {
+    await this.transport.connect();
+    this.removeMessageListener = this.transport.on("message", (message) => {
+      void this.handleMessage(message).catch(() => {
+      });
+    });
+    this.removeErrorListener = this.transport.on("error", (error) => {
+      for (const pending of this.pendingRequests.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+      }
+      this.pendingRequests.clear();
+    });
+  }
+  async disconnect() {
+    if (this.removeMessageListener) {
+      this.removeMessageListener();
+      this.removeMessageListener = null;
+    }
+    if (this.removeErrorListener) {
+      this.removeErrorListener();
+      this.removeErrorListener = null;
+    }
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new CodexProviderError("Client disconnected."));
+    }
+    this.pendingRequests.clear();
+    await this.transport.disconnect();
+  }
+  async request(method, params, timeoutMs = this.requestTimeoutMs) {
+    const id = this.nextId++;
+    const message = params === void 0 ? { id, method } : { id, method, params };
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new CodexProviderError(`Request timed out: ${method}`));
+      }, timeoutMs);
+      this.pendingRequests.set(id, {
+        resolve: (value) => resolve(value),
+        reject,
+        timer
+      });
+    });
+    await this.transport.sendMessage(message);
+    return promise;
+  }
+  async notification(method, params) {
+    await this.transport.sendNotification(method, params);
+  }
+  onNotification(method, handler) {
+    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.notificationHandlers.set(method, handlers);
+    return () => {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.notificationHandlers.delete(method);
+      }
+    };
+  }
+  onAnyNotification(handler) {
+    this.anyNotificationHandlers.add(handler);
+    return () => {
+      this.anyNotificationHandlers.delete(handler);
+    };
+  }
+  onRequest(method, handler) {
+    this.requestHandlers.set(method, handler);
+    return () => {
+      this.requestHandlers.delete(method);
+    };
+  }
+  onToolCallRequest(handler) {
+    return this.onRequest(
+      "item/tool/call",
+      async (params, request) => handler(params ?? {}, request)
+    );
+  }
+  async handleMessage(message) {
+    if (isResponse(message)) {
+      this.handleResponse(message);
+      return;
+    }
+    if (!isRequestOrNotification(message)) {
+      return;
+    }
+    const hasRequestId = "id" in message && message.id !== void 0;
+    if (hasRequestId) {
+      await this.handleInboundRequest(message);
+      return;
+    }
+    await this.handleNotification(message.method, message.params);
+  }
+  handleResponse(message) {
+    const pending = this.pendingRequests.get(message.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(message.id);
+    if ("error" in message) {
+      pending.reject(new JsonRpcError(message.error));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+  async handleNotification(method, params) {
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      for (const handler of handlers) {
+        await handler(params);
+      }
+    }
+    for (const handler of this.anyNotificationHandlers) {
+      await handler(method, params);
+    }
+  }
+  async handleInboundRequest(request) {
+    const handler = this.requestHandlers.get(request.method);
+    if (!handler) {
+      await this.transport.sendMessage({
+        id: request.id,
+        error: {
+          code: -32601,
+          message: `Method not found: ${request.method}`
+        }
+      });
+      return;
+    }
+    try {
+      const result = await handler(request.params, request);
+      await this.transport.sendMessage({
+        id: request.id,
+        result
+      });
+    } catch (error) {
+      try {
+        await this.transport.sendMessage({
+          id: request.id,
+          error: {
+            code: -32e3,
+            message: error instanceof Error ? error.message : "Request handler failed"
+          }
+        });
+      } catch {
+      }
+    }
+  }
+};
+
+// src/client/transport-persistent.ts
+var PersistentTransport = class {
+  pool;
+  worker = null;
+  pendingInitializeId = null;
+  initializeIntercepted = false;
+  messageListeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  closeListeners = /* @__PURE__ */ new Set();
+  constructor(settings) {
+    this.pool = settings.pool;
+  }
+  async connect() {
+    this.worker = this.pool.acquire();
+    await this.worker.ensureConnected();
+  }
+  disconnect() {
+    if (this.worker) {
+      const w = this.worker;
+      this.worker = null;
+      this.messageListeners.clear();
+      this.errorListeners.clear();
+      this.closeListeners.clear();
+      this.pool.release(w);
+    }
+    return Promise.resolve();
+  }
+  async sendMessage(message) {
+    if (!this.worker) {
+      throw new Error("PersistentTransport is not connected.");
+    }
+    if (isInitializeRequest(message)) {
+      if (this.worker.initialized) {
+        this.initializeIntercepted = true;
+        const requestId = message.id;
+        const cachedResult = this.worker.initializeResult;
+        queueMicrotask(() => {
+          for (const listener of this.messageListeners) {
+            listener({ id: requestId, result: cachedResult });
+          }
+        });
+        return;
+      }
+      this.initializeIntercepted = false;
+      this.pendingInitializeId = message.id;
+    }
+    await this.worker.sendMessage(message);
+  }
+  async sendNotification(method, params) {
+    if (!this.worker) {
+      throw new Error("PersistentTransport is not connected.");
+    }
+    if (method === "initialized" && this.initializeIntercepted) {
+      return;
+    }
+    await this.worker.sendNotification(method, params);
+  }
+  on(event, listener) {
+    if (!this.worker) {
+      throw new Error("PersistentTransport is not connected.");
+    }
+    if (event === "message") {
+      const msgListener = listener;
+      const wrappedListener = ((incoming) => {
+        if (this.pendingInitializeId !== null && "id" in incoming && incoming.id === this.pendingInitializeId && "result" in incoming) {
+          this.worker?.markInitialized(incoming.result);
+          this.pendingInitializeId = null;
+        }
+        msgListener(incoming);
+      });
+      const workerUnsub = this.worker.onSession(event, wrappedListener);
+      this.messageListeners.add(msgListener);
+      return () => {
+        workerUnsub();
+        this.messageListeners.delete(msgListener);
+      };
+    }
+    if (event === "error") {
+      const errListener = listener;
+      const workerUnsub = this.worker.onSession(event, listener);
+      this.errorListeners.add(errListener);
+      return () => {
+        workerUnsub();
+        this.errorListeners.delete(errListener);
+      };
+    }
+    if (event === "close") {
+      const closeListener = listener;
+      const workerUnsub = this.worker.onSession(event, listener);
+      this.closeListeners.add(closeListener);
+      return () => {
+        workerUnsub();
+        this.closeListeners.delete(closeListener);
+      };
+    }
+    return this.worker.onSession(event, listener);
+  }
+  getPendingToolCall() {
+    return this.worker?.pendingToolCall ?? null;
+  }
+  async respondToToolCall(result) {
+    if (!this.worker?.pendingToolCall) {
+      throw new Error("No pending tool call to respond to.");
+    }
+    const { requestId } = this.worker.pendingToolCall;
+    this.worker.pendingToolCall = null;
+    await this.worker.sendMessage({
+      id: requestId,
+      result
+    });
+  }
+  parkToolCall(pending) {
+    if (!this.worker) {
+      throw new Error("PersistentTransport is not connected.");
+    }
+    this.worker.pendingToolCall = pending;
+  }
+};
+function isInitializeRequest(message) {
+  return "id" in message && "method" in message && message.method === "initialize";
+}
+var DEFAULT_COMMAND = "codex";
+var DEFAULT_ARGS = ["app-server", "--listen", "stdio://"];
+var StdioTransport = class {
+  settings;
+  process = null;
+  listeners = {
+    message: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    close: /* @__PURE__ */ new Set()
+  };
+  stdoutBuffer = "";
+  constructor(settings = {}) {
+    this.settings = settings;
+  }
+  connect() {
+    if (this.process !== null) {
+      return Promise.resolve();
+    }
+    const options = {
+      cwd: this.settings.cwd,
+      env: this.settings.env,
+      stdio: "pipe"
+    };
+    const child = child_process.spawn(
+      this.settings.command ?? DEFAULT_COMMAND,
+      this.settings.args ?? DEFAULT_ARGS,
+      options
+    );
+    this.process = child;
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      this.handleStdoutChunk(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      this.emit("error", new Error(`codex stderr: ${typeof chunk === "string" ? chunk : chunk.toString("utf8")}`));
+    });
+    child.on("error", (error) => {
+      this.emit("error", error);
+    });
+    child.on("close", (code, signal) => {
+      this.process = null;
+      this.emit("close", code, signal);
+    });
+    return Promise.resolve();
+  }
+  async disconnect() {
+    if (this.process === null) {
+      return;
+    }
+    const child = this.process;
+    this.process = null;
+    await new Promise((resolve) => {
+      let finished = false;
+      const finish = () => {
+        if (!finished) {
+          finished = true;
+          resolve();
+        }
+      };
+      child.once("close", () => finish());
+      child.once("exit", () => finish());
+      if (!child.killed) {
+        child.kill();
+      }
+      setTimeout(finish, 250);
+    });
+  }
+  async sendMessage(message) {
+    if (this.process === null || this.process.stdin.destroyed) {
+      throw new Error("StdioTransport is not connected.");
+    }
+    const payload = `${JSON.stringify(message)}
+`;
+    await new Promise((resolve, reject) => {
+      this.process?.stdin.write(payload, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async sendNotification(method, params) {
+    await this.sendMessage(
+      params === void 0 ? { method } : { method, params }
+    );
+  }
+  on(event, listener) {
+    const listeners = this.listeners[event];
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  handleStdoutChunk(chunk) {
+    this.stdoutBuffer += chunk;
+    let lineBreakIndex = this.stdoutBuffer.indexOf("\n");
+    while (lineBreakIndex >= 0) {
+      const line = this.stdoutBuffer.slice(0, lineBreakIndex).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(lineBreakIndex + 1);
+      if (line.length > 0) {
+        try {
+          const message = JSON.parse(line);
+          this.emit("message", message);
+        } catch (error) {
+          this.emit("error", error);
+        }
+      }
+      lineBreakIndex = this.stdoutBuffer.indexOf("\n");
+    }
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    for (const listener of listeners) {
+      listener(...args);
+    }
+  }
+};
+
+// src/client/transport-websocket.ts
+var DEFAULT_WS_URL = "ws://localhost:3000";
+var WebSocketTransport = class {
+  settings;
+  socket = null;
+  listeners = {
+    message: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    close: /* @__PURE__ */ new Set()
+  };
+  constructor(settings = {}) {
+    this.settings = settings;
+  }
+  async connect() {
+    if (this.socket && this.socket.readyState === this.socket.OPEN) {
+      return;
+    }
+    const WebSocketCtor = globalThis.WebSocket;
+    if (!WebSocketCtor) {
+      throw new Error("WebSocket is not available in this runtime.");
+    }
+    const socket = new WebSocketCtor(
+      this.settings.url ?? DEFAULT_WS_URL,
+      void 0,
+      this.settings.headers ? { headers: this.settings.headers } : void 0
+    );
+    this.socket = socket;
+    socket.addEventListener("message", (event) => {
+      this.handleIncomingMessage(event.data);
+    });
+    socket.addEventListener("error", (event) => {
+      this.emit("error", event);
+    });
+    socket.addEventListener("close", (event) => {
+      this.socket = null;
+      this.emit("close", event.code, null);
+    });
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        socket.removeEventListener("open", onOpen);
+        socket.removeEventListener("error", onError);
+        resolve();
+      };
+      const onError = (event) => {
+        socket.removeEventListener("open", onOpen);
+        socket.removeEventListener("error", onError);
+        reject(new Error(`WebSocket connection failed: ${String(event.type)}`));
+      };
+      socket.addEventListener("open", onOpen, { once: true });
+      socket.addEventListener("error", onError, { once: true });
+    });
+  }
+  async disconnect() {
+    if (!this.socket) {
+      return;
+    }
+    const socket = this.socket;
+    await new Promise((resolve) => {
+      let finished = false;
+      const finish = () => {
+        if (!finished) {
+          finished = true;
+          resolve();
+        }
+      };
+      socket.addEventListener("close", () => finish(), { once: true });
+      socket.close();
+      setTimeout(finish, 250);
+    });
+    this.socket = null;
+  }
+  sendMessage(message) {
+    if (!this.socket || this.socket.readyState !== this.socket.OPEN) {
+      return Promise.reject(new Error("WebSocketTransport is not connected."));
+    }
+    this.socket.send(JSON.stringify(message));
+    return Promise.resolve();
+  }
+  async sendNotification(method, params) {
+    await this.sendMessage(
+      params === void 0 ? { method } : { method, params }
+    );
+  }
+  on(event, listener) {
+    const listeners = this.listeners[event];
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  handleIncomingMessage(raw) {
+    try {
+      if (typeof raw !== "string") {
+        return;
+      }
+      const message = JSON.parse(raw);
+      this.emit("message", message);
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    for (const listener of listeners) {
+      listener(...args);
+    }
+  }
+};
+
+// src/client/worker.ts
+var CodexWorker = class {
+  state = "disconnected";
+  initialized = false;
+  initializeResult = void 0;
+  pendingToolCall = null;
+  inner = null;
+  settings;
+  idleTimer = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  sessionListeners = [];
+  constructor(settings) {
+    this.settings = settings;
+  }
+  async ensureConnected() {
+    if (this.inner) {
+      return;
+    }
+    this.inner = this.settings.transportFactory();
+    this.inner.on("close", () => {
+      this.initialized = false;
+      this.initializeResult = void 0;
+      this.inner = null;
+      this.state = "disconnected";
+    });
+    this.inner.on("error", () => {
+      this.initialized = false;
+      this.initializeResult = void 0;
+      this.inner = null;
+      this.state = "disconnected";
+    });
+    await this.inner.connect();
+  }
+  acquire() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    this.state = "busy";
+  }
+  release() {
+    this.clearSessionListeners();
+    this.state = "idle";
+    if (this.settings.idleTimeoutMs > 0) {
+      this.idleTimer = setTimeout(() => {
+        void this.shutdown();
+      }, this.settings.idleTimeoutMs);
+    }
+  }
+  markInitialized(result) {
+    this.initialized = true;
+    this.initializeResult = result;
+  }
+  onSession(event, listener) {
+    if (!this.inner) {
+      throw new Error("Worker has no active transport.");
+    }
+    const unsubscribe = this.inner.on(event, listener);
+    this.sessionListeners.push({ event, listener, unsubscribe });
+    return unsubscribe;
+  }
+  clearSessionListeners() {
+    for (const entry of this.sessionListeners) {
+      entry.unsubscribe();
+    }
+    this.sessionListeners = [];
+  }
+  async sendMessage(message) {
+    if (!this.inner) {
+      throw new Error("Worker has no active transport.");
+    }
+    await this.inner.sendMessage(message);
+  }
+  async sendNotification(method, params) {
+    if (!this.inner) {
+      throw new Error("Worker has no active transport.");
+    }
+    await this.inner.sendNotification(method, params);
+  }
+  async shutdown() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    this.clearSessionListeners();
+    if (this.inner) {
+      const transport = this.inner;
+      this.inner = null;
+      this.initialized = false;
+      this.initializeResult = void 0;
+      this.state = "disconnected";
+      await transport.disconnect();
+    } else {
+      this.state = "disconnected";
+    }
+  }
+};
+
+// src/client/worker-pool.ts
+var CodexWorkerPool = class {
+  workers;
+  shutdownCalled = false;
+  constructor(settings) {
+    const size = settings.poolSize ?? 1;
+    const idleTimeoutMs = settings.idleTimeoutMs ?? 3e5;
+    this.workers = Array.from(
+      { length: size },
+      () => new CodexWorker({
+        transportFactory: settings.transportFactory,
+        idleTimeoutMs
+      })
+    );
+  }
+  acquire() {
+    if (this.shutdownCalled) {
+      throw new CodexProviderError("Worker pool has been shut down.");
+    }
+    const worker = this.workers.find(
+      (w) => w.state === "idle" || w.state === "disconnected"
+    );
+    if (!worker) {
+      throw new CodexProviderError(
+        "All workers are busy. Try again later or increase poolSize."
+      );
+    }
+    worker.acquire();
+    return worker;
+  }
+  release(worker) {
+    worker.release();
+  }
+  async shutdown() {
+    this.shutdownCalled = true;
+    await Promise.all(this.workers.map((w) => w.shutdown()));
+  }
+};
+
+// src/dynamic-tools.ts
+function toTextResult(message, success) {
+  const contentItems = [{ type: "inputText", text: message }];
+  return { success, contentItems };
+}
+function withTimeout(promise, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new CodexProviderError(`Dynamic tool execution timed out after ${timeoutMs}ms.`));
+    }, timeoutMs);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }).catch((error) => {
+      clearTimeout(timer);
+      reject(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+}
+var DynamicToolsDispatcher = class {
+  handlers = /* @__PURE__ */ new Map();
+  timeoutMs;
+  constructor(settings = {}) {
+    this.timeoutMs = settings.timeoutMs ?? 3e4;
+    if (settings.tools) {
+      for (const [name, def] of Object.entries(settings.tools)) {
+        this.register(name, def.execute);
+      }
+    }
+    if (settings.handlers) {
+      for (const [name, handler] of Object.entries(settings.handlers)) {
+        this.register(name, handler);
+      }
+    }
+  }
+  register(name, handler) {
+    this.handlers.set(name, handler);
+  }
+  attach(client) {
+    return client.onToolCallRequest(async (params) => this.dispatch(params));
+  }
+  async dispatch(params) {
+    const toolName = params.tool ?? params.toolName;
+    if (!toolName) {
+      return toTextResult("Dynamic tool call is missing the tool name.", false);
+    }
+    const handler = this.handlers.get(toolName);
+    if (!handler) {
+      return toTextResult(`No dynamic tool handler registered for "${toolName}".`, false);
+    }
+    const context = {
+      toolName,
+      ...params.threadId ? { threadId: params.threadId } : {},
+      ...params.turnId ? { turnId: params.turnId } : {},
+      ...params.callId ? { callId: params.callId } : {}
+    };
+    const args = params.arguments ?? params.input;
+    try {
+      return await withTimeout(handler(args, context), this.timeoutMs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Dynamic tool execution failed.";
+      return toTextResult(message, false);
+    }
+  }
+};
+
+// package.json
+var package_default = {
+  name: "@janole/ai-sdk-provider-codex-asp",
+  version: "0.1.0"};
+
+// src/package-info.ts
+var PACKAGE_NAME = package_default.name;
+var PACKAGE_VERSION = package_default.version;
+
+// src/protocol/provider-metadata.ts
+var CODEX_PROVIDER_ID = "codex-app-server";
+function codexProviderMetadata(threadId) {
+  if (!threadId) {
+    return void 0;
+  }
+  return { [CODEX_PROVIDER_ID]: { threadId } };
+}
+function withProviderMetadata(part, threadId) {
+  const meta = codexProviderMetadata(threadId);
+  return meta ? { ...part, providerMetadata: meta } : part;
+}
+
+// src/protocol/event-mapper.ts
+var EMPTY_USAGE = {
+  inputTokens: {
+    total: void 0,
+    noCache: void 0,
+    cacheRead: void 0,
+    cacheWrite: void 0
+  },
+  outputTokens: {
+    total: void 0,
+    text: void 0,
+    reasoning: void 0
+  }
+};
+function toFinishReason(status) {
+  switch (status) {
+    case "completed":
+      return { unified: "stop", raw: "completed" };
+    case "failed":
+      return { unified: "error", raw: "failed" };
+    case "interrupted":
+      return { unified: "other", raw: "interrupted" };
+    default:
+      return { unified: "other", raw: void 0 };
+  }
+}
+var CodexEventMapper = class {
+  streamStarted = false;
+  openTextParts = /* @__PURE__ */ new Set();
+  threadId;
+  setThreadId(threadId) {
+    this.threadId = threadId;
+  }
+  map(event) {
+    const parts = [];
+    const withMeta = (part) => withProviderMetadata(part, this.threadId);
+    const pushStreamStart = () => {
+      if (!this.streamStarted) {
+        parts.push({ type: "stream-start", warnings: [] });
+        this.streamStarted = true;
+      }
+    };
+    switch (event.method) {
+      case "turn/started": {
+        pushStreamStart();
+        break;
+      }
+      case "item/started": {
+        const item = event.params ?? {};
+        if (item.itemType === "assistantMessage" && item.itemId) {
+          pushStreamStart();
+          this.openTextParts.add(item.itemId);
+          parts.push(withMeta({ type: "text-start", id: item.itemId }));
+        }
+        break;
+      }
+      case "item/agentMessage/delta": {
+        const delta = event.params ?? {};
+        if (!delta.itemId || !delta.delta) {
+          break;
+        }
+        pushStreamStart();
+        if (!this.openTextParts.has(delta.itemId)) {
+          this.openTextParts.add(delta.itemId);
+          parts.push(withMeta({ type: "text-start", id: delta.itemId }));
+        }
+        parts.push(withMeta({ type: "text-delta", id: delta.itemId, delta: delta.delta }));
+        break;
+      }
+      case "item/completed": {
+        const item = event.params ?? {};
+        if (item.itemType === "assistantMessage" && item.itemId && this.openTextParts.has(item.itemId)) {
+          parts.push(withMeta({ type: "text-end", id: item.itemId }));
+          this.openTextParts.delete(item.itemId);
+        }
+        break;
+      }
+      case "item/tool/callStarted": {
+        const params = event.params ?? {};
+        if (params.callId && params.tool) {
+          pushStreamStart();
+          parts.push(withMeta({ type: "tool-input-start", id: params.callId, toolName: params.tool, dynamic: true }));
+        }
+        break;
+      }
+      case "item/tool/callDelta": {
+        const params = event.params ?? {};
+        if (params.callId && params.delta) {
+          parts.push(withMeta({ type: "tool-input-delta", id: params.callId, delta: params.delta }));
+        }
+        break;
+      }
+      case "item/tool/callFinished": {
+        const params = event.params ?? {};
+        if (params.callId) {
+          parts.push(withMeta({ type: "tool-input-end", id: params.callId }));
+        }
+        break;
+      }
+      case "turn/completed": {
+        pushStreamStart();
+        for (const itemId of this.openTextParts) {
+          parts.push(withMeta({ type: "text-end", id: itemId }));
+        }
+        this.openTextParts.clear();
+        const completed = event.params ?? {};
+        parts.push(withMeta({ type: "finish", finishReason: toFinishReason(completed.status), usage: EMPTY_USAGE }));
+        break;
+      }
+    }
+    return parts;
+  }
+};
+
+// src/protocol/prompt-mapper.ts
+function mapSystemPrompt(prompt) {
+  const chunks = [];
+  for (const message of prompt) {
+    if (message.role === "system") {
+      const text = message.content.trim();
+      if (text.length > 0) {
+        chunks.push(text);
+      }
+    }
+  }
+  return chunks.length > 0 ? chunks.join("\n\n") : void 0;
+}
+function mapPromptToTurnInput(prompt, isResume = false) {
+  if (isResume) {
+    for (let i = prompt.length - 1; i >= 0; i--) {
+      const message = prompt[i];
+      if (message?.role === "user") {
+        const items = [];
+        for (const part of message.content) {
+          if (part.type === "text") {
+            const text = part.text.trim();
+            if (text.length > 0) {
+              items.push({ type: "text", text, text_elements: [] });
+            }
+          }
+        }
+        return items;
+      }
+    }
+    return [];
+  }
+  const chunks = [];
+  for (const message of prompt) {
+    if (message.role === "user") {
+      for (const part of message.content) {
+        if (part.type === "text") {
+          const text = part.text.trim();
+          if (text.length > 0) {
+            chunks.push(text);
+          }
+        }
+      }
+    }
+  }
+  return [{ type: "text", text: chunks.join("\n\n"), text_elements: [] }];
+}
+
+// src/model.ts
+function createEmptyUsage() {
+  return {
+    inputTokens: {
+      total: void 0,
+      noCache: void 0,
+      cacheRead: void 0,
+      cacheWrite: void 0
+    },
+    outputTokens: {
+      total: void 0,
+      text: void 0,
+      reasoning: void 0
+    }
+  };
+}
+function extractThreadId(result) {
+  const threadId = result.threadId ?? result.thread?.id;
+  if (!threadId) {
+    throw new CodexProviderError("thread/start response does not include a thread id.");
+  }
+  return threadId;
+}
+function extractTurnId(result) {
+  const turnId = result.turnId ?? result.turn?.id;
+  if (!turnId) {
+    throw new CodexProviderError("turn/start response does not include a turn id.");
+  }
+  return turnId;
+}
+function extractResumeThreadId(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const message = prompt[i];
+    if (message?.role === "assistant") {
+      const meta = message.providerOptions?.["codex-app-server"];
+      if (meta && typeof meta["threadId"] === "string") {
+        return meta["threadId"];
+      }
+    }
+  }
+  return void 0;
+}
+function extractToolResults(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const message = prompt[i];
+    if (message?.role === "tool") {
+      const contentItems = [];
+      let success = true;
+      for (const part of message.content) {
+        if (part.type === "tool-result") {
+          if (part.output.type === "text") {
+            contentItems.push({ type: "inputText", text: part.output.value });
+          } else if (part.output.type === "json") {
+            contentItems.push({ type: "inputText", text: JSON.stringify(part.output.value) });
+          } else if (part.output.type === "execution-denied") {
+            success = false;
+            contentItems.push({
+              type: "inputText",
+              text: part.output.reason ?? "Tool execution was denied."
+            });
+          }
+        }
+      }
+      if (contentItems.length > 0) {
+        return { success, contentItems };
+      }
+    }
+  }
+  return void 0;
+}
+function sdkToolsToCodexDynamicTools(tools) {
+  return tools.filter((t) => t.type === "function").map((t) => ({
+    name: t.name,
+    ...t.description ? { description: t.description } : {},
+    inputSchema: t.inputSchema
+  }));
+}
+function isPassThroughContentPart(part) {
+  switch (part.type) {
+    case "tool-call":
+    case "tool-result":
+    case "file":
+    case "source":
+    case "tool-approval-request":
+      return true;
+    default:
+      return false;
+  }
+}
+var CodexLanguageModel = class {
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  supportedUrls = {};
+  settings;
+  config;
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.provider = config.provider;
+  }
+  async doGenerate(options) {
+    void this.settings;
+    const streamResult = await this.doStream(options);
+    const reader = streamResult.stream.getReader();
+    const textOrder = [];
+    const textById = /* @__PURE__ */ new Map();
+    const passThroughContent = [];
+    let warnings = [];
+    let finishReason = {
+      unified: "other",
+      raw: void 0
+    };
+    let usage = createEmptyUsage();
+    let providerMetadata;
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value.type === "stream-start") {
+        warnings = value.warnings;
+        continue;
+      }
+      if (value.type === "text-start") {
+        if (!textById.has(value.id)) {
+          textOrder.push(value.id);
+          textById.set(value.id, "");
+        }
+        continue;
+      }
+      if (value.type === "text-delta") {
+        if (!textById.has(value.id)) {
+          textOrder.push(value.id);
+          textById.set(value.id, value.delta);
+        } else {
+          textById.set(value.id, `${textById.get(value.id) ?? ""}${value.delta}`);
+        }
+        continue;
+      }
+      if (value.type === "finish") {
+        finishReason = value.finishReason;
+        usage = value.usage;
+        providerMetadata = value.providerMetadata;
+        continue;
+      }
+      if (value.type === "error") {
+        if (value.error instanceof Error) {
+          throw value.error;
+        }
+        throw new CodexProviderError("Generation stream emitted an error.", {
+          cause: value.error
+        });
+      }
+      if (isPassThroughContentPart(value)) {
+        passThroughContent.push(value);
+      }
+    }
+    const textContent = textOrder.map((id) => {
+      const text = textById.get(id) ?? "";
+      if (text.length === 0) {
+        return null;
+      }
+      return {
+        type: "text",
+        text
+      };
+    }).filter((part) => part !== null);
+    return {
+      content: [...textContent, ...passThroughContent],
+      finishReason,
+      usage,
+      warnings,
+      ...providerMetadata ? { providerMetadata } : {},
+      ...streamResult.request ? { request: streamResult.request } : {}
+    };
+  }
+  registerCrossCallToolHandler(client, controller, persistentTransport, threadId, closeSuccessfully) {
+    client.onToolCallRequest((params, request) => {
+      const toolName = params.tool ?? params.toolName ?? "unknown";
+      const callId = params.callId ?? `call_${Date.now()}`;
+      const args = params.arguments ?? params.input ?? {};
+      const withMeta = (part) => withProviderMetadata(part, threadId);
+      persistentTransport.parkToolCall({
+        requestId: request.id,
+        callId,
+        toolName,
+        args,
+        threadId
+      });
+      controller.enqueue(withMeta({
+        type: "tool-call",
+        toolCallId: callId,
+        toolName,
+        input: typeof args === "string" ? args : JSON.stringify(args)
+      }));
+      controller.enqueue(withMeta({
+        type: "finish",
+        finishReason: { unified: "tool-calls", raw: "tool-calls" },
+        usage: createEmptyUsage()
+      }));
+      void closeSuccessfully();
+      return new Promise(() => {
+      });
+    });
+  }
+  doStream(options) {
+    const transport = this.config.providerSettings.transportFactory ? this.config.providerSettings.transportFactory() : this.config.providerSettings.transport?.type === "websocket" ? new WebSocketTransport(this.config.providerSettings.transport.websocket) : new StdioTransport(this.config.providerSettings.transport?.stdio);
+    const client = new AppServerClient(transport);
+    const mapper = new CodexEventMapper();
+    const stream = new ReadableStream({
+      start: (controller) => {
+        let closed = false;
+        const closeWithError = async (error) => {
+          if (closed) {
+            return;
+          }
+          controller.enqueue({ type: "error", error });
+          closed = true;
+          try {
+            controller.close();
+          } finally {
+            await client.disconnect();
+          }
+        };
+        const closeSuccessfully = async () => {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            controller.close();
+          } finally {
+            await client.disconnect();
+          }
+        };
+        const abortHandler = () => {
+          void closeWithError(new DOMException("Aborted", "AbortError"));
+        };
+        if (options.abortSignal) {
+          if (options.abortSignal.aborted) {
+            abortHandler();
+            return;
+          }
+          options.abortSignal.addEventListener("abort", abortHandler, { once: true });
+        }
+        void (async () => {
+          try {
+            await client.connect();
+            const persistentTransport = transport instanceof PersistentTransport ? transport : null;
+            const pendingToolCall = persistentTransport?.getPendingToolCall() ?? null;
+            if (pendingToolCall && persistentTransport) {
+              const toolResult = extractToolResults(options.prompt);
+              mapper.setThreadId(pendingToolCall.threadId);
+              client.onAnyNotification((method, params) => {
+                const parts = mapper.map({ method, params });
+                for (const part of parts) {
+                  controller.enqueue(part);
+                  if (part.type === "finish") {
+                    void closeSuccessfully();
+                  }
+                }
+              });
+              this.registerCrossCallToolHandler(
+                client,
+                controller,
+                persistentTransport,
+                pendingToolCall.threadId,
+                closeSuccessfully
+              );
+              const approvalsDispatcher2 = new ApprovalsDispatcher({
+                ...this.config.providerSettings.approvals?.onCommandApproval ? { onCommandApproval: this.config.providerSettings.approvals.onCommandApproval } : {},
+                ...this.config.providerSettings.approvals?.onFileChangeApproval ? { onFileChangeApproval: this.config.providerSettings.approvals.onFileChangeApproval } : {}
+              });
+              approvalsDispatcher2.attach(client);
+              await persistentTransport.respondToToolCall(
+                toolResult ?? { success: true, contentItems: [] }
+              );
+              return;
+            }
+            const dynamicToolsEnabled = this.config.providerSettings.experimentalApi === true;
+            if (dynamicToolsEnabled) {
+              const dispatcher = new DynamicToolsDispatcher({
+                ...this.config.providerSettings.tools ? { tools: this.config.providerSettings.tools } : {},
+                ...this.config.providerSettings.toolHandlers ? { handlers: this.config.providerSettings.toolHandlers } : {},
+                ...this.config.providerSettings.toolTimeoutMs !== void 0 ? { timeoutMs: this.config.providerSettings.toolTimeoutMs } : {}
+              });
+              dispatcher.attach(client);
+            }
+            const approvalsDispatcher = new ApprovalsDispatcher({
+              ...this.config.providerSettings.approvals?.onCommandApproval ? { onCommandApproval: this.config.providerSettings.approvals.onCommandApproval } : {},
+              ...this.config.providerSettings.approvals?.onFileChangeApproval ? { onFileChangeApproval: this.config.providerSettings.approvals.onFileChangeApproval } : {}
+            });
+            approvalsDispatcher.attach(client);
+            client.onAnyNotification((method, params) => {
+              const parts = mapper.map({ method, params });
+              for (const part of parts) {
+                controller.enqueue(part);
+                if (part.type === "finish") {
+                  void closeSuccessfully();
+                }
+              }
+            });
+            const providerToolDefs = this.config.providerSettings.tools;
+            const providerDynamicTools = providerToolDefs ? Object.entries(providerToolDefs).map(([name, def]) => ({
+              name,
+              description: def.description,
+              inputSchema: def.inputSchema
+            })) : [];
+            const sdkDynamicTools = options.tools ? sdkToolsToCodexDynamicTools(options.tools) : [];
+            const allDynamicTools = [...providerDynamicTools, ...sdkDynamicTools];
+            const dynamicTools = allDynamicTools.length > 0 ? allDynamicTools : void 0;
+            const hasSdkTools = sdkDynamicTools.length > 0;
+            const needsExperimentalApi = this.config.providerSettings.experimentalApi === true || dynamicTools !== void 0;
+            const initializeParams = {
+              clientInfo: this.config.providerSettings.clientInfo ?? {
+                name: PACKAGE_NAME,
+                version: PACKAGE_VERSION
+              },
+              ...needsExperimentalApi ? { capabilities: { experimentalApi: true } } : {}
+            };
+            await client.request("initialize", initializeParams);
+            await client.notification("initialized");
+            const resumeThreadId = extractResumeThreadId(options.prompt);
+            const developerInstructions = mapSystemPrompt(options.prompt);
+            let threadId;
+            if (resumeThreadId) {
+              const resumeParams = {
+                threadId: resumeThreadId,
+                persistExtendedHistory: false,
+                ...developerInstructions ? { developerInstructions } : {}
+              };
+              const resumeResult = await client.request(
+                "thread/resume",
+                resumeParams
+              );
+              threadId = resumeResult.threadId ?? resumeResult.thread?.id ?? resumeThreadId;
+            } else {
+              const threadStartParams = {
+                model: this.config.providerSettings.defaultModel ?? this.modelId,
+                ...dynamicTools ? { dynamicTools } : {},
+                ...developerInstructions ? { developerInstructions } : {},
+                ...this.config.providerSettings.defaultThreadSettings?.cwd ? { cwd: this.config.providerSettings.defaultThreadSettings.cwd } : {},
+                ...this.config.providerSettings.defaultThreadSettings?.approvalPolicy ? {
+                  approvalPolicy: this.config.providerSettings.defaultThreadSettings.approvalPolicy
+                } : {},
+                ...this.config.providerSettings.defaultThreadSettings?.sandbox ? {
+                  sandbox: this.config.providerSettings.defaultThreadSettings.sandbox
+                } : {}
+              };
+              const threadStartResult = await client.request(
+                "thread/start",
+                threadStartParams
+              );
+              threadId = extractThreadId(threadStartResult);
+            }
+            mapper.setThreadId(threadId);
+            if (hasSdkTools && persistentTransport) {
+              this.registerCrossCallToolHandler(
+                client,
+                controller,
+                persistentTransport,
+                threadId,
+                closeSuccessfully
+              );
+            }
+            const turnStartResult = await client.request("turn/start", {
+              threadId,
+              input: mapPromptToTurnInput(options.prompt, !!resumeThreadId)
+            });
+            extractTurnId(turnStartResult);
+          } catch (error) {
+            await closeWithError(error);
+          }
+        })();
+      },
+      cancel: async () => {
+        await client.disconnect();
+      }
+    });
+    return Promise.resolve({ stream });
+  }
+};
+
+// src/client/persistent-pool-registry.ts
+var GLOBAL_PERSISTENT_POOL_DEFAULT_KEY = "default";
+var globalPersistentPools = /* @__PURE__ */ new Map();
+function acquirePersistentPool(settings) {
+  if (settings.scope === "provider") {
+    const pool2 = new CodexWorkerPool({
+      poolSize: settings.poolSize,
+      transportFactory: settings.transportFactory,
+      idleTimeoutMs: settings.idleTimeoutMs
+    });
+    let released2 = false;
+    return {
+      pool: pool2,
+      async release() {
+        if (released2) {
+          return;
+        }
+        released2 = true;
+        await pool2.shutdown();
+      }
+    };
+  }
+  const key = settings.key ?? GLOBAL_PERSISTENT_POOL_DEFAULT_KEY;
+  const existing = globalPersistentPools.get(key);
+  if (existing) {
+    if (existing.poolSize !== settings.poolSize || existing.idleTimeoutMs !== settings.idleTimeoutMs) {
+      throw new Error(
+        `Global persistent pool "${key}" already exists with different settings.`
+      );
+    }
+    existing.refCount++;
+    let released2 = false;
+    return {
+      pool: existing.pool,
+      async release() {
+        if (released2) {
+          return;
+        }
+        released2 = true;
+        const entry = globalPersistentPools.get(key);
+        if (!entry) {
+          return;
+        }
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+          globalPersistentPools.delete(key);
+          await entry.pool.shutdown();
+        }
+      }
+    };
+  }
+  const pool = new CodexWorkerPool({
+    poolSize: settings.poolSize,
+    transportFactory: settings.transportFactory,
+    idleTimeoutMs: settings.idleTimeoutMs
+  });
+  globalPersistentPools.set(key, {
+    pool,
+    refCount: 1,
+    poolSize: settings.poolSize,
+    idleTimeoutMs: settings.idleTimeoutMs
+  });
+  let released = false;
+  return {
+    pool,
+    async release() {
+      if (released) {
+        return;
+      }
+      released = true;
+      const entry = globalPersistentPools.get(key);
+      if (!entry) {
+        return;
+      }
+      entry.refCount--;
+      if (entry.refCount <= 0) {
+        globalPersistentPools.delete(key);
+        await entry.pool.shutdown();
+      }
+    }
+  };
+}
+
+// src/provider.ts
+var PROVIDER_ID = "codex-app-server";
+function createNoSuchModelError(modelId, modelType) {
+  return new provider.NoSuchModelError({ modelId, modelType });
+}
+function createCodexAppServer(settings = {}) {
+  let persistentPoolHandle = null;
+  const baseTransportFactory = settings.transportFactory;
+  if (settings.persistent) {
+    const scope = settings.persistent.scope ?? "provider";
+    const poolSize = settings.persistent.poolSize ?? 1;
+    const idleTimeoutMs = settings.persistent.idleTimeoutMs ?? 3e5;
+    const poolTransportFactory = baseTransportFactory ?? (settings.transport?.type === "websocket" ? () => new WebSocketTransport(settings.transport?.websocket) : () => new StdioTransport(settings.transport?.stdio));
+    persistentPoolHandle = acquirePersistentPool({
+      scope,
+      ...settings.persistent.key !== void 0 ? { key: settings.persistent.key } : {},
+      poolSize,
+      idleTimeoutMs,
+      transportFactory: poolTransportFactory
+    });
+  }
+  const persistentPool = persistentPoolHandle?.pool ?? null;
+  const effectiveTransportFactory = persistentPool ? () => new PersistentTransport({ pool: persistentPool }) : baseTransportFactory;
+  const resolvedSettings = Object.freeze({
+    ...settings.defaultModel ? { defaultModel: settings.defaultModel } : {},
+    ...settings.experimentalApi !== void 0 ? { experimentalApi: settings.experimentalApi } : {},
+    ...settings.clientInfo ? {
+      clientInfo: {
+        ...settings.clientInfo
+      }
+    } : {},
+    ...settings.transport ? {
+      transport: {
+        ...settings.transport.type ? { type: settings.transport.type } : {},
+        ...settings.transport.stdio ? { stdio: { ...settings.transport.stdio } } : {},
+        ...settings.transport.websocket ? { websocket: { ...settings.transport.websocket } } : {}
+      }
+    } : {},
+    ...settings.defaultThreadSettings ? { defaultThreadSettings: { ...settings.defaultThreadSettings } } : {},
+    ...effectiveTransportFactory ? { transportFactory: effectiveTransportFactory } : {},
+    ...settings.tools ? { tools: { ...settings.tools } } : {},
+    ...settings.toolHandlers ? { toolHandlers: { ...settings.toolHandlers } } : {},
+    ...settings.toolTimeoutMs !== void 0 ? { toolTimeoutMs: settings.toolTimeoutMs } : {},
+    ...settings.approvals ? { approvals: { ...settings.approvals } } : {}
+  });
+  const createLanguageModel = (modelId, modelSettings = {}) => new CodexLanguageModel(modelId, modelSettings, {
+    provider: PROVIDER_ID,
+    providerSettings: resolvedSettings
+  });
+  const providerFn = ((modelId, modelSettings = {}) => createLanguageModel(modelId, modelSettings));
+  const provider = Object.assign(providerFn, {
+    specificationVersion: "v3",
+    settings: resolvedSettings,
+    languageModel(modelId) {
+      return createLanguageModel(modelId);
+    },
+    chat(modelId, modelSettings = {}) {
+      return createLanguageModel(modelId, modelSettings);
+    },
+    embeddingModel(modelId) {
+      throw createNoSuchModelError(modelId, "embeddingModel");
+    },
+    imageModel(modelId) {
+      throw createNoSuchModelError(modelId, "imageModel");
+    },
+    async shutdown() {
+      if (!persistentPoolHandle) {
+        return;
+      }
+      const handle = persistentPoolHandle;
+      persistentPoolHandle = null;
+      await handle.release();
+    }
+  });
+  return provider;
+}
+var codexAppServer = createCodexAppServer();
+var createCodexProvider = createCodexAppServer;
+
+exports.AppServerClient = AppServerClient;
+exports.ApprovalsDispatcher = ApprovalsDispatcher;
+exports.CODEX_PROVIDER_ID = CODEX_PROVIDER_ID;
+exports.CodexEventMapper = CodexEventMapper;
+exports.CodexLanguageModel = CodexLanguageModel;
+exports.CodexNotImplementedError = CodexNotImplementedError;
+exports.CodexProviderError = CodexProviderError;
+exports.CodexWorker = CodexWorker;
+exports.CodexWorkerPool = CodexWorkerPool;
+exports.DynamicToolsDispatcher = DynamicToolsDispatcher;
+exports.JsonRpcError = JsonRpcError;
+exports.PACKAGE_NAME = PACKAGE_NAME;
+exports.PACKAGE_VERSION = PACKAGE_VERSION;
+exports.PersistentTransport = PersistentTransport;
+exports.StdioTransport = StdioTransport;
+exports.WebSocketTransport = WebSocketTransport;
+exports.codexAppServer = codexAppServer;
+exports.codexProviderMetadata = codexProviderMetadata;
+exports.createCodexAppServer = createCodexAppServer;
+exports.createCodexProvider = createCodexProvider;
+exports.mapPromptToTurnInput = mapPromptToTurnInput;
+exports.mapSystemPrompt = mapSystemPrompt;
+exports.withProviderMetadata = withProviderMetadata;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map