@meetopenbot/codex 1.0.10 → 1.0.12

package/dist/index.js

@@ -1,543 +1,187 @@
-// node_modules/.pnpm/@openai+codex-sdk@0.111.0/node_modules/@openai/codex-sdk/dist/index.js
-import { promises as fs } from "fs";
-import os from "os";
-import path from "path";
-import { spawn } from "child_process";
-import path2 from "path";
-import readline from "readline";
-import { createRequire } from "module";
-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 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,
-      modelReasoningEffort: options?.modelReasoningEffort,
-      signal: turnOptions.signal,
-      networkAccessEnabled: options?.networkAccessEnabled,
-      webSearchMode: options?.webSearchMode,
-      webSearchEnabled: options?.webSearchEnabled,
-      approvalPolicy: options?.approvalPolicy,
-      additionalDirectories: options?.additionalDirectories
-    });
-    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;
+// index.ts
+import {
+  definePlugin,
+  shouldHandleInvoke,
+  agentOutput,
+  uiWidget
+} from "@meetopenbot/plugin-sdk";
+import {
+  Codex
+} from "@openai/codex-sdk";
+var codex_default = definePlugin({
+  id: "codex",
+  name: "Codex",
+  description: "Codex integration tools for OpenBot",
+  configSchema: {
+    type: "object",
+    properties: {
+      apiKey: { type: "string", description: "Codex API Key", format: "password" },
+      baseURL: { type: "string", description: "Custom OpenAI-compatible endpoint" },
+      codexPathOverride: { type: "string", description: "Path to codex CLI" },
+      model: { type: "string", description: "Model to use", default: "gpt-5-codex" },
+      workingDirectory: { type: "string", description: "Working directory for Codex" },
+      skipGitRepoCheck: { type: "boolean", description: "Skip git repo check", default: true },
+      sandboxMode: {
+        type: "string",
+        enum: ["workspace-read", "workspace-write", "full-read", "full-write"],
+        description: "Sandbox mode",
+        default: "workspace-write"
+      },
+      approvalPolicy: {
+        type: "string",
+        enum: ["always", "never", "automatic"],
+        description: "Approval policy",
+        default: "never"
+      },
+      networkAccessEnabled: { type: "boolean", description: "Enable network access" },
+      webSearchMode: {
+        type: "string",
+        enum: ["always", "never", "automatic"],
+        description: "Web search mode"
+      }
+    }
+  },
+  factory: (context) => {
+    const config = context.config;
+    const env = globalThis?.process?.env || {};
+    const apiKey = config.apiKey ?? env.CODEX_API_KEY ?? env.OPENAI_API_KEY;
+    const codexPathOverride = config.codexPathOverride ?? env.CODEX_PATH ?? env.CODEX_CLI_PATH;
+    const model = config.model?.split("/").pop() || "gpt-5-codex";
+    let client;
+    const getClient = () => {
+      if (!client) {
+        client = new Codex({
+          apiKey,
+          ...codexPathOverride && { codexPathOverride },
+          ...config.baseURL && { baseUrl: config.baseURL }
+        });
       }
-    } 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;
+      return client;
+    };
+    let thread = null;
+    const getThread = (state, meta) => {
+      if (thread) return thread;
+      const workingDirectory = config.workingDirectory || state?.channelDetails?.cwd || globalThis?.process?.cwd() || "/tmp";
+      const threadOptions = {
+        model,
+        workingDirectory,
+        skipGitRepoCheck: config.skipGitRepoCheck ?? true,
+        sandboxMode: config.sandboxMode ?? "workspace-write",
+        approvalPolicy: config.approvalPolicy ?? "never",
+        ...typeof config.networkAccessEnabled === "boolean" && {
+          networkAccessEnabled: config.networkAccessEnabled
+        },
+        ...config.webSearchMode && {
+          webSearchMode: config.webSearchMode
         }
-        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 };
-  }
-};
-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 INTERNAL_ORIGINATOR_ENV = "CODEX_INTERNAL_ORIGINATOR_OVERRIDE";
-var TYPESCRIPT_SDK_ORIGINATOR = "codex_sdk_ts";
-var CODEX_NPM_NAME = "@openai/codex";
-var PLATFORM_PACKAGE_BY_TARGET = {
-  "x86_64-unknown-linux-musl": "@openai/codex-linux-x64",
-  "aarch64-unknown-linux-musl": "@openai/codex-linux-arm64",
-  "x86_64-apple-darwin": "@openai/codex-darwin-x64",
-  "aarch64-apple-darwin": "@openai/codex-darwin-arm64",
-  "x86_64-pc-windows-msvc": "@openai/codex-win32-x64",
-  "aarch64-pc-windows-msvc": "@openai/codex-win32-arm64"
-};
-var moduleRequire = createRequire(import.meta.url);
-var CodexExec = class {
-  executablePath;
-  envOverride;
-  configOverrides;
-  constructor(executablePath = null, env, configOverrides) {
-    this.executablePath = executablePath || findCodexPath();
-    this.envOverride = env;
-    this.configOverrides = configOverrides;
-  }
-  async *run(args) {
-    const commandArgs = ["exec", "--experimental-json"];
-    if (this.configOverrides) {
-      for (const override of serializeConfigOverrides(this.configOverrides)) {
-        commandArgs.push("--config", override);
-      }
-    }
-    if (args.model) {
-      commandArgs.push("--model", args.model);
-    }
-    if (args.sandboxMode) {
-      commandArgs.push("--sandbox", args.sandboxMode);
-    }
-    if (args.workingDirectory) {
-      commandArgs.push("--cd", args.workingDirectory);
-    }
-    if (args.additionalDirectories?.length) {
-      for (const dir of args.additionalDirectories) {
-        commandArgs.push("--add-dir", dir);
-      }
-    }
-    if (args.skipGitRepoCheck) {
-      commandArgs.push("--skip-git-repo-check");
-    }
-    if (args.outputSchemaFile) {
-      commandArgs.push("--output-schema", args.outputSchemaFile);
-    }
-    if (args.modelReasoningEffort) {
-      commandArgs.push("--config", `model_reasoning_effort="${args.modelReasoningEffort}"`);
-    }
-    if (args.networkAccessEnabled !== void 0) {
-      commandArgs.push(
-        "--config",
-        `sandbox_workspace_write.network_access=${args.networkAccessEnabled}`
-      );
-    }
-    if (args.webSearchMode) {
-      commandArgs.push("--config", `web_search="${args.webSearchMode}"`);
-    } else if (args.webSearchEnabled === true) {
-      commandArgs.push("--config", `web_search="live"`);
-    } else if (args.webSearchEnabled === false) {
-      commandArgs.push("--config", `web_search="disabled"`);
-    }
-    if (args.approvalPolicy) {
-      commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
-    }
-    if (args.threadId) {
-      commandArgs.push("resume", args.threadId);
-    }
-    if (args.images?.length) {
-      for (const image of args.images) {
-        commandArgs.push("--image", image);
+      };
+      const threadId = state?.threadId || meta?.threadId;
+      thread = threadId ? getClient().resumeThread(threadId, threadOptions) : getClient().startThread(threadOptions);
+      if (!threadId && state) {
+        state.threadId = thread.id;
       }
-    }
-    const env = {};
-    if (this.envOverride) {
-      Object.assign(env, this.envOverride);
-    } else {
-      for (const [key, value] of Object.entries(process.env)) {
-        if (value !== void 0) {
-          env[key] = value;
+      return thread;
+    };
+    return (builder) => {
+      builder.on("agent:invoke", async function* (event, ctx) {
+        if (!shouldHandleInvoke(event, context.agentId)) return;
+        const { content } = event.data || {};
+        if (!content) {
+          yield agentOutput({
+            agentId: context.agentId,
+            content: "No content provided.",
+            threadId: event.meta?.threadId
+          });
+          return;
         }
-      }
-    }
-    if (!env[INTERNAL_ORIGINATOR_ENV]) {
-      env[INTERNAL_ORIGINATOR_ENV] = TYPESCRIPT_SDK_ORIGINATOR;
-    }
-    if (args.baseUrl) {
-      env.OPENAI_BASE_URL = args.baseUrl;
-    }
-    if (args.apiKey) {
-      env.CODEX_API_KEY = args.apiKey;
-    }
-    const child = spawn(this.executablePath, commandArgs, {
-      env,
-      signal: args.signal
-    });
-    let spawnError = null;
-    child.once("error", (err) => spawnError = err);
-    if (!child.stdin) {
-      child.kill();
-      throw new Error("Child process has no stdin");
-    }
-    child.stdin.write(args.input);
-    child.stdin.end();
-    if (!child.stdout) {
-      child.kill();
-      throw new Error("Child process has no stdout");
-    }
-    const stderrChunks = [];
-    if (child.stderr) {
-      child.stderr.on("data", (data) => {
-        stderrChunks.push(data);
-      });
-    }
-    const exitPromise = new Promise(
-      (resolve) => {
-        child.once("exit", (code, signal) => {
-          resolve({ code, signal });
-        });
-      }
-    );
-    const rl = readline.createInterface({
-      input: child.stdout,
-      crlfDelay: Infinity
-    });
-    try {
-      for await (const line of rl) {
-        yield line;
-      }
-      if (spawnError) throw spawnError;
-      const { code, signal } = await exitPromise;
-      if (code !== 0 || signal) {
-        const stderrBuffer = Buffer.concat(stderrChunks);
-        const detail = signal ? `signal ${signal}` : `code ${code ?? 1}`;
-        throw new Error(`Codex Exec exited with ${detail}: ${stderrBuffer.toString("utf8")}`);
-      }
-    } finally {
-      rl.close();
-      child.removeAllListeners();
-      try {
-        if (!child.killed) child.kill();
-      } catch {
-      }
-    }
-  }
-};
-function serializeConfigOverrides(configOverrides) {
-  const overrides = [];
-  flattenConfigOverrides(configOverrides, "", overrides);
-  return overrides;
-}
-function flattenConfigOverrides(value, prefix, overrides) {
-  if (!isPlainObject(value)) {
-    if (prefix) {
-      overrides.push(`${prefix}=${toTomlValue(value, prefix)}`);
-      return;
-    } else {
-      throw new Error("Codex config overrides must be a plain object");
-    }
-  }
-  const entries = Object.entries(value);
-  if (!prefix && entries.length === 0) {
-    return;
-  }
-  if (prefix && entries.length === 0) {
-    overrides.push(`${prefix}={}`);
-    return;
-  }
-  for (const [key, child] of entries) {
-    if (!key) {
-      throw new Error("Codex config override keys must be non-empty strings");
-    }
-    if (child === void 0) {
-      continue;
-    }
-    const path3 = prefix ? `${prefix}.${key}` : key;
-    if (isPlainObject(child)) {
-      flattenConfigOverrides(child, path3, overrides);
-    } else {
-      overrides.push(`${path3}=${toTomlValue(child, path3)}`);
-    }
-  }
-}
-function toTomlValue(value, path3) {
-  if (typeof value === "string") {
-    return JSON.stringify(value);
-  } else if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Codex config override at ${path3} must be a finite number`);
-    }
-    return `${value}`;
-  } else if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  } else if (Array.isArray(value)) {
-    const rendered = value.map((item, index) => toTomlValue(item, `${path3}[${index}]`));
-    return `[${rendered.join(", ")}]`;
-  } else if (isPlainObject(value)) {
-    const parts = [];
-    for (const [key, child] of Object.entries(value)) {
-      if (!key) {
-        throw new Error("Codex config override keys must be non-empty strings");
-      }
-      if (child === void 0) {
-        continue;
-      }
-      parts.push(`${formatTomlKey(key)} = ${toTomlValue(child, `${path3}.${key}`)}`);
-    }
-    return `{${parts.join(", ")}}`;
-  } else if (value === null) {
-    throw new Error(`Codex config override at ${path3} cannot be null`);
-  } else {
-    const typeName = typeof value;
-    throw new Error(`Unsupported Codex config override value at ${path3}: ${typeName}`);
-  }
-}
-var TOML_BARE_KEY = /^[A-Za-z0-9_-]+$/;
-function formatTomlKey(key) {
-  return TOML_BARE_KEY.test(key) ? key : JSON.stringify(key);
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function findCodexPath() {
-  const { platform, arch } = process;
-  let targetTriple = null;
-  switch (platform) {
-    case "linux":
-    case "android":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-unknown-linux-musl";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-unknown-linux-musl";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "darwin":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-apple-darwin";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-apple-darwin";
-          break;
-        default:
-          break;
-      }
-      break;
-    case "win32":
-      switch (arch) {
-        case "x64":
-          targetTriple = "x86_64-pc-windows-msvc";
-          break;
-        case "arm64":
-          targetTriple = "aarch64-pc-windows-msvc";
-          break;
-        default:
-          break;
-      }
-      break;
-    default:
-      break;
-  }
-  if (!targetTriple) {
-    throw new Error(`Unsupported platform: ${platform} (${arch})`);
-  }
-  const platformPackage = PLATFORM_PACKAGE_BY_TARGET[targetTriple];
-  if (!platformPackage) {
-    throw new Error(`Unsupported target triple: ${targetTriple}`);
-  }
-  let vendorRoot;
-  try {
-    const codexPackageJsonPath = moduleRequire.resolve(`${CODEX_NPM_NAME}/package.json`);
-    const codexRequire = createRequire(codexPackageJsonPath);
-    const platformPackageJsonPath = codexRequire.resolve(`${platformPackage}/package.json`);
-    vendorRoot = path2.join(path2.dirname(platformPackageJsonPath), "vendor");
-  } catch {
-    throw new Error(
-      `Unable to locate Codex CLI binaries. Ensure ${CODEX_NPM_NAME} is installed with optional dependencies.`
-    );
-  }
-  const archRoot = path2.join(vendorRoot, targetTriple);
-  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
-  const binaryPath = path2.join(archRoot, "codex", codexBinaryName);
-  return binaryPath;
-}
-var Codex = class {
-  exec;
-  options;
-  constructor(options = {}) {
-    const { codexPathOverride, env, config } = options;
-    this.exec = new CodexExec(codexPathOverride, env, config);
-    this.options = options;
-  }
-  /**
-   * 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);
-  }
-};
+        try {
+          const turn = await getThread(ctx?.state, event.meta).runStreamed(content);
+          for await (const chunk of turn.events) {
+            if (chunk.type === "item.completed") {
+              const { item } = chunk;
+              if (item.type === "agent_message") {
+                yield agentOutput({
+                  agentId: context.agentId,
+                  content: item.text,
+                  threadId: event.meta?.threadId
+                });
+                continue;
+              }
+              let title = "";
+              let body = "";
+              switch (item.type) {
+                case "reasoning":
+                  title = "Reasoning";
+                  body = item.text;
+                  break;
+                case "command_execution":
+                  title = "Command Execution";
+                  body = `Executing: ${item.command}`;
+                  break;
+                case "file_change":
+                  title = "File Change";
+                  body = item.changes.map((change) => `${change.path}: ${change.kind || change.action}`).join("\n");
+                  break;
+                case "mcp_tool_call":
+                  title = `Tool: ${item.tool}`;
+                  body = `Arguments: ${JSON.stringify(item.arguments, null, 2)}`;
+                  if (item.result) {
+                    body += `
 
-// index.ts
-var codexPlugin = (options = { model: "gpt-5-codex" }) => (builder) => {
-  const env = globalThis?.process?.env || {};
-  const apiKey = options.apiKey ?? env.CODEX_API_KEY ?? env.OPENAI_API_KEY;
-  const codexPathOverride = options.codexPathOverride ?? env.CODEX_PATH ?? env.CODEX_CLI_PATH;
-  const model = options.model?.split("/").pop() || "gpt-5-codex";
-  let client;
-  const getClient = () => {
-    if (!client) {
-      client = new Codex({
-        apiKey,
-        ...codexPathOverride && { codexPathOverride },
-        ...options.baseURL && { baseUrl: options.baseURL }
-      });
-    }
-    return client;
-  };
-  let thread = null;
-  const getThread = (state) => {
-    if (thread) return thread;
-    const workingDirectory = options.workingDirectory || state?.channelDetails?.cwd || globalThis?.process?.cwd() || "/tmp";
-    const threadOptions = {
-      model,
-      workingDirectory,
-      skipGitRepoCheck: options.skipGitRepoCheck ?? false,
-      sandboxMode: options.sandboxMode ?? "workspace-write",
-      ...options.approvalPolicy && { approvalPolicy: options.approvalPolicy },
-      ...typeof options.networkAccessEnabled === "boolean" && { networkAccessEnabled: options.networkAccessEnabled },
-      ...options.webSearchMode && { webSearchMode: options.webSearchMode }
-    };
-    const threadId = state?.threadId;
-    thread = threadId ? getClient().resumeThread(threadId, threadOptions) : getClient().startThread(threadOptions);
-    if (!threadId && state) {
-      state.threadId = thread.id;
-    }
-    return thread;
-  };
-  builder.on("agent:invoke", async function* (event, ctx) {
-    const { content } = event.data;
-    if (!content) {
-      yield { type: "agent:output", data: { content: "No content provided." } };
-      return;
-    }
-    try {
-      const turn = await getThread(ctx?.state).runStreamed(content);
-      for await (const chunk of turn.events) {
-        if (chunk.type === "item.completed") {
-          if (chunk.item.type === "agent_message") {
-            yield { type: "agent:output", data: { content: chunk.item.text } };
-          }
-          if (chunk.item.type === "reasoning") {
-            yield { type: "agent:output", data: { content: chunk.item.text } };
-          }
-          if (chunk.item.type === "command_execution") {
-            yield { type: "agent:output", data: { content: chunk.item.command } };
-          }
-          if (chunk.item.type === "file_change") {
-            yield { type: "agent:output", data: { content: chunk.item.changes.map((change) => `${change.path}: ${change.action}`).join("\n") } };
-          }
-          if (chunk.item.type === "error") {
-            yield { type: "agent:output", data: { content: `Error: ${chunk.item.message}` } };
-          }
-          if (chunk.item.type === "todo_list") {
-            yield { type: "agent:output", data: { content: chunk.item.items.map((item) => `- ${item.text} (${item.completed ? "completed" : "pending"})`).join("\n") } };
-          }
-          if (chunk.item.type === "web_search") {
-            yield { type: "agent:output", data: { content: `Query: ${chunk.item.query}` } };
+Result: ${JSON.stringify(
+                      item.result.structured_content || item.result.content,
+                      null,
+                      2
+                    )}`;
+                  }
+                  if (item.error) {
+                    body += `
+
+Error: ${item.error.message}`;
+                  }
+                  break;
+                case "web_search":
+                  title = "Web Search";
+                  body = `Searching: ${item.query}`;
+                  break;
+                case "todo_list":
+                  title = "Todo List";
+                  body = item.items.map(
+                    (todo) => `- ${todo.text} (${todo.completed ? "completed" : "pending"})`
+                  ).join("\n");
+                  break;
+                case "error":
+                  title = "Error";
+                  body = item.message;
+                  break;
+              }
+              if (title && body) {
+                yield uiWidget({
+                  agentId: context.agentId,
+                  threadId: event.meta?.threadId,
+                  widget: {
+                    kind: "message",
+                    title,
+                    body,
+                    // @ts-ignore
+                    variant: "basic",
+                    display: "collapsed"
+                  }
+                });
+              }
+            }
           }
+        } catch (error) {
+          yield agentOutput({
+            agentId: context.agentId,
+            content: `Error: ${error?.message || "Codex request failed."}`,
+            threadId: event.meta?.threadId
+          });
         }
-      }
-    } catch (error) {
-      yield {
-        type: "agent:output",
-        data: { content: `Error: ${error?.message || "Codex request failed."}` }
-      };
-    }
-  });
-};
-var plugin = {
-  id: "codex",
-  name: "Codex",
-  description: "Codex integration tools for OpenBot",
-  kind: "runtime",
-  factory: (options) => codexPlugin(options)
-};
+      });
+    };
+  }
+});
 export {
-  codexPlugin,
-  plugin
+  codex_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/codex",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
   "description": "Codex tools plugin for OpenBot",
   "main": "./dist/index.js",
@@ -15,16 +15,16 @@
     "assets"
   ],
   "scripts": {
-    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:ai --external:zod --external:melony --external:@melony/ui-kit",
+    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@meetopenbot/plugin-sdk --external:@openai/codex-sdk --external:zod",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@openai/codex-sdk": "^0.111.0",
-    "melony": "^0.2.9"
+    "@meetopenbot/plugin-sdk": "^0.1.2",
+    "@openai/codex-sdk": "^0.138.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "esbuild": "^0.21.0",
-    "zod": "^3.23.8"
+    "zod": "^4.4.3"
   }
-}
+}