@codex-native/sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,638 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+
+// src/outputSchemaFile.ts
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+async function createOutputSchemaFile(schema) {
+  if (schema === void 0) {
+    return { cleanup: async () => {
+    } };
+  }
+  if (!isJsonObject(schema)) {
+    throw new Error("outputSchema must be a plain JSON object");
+  }
+  const schemaDir = await fs.mkdtemp(path.join(os.tmpdir(), "codex-output-schema-"));
+  const schemaPath = path.join(schemaDir, "schema.json");
+  const cleanup = async () => {
+    try {
+      await fs.rm(schemaDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    await fs.writeFile(schemaPath, JSON.stringify(schema), "utf8");
+    return { schemaPath, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_outputSchemaFile = __esm({
+  "src/outputSchemaFile.ts"() {
+    "use strict";
+  }
+});
+
+// src/thread.ts
+function normalizeInput(input) {
+  if (typeof input === "string") {
+    return { prompt: input, images: [] };
+  }
+  const promptParts = [];
+  const images = [];
+  for (const item of input) {
+    if (item.type === "text") {
+      promptParts.push(item.text);
+    } else if (item.type === "local_image") {
+      images.push(item.path);
+    }
+  }
+  return { prompt: promptParts.join("\n\n"), images };
+}
+var Thread;
+var init_thread = __esm({
+  "src/thread.ts"() {
+    "use strict";
+    init_outputSchemaFile();
+    Thread = class {
+      _exec;
+      _options;
+      _id;
+      _threadOptions;
+      /** Returns the ID of the thread. Populated after the first turn starts. */
+      get id() {
+        return this._id;
+      }
+      /* @internal */
+      constructor(exec, options, threadOptions, id = null) {
+        this._exec = exec;
+        this._options = options;
+        this._id = id;
+        this._threadOptions = threadOptions;
+      }
+      /** Provides the input to the agent and streams events as they are produced during the turn. */
+      async runStreamed(input, turnOptions = {}) {
+        return { events: this.runStreamedInternal(input, turnOptions) };
+      }
+      async *runStreamedInternal(input, turnOptions = {}) {
+        const { schemaPath, cleanup } = await createOutputSchemaFile(turnOptions.outputSchema);
+        const options = this._threadOptions;
+        const { prompt, images } = normalizeInput(input);
+        const generator = this._exec.run({
+          input: prompt,
+          baseUrl: this._options.baseUrl,
+          apiKey: this._options.apiKey,
+          threadId: this._id,
+          images,
+          model: options?.model,
+          sandboxMode: options?.sandboxMode,
+          workingDirectory: options?.workingDirectory,
+          skipGitRepoCheck: options?.skipGitRepoCheck,
+          outputSchemaFile: schemaPath,
+          outputSchema: turnOptions.outputSchema
+        });
+        try {
+          for await (const item of generator) {
+            let parsed;
+            try {
+              parsed = JSON.parse(item);
+            } catch (error) {
+              throw new Error(`Failed to parse item: ${item}`, { cause: error });
+            }
+            if (parsed.type === "thread.started") {
+              this._id = parsed.thread_id;
+            }
+            yield parsed;
+          }
+        } finally {
+          await cleanup();
+        }
+      }
+      /** Provides the input to the agent and returns the completed turn. */
+      async run(input, turnOptions = {}) {
+        const generator = this.runStreamedInternal(input, turnOptions);
+        const items = [];
+        let finalResponse = "";
+        let usage = null;
+        let turnFailure = null;
+        for await (const event of generator) {
+          if (event.type === "item.completed") {
+            if (event.item.type === "agent_message") {
+              finalResponse = event.item.text;
+            }
+            items.push(event.item);
+          } else if (event.type === "turn.completed") {
+            usage = event.usage;
+          } else if (event.type === "turn.failed") {
+            turnFailure = event.error;
+            break;
+          }
+        }
+        if (turnFailure) {
+          throw new Error(turnFailure.message);
+        }
+        return { items, finalResponse, usage };
+      }
+    };
+  }
+});
+
+// src/nativeBinding.ts
+import { createRequire } from "module";
+function getNativeBinding() {
+  if (cachedBinding !== void 0) {
+    return cachedBinding;
+  }
+  const require2 = createRequire(import.meta.url);
+  try {
+    const binding = require2("../index.js");
+    cachedBinding = binding;
+    return cachedBinding;
+  } catch (error) {
+    console.warn("Failed to load native NAPI binding:", error);
+    cachedBinding = null;
+    return cachedBinding;
+  }
+}
+var cachedBinding;
+var init_nativeBinding = __esm({
+  "src/nativeBinding.ts"() {
+    "use strict";
+  }
+});
+
+// src/exec.ts
+var CodexExec, AsyncQueue;
+var init_exec = __esm({
+  "src/exec.ts"() {
+    "use strict";
+    init_nativeBinding();
+    CodexExec = class {
+      native;
+      constructor() {
+        const nativeBinding = getNativeBinding();
+        if (!nativeBinding) {
+          throw new Error(
+            "Native NAPI binding not available. Make sure @openai/codex-native is properly installed and built."
+          );
+        }
+        this.native = nativeBinding;
+      }
+      async *run(args) {
+        const binding = this.native;
+        const queue = new AsyncQueue();
+        const request = {
+          prompt: args.input,
+          threadId: args.threadId ?? void 0,
+          images: args.images && args.images.length > 0 ? args.images : void 0,
+          model: args.model,
+          sandboxMode: args.sandboxMode,
+          workingDirectory: args.workingDirectory,
+          skipGitRepoCheck: args.skipGitRepoCheck,
+          outputSchema: args.outputSchema,
+          baseUrl: args.baseUrl,
+          apiKey: args.apiKey
+        };
+        let runPromise;
+        try {
+          runPromise = binding.runThreadStream(request, (err, eventJson) => {
+            if (err) {
+              queue.fail(err);
+              return;
+            }
+            try {
+              queue.push(eventJson ?? "null");
+            } catch (error) {
+              queue.fail(error);
+            }
+          }).then(
+            () => {
+              queue.end();
+            },
+            (error) => {
+              queue.fail(error);
+            }
+          );
+        } catch (error) {
+          queue.fail(error);
+          throw error;
+        }
+        let loopError;
+        try {
+          for await (const value of queue) {
+            yield value;
+          }
+          await runPromise;
+        } catch (error) {
+          loopError = error;
+          throw error;
+        } finally {
+          queue.end();
+          if (loopError) {
+            await runPromise.catch(() => {
+            });
+          }
+        }
+      }
+    };
+    AsyncQueue = class {
+      buffer = [];
+      waiters = [];
+      ended = false;
+      error;
+      push(value) {
+        if (this.ended) return;
+        if (this.waiters.length > 0) {
+          const waiter = this.waiters.shift();
+          waiter.resolve({ value, done: false });
+          return;
+        }
+        this.buffer.push(value);
+      }
+      end() {
+        if (this.ended) return;
+        this.ended = true;
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters) {
+          waiter.resolve({ value: void 0, done: true });
+        }
+      }
+      fail(error) {
+        if (this.ended) return;
+        this.error = error;
+        this.ended = true;
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters) {
+          waiter.reject(error);
+        }
+      }
+      async next() {
+        if (this.buffer.length > 0) {
+          const value = this.buffer.shift();
+          return { value, done: false };
+        }
+        if (this.error) {
+          return Promise.reject(this.error);
+        }
+        if (this.ended) {
+          return { value: void 0, done: true };
+        }
+        return new Promise((resolve, reject) => {
+          this.waiters.push({ resolve, reject });
+        });
+      }
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+});
+
+// src/codex.ts
+var codex_exports = {};
+__export(codex_exports, {
+  Codex: () => Codex
+});
+var Codex;
+var init_codex = __esm({
+  "src/codex.ts"() {
+    "use strict";
+    init_exec();
+    init_nativeBinding();
+    init_thread();
+    Codex = class {
+      exec;
+      options;
+      nativeBinding;
+      constructor(options = {}) {
+        const predefinedTools = options.tools ? [...options.tools] : [];
+        this.nativeBinding = getNativeBinding();
+        this.options = { ...options, tools: [] };
+        if (this.nativeBinding) {
+          if (typeof this.nativeBinding.clearRegisteredTools === "function") {
+            this.nativeBinding.clearRegisteredTools();
+          }
+          for (const tool of predefinedTools) {
+            this.registerTool(tool);
+          }
+        }
+        this.exec = new CodexExec();
+      }
+      registerTool(tool) {
+        if (!this.nativeBinding) {
+          throw new Error("Native tool registration requires the NAPI binding");
+        }
+        if (typeof this.nativeBinding.registerTool !== "function") {
+          console.warn("registerTool is not available in this build - tools feature may be incomplete");
+          return;
+        }
+        const { handler, ...info } = tool;
+        this.nativeBinding.registerTool(info, handler);
+        if (!this.options.tools) {
+          this.options.tools = [];
+        }
+        this.options.tools.push(tool);
+      }
+      /**
+       * Starts a new conversation with an agent.
+       * @returns A new thread instance.
+       */
+      startThread(options = {}) {
+        return new Thread(this.exec, this.options, options);
+      }
+      /**
+       * Resumes a conversation with an agent based on the thread id.
+       * Threads are persisted in ~/.codex/sessions.
+       *
+       * @param id The id of the thread to resume.
+       * @returns A new thread instance.
+       */
+      resumeThread(id, options = {}) {
+        return new Thread(this.exec, this.options, options, id);
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_thread();
+init_codex();
+
+// src/agents/CodexProvider.ts
+var CodexProvider = class {
+  codex = null;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      workingDirectory: options.workingDirectory || process.cwd(),
+      skipGitRepoCheck: options.skipGitRepoCheck ?? false,
+      ...options
+    };
+  }
+  /**
+   * Lazy initialization of Codex instance
+   */
+  getCodex() {
+    if (!this.codex) {
+      const { Codex: CodexClass } = (init_codex(), __toCommonJS(codex_exports));
+      this.codex = new CodexClass({
+        apiKey: this.options.apiKey,
+        baseUrl: this.options.baseUrl
+      });
+    }
+    return this.codex;
+  }
+  getModel(modelName) {
+    const model = modelName || this.options.defaultModel;
+    return new CodexModel(this.getCodex(), model, this.options);
+  }
+};
+var CodexModel = class {
+  codex;
+  modelName;
+  thread = null;
+  options;
+  constructor(codex, modelName, options) {
+    this.codex = codex;
+    this.modelName = modelName;
+    this.options = options;
+  }
+  /**
+   * Get or create the thread for this model instance
+   */
+  getThread(conversationId) {
+    if (conversationId && !this.thread) {
+      this.thread = this.codex.resumeThread(conversationId, this.getThreadOptions());
+    } else if (!this.thread) {
+      this.thread = this.codex.startThread(this.getThreadOptions());
+    }
+    return this.thread;
+  }
+  getThreadOptions() {
+    return {
+      model: this.modelName,
+      workingDirectory: this.options.workingDirectory,
+      skipGitRepoCheck: this.options.skipGitRepoCheck
+    };
+  }
+  async getResponse(request) {
+    const thread = this.getThread(request.conversationId || request.previousResponseId);
+    const input = this.convertRequestToInput(request);
+    const turn = await thread.run(input, {
+      outputSchema: request.outputType?.schema
+    });
+    return {
+      usage: this.convertUsage(turn.usage),
+      output: this.convertItemsToOutput(turn.items, turn.finalResponse),
+      responseId: thread.id || void 0
+    };
+  }
+  async *getStreamedResponse(request) {
+    const thread = this.getThread(request.conversationId || request.previousResponseId);
+    const input = this.convertRequestToInput(request);
+    const { events } = await thread.runStreamed(input, {
+      outputSchema: request.outputType?.schema
+    });
+    let accumulatedText = "";
+    for await (const event of events) {
+      const streamEvents = this.convertCodexEventToStreamEvent(event, accumulatedText);
+      if (event.type === "item.completed" && event.item.type === "agent_message") {
+        accumulatedText = event.item.text;
+      }
+      for (const streamEvent of streamEvents) {
+        yield streamEvent;
+      }
+    }
+  }
+  /**
+   * Convert ModelRequest to Codex Input format
+   */
+  convertRequestToInput(request) {
+    const parts = [];
+    if (request.systemInstructions) {
+      parts.push({
+        type: "text",
+        text: `<system>
+${request.systemInstructions}
+</system>
+
+`
+      });
+    }
+    if (typeof request.input === "string") {
+      parts.push({ type: "text", text: request.input });
+    } else {
+      for (const item of request.input) {
+        if (item.type === "input_text") {
+          parts.push({ type: "text", text: item.text });
+        } else if (item.type === "input_image") {
+          if (typeof item.image === "string") {
+            continue;
+          } else if ("url" in item.image) {
+            continue;
+          } else if ("fileId" in item.image) {
+            continue;
+          }
+        }
+      }
+    }
+    if (parts.length === 1 && parts[0].type === "text") {
+      return parts[0].text;
+    }
+    return parts;
+  }
+  /**
+   * Convert Codex Usage to ModelResponse Usage
+   */
+  convertUsage(usage) {
+    if (!usage) {
+      return {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+      };
+    }
+    const inputTokensDetails = usage.cached_input_tokens ? [{ cachedTokens: usage.cached_input_tokens }] : void 0;
+    return {
+      inputTokens: usage.input_tokens,
+      outputTokens: usage.output_tokens,
+      totalTokens: usage.input_tokens + usage.output_tokens,
+      inputTokensDetails
+    };
+  }
+  /**
+   * Convert Codex ThreadItems to AgentOutputItems
+   */
+  convertItemsToOutput(items, finalResponse) {
+    const output = [];
+    for (const item of items) {
+      switch (item.type) {
+        case "agent_message": {
+          const content = [
+            {
+              type: "output_text",
+              text: item.text
+            }
+          ];
+          output.push({
+            type: "message",
+            role: "assistant",
+            status: "completed",
+            content
+          });
+          break;
+        }
+        case "reasoning": {
+          output.push({
+            type: "reasoning",
+            reasoning: item.text
+          });
+          break;
+        }
+        // Codex handles tools internally, so we don't expose them as function calls
+        // The results are already incorporated into the agent_message
+        case "command_execution":
+        case "file_change":
+        case "mcp_tool_call":
+          break;
+        default:
+          break;
+      }
+    }
+    if (output.length === 0 && finalResponse) {
+      output.push({
+        type: "message",
+        role: "assistant",
+        status: "completed",
+        content: [
+          {
+            type: "output_text",
+            text: finalResponse
+          }
+        ]
+      });
+    }
+    return output;
+  }
+  /**
+   * Convert Codex ThreadEvent to OpenAI Agents StreamEvent
+   */
+  convertCodexEventToStreamEvent(event, previousText) {
+    const events = [];
+    switch (event.type) {
+      case "thread.started":
+        events.push({ type: "response_started" });
+        break;
+      case "turn.started":
+        break;
+      case "item.started":
+        break;
+      case "item.completed":
+        if (event.item.type === "agent_message") {
+          events.push({
+            type: "output_text_done",
+            text: event.item.text
+          });
+        } else if (event.item.type === "reasoning") {
+          events.push({
+            type: "reasoning_done",
+            reasoning: event.item.text
+          });
+        }
+        break;
+      case "turn.completed":
+        events.push({
+          type: "response_done",
+          response: {
+            usage: this.convertUsage(event.usage),
+            output: [],
+            // Items were already emitted
+            responseId: this.thread?.id || void 0
+          }
+        });
+        break;
+      case "turn.failed":
+        events.push({
+          type: "error",
+          error: {
+            message: event.error.message
+          }
+        });
+        break;
+      default:
+        break;
+    }
+    return events;
+  }
+};
+export {
+  Codex,
+  CodexProvider,
+  Thread
+};
+//# sourceMappingURL=index.mjs.map