oh-my-fable 0.1.1 → 0.1.2

package/README.md

@@ -128,8 +128,10 @@ console.log(result.ctx.plan.steps);
 npm i oh-my-fable        # zero runtime dependencies
 ```
 
-Node ≥ 18. The `AnthropicProvider` talks to the API over `fetch` — no SDK. Bring
-any model by implementing the `Provider` interface (three methods).
+Node ≥ 18. Ships with `AnthropicProvider` and `OpenAICompatProvider` (works with
+OpenAI, Ollama, LM Studio, OpenRouter, Groq… — `ollama("llama3.1")` for a local
+model with no key), both over `fetch`, no SDK. Or bring any model by implementing
+the `Provider` interface (three methods).
 
 ## Or use it from the terminal
 
@@ -138,14 +140,33 @@ Don't want to write code? It ships a CLI (zero extra deps):
 ```bash
 npx oh-my-fable demo                       # watch crash → resume, no API key
 
+# already use Claude Code or Codex? drive it — uses that login, no separate key:
+npx oh-my-fable run "outline a talk on durable agents" --provider claude
+
+# or a LOCAL model (Ollama / LM Studio), also no key:
+npx oh-my-fable run "outline a talk on durable agents" --provider ollama --model llama3.1
+
+# or any hosted model:
 export ANTHROPIC_API_KEY=sk-...
 npx oh-my-fable run "summarize README.md into SUMMARY.md" --tools fs
