rhachet-brains-openai 0.1.6 → 0.1.8

package/dist/index.js

@@ -1,18 +1,560 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./contract/sdk"), exports);
-//# sourceMappingURL=index.js.map
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  genBrainAtom: () => genBrainAtom,
+  genBrainRepl: () => genBrainRepl,
+  getBrainAtomsByOpenAI: () => getBrainAtomsByOpenAI,
+  getBrainReplsByOpenAI: () => getBrainReplsByOpenAI
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/domain.operations/atoms/genBrainAtom.ts
+var import_openai = __toESM(require("openai"));
+var import_rhachet = require("rhachet");
+var import_zod = require("zod");
+var CONFIG_BY_SLUG = {
+  "openai/gpt-4o": {
+    model: "gpt-4o",
+    description: "gpt-4o - multimodal model for reasoning and vision"
+  },
+  "openai/gpt-4o-mini": {
+    model: "gpt-4o-mini",
+    description: "gpt-4o-mini - fast and cost-effective multimodal model"
+  },
+  "openai/gpt-4-turbo": {
+    model: "gpt-4-turbo",
+    description: "gpt-4-turbo - high capability with vision support"
+  },
+  "openai/o1": {
+    model: "o1",
+    description: "o1 - advanced reasoning model for complex problems"
+  },
+  "openai/o1-mini": {
+    model: "o1-mini",
+    description: "o1-mini - fast reasoning model for coding and math"
+  },
+  "openai/o1-preview": {
+    model: "o1-preview",
+    description: "o1-preview - preview of advanced reasoning capabilities"
+  }
+};
+var genBrainAtom = (input) => {
+  const config = CONFIG_BY_SLUG[input.slug];
+  return new import_rhachet.BrainAtom({
+    repo: "openai",
+    slug: input.slug,
+    description: config.description,
+    /**
+     * .what = stateless inference (no tool use)
+     * .why = provides direct model access for reasoning tasks
+     */
+    ask: async (askInput, context) => {
+      const systemPrompt = askInput.role.briefs ? await (0, import_rhachet.castBriefsToPrompt)({ briefs: askInput.role.briefs }) : void 0;
+      const openai = context?.openai ?? new import_openai.default({ apiKey: process.env.OPENAI_API_KEY });
+      const messages = [];
+      if (systemPrompt) {
+        messages.push({ role: "system", content: systemPrompt });
+      }
+      messages.push({ role: "user", content: askInput.prompt });
+      const jsonSchema = import_zod.z.toJSONSchema(askInput.schema.output);
+      const isObjectSchema = typeof jsonSchema === "object" && jsonSchema !== null && "type" in jsonSchema && jsonSchema.type === "object";
+      const response = await openai.chat.completions.create({
+        model: config.model,
+        messages,
+        ...isObjectSchema && {
+          response_format: {
+            type: "json_schema",
+            json_schema: {
+              name: "response",
+              strict: true,
+              schema: jsonSchema
+            }
+          }
+        }
+      });
+      const content = response.choices[0]?.message?.content ?? "";
+      if (isObjectSchema) {
+        const parsed = JSON.parse(content);
+        return askInput.schema.output.parse(parsed);
+      }
+      return askInput.schema.output.parse(content);
+    }
+  });
+};
+
+// node_modules/.pnpm/@openai+codex-sdk@0.77.0/node_modules/@openai/codex-sdk/dist/index.js
+var import_fs = require("fs");
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+var import_path2 = __toESM(require("path"), 1);
+var import_readline = __toESM(require("readline"), 1);
+var import_url = require("url");
+var import_meta = { get url() {
+  var path = require('path');
+  var fs = require('fs');
+  var dir = process.cwd();
+  while (dir !== path.dirname(dir)) {
+    var candidate = path.join(dir, 'node_modules', '@openai', 'codex-sdk', 'dist', 'index.js');
+    if (fs.existsSync(candidate)) return require('url').pathToFileURL(candidate).href;
+    dir = path.dirname(dir);
+  }
+  throw new Error('@openai/codex-sdk not found. Install it as a peer dependency.');
+} };
+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 import_fs.promises.mkdtemp(import_path.default.join(import_os.default.tmpdir(), "codex-output-schema-"));
+  const schemaPath = import_path.default.join(schemaDir, "schema.json");
+  const cleanup = async () => {
+    try {
+      await import_fs.promises.rm(schemaDir, { recursive: true, force: true });
+    } catch {
+    }
+  };
+  try {
+    await import_fs.promises.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,
+      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;
+      }
+    } 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 };
+  }
+};
+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 CodexExec = class {
+  executablePath;
+  envOverride;
+  constructor(executablePath = null, env) {
+    this.executablePath = executablePath || findCodexPath();
+    this.envOverride = env;
+  }
+  async *run(args) {
+    const commandArgs = ["exec", "--experimental-json"];
+    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.webSearchEnabled !== void 0) {
+      commandArgs.push("--config", `features.web_search_request=${args.webSearchEnabled}`);
+    }
+    if (args.approvalPolicy) {
+      commandArgs.push("--config", `approval_policy="${args.approvalPolicy}"`);
+    }
+    if (args.images?.length) {
+      for (const image of args.images) {
+        commandArgs.push("--image", image);
+      }
+    }
+    if (args.threadId) {
+      commandArgs.push("resume", args.threadId);
+    }
+    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;
+        }
+      }
+    }
+    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 = (0, import_child_process.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 rl = import_readline.default.createInterface({
+      input: child.stdout,
+      crlfDelay: Infinity
+    });
+    try {
+      for await (const line of rl) {
+        yield line;
+      }
+      const exitCode = new Promise((resolve, reject) => {
+        child.once("exit", (code) => {
+          if (code === 0) {
+            resolve(code);
+          } else {
+            const stderrBuffer = Buffer.concat(stderrChunks);
+            reject(
+              new Error(`Codex Exec exited with code ${code}: ${stderrBuffer.toString("utf8")}`)
+            );
+          }
+        });
+      });
+      if (spawnError) throw spawnError;
+      await exitCode;
+    } finally {
+      rl.close();
+      child.removeAllListeners();
+      try {
+        if (!child.killed) child.kill();
+      } catch {
+      }
+    }
+  }
+};
+var scriptFileName = (0, import_url.fileURLToPath)(import_meta.url);
+var scriptDirName = import_path2.default.dirname(scriptFileName);
+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 vendorRoot = import_path2.default.join(scriptDirName, "..", "vendor");
+  const archRoot = import_path2.default.join(vendorRoot, targetTriple);
+  const codexBinaryName = process.platform === "win32" ? "codex.exe" : "codex";
+  const binaryPath = import_path2.default.join(archRoot, "codex", codexBinaryName);
+  return binaryPath;
+}
+var Codex = class {
+  exec;
+  options;
+  constructor(options = {}) {
+    this.exec = new CodexExec(options.codexPathOverride, options.env);
+    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);
+  }
+};
+
+// src/domain.operations/repls/genBrainRepl.ts
+var import_rhachet2 = require("rhachet");
+var import_wrapper_fns = require("wrapper-fns");
+
+// src/infra/schema/asJsonSchema.ts
+var import_zod2 = require("zod");
+var asJsonSchema = (input) => {
+  return import_zod2.z.toJSONSchema(input.schema, { target: "openAi" });
+};
+
+// src/domain.operations/repls/genBrainRepl.ts
+var CONFIG_BY_SLUG2 = {
+  "openai/codex": {
+    model: void 0,
+    // use SDK default (gpt-5.1-codex-max)
+    description: "codex - agentic coding assistant (default model)"
+  },
+  "openai/codex/max": {
+    model: "gpt-5.1-codex-max",
+    description: "codex max - optimized for long-horizon agentic coding"
+  },
+  "openai/codex/mini": {
+    model: "gpt-5.1-codex-mini",
+    description: "codex mini - fast and cost-effective"
+  },
+  "openai/codex/5.2": {
+    model: "gpt-5.2-codex",
+    description: "codex 5.2 - most advanced agentic coding model"
+  }
+};
+var composePromptWithSystem = (userPrompt, systemPrompt) => {
+  if (!systemPrompt) return userPrompt;
+  return `${systemPrompt}
+
+---
+
+${userPrompt}`;
+};
+var invokeCodex = async (input) => {
+  const systemPrompt = input.role.briefs ? await (0, import_rhachet2.castBriefsToPrompt)({ briefs: input.role.briefs }) : void 0;
+  const outputSchema = asJsonSchema({
+    schema: input.schema.output
+  });
+  const codex = new Codex({
+    apiKey: process.env.OPENAI_API_KEY
+  });
+  const sandboxMode = input.mode === "ask" ? "read-only" : "workspace-write";
+  const thread = codex.startThread({
+    model: input.model,
+    sandboxMode
+  });
+  const fullPrompt = composePromptWithSystem(input.prompt, systemPrompt);
+  const response = await (0, import_wrapper_fns.withRetry)(
+    (0, import_wrapper_fns.withTimeout)(async () => thread.run(fullPrompt, { outputSchema }), {
+      threshold: { seconds: 60 }
+    })
+  )();
+  return input.schema.output.parse(JSON.parse(response.finalResponse));
+};
+var genBrainRepl = (input) => {
+  const config = CONFIG_BY_SLUG2[input.slug];
+  const modelSlug = input.slug.replace(/^openai\//, "");
+  return new import_rhachet2.BrainRepl({
+    repo: "openai",
+    slug: modelSlug,
+    description: config.description,
+    /**
+     * .what = readonly analysis (research, queries, code review)
+     * .why = provides safe, non-mutating agent interactions via read-only sandbox
+     */
+    ask: async (askInput, _context) => invokeCodex({ mode: "ask", model: config.model, ...askInput }),
+    /**
+     * .what = read+write actions (code changes, file edits)
+     * .why = provides full agentic capabilities via workspace-write sandbox
+     */
+    act: async (actInput, _context) => invokeCodex({ mode: "act", model: config.model, ...actInput })
+  });
+};
+
+// src/contract/sdk/index.ts
+var getBrainAtomsByOpenAI = () => {
+  return [genBrainAtom({ slug: "openai/gpt-4o" })];
+};
+var getBrainReplsByOpenAI = () => {
+  return [genBrainRepl({ slug: "openai/codex" })];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genBrainAtom,
+  genBrainRepl,
+  getBrainAtomsByOpenAI,
+  getBrainReplsByOpenAI
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "rhachet-brains-openai",
   "author": "ehmpathy",
   "description": "rhachet brain.atom and brain.repl adapter for openai",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "repository": "ehmpathy/rhachet-brains-openai",
   "homepage": "https://github.com/ehmpathy/rhachet-brains-openai",
   "keywords": [
@@ -34,8 +34,7 @@
     "build:clean:bun": "rm -f ./bin/*.bc",
     "build:clean:tsc": "(chmod -R u+w dist 2>/dev/null || true) && rm -rf dist/",
     "build:clean": "npm run build:clean:tsc && npm run build:clean:bun",
-    "build:compile:tsc": "tsc -p ./tsconfig.build.json && tsc-alias -p ./tsconfig.build.json",
-    "build:compile": "npm run build:compile:tsc && npm run build:compile:bun --if-present",
+    "build:compile": "bash bin/compile.withshim.sh",
     "build": "npm run build:clean && npm run build:compile && npm run build:complete --if-present",
     "test:commits": "LAST_TAG=$(git describe --tags --abbrev=0 @^ 2> /dev/null || git rev-list --max-parents=0 HEAD) && npx commitlint --from $LAST_TAG --to HEAD --verbose",
     "test:types": "tsc -p ./tsconfig.json --noEmit",
@@ -59,7 +58,6 @@
     "prepare": "if [ -e .git ] && [ -z $CI ]; then npm run prepare:husky && npm run prepare:rhachet; fi"
   },
   "dependencies": {
-    "@openai/codex-sdk": "0.77.0",
     "domain-objects": "0.31.9",
     "helpful-errors": "1.5.3",
     "openai": "5.8.2",
@@ -73,6 +71,7 @@
     "@biomejs/biome": "2.3.8",
     "@commitlint/cli": "19.5.0",
     "@commitlint/config-conventional": "19.5.0",
+    "@openai/codex-sdk": "0.77.0",
     "@swc/core": "1.15.3",
     "@swc/jest": "0.2.39",
     "@tsconfig/node20": "20.1.5",
@@ -85,6 +84,7 @@
     "declastruct": "1.7.3",
     "declastruct-github": "1.3.0",
     "depcheck": "1.4.3",
+    "esbuild": "0.27.2",
     "esbuild-register": "3.6.0",
     "husky": "8.0.3",
     "jest": "30.2.0",
@@ -99,6 +99,7 @@
     "yalc": "1.0.0-pre.53"
   },
   "peerDependencies": {
+    "@openai/codex-sdk": ">=0.77.0",
     "rhachet": ">=1.21.4"
   },
   "config": {

package/dist/contract/sdk/index.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genBrainRepl = exports.genBrainAtom = exports.getBrainReplsByOpenAI = exports.getBrainAtomsByOpenAI = void 0;
-const genBrainAtom_1 = require("../../domain.operations/atoms/genBrainAtom");
-const genBrainRepl_1 = require("../../domain.operations/repls/genBrainRepl");
-/**
- * .what = returns all brain atoms provided by openai
- * .why = enables consumers to register openai atoms with genContextBrain
- */
-const getBrainAtomsByOpenAI = () => {
-    return [(0, genBrainAtom_1.genBrainAtom)({ slug: 'openai/gpt-4o' })];
-};
-exports.getBrainAtomsByOpenAI = getBrainAtomsByOpenAI;
-/**
- * .what = returns all brain repls provided by openai
- * .why = enables consumers to register openai repls with genContextBrain
- */
-const getBrainReplsByOpenAI = () => {
-    return [(0, genBrainRepl_1.genBrainRepl)({ slug: 'openai/codex' })];
-};
-exports.getBrainReplsByOpenAI = getBrainReplsByOpenAI;
-// re-export factories for direct access
-var genBrainAtom_2 = require("../../domain.operations/atoms/genBrainAtom");
-Object.defineProperty(exports, "genBrainAtom", { enumerable: true, get: function () { return genBrainAtom_2.genBrainAtom; } });
-var genBrainRepl_2 = require("../../domain.operations/repls/genBrainRepl");
-Object.defineProperty(exports, "genBrainRepl", { enumerable: true, get: function () { return genBrainRepl_2.genBrainRepl; } });
-//# sourceMappingURL=index.js.map

package/dist/contract/sdk/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/contract/sdk/index.ts"],"names":[],"mappings":";;;AAEA,6EAA0E;AAC1E,6EAA0E;AAE1E;;;GAGG;AACI,MAAM,qBAAqB,GAAG,GAAgB,EAAE;IACrD,OAAO,CAAC,IAAA,2BAAY,EAAC,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC;AACnD,CAAC,CAAC;AAFW,QAAA,qBAAqB,yBAEhC;AAEF;;;GAGG;AACI,MAAM,qBAAqB,GAAG,GAAgB,EAAE;IACrD,OAAO,CAAC,IAAA,2BAAY,EAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;AAClD,CAAC,CAAC;AAFW,QAAA,qBAAqB,yBAEhC;AAEF,wCAAwC;AACxC,2EAA0E;AAAjE,4GAAA,YAAY,OAAA;AACrB,2EAA0E;AAAjE,4GAAA,YAAY,OAAA"}

package/dist/domain.operations/atoms/genBrainAtom.js

@@ -1,108 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genBrainAtom = void 0;
-const openai_1 = __importDefault(require("openai"));
-const rhachet_1 = require("rhachet");
-const zod_1 = require("zod");
-/**
- * .what = model configuration by slug
- * .why = maps slugs to API model names and descriptions
- */
-const CONFIG_BY_SLUG = {
-    'openai/gpt-4o': {
-        model: 'gpt-4o',
-        description: 'gpt-4o - multimodal model for reasoning and vision',
-    },
-    'openai/gpt-4o-mini': {
-        model: 'gpt-4o-mini',
-        description: 'gpt-4o-mini - fast and cost-effective multimodal model',
-    },
-    'openai/gpt-4-turbo': {
-        model: 'gpt-4-turbo',
-        description: 'gpt-4-turbo - high capability with vision support',
-    },
-    'openai/o1': {
-        model: 'o1',
-        description: 'o1 - advanced reasoning model for complex problems',
-    },
-    'openai/o1-mini': {
-        model: 'o1-mini',
-        description: 'o1-mini - fast reasoning model for coding and math',
-    },
-    'openai/o1-preview': {
-        model: 'o1-preview',
-        description: 'o1-preview - preview of advanced reasoning capabilities',
-    },
-};
-/**
- * .what = factory to generate openai brain atom instances
- * .why = enables model variant selection via slug
- *
- * .example
- *   genBrainAtom({ slug: 'openai/gpt-4o' })
- *   genBrainAtom({ slug: 'openai/gpt-4o-mini' }) // fast + cheap
- *   genBrainAtom({ slug: 'openai/o1' }) // advanced reasoning
- */
-const genBrainAtom = (input) => {
-    const config = CONFIG_BY_SLUG[input.slug];
-    return new rhachet_1.BrainAtom({
-        repo: 'openai',
-        slug: input.slug,
-        description: config.description,
-        /**
-         * .what = stateless inference (no tool use)
-         * .why = provides direct model access for reasoning tasks
-         */
-        ask: async (askInput, context) => {
-            // compose system prompt from briefs
-            const systemPrompt = askInput.role.briefs
-                ? await (0, rhachet_1.castBriefsToPrompt)({ briefs: askInput.role.briefs })
-                : undefined;
-            // get openai client from context or create new one
-            const openai = context?.openai ??
-                new openai_1.default({ apiKey: process.env.OPENAI_API_KEY });
-            // build messages array
-            const messages = [];
-            if (systemPrompt) {
-                messages.push({ role: 'system', content: systemPrompt });
-            }
-            messages.push({ role: 'user', content: askInput.prompt });
-            // convert zod schema to json schema for structured output
-            const jsonSchema = zod_1.z.toJSONSchema(askInput.schema.output);
-            // check if schema is an object type (openai only supports object schemas for response_format)
-            const isObjectSchema = typeof jsonSchema === 'object' &&
-                jsonSchema !== null &&
-                'type' in jsonSchema &&
-                jsonSchema.type === 'object';
-            // call openai api, with response_format only for object schemas
-            const response = await openai.chat.completions.create({
-                model: config.model,
-                messages,
-                ...(isObjectSchema && {
-                    response_format: {
-                        type: 'json_schema',
-                        json_schema: {
-                            name: 'response',
-                            strict: true,
-                            schema: jsonSchema,
-                        },
-                    },
-                }),
-            });
-            // extract content from response
-            const content = response.choices[0]?.message?.content ?? '';
-            // parse response based on schema type
-            if (isObjectSchema) {
-                const parsed = JSON.parse(content);
-                return askInput.schema.output.parse(parsed);
-            }
-            // for non-object schemas, validate the raw content directly
-            return askInput.schema.output.parse(content);
-        },
-    });
-};
-exports.genBrainAtom = genBrainAtom;
-//# sourceMappingURL=genBrainAtom.js.map

package/dist/domain.operations/atoms/genBrainAtom.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"genBrainAtom.js","sourceRoot":"","sources":["../../../src/domain.operations/atoms/genBrainAtom.ts"],"names":[],"mappings":"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"}

package/dist/domain.operations/repls/genBrainRepl.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.genBrainRepl = void 0;
-const codex_sdk_1 = require("@openai/codex-sdk");
-const rhachet_1 = require("rhachet");
-const wrapper_fns_1 = require("wrapper-fns");
-const asJsonSchema_1 = require("../../infra/schema/asJsonSchema");
-/**
- * .what = model configuration by slug
- * .why = maps slugs to API model names and descriptions
- */
-const CONFIG_BY_SLUG = {
-    'openai/codex': {
-        model: undefined, // use SDK default (gpt-5.1-codex-max)
-        description: 'codex - agentic coding assistant (default model)',
-    },
-    'openai/codex/max': {
-        model: 'gpt-5.1-codex-max',
-        description: 'codex max - optimized for long-horizon agentic coding',
-    },
-    'openai/codex/mini': {
-        model: 'gpt-5.1-codex-mini',
-        description: 'codex mini - fast and cost-effective',
-    },
-    'openai/codex/5.2': {
-        model: 'gpt-5.2-codex',
-        description: 'codex 5.2 - most advanced agentic coding model',
-    },
-};
-/**
- * .what = composes full prompt with optional system context
- * .why = codex-sdk ThreadOptions doesn't have systemPrompt, must prepend to user prompt
- */
-const composePromptWithSystem = (userPrompt, systemPrompt) => {
-    if (!systemPrompt)
-        return userPrompt;
-    return `${systemPrompt}\n\n---\n\n${userPrompt}`;
-};
-/**
- * .what = invokes codex sdk with specified sandbox mode
- * .why = dedupes shared logic between ask (read-only) and act (workspace-write)
- */
-const invokeCodex = async (input) => {
-    // compose system prompt from briefs
-    const systemPrompt = input.role.briefs
-        ? await (0, rhachet_1.castBriefsToPrompt)({ briefs: input.role.briefs })
-        : undefined;
-    // convert zod schema to json schema for native enforcement
-    const outputSchema = (0, asJsonSchema_1.asJsonSchema)({
-        schema: input.schema.output,
-    });
-    // create codex client
-    const codex = new codex_sdk_1.Codex({
-        apiKey: process.env.OPENAI_API_KEY,
-    });
-    // start thread with sandbox mode based on operation type
-    const sandboxMode = input.mode === 'ask' ? 'read-only' : 'workspace-write';
-    const thread = codex.startThread({
-        model: input.model,
-        sandboxMode,
-    });
-    // compose full prompt and run with timeout + retry for resilience
-    const fullPrompt = composePromptWithSystem(input.prompt, systemPrompt);
-    const response = await (0, wrapper_fns_1.withRetry)((0, wrapper_fns_1.withTimeout)(async () => thread.run(fullPrompt, { outputSchema }), {
-        threshold: { seconds: 60 },
-    }))();
-    // parse output via schema for runtime validation
-    return input.schema.output.parse(JSON.parse(response.finalResponse));
-};
-/**
- * .what = factory to generate openai codex brain repl instances
- * .why = enables model variant selection via slug
- *
- * .example
- *   genBrainRepl({ slug: 'openai/codex' }) // default model
- *   genBrainRepl({ slug: 'openai/codex/mini' }) // fast + cheap
- *   genBrainRepl({ slug: 'openai/codex/5.2' }) // most advanced
- */
-const genBrainRepl = (input) => {
-    const config = CONFIG_BY_SLUG[input.slug];
-    // extract model slug without the repo prefix (e.g., 'openai/codex' -> 'codex')
-    const modelSlug = input.slug.replace(/^openai\//, '');
-    return new rhachet_1.BrainRepl({
-        repo: 'openai',
-        slug: modelSlug,
-        description: config.description,
-        /**
-         * .what = readonly analysis (research, queries, code review)
-         * .why = provides safe, non-mutating agent interactions via read-only sandbox
-         */
-        ask: async (askInput, _context) => invokeCodex({ mode: 'ask', model: config.model, ...askInput }),
-        /**
-         * .what = read+write actions (code changes, file edits)
-         * .why = provides full agentic capabilities via workspace-write sandbox
-         */
-        act: async (actInput, _context) => invokeCodex({ mode: 'act', model: config.model, ...actInput }),
-    });
-};
-exports.genBrainRepl = genBrainRepl;
-//# sourceMappingURL=genBrainRepl.js.map

package/dist/domain.operations/repls/genBrainRepl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"genBrainRepl.js","sourceRoot":"","sources":["../../../src/domain.operations/repls/genBrainRepl.ts"],"names":[],"mappings":"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"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B"}

package/dist/infra/schema/asJsonSchema.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.asJsonSchema = void 0;
-const zod_1 = require("zod");
-/**
- * .what = convert a zod schema to JSON schema for native SDK enforcement
- * .why = enables native structured output support in SDKs, reducing
- *   token waste on validation retries
- *
- * .note = different SDKs require different conversion options:
- *   - claude-agent-sdk: { $refStrategy: 'root' }
- *   - codex-sdk: { target: 'openAi' }
- */
-const asJsonSchema = (input) => {
-    return zod_1.z.toJSONSchema(input.schema, { target: 'openAi' });
-};
-exports.asJsonSchema = asJsonSchema;
-//# sourceMappingURL=asJsonSchema.js.map

package/dist/infra/schema/asJsonSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asJsonSchema.js","sourceRoot":"","sources":["../../../src/infra/schema/asJsonSchema.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB;;;;;;;;GAQG;AACI,MAAM,YAAY,GAAG,CAAC,KAA8B,EAAU,EAAE;IACrE,OAAO,OAAC,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;AAC5D,CAAC,CAAC;AAFW,QAAA,YAAY,gBAEvB"}