-npx oh-my-fable run "outline a talk on durable agents" --success "5 sections"
 
 npx oh-my-fable list                       # your saved runs
 npx oh-my-fable resume run_abc123          # continue one from its checkpoint
 ```
 
+**You don't need an Anthropic API key.** Pick how it talks to a model:
+
+| `--provider` | uses | key? |
+| --- | --- | --- |
+| `claude` / `codex` | your Claude Code / Codex CLI login | **none** — rides the CLI's auth |
+| `ollama` | a local Ollama model | **none** |
+| `--base-url <url>` | LM Studio / OpenRouter / Groq / any OpenAI-compatible | per that server |
+| `openai` | OpenAI | `OPENAI_API_KEY` |
+| *(default)* | Anthropic | `ANTHROPIC_API_KEY` |
+
+(The CLI-driven providers are text-only — great for planning/reasoning runs; they
+don't expose `--tools`.)
+
 You watch the plan form and each step get reflected on, live. `--tools fs` gives
 the agent a sandboxed `read_file`/`write_file`/`list_dir` (confined to the working
 directory) so a terminal run can actually produce files; without it, runs are

package/dist/cli.cjs

@@ -905,6 +905,164 @@ var AnthropicProvider = class {
   }
 };
 
+// src/providers/openai.ts
+var FINISH = { stop: "end", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens" };
+var OpenAICompatProvider = class {
+  name;
+  baseUrl;
+  apiKey;
+  model;
+  maxRetries;
+  defaultMaxTokens;
+  constructor(opts) {
+    if (!opts.baseUrl) throw new Error("OpenAICompatProvider needs a baseUrl.");
+    if (!opts.model) throw new Error("OpenAICompatProvider needs a model.");
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.model = opts.model;
+    this.name = opts.label ?? "openai-compatible";
+    this.maxRetries = opts.maxRetries ?? 4;
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 4096;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const body = {
+      model: this.model,
+      messages: req.messages.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      temperature: req.temperature ?? 1
+    };
+    if (req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    }
+    const data = await withRetry(
+      async () => {
+        const headers = { "content-type": "application/json" };
+        if (this.apiKey) headers["authorization"] = `Bearer ${this.apiKey}`;
+        const res = await fetch(`${this.baseUrl}/chat/completions`, { method: "POST", headers, body: JSON.stringify(body) });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          const err = new Error(`${this.name} ${res.status}: ${text.slice(0, 300)}`);
+          err.status = res.status;
+          throw err;
+        }
+        return await res.json();
+      },
+      {
+        retries: this.maxRetries,
+        isRetryable: (e) => {
+          const s = e.status;
+          return s === void 0 || s === 429 || s >= 500 && s < 600;
+        }
+      }
+    );
+    const choice = data.choices?.[0];
+    const content = typeof choice?.message?.content === "string" ? choice.message.content : "";
+    const toolCalls = [];
+    for (const tc of choice?.message?.tool_calls ?? []) {
+      if (!tc.function?.name) continue;
+      let input = {};
+      try {
+        input = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+      } catch {
+        input = tc.function.arguments ?? {};
+      }
+      toolCalls.push({ id: tc.id ?? tc.function.name, name: tc.function.name, input });
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      tokensIn: data.usage?.prompt_tokens ?? 0,
+      tokensOut: data.usage?.completion_tokens ?? 0,
+      stopReason: FINISH[choice?.finish_reason ?? ""] ?? "end"
+    };
+  }
+};
+function ollama(model, opts = {}) {
+  return new OpenAICompatProvider({ baseUrl: "http://localhost:11434/v1", model, label: "ollama", ...opts });
+}
+
+// src/providers/cli.ts
+var import_node_child_process = require("child_process");
+function flatten(messages) {
+  const parts = [];
+  for (const m of messages) {
+    if (m.role === "assistant") parts.push(`Assistant: ${m.content}`);
+    else parts.push(m.content);
+  }
+  return parts.join("\n\n");
+}
+function runCli(command, args, input, timeoutMs, env) {
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = (0, import_node_child_process.spawn)(command, args, { env: { ...process.env, ...env } });
+    } catch (e) {
+      return reject(e);
+    }
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${command} timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e.code === "ENOENT" ? new Error(`"${command}" is not installed or not on your PATH.`) : e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve2(out);
+      else reject(new Error(`${command} exited ${code}: ${err.trim().slice(0, 300)}`));
+    });
+    if (input !== null) child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+var CliProvider = class {
+  name;
+  command;
+  args;
+  promptVia;
+  parse;
+  env;
+  timeoutMs;
+  constructor(opts) {
+    this.command = opts.command;
+    this.args = opts.args ?? [];
+    this.promptVia = opts.promptVia ?? "arg";
+    this.parse = opts.parse ?? ((s) => s.trim());
+    this.env = opts.env;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.name = opts.label ?? `cli:${opts.command}`;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const prompt = flatten(req.messages);
+    const args = this.promptVia === "arg" ? [...this.args, prompt] : this.args;
+    const stdout = await runCli(this.command, args, this.promptVia === "stdin" ? prompt : null, this.timeoutMs, this.env);
+    const content = this.parse(stdout);
+    return {
+      content,
+      tokensIn: estimateTokens(req.messages),
+      tokensOut: Math.ceil(content.length / 4),
+      stopReason: "end"
+    };
+  }
+};
+function claudeCode(opts = {}) {
+  return new CliProvider({ command: "claude", args: ["-p"], promptVia: "arg", label: "claude-code", ...opts });
+}
+function codexCli(opts = {}) {
+  return new CliProvider({ command: "codex", args: ["exec"], promptVia: "arg", label: "codex", ...opts });
+}
+
 // src/index.ts
 function buildDeps(config, serializable) {
   const provider = config.provider;
@@ -1006,10 +1164,27 @@ function renderer() {
   };
 }
 function makeProvider(flags) {
+  const str = (k) => typeof flags[k] === "string" ? flags[k] : void 0;
+  const model = str("model");
+  const provider = str("provider");
+  const baseUrl = str("base-url");
+  const apiKey = str("api-key");
   try {
-    return new AnthropicProvider({ model: typeof flags["model"] === "string" ? flags["model"] : void 0 });
+    if (provider === "claude" || provider === "claude-code") return claudeCode();
+    if (provider === "codex") return codexCli();
+    if (provider === "ollama") return ollama(model ?? "llama3.1", baseUrl ? { baseUrl } : {});
+    if (provider === "openai") {
+      return new OpenAICompatProvider({ baseUrl: baseUrl ?? "https://api.openai.com/v1", apiKey: apiKey ?? process.env["OPENAI_API_KEY"], model: model ?? "gpt-4o-mini", label: "openai" });
+    }
+    if (baseUrl) {
+      if (!model) fail("--base-url needs --model too.");
+      return new OpenAICompatProvider({ baseUrl, apiKey: apiKey ?? process.env["OPENAI_API_KEY"], model });
+    }
+    return new AnthropicProvider({ model });
   } catch (err) {
-    fail(err.message + "\nSet ANTHROPIC_API_KEY, or run `oh-my-fable demo` (no key needed).");
+    fail(
+      err.message + "\n\nNo API key needed \u2014 pick one:\n  --provider claude                    (your Claude Code login)\n  --provider ollama --model llama3.1   (a local model)\nOr just watch the mechanics:  oh-my-fable demo"
+    );
   }
 }
 function commonConfig(flags, provider) {
@@ -1152,18 +1327,24 @@ ${bold("Usage")}
   oh-my-fable list                list saved runs
   oh-my-fable demo                watch crash \u2192 resume, scripted (no API key)
 
+${bold("Model")} ${dim("(default: Anthropic, needs ANTHROPIC_API_KEY)")}
+  --provider claude                         drive your Claude Code CLI \u2014 uses its login, NO separate key
+  --provider codex                          drive your Codex CLI \u2014 same idea
+  --provider ollama --model llama3.1        a LOCAL model \u2014 no API key, no cost
+  --provider openai --model gpt-4o-mini     OpenAI (OPENAI_API_KEY)
+  --base-url <url> --model <id> [--api-key] any OpenAI-compatible server (LM Studio, OpenRouter, Groq, \u2026)
+
 ${bold("Options for run")}
   --success "a; b"   success criteria (semicolon-separated)
   --tools fs         allow sandboxed read_file/write_file/list_dir (default: none)
-  --model <id>       model for the Anthropic provider
   --max-steps <n>    step budget          --max-tokens <n>   token budget
   --runs-dir <dir>   where checkpoints live (default: runs/)
   --quiet            no live event stream
 
 ${bold("Examples")}
-  oh-my-fable run "summarize README.md into SUMMARY.md" --tools fs
-  oh-my-fable run "outline a talk on durable agents" --success "an outline with 5 sections"
-  oh-my-fable demo
+  oh-my-fable run "outline a talk on durable agents" --provider ollama --model llama3.1
+  oh-my-fable run "summarize README.md into SUMMARY.md" --tools fs    ${dim("# uses Anthropic")}
+  oh-my-fable demo                                                    ${dim("# no key at all")}
 
 ${dim(`It's also a library: import { run, AnthropicProvider } from "oh-my-fable".`)}
 `);

package/dist/cli.js

@@ -904,6 +904,164 @@ var AnthropicProvider = class {
   }
 };
 
+// src/providers/openai.ts
+var FINISH = { stop: "end", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens" };
+var OpenAICompatProvider = class {
+  name;
+  baseUrl;
+  apiKey;
+  model;
+  maxRetries;
+  defaultMaxTokens;
+  constructor(opts) {
+    if (!opts.baseUrl) throw new Error("OpenAICompatProvider needs a baseUrl.");
+    if (!opts.model) throw new Error("OpenAICompatProvider needs a model.");
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.model = opts.model;
+    this.name = opts.label ?? "openai-compatible";
+    this.maxRetries = opts.maxRetries ?? 4;
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 4096;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const body = {
+      model: this.model,
+      messages: req.messages.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      temperature: req.temperature ?? 1
+    };
+    if (req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    }
+    const data = await withRetry(
+      async () => {
+        const headers = { "content-type": "application/json" };
+        if (this.apiKey) headers["authorization"] = `Bearer ${this.apiKey}`;
+        const res = await fetch(`${this.baseUrl}/chat/completions`, { method: "POST", headers, body: JSON.stringify(body) });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          const err = new Error(`${this.name} ${res.status}: ${text.slice(0, 300)}`);
+          err.status = res.status;
+          throw err;
+        }
+        return await res.json();
+      },
+      {
+        retries: this.maxRetries,
+        isRetryable: (e) => {
+          const s = e.status;
+          return s === void 0 || s === 429 || s >= 500 && s < 600;
+        }
+      }
+    );
+    const choice = data.choices?.[0];
+    const content = typeof choice?.message?.content === "string" ? choice.message.content : "";
+    const toolCalls = [];
+    for (const tc of choice?.message?.tool_calls ?? []) {
+      if (!tc.function?.name) continue;
+      let input = {};
+      try {
+        input = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+      } catch {
+        input = tc.function.arguments ?? {};
+      }
+      toolCalls.push({ id: tc.id ?? tc.function.name, name: tc.function.name, input });
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      tokensIn: data.usage?.prompt_tokens ?? 0,
+      tokensOut: data.usage?.completion_tokens ?? 0,
+      stopReason: FINISH[choice?.finish_reason ?? ""] ?? "end"
+    };
+  }
+};
+function ollama(model, opts = {}) {
+  return new OpenAICompatProvider({ baseUrl: "http://localhost:11434/v1", model, label: "ollama", ...opts });
+}
+
+// src/providers/cli.ts
+import { spawn } from "child_process";
+function flatten(messages) {
+  const parts = [];
+  for (const m of messages) {
+    if (m.role === "assistant") parts.push(`Assistant: ${m.content}`);
+    else parts.push(m.content);
+  }
+  return parts.join("\n\n");
+}
+function runCli(command, args, input, timeoutMs, env) {
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = spawn(command, args, { env: { ...process.env, ...env } });
+    } catch (e) {
+      return reject(e);
+    }
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${command} timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e.code === "ENOENT" ? new Error(`"${command}" is not installed or not on your PATH.`) : e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve2(out);
+      else reject(new Error(`${command} exited ${code}: ${err.trim().slice(0, 300)}`));
+    });
+    if (input !== null) child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+var CliProvider = class {
+  name;
+  command;
+  args;
+  promptVia;
+  parse;
+  env;
+  timeoutMs;
+  constructor(opts) {
+    this.command = opts.command;
+    this.args = opts.args ?? [];
+    this.promptVia = opts.promptVia ?? "arg";
+    this.parse = opts.parse ?? ((s) => s.trim());
+    this.env = opts.env;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.name = opts.label ?? `cli:${opts.command}`;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const prompt = flatten(req.messages);
+    const args = this.promptVia === "arg" ? [...this.args, prompt] : this.args;
+    const stdout = await runCli(this.command, args, this.promptVia === "stdin" ? prompt : null, this.timeoutMs, this.env);
+    const content = this.parse(stdout);
+    return {
+      content,
+      tokensIn: estimateTokens(req.messages),
+      tokensOut: Math.ceil(content.length / 4),
+      stopReason: "end"
+    };
+  }
+};
+function claudeCode(opts = {}) {
+  return new CliProvider({ command: "claude", args: ["-p"], promptVia: "arg", label: "claude-code", ...opts });
+}
+function codexCli(opts = {}) {
+  return new CliProvider({ command: "codex", args: ["exec"], promptVia: "arg", label: "codex", ...opts });
+}
+
 // src/index.ts
 function buildDeps(config, serializable) {
   const provider = config.provider;
@@ -1005,10 +1163,27 @@ function renderer() {
   };
 }
 function makeProvider(flags) {
+  const str = (k) => typeof flags[k] === "string" ? flags[k] : void 0;
+  const model = str("model");
+  const provider = str("provider");
+  const baseUrl = str("base-url");
+  const apiKey = str("api-key");
   try {
-    return new AnthropicProvider({ model: typeof flags["model"] === "string" ? flags["model"] : void 0 });
+    if (provider === "claude" || provider === "claude-code") return claudeCode();
+    if (provider === "codex") return codexCli();
+    if (provider === "ollama") return ollama(model ?? "llama3.1", baseUrl ? { baseUrl } : {});
+    if (provider === "openai") {
+      return new OpenAICompatProvider({ baseUrl: baseUrl ?? "https://api.openai.com/v1", apiKey: apiKey ?? process.env["OPENAI_API_KEY"], model: model ?? "gpt-4o-mini", label: "openai" });
+    }
+    if (baseUrl) {
+      if (!model) fail("--base-url needs --model too.");
+      return new OpenAICompatProvider({ baseUrl, apiKey: apiKey ?? process.env["OPENAI_API_KEY"], model });
+    }
+    return new AnthropicProvider({ model });
   } catch (err) {
-    fail(err.message + "\nSet ANTHROPIC_API_KEY, or run `oh-my-fable demo` (no key needed).");
+    fail(
+      err.message + "\n\nNo API key needed \u2014 pick one:\n  --provider claude                    (your Claude Code login)\n  --provider ollama --model llama3.1   (a local model)\nOr just watch the mechanics:  oh-my-fable demo"
+    );
   }
 }
 function commonConfig(flags, provider) {
@@ -1151,18 +1326,24 @@ ${bold("Usage")}
   oh-my-fable list                list saved runs
   oh-my-fable demo                watch crash \u2192 resume, scripted (no API key)
 
+${bold("Model")} ${dim("(default: Anthropic, needs ANTHROPIC_API_KEY)")}
+  --provider claude                         drive your Claude Code CLI \u2014 uses its login, NO separate key
+  --provider codex                          drive your Codex CLI \u2014 same idea
+  --provider ollama --model llama3.1        a LOCAL model \u2014 no API key, no cost
+  --provider openai --model gpt-4o-mini     OpenAI (OPENAI_API_KEY)
+  --base-url <url> --model <id> [--api-key] any OpenAI-compatible server (LM Studio, OpenRouter, Groq, \u2026)
+
 ${bold("Options for run")}
   --success "a; b"   success criteria (semicolon-separated)
   --tools fs         allow sandboxed read_file/write_file/list_dir (default: none)
-  --model <id>       model for the Anthropic provider
   --max-steps <n>    step budget          --max-tokens <n>   token budget
   --runs-dir <dir>   where checkpoints live (default: runs/)
   --quiet            no live event stream
 
 ${bold("Examples")}
-  oh-my-fable run "summarize README.md into SUMMARY.md" --tools fs
-  oh-my-fable run "outline a talk on durable agents" --success "an outline with 5 sections"
-  oh-my-fable demo
+  oh-my-fable run "outline a talk on durable agents" --provider ollama --model llama3.1
+  oh-my-fable run "summarize README.md into SUMMARY.md" --tools fs    ${dim("# uses Anthropic")}
+  oh-my-fable demo                                                    ${dim("# no key at all")}
 
 ${dim(`It's also a library: import { run, AnthropicProvider } from "oh-my-fable".`)}
 `);

package/dist/index.cjs

@@ -21,22 +21,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AnthropicProvider: () => AnthropicProvider,
+  CliProvider: () => CliProvider,
   ContextManager: () => ContextManager,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
   Executor: () => Executor,
   FileStore: () => FileStore,
   MemoryStore: () => MemoryStore,
+  OpenAICompatProvider: () => OpenAICompatProvider,
   Planner: () => Planner,
   Reflector: () => Reflector,
   ScriptedProvider: () => ScriptedProvider,
   ToolRegistry: () => ToolRegistry,
   checkBudget: () => checkBudget,
+  claudeCode: () => claudeCode,
+  codexCli: () => codexCli,
   createContext: () => createContext,
   defineTool: () => defineTool,
   estimateTokens: () => estimateTokens,
   fsTools: () => fsTools,
   genId: () => genId,
   nextPendingStep: () => nextPendingStep,
+  ollama: () => ollama,
   reply: () => reply,
   resolveSerializable: () => resolveSerializable,
   resume: () => resume,
@@ -925,6 +930,164 @@ var AnthropicProvider = class {
   }
 };
 
+// src/providers/openai.ts
+var FINISH = { stop: "end", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens" };
+var OpenAICompatProvider = class {
+  name;
+  baseUrl;
+  apiKey;
+  model;
+  maxRetries;
+  defaultMaxTokens;
+  constructor(opts) {
+    if (!opts.baseUrl) throw new Error("OpenAICompatProvider needs a baseUrl.");
+    if (!opts.model) throw new Error("OpenAICompatProvider needs a model.");
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.model = opts.model;
+    this.name = opts.label ?? "openai-compatible";
+    this.maxRetries = opts.maxRetries ?? 4;
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 4096;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const body = {
+      model: this.model,
+      messages: req.messages.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      temperature: req.temperature ?? 1
+    };
+    if (req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    }
+    const data = await withRetry(
+      async () => {
+        const headers = { "content-type": "application/json" };
+        if (this.apiKey) headers["authorization"] = `Bearer ${this.apiKey}`;
+        const res = await fetch(`${this.baseUrl}/chat/completions`, { method: "POST", headers, body: JSON.stringify(body) });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          const err = new Error(`${this.name} ${res.status}: ${text.slice(0, 300)}`);
+          err.status = res.status;
+          throw err;
+        }
+        return await res.json();
+      },
+      {
+        retries: this.maxRetries,
+        isRetryable: (e) => {
+          const s = e.status;
+          return s === void 0 || s === 429 || s >= 500 && s < 600;
+        }
+      }
+    );
+    const choice = data.choices?.[0];
+    const content = typeof choice?.message?.content === "string" ? choice.message.content : "";
+    const toolCalls = [];
+    for (const tc of choice?.message?.tool_calls ?? []) {
+      if (!tc.function?.name) continue;
+      let input = {};
+      try {
+        input = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+      } catch {
+        input = tc.function.arguments ?? {};
+      }
+      toolCalls.push({ id: tc.id ?? tc.function.name, name: tc.function.name, input });
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      tokensIn: data.usage?.prompt_tokens ?? 0,
+      tokensOut: data.usage?.completion_tokens ?? 0,
+      stopReason: FINISH[choice?.finish_reason ?? ""] ?? "end"
+    };
+  }
+};
+function ollama(model, opts = {}) {
+  return new OpenAICompatProvider({ baseUrl: "http://localhost:11434/v1", model, label: "ollama", ...opts });
+}
+
+// src/providers/cli.ts
+var import_node_child_process = require("child_process");
+function flatten(messages) {
+  const parts = [];
+  for (const m of messages) {
+    if (m.role === "assistant") parts.push(`Assistant: ${m.content}`);
+    else parts.push(m.content);
+  }
+  return parts.join("\n\n");
+}
+function runCli(command, args, input, timeoutMs, env) {
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = (0, import_node_child_process.spawn)(command, args, { env: { ...process.env, ...env } });
+    } catch (e) {
+      return reject(e);
+    }
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${command} timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e.code === "ENOENT" ? new Error(`"${command}" is not installed or not on your PATH.`) : e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve2(out);
+      else reject(new Error(`${command} exited ${code}: ${err.trim().slice(0, 300)}`));
+    });
+    if (input !== null) child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+var CliProvider = class {
+  name;
+  command;
+  args;
+  promptVia;
+  parse;
+  env;
+  timeoutMs;
+  constructor(opts) {
+    this.command = opts.command;
+    this.args = opts.args ?? [];
+    this.promptVia = opts.promptVia ?? "arg";
+    this.parse = opts.parse ?? ((s) => s.trim());
+    this.env = opts.env;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.name = opts.label ?? `cli:${opts.command}`;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const prompt = flatten(req.messages);
+    const args = this.promptVia === "arg" ? [...this.args, prompt] : this.args;
+    const stdout = await runCli(this.command, args, this.promptVia === "stdin" ? prompt : null, this.timeoutMs, this.env);
+    const content = this.parse(stdout);
+    return {
+      content,
+      tokensIn: estimateTokens(req.messages),
+      tokensOut: Math.ceil(content.length / 4),
+      stopReason: "end"
+    };
+  }
+};
+function claudeCode(opts = {}) {
+  return new CliProvider({ command: "claude", args: ["-p"], promptVia: "arg", label: "claude-code", ...opts });
+}
+function codexCli(opts = {}) {
+  return new CliProvider({ command: "codex", args: ["exec"], promptVia: "arg", label: "codex", ...opts });
+}
+
 // src/index.ts
 function buildDeps(config, serializable) {
   const provider = config.provider;
@@ -958,22 +1121,27 @@ async function runWith(ctx, config) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AnthropicProvider,
+  CliProvider,
   ContextManager,
   DEFAULT_CONFIG,
   Executor,
   FileStore,
   MemoryStore,
+  OpenAICompatProvider,
   Planner,
   Reflector,
   ScriptedProvider,
   ToolRegistry,
   checkBudget,
+  claudeCode,
+  codexCli,
   createContext,
   defineTool,
   estimateTokens,
   fsTools,
   genId,
   nextPendingStep,
+  ollama,
   reply,
   resolveSerializable,
   resume,

package/dist/index.d.cts

@@ -377,6 +377,75 @@ declare class AnthropicProvider implements Provider {
     complete(req: CompletionRequest): Promise<CompletionResult>;
 }
 
+interface OpenAICompatOptions {
+    /** e.g. http://localhost:11434/v1 (Ollama), http://localhost:1234/v1 (LM Studio), https://api.openai.com/v1 */
+    baseUrl: string;
+    /** Optional — local servers don't need one. */
+    apiKey?: string;
+    model: string;
+    label?: string;
+    maxRetries?: number;
+    defaultMaxTokens?: number;
+}
+/**
+ * Talks the OpenAI Chat Completions format — which means it works with almost
+ * everything: **Ollama and LM Studio (local, no API key)**, llama.cpp's server,
+ * OpenRouter, Groq, Together, OpenAI itself… Point `baseUrl` at any of them.
+ * No SDK, no dependencies.
+ */
+declare class OpenAICompatProvider implements Provider {
+    readonly name: string;
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly model;
+    private readonly maxRetries;
+    private readonly defaultMaxTokens;
+    constructor(opts: OpenAICompatOptions);
+    estimateTokens(messages: Message[]): number;
+    complete(req: CompletionRequest): Promise<CompletionResult>;
+}
+/** Convenience: a local Ollama model, no API key. `ollama("llama3.1")`. */
+declare function ollama(model: string, opts?: Partial<OpenAICompatOptions>): OpenAICompatProvider;
+
+interface CliProviderOptions {
+    /** The executable, e.g. "claude" or "codex". */
+    command: string;
+    /** Fixed args before the prompt, e.g. ["-p"] for Claude Code print mode. */
+    args?: string[];
+    /** Pass the prompt as the final arg ("arg", default) or on stdin ("stdin"). */
+    promptVia?: "arg" | "stdin";
+    /** Extract the assistant text from the command's stdout. Default: trim. */
+    parse?: (stdout: string) => string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    label?: string;
+}
+/**
+ * Drives an agentic CLI (Claude Code, Codex, …) in non-interactive mode: every
+ * model call shells out to the command and captures its stdout. This means
+ * people who use those CLIs via a **subscription login use oh-my-fable with no
+ * separate API key** — it rides whatever auth the CLI already has.
+ *
+ * Note: it returns text only (no native tool-calling), so the agent runs in
+ * pure-reasoning mode; `--tools fs` is unavailable through a CLI provider.
+ */
+declare class CliProvider implements Provider {
+    readonly name: string;
+    private readonly command;
+    private readonly args;
+    private readonly promptVia;
+    private readonly parse;
+    private readonly env?;
+    private readonly timeoutMs;
+    constructor(opts: CliProviderOptions);
+    estimateTokens(messages: Message[]): number;
+    complete(req: CompletionRequest): Promise<CompletionResult>;
+}
+/** Claude Code in print mode — uses your existing `claude` auth (subscription or key). */
+declare function claudeCode(opts?: Partial<CliProviderOptions>): CliProvider;
+/** OpenAI Codex CLI in non-interactive exec mode — uses your existing `codex` auth. */
+declare function codexCli(opts?: Partial<CliProviderOptions>): CliProvider;
+
 /** Run an agent to completion (or to a budget halt). The whole run is checkpointed every step. */
 declare function run(goal: Goal | string, config: RunConfig): Promise<RunResult>;
 /** Resume a run from its last checkpoint — same plan, same progress, continues where it died. */
@@ -384,4 +453,4 @@ declare function resume(runId: string, config: RunConfig): Promise<RunResult>;
 /** Continue a RunContext you already hold in memory (advanced; same as resume without the store load). */
 declare function runWith(ctx: RunContext, config: RunConfig): Promise<RunResult>;
 
-export { type AnthropicOptions, AnthropicProvider, type BudgetState, type CompletionRequest, type CompletionResult, ContextManager, DEFAULT_CONFIG, type Digest, Executor, FileStore, type Goal, type LoopDeps, MemoryStore, type Message, type Observation, type Plan, type PlanStatus, Planner, type Progress, type Provider, type Reflection, Reflector, type Role, type RunConfig, type RunContext, type RunEvent, type RunResult, type RunStatus, type RunSummary, ScriptedProvider, type ScriptedResponse, type SerializableConfig, type Step, type StepStatus, type StopReason, type Store, type Tool, type ToolCall, ToolRegistry, type ToolResult, type ToolSchema, checkBudget, createContext, defineTool, estimateTokens, fsTools, genId, nextPendingStep, reply, resolveSerializable, resume, run, runLoop, runWith, withRetry };
+export { type AnthropicOptions, AnthropicProvider, type BudgetState, CliProvider, type CliProviderOptions, type CompletionRequest, type CompletionResult, ContextManager, DEFAULT_CONFIG, type Digest, Executor, FileStore, type Goal, type LoopDeps, MemoryStore, type Message, type Observation, type OpenAICompatOptions, OpenAICompatProvider, type Plan, type PlanStatus, Planner, type Progress, type Provider, type Reflection, Reflector, type Role, type RunConfig, type RunContext, type RunEvent, type RunResult, type RunStatus, type RunSummary, ScriptedProvider, type ScriptedResponse, type SerializableConfig, type Step, type StepStatus, type StopReason, type Store, type Tool, type ToolCall, ToolRegistry, type ToolResult, type ToolSchema, checkBudget, claudeCode, codexCli, createContext, defineTool, estimateTokens, fsTools, genId, nextPendingStep, ollama, reply, resolveSerializable, resume, run, runLoop, runWith, withRetry };

package/dist/index.d.ts

@@ -377,6 +377,75 @@ declare class AnthropicProvider implements Provider {
     complete(req: CompletionRequest): Promise<CompletionResult>;
 }
 
+interface OpenAICompatOptions {
+    /** e.g. http://localhost:11434/v1 (Ollama), http://localhost:1234/v1 (LM Studio), https://api.openai.com/v1 */
+    baseUrl: string;
+    /** Optional — local servers don't need one. */
+    apiKey?: string;
+    model: string;
+    label?: string;
+    maxRetries?: number;
+    defaultMaxTokens?: number;
+}
+/**
+ * Talks the OpenAI Chat Completions format — which means it works with almost
+ * everything: **Ollama and LM Studio (local, no API key)**, llama.cpp's server,
+ * OpenRouter, Groq, Together, OpenAI itself… Point `baseUrl` at any of them.
+ * No SDK, no dependencies.
+ */
+declare class OpenAICompatProvider implements Provider {
+    readonly name: string;
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly model;
+    private readonly maxRetries;
+    private readonly defaultMaxTokens;
+    constructor(opts: OpenAICompatOptions);
+    estimateTokens(messages: Message[]): number;
+    complete(req: CompletionRequest): Promise<CompletionResult>;
+}
+/** Convenience: a local Ollama model, no API key. `ollama("llama3.1")`. */
+declare function ollama(model: string, opts?: Partial<OpenAICompatOptions>): OpenAICompatProvider;
+
+interface CliProviderOptions {
+    /** The executable, e.g. "claude" or "codex". */
+    command: string;
+    /** Fixed args before the prompt, e.g. ["-p"] for Claude Code print mode. */
+    args?: string[];
+    /** Pass the prompt as the final arg ("arg", default) or on stdin ("stdin"). */
+    promptVia?: "arg" | "stdin";
+    /** Extract the assistant text from the command's stdout. Default: trim. */
+    parse?: (stdout: string) => string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    label?: string;
+}
+/**
+ * Drives an agentic CLI (Claude Code, Codex, …) in non-interactive mode: every
+ * model call shells out to the command and captures its stdout. This means
+ * people who use those CLIs via a **subscription login use oh-my-fable with no
+ * separate API key** — it rides whatever auth the CLI already has.
+ *
+ * Note: it returns text only (no native tool-calling), so the agent runs in
+ * pure-reasoning mode; `--tools fs` is unavailable through a CLI provider.
+ */
+declare class CliProvider implements Provider {
+    readonly name: string;
+    private readonly command;
+    private readonly args;
+    private readonly promptVia;
+    private readonly parse;
+    private readonly env?;
+    private readonly timeoutMs;
+    constructor(opts: CliProviderOptions);
+    estimateTokens(messages: Message[]): number;
+    complete(req: CompletionRequest): Promise<CompletionResult>;
+}
+/** Claude Code in print mode — uses your existing `claude` auth (subscription or key). */
+declare function claudeCode(opts?: Partial<CliProviderOptions>): CliProvider;
+/** OpenAI Codex CLI in non-interactive exec mode — uses your existing `codex` auth. */
+declare function codexCli(opts?: Partial<CliProviderOptions>): CliProvider;
+
 /** Run an agent to completion (or to a budget halt). The whole run is checkpointed every step. */
 declare function run(goal: Goal | string, config: RunConfig): Promise<RunResult>;
 /** Resume a run from its last checkpoint — same plan, same progress, continues where it died. */
@@ -384,4 +453,4 @@ declare function resume(runId: string, config: RunConfig): Promise<RunResult>;
 /** Continue a RunContext you already hold in memory (advanced; same as resume without the store load). */
 declare function runWith(ctx: RunContext, config: RunConfig): Promise<RunResult>;
 
-export { type AnthropicOptions, AnthropicProvider, type BudgetState, type CompletionRequest, type CompletionResult, ContextManager, DEFAULT_CONFIG, type Digest, Executor, FileStore, type Goal, type LoopDeps, MemoryStore, type Message, type Observation, type Plan, type PlanStatus, Planner, type Progress, type Provider, type Reflection, Reflector, type Role, type RunConfig, type RunContext, type RunEvent, type RunResult, type RunStatus, type RunSummary, ScriptedProvider, type ScriptedResponse, type SerializableConfig, type Step, type StepStatus, type StopReason, type Store, type Tool, type ToolCall, ToolRegistry, type ToolResult, type ToolSchema, checkBudget, createContext, defineTool, estimateTokens, fsTools, genId, nextPendingStep, reply, resolveSerializable, resume, run, runLoop, runWith, withRetry };
+export { type AnthropicOptions, AnthropicProvider, type BudgetState, CliProvider, type CliProviderOptions, type CompletionRequest, type CompletionResult, ContextManager, DEFAULT_CONFIG, type Digest, Executor, FileStore, type Goal, type LoopDeps, MemoryStore, type Message, type Observation, type OpenAICompatOptions, OpenAICompatProvider, type Plan, type PlanStatus, Planner, type Progress, type Provider, type Reflection, Reflector, type Role, type RunConfig, type RunContext, type RunEvent, type RunResult, type RunStatus, type RunSummary, ScriptedProvider, type ScriptedResponse, type SerializableConfig, type Step, type StepStatus, type StopReason, type Store, type Tool, type ToolCall, ToolRegistry, type ToolResult, type ToolSchema, checkBudget, claudeCode, codexCli, createContext, defineTool, estimateTokens, fsTools, genId, nextPendingStep, ollama, reply, resolveSerializable, resume, run, runLoop, runWith, withRetry };

package/dist/index.js

@@ -876,6 +876,164 @@ var AnthropicProvider = class {
   }
 };
 
+// src/providers/openai.ts
+var FINISH = { stop: "end", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens" };
+var OpenAICompatProvider = class {
+  name;
+  baseUrl;
+  apiKey;
+  model;
+  maxRetries;
+  defaultMaxTokens;
+  constructor(opts) {
+    if (!opts.baseUrl) throw new Error("OpenAICompatProvider needs a baseUrl.");
+    if (!opts.model) throw new Error("OpenAICompatProvider needs a model.");
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.model = opts.model;
+    this.name = opts.label ?? "openai-compatible";
+    this.maxRetries = opts.maxRetries ?? 4;
+    this.defaultMaxTokens = opts.defaultMaxTokens ?? 4096;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const body = {
+      model: this.model,
+      messages: req.messages.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: req.maxTokens ?? this.defaultMaxTokens,
+      temperature: req.temperature ?? 1
+    };
+    if (req.tools?.length) {
+      body["tools"] = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    }
+    const data = await withRetry(
+      async () => {
+        const headers = { "content-type": "application/json" };
+        if (this.apiKey) headers["authorization"] = `Bearer ${this.apiKey}`;
+        const res = await fetch(`${this.baseUrl}/chat/completions`, { method: "POST", headers, body: JSON.stringify(body) });
+        if (!res.ok) {
+          const text = await res.text().catch(() => "");
+          const err = new Error(`${this.name} ${res.status}: ${text.slice(0, 300)}`);
+          err.status = res.status;
+          throw err;
+        }
+        return await res.json();
+      },
+      {
+        retries: this.maxRetries,
+        isRetryable: (e) => {
+          const s = e.status;
+          return s === void 0 || s === 429 || s >= 500 && s < 600;
+        }
+      }
+    );
+    const choice = data.choices?.[0];
+    const content = typeof choice?.message?.content === "string" ? choice.message.content : "";
+    const toolCalls = [];
+    for (const tc of choice?.message?.tool_calls ?? []) {
+      if (!tc.function?.name) continue;
+      let input = {};
+      try {
+        input = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+      } catch {
+        input = tc.function.arguments ?? {};
+      }
+      toolCalls.push({ id: tc.id ?? tc.function.name, name: tc.function.name, input });
+    }
+    return {
+      content,
+      toolCalls: toolCalls.length ? toolCalls : void 0,
+      tokensIn: data.usage?.prompt_tokens ?? 0,
+      tokensOut: data.usage?.completion_tokens ?? 0,
+      stopReason: FINISH[choice?.finish_reason ?? ""] ?? "end"
+    };
+  }
+};
+function ollama(model, opts = {}) {
+  return new OpenAICompatProvider({ baseUrl: "http://localhost:11434/v1", model, label: "ollama", ...opts });
+}
+
+// src/providers/cli.ts
+import { spawn } from "child_process";
+function flatten(messages) {
+  const parts = [];
+  for (const m of messages) {
+    if (m.role === "assistant") parts.push(`Assistant: ${m.content}`);
+    else parts.push(m.content);
+  }
+  return parts.join("\n\n");
+}
+function runCli(command, args, input, timeoutMs, env) {
+  return new Promise((resolve2, reject) => {
+    let child;
+    try {
+      child = spawn(command, args, { env: { ...process.env, ...env } });
+    } catch (e) {
+      return reject(e);
+    }
+    let out = "";
+    let err = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${command} timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    child.stdout.on("data", (d) => out += d);
+    child.stderr.on("data", (d) => err += d);
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e.code === "ENOENT" ? new Error(`"${command}" is not installed or not on your PATH.`) : e);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve2(out);
+      else reject(new Error(`${command} exited ${code}: ${err.trim().slice(0, 300)}`));
+    });
+    if (input !== null) child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+var CliProvider = class {
+  name;
+  command;
+  args;
+  promptVia;
+  parse;
+  env;
+  timeoutMs;
+  constructor(opts) {
+    this.command = opts.command;
+    this.args = opts.args ?? [];
+    this.promptVia = opts.promptVia ?? "arg";
+    this.parse = opts.parse ?? ((s) => s.trim());
+    this.env = opts.env;
+    this.timeoutMs = opts.timeoutMs ?? 12e4;
+    this.name = opts.label ?? `cli:${opts.command}`;
+  }
+  estimateTokens(messages) {
+    return estimateTokens(messages);
+  }
+  async complete(req) {
+    const prompt = flatten(req.messages);
+    const args = this.promptVia === "arg" ? [...this.args, prompt] : this.args;
+    const stdout = await runCli(this.command, args, this.promptVia === "stdin" ? prompt : null, this.timeoutMs, this.env);
+    const content = this.parse(stdout);
+    return {
+      content,
+      tokensIn: estimateTokens(req.messages),
+      tokensOut: Math.ceil(content.length / 4),
+      stopReason: "end"
+    };
+  }
+};
+function claudeCode(opts = {}) {
+  return new CliProvider({ command: "claude", args: ["-p"], promptVia: "arg", label: "claude-code", ...opts });
+}
+function codexCli(opts = {}) {
+  return new CliProvider({ command: "codex", args: ["exec"], promptVia: "arg", label: "codex", ...opts });
+}
+
 // src/index.ts
 function buildDeps(config, serializable) {
   const provider = config.provider;
@@ -908,22 +1066,27 @@ async function runWith(ctx, config) {
 }
 export {
   AnthropicProvider,
+  CliProvider,
   ContextManager,
   DEFAULT_CONFIG,
   Executor,
   FileStore,
   MemoryStore,
+  OpenAICompatProvider,
   Planner,
   Reflector,
   ScriptedProvider,
   ToolRegistry,
   checkBudget,
+  claudeCode,
+  codexCli,
   createContext,
   defineTool,
   estimateTokens,
   fsTools,
   genId,
   nextPendingStep,
+  ollama,
   reply,
   resolveSerializable,
   resume,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-fable",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "The autonomous-agent harness that actually finishes long tasks — because it plans first, self-corrects every step, and survives crashes. The whole run lives in one serializable RunContext, checkpointed after every step, so it resumes exactly where it died. Model-agnostic, zero dependencies, deterministically testable.",
   "type": "module",
   "main": "./dist/index.js",