agenticweb-cli 0.1.1 → 0.2.0

package/README.md

@@ -40,10 +40,25 @@ npx agenticweb-cli serve --edge
 ```
 
 - **init** starts a project and asks you to prove you own the site (a DNS record or a small file).
-- **build** reads your site and pulls out what matters: pages, products, menus, hours, FAQs and policies. With an `ANTHROPIC_API_KEY` it uses Claude. Without one, built-in rules still do a good job.
+- **build** reads your site and pulls out what matters: pages, products, menus, hours, FAQs and policies.
 - **review** opens a page where you choose what agents can see and which actions they can use. Everything starts off.
 - **serve --edge** shows your site with the agent version added, at `http://127.0.0.1:8787`.
 
+## Do I need an AI key?
+
+**No.** AgenticWeb works fully without one. The benchmark above was run with no AI key at all.
+
+**What an AI provider is for:** it's the AI that AgenticWeb can call on for a few optional extras. The core work never depends on it: building the agent version, the safety checks, bookings and checkout all run on AgenticWeb's own rules.
+
+| | Without a key | With a key |
+|---|---|---|
+| Reading your site | Built-in rules, good for well-built sites | Smarter on messy pages (and PDFs, with Claude) |
+| Answering agents' questions | The matching facts, with sources | A short written answer, with sources |
+| Testing your site as an agent | Quick checks with set answers | A real AI agent tries each task |
+| Questions your site can't answer yet | The question, for you to answer | A draft answer from your site's own facts |
+
+**Pick any provider:** Claude (the default), OpenAI, DeepSeek, Gemini, or a free model running on your own computer (Ollama or LM Studio). It's one line in the config, and the [guide](docs/GUIDE.md#choosing-an-ai-provider) shows how. Your key stays on your computer or server, and requests go straight to the provider you chose, never to us.
+
 ## Put it on your site
 
 **Recommended: edge mode.** AgenticWeb runs in front of your site on your own domain. Nothing gets installed on your site, so it works with WordPress, Shopify themes, Webflow, custom code or anything else.
@@ -62,15 +77,15 @@ This prepares a Cloudflare Worker for your domain. Not on Cloudflare? Use `--tar
 | Markdown pages | Any page, as clean text, when an agent asks for it |
 | Product and business data | Prices, stock, hours and FAQs in the standard schema.org format |
 | `/.agent/ask` | Ask a question in plain words and get an answer with sources |
-| MCP server | Your site as tools for Claude and other AI apps |
+| MCP server | Your site as tools for ChatGPT, Claude, Gemini, Cursor and other AI apps |
 | WebMCP | The same tools for AI agents built into browsers |
 | UCP and ACP checkout | The checkout protocols shopping agents use, for any store, not only Shopify |
 
 ## Check that it works
 
-- **Test it like an agent.** `agenticweb test` runs your real tasks, like "book a table for 4 on Friday", as an AI agent on both your site and the agent version. You get an **Agent Readiness score**, a badge, and a warning when a task that used to work breaks.
+- **Test it like an agent.** `npx agenticweb-cli test` tries your real tasks, like "book a table for 4 on Friday", on both your site and the agent version (with an AI key, a real AI agent does them). You get an **Agent Readiness score**, a badge, and a warning when a task that used to work breaks.
 - **Prove it's the same story.** Every build checks each fact (prices, hours, contact details) against your live pages and signs the result with your key. Anyone can check it with `npx agenticweb-cli check <agent-branch-url>`.
-- **Fill the gaps.** `agenticweb suggest` turns questions agents asked that your site couldn't answer into drafted FAQ answers. You approve them and add them to your site, and agents pick them up from there.
+- **Fill the gaps.** `npx agenticweb-cli suggest` lists questions agents asked that your site couldn't answer, with a draft answer for each if you have an AI key. You approve them and add them to your site, and agents pick them up from there.
 
 ## Works with
 
@@ -88,10 +103,11 @@ Shopify, WooCommerce, Stripe, Cal.com, any API with an OpenAPI description, any
 
 More in [SECURITY.md](SECURITY.md).
 
-## Use it from Claude
+## Use it from your AI assistant
 
-- **Claude Code:** run `/plugin marketplace add adibfarah/agenticweb`, then `/agentify https://mysite.com`, and Claude walks you through each step.
-- **Claude Desktop or any MCP app:** add an MCP server with the command `npx` and the arguments `["agenticweb-cli@latest", "mcp"]`.
+- **Any coding assistant** (Claude Code, Codex, Cursor, Gemini CLI and others) can run the `npx agenticweb-cli` commands for you.
+- **Any MCP app** (ChatGPT, Claude Desktop, Cursor, VS Code and others): add an MCP server with the command `npx` and the arguments `["agenticweb-cli@latest", "mcp"]`.
+- **Claude Code plugin:** run `/plugin marketplace add adibfarah/agenticweb`, then `/agentify https://mysite.com` for a guided walkthrough.
 
 ## Learn more
 

package/dist/agenticweb.mjs

@@ -20788,6 +20788,122 @@ var init_util2 = __esm({
   }
 });
 
+// packages/core/src/llm-providers.ts
+function resolveLlm(s, env) {
+  if (!s.enabled) return void 0;
+  const info = PROVIDERS[s.provider];
+  const keyEnv = s.apiKeyEnv ?? info.apiKeyEnv;
+  const apiKey = env[keyEnv] || void 0;
+  if (s.provider === "anthropic") {
+    if (!apiKey && !env.ANTHROPIC_AUTH_TOKEN && !env.ANTHROPIC_PROFILE) return void 0;
+  } else if (!apiKey && !(s.provider === "openai-compatible" && s.baseUrl)) {
+    return void 0;
+  }
+  const baseUrl = s.baseUrl ?? info.baseUrl;
+  if (s.provider === "openai-compatible" && !baseUrl) throw new Error('llm.provider is "openai-compatible": set llm.baseUrl, e.g. "http://localhost:11434/v1".');
+  return {
+    provider: s.provider,
+    label: info.label,
+    apiKey,
+    baseUrl,
+    jsonMode: info.jsonMode,
+    maxTokensParam: info.maxTokensParam,
+    model: (configured) => {
+      if (s.model) return s.model;
+      if (s.provider === "anthropic") return configured || info.defaultModel;
+      if (configured && !configured.startsWith("claude-")) return configured;
+      if (!info.defaultModel) throw new Error(`Set llm.model to a model your ${info.label} serves.`);
+      return info.defaultModel;
+    }
+  };
+}
+async function chatCompletion(r, body, f = fetch) {
+  if (!r.baseUrl) throw new Error(`${r.label} has no API address.`);
+  const res = await f(`${r.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...r.apiKey ? { authorization: `Bearer ${r.apiKey}` } : {} },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`${r.label} returned HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  return await res.json();
+}
+function jsonSchemaOf(schema) {
+  const clean = (v) => {
+    if (Array.isArray(v)) return v.map(clean);
+    if (!v || typeof v !== "object") return v;
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (k === "$schema") continue;
+      if (k === "type" && Array.isArray(val)) {
+        const types = val.filter((t) => t !== "null");
+        out.type = types[0] ?? "string";
+        if (types.length < val.length) out.nullable = true;
+        continue;
+      }
+      out[k] = clean(val);
+    }
+    return out;
+  };
+  return clean(external_exports.toJSONSchema(schema, { unrepresentable: "any" }));
+}
+async function extractJson(r, args, f = fetch) {
+  const schemaJson = jsonSchemaOf(args.schema);
+  const system = r.jsonMode === "schema" ? args.system : `${args.system}
+
+Reply with one JSON object only, matching this JSON Schema:
+${JSON.stringify(schemaJson)}`;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: args.content }
+  ];
+  const format = r.jsonMode === "schema" ? { type: "json_schema", json_schema: { name: "result", schema: schemaJson, strict: false } } : { type: "json_object" };
+  let problem = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await chatCompletion(r, { model: r.model(args.model), messages, response_format: format, ...maxTokens(r, args.maxTokens ?? 8e3) }, f);
+    const choice = res.choices[0];
+    if (!choice) throw new Error(`${r.label} returned no answer.`);
+    if (choice.message.refusal || choice.finish_reason === "content_filter") throw new Error(`${r.label} declined to process this content.`);
+    const text2 = choice.message.content ?? "";
+    let value;
+    try {
+      value = parseJson(text2);
+    } catch {
+      problem = "The reply wasn't valid JSON.";
+      messages.push({ role: "assistant", content: text2 }, { role: "user", content: `${problem} Reply with the JSON object only.` });
+      continue;
+    }
+    const parsed = args.schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+    problem = parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    messages.push({ role: "assistant", content: text2 }, { role: "user", content: `That JSON doesn't match the schema (${problem}). Reply with corrected JSON only.` });
+  }
+  throw new Error(`${r.label} didn't return valid data: ${problem}`);
+}
+var PROVIDER_IDS, PROVIDERS, maxTokens, parseJson;
+var init_llm_providers = __esm({
+  "packages/core/src/llm-providers.ts"() {
+    "use strict";
+    init_zod();
+    PROVIDER_IDS = ["anthropic", "openai", "deepseek", "gemini", "openai-compatible"];
+    PROVIDERS = {
+      anthropic: { label: "Claude", apiKeyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", jsonMode: "schema", maxTokensParam: "max_tokens" },
+      openai: { label: "OpenAI", baseUrl: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", defaultModel: "gpt-6.1-sol", jsonMode: "schema", maxTokensParam: "max_completion_tokens" },
+      deepseek: { label: "DeepSeek", baseUrl: "https://api.deepseek.com", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-flash", jsonMode: "object", maxTokensParam: "max_tokens" },
+      gemini: {
+        label: "Gemini",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        apiKeyEnv: "GEMINI_API_KEY",
+        defaultModel: "gemini-3-flash-preview",
+        jsonMode: "schema",
+        maxTokensParam: "max_tokens"
+      },
+      "openai-compatible": { label: "OpenAI-compatible API", apiKeyEnv: "LLM_API_KEY", defaultModel: "", jsonMode: "object", maxTokensParam: "max_tokens" }
+    };
+    maxTokens = (r, n) => ({ [r.maxTokensParam]: n });
+    parseJson = (text2) => JSON.parse(text2.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, ""));
+  }
+});
+
 // packages/core/src/config.ts
 var ActionOverride, crawlDefaults, llmDefaults, edgeDefaults, testsDefaults, commerceDefaults, ProjectConfig;
 var init_config = __esm({
@@ -20795,6 +20911,7 @@ var init_config = __esm({
     "use strict";
     init_zod();
     init_schema();
+    init_llm_providers();
     ActionOverride = external_exports.object({
       name: external_exports.string(),
       enabled: external_exports.boolean().optional(),
@@ -20810,6 +20927,7 @@ var init_config = __esm({
     crawlDefaults = { maxPages: 200, include: [], exclude: [], render: "fetch", respectRobots: true, concurrency: 4 };
     llmDefaults = {
       enabled: true,
+      provider: "anthropic",
       classifyModel: "claude-opus-5-5",
       extractModel: "claude-opus-5-5",
       actionsModel: "claude-opus-5-5",
@@ -20851,6 +20969,14 @@ var init_config = __esm({
       actions: external_exports.array(ActionOverride).default([]),
       llm: external_exports.object({
         enabled: external_exports.boolean().default(true),
+        /** Which AI to use: Claude (default), OpenAI, DeepSeek, Gemini, or any OpenAI-compatible API (including local ones). */
+        provider: external_exports.enum(PROVIDER_IDS).default("anthropic"),
+        /** API address for "openai-compatible", e.g. http://localhost:11434/v1 for Ollama. */
+        baseUrl: external_exports.string().url().optional(),
+        /** Env var holding the API key, if not the provider's usual one (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY, LLM_API_KEY). */
+        apiKeyEnv: external_exports.string().optional(),
+        /** One model for every step. Without it, non-Claude providers use their own default model. */
+        model: external_exports.string().optional(),
         classifyModel: external_exports.string().default(llmDefaults.classifyModel),
         extractModel: external_exports.string().default(llmDefaults.extractModel),
         actionsModel: external_exports.string().default(llmDefaults.actionsModel),
@@ -20951,6 +21077,7 @@ var init_src = __esm({
     init_fields();
     init_util2();
     init_config();
+    init_llm_providers();
   }
 });
 
@@ -90044,9 +90171,9 @@ var init_client = __esm({
           }
           return url2.toString();
         }
-        _calculateNonstreamingTimeout(maxTokens) {
+        _calculateNonstreamingTimeout(maxTokens2) {
           const defaultTimeout = 10 * 60;
-          const expectedTimeout = 60 * 60 * maxTokens / 128e3;
+          const expectedTimeout = 60 * 60 * maxTokens2 / 128e3;
           if (expectedTimeout > defaultTimeout) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#streaming-responses for more details");
           }
@@ -90396,11 +90523,11 @@ var init_client = __esm({
           const jitter2 = 1 - Math.random() * 0.25;
           return sleepSeconds * jitter2 * 1e3;
         }
-        calculateNonstreamingTimeout(maxTokens, maxNonstreamingTokens) {
+        calculateNonstreamingTimeout(maxTokens2, maxNonstreamingTokens) {
           const maxTime = 60 * 60 * 1e3;
           const defaultTime = 60 * 10 * 1e3;
-          const expectedTime = maxTime * maxTokens / 128e3;
-          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens > maxNonstreamingTokens) {
+          const expectedTime = maxTime * maxTokens2 / 128e3;
+          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens2 > maxNonstreamingTokens) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#long-requests for more details");
           }
           return defaultTime;
@@ -91266,15 +91393,26 @@ var init_zod2 = __esm({
 });
 
 // packages/understand/src/llm.ts
-function hasClaudeCredentials(env = process.env) {
-  return Boolean(env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_PROFILE);
+function llmFromSettings(s, env = process.env, f) {
+  const r = resolveLlm(s, env);
+  if (!r) return void 0;
+  if (r.provider === "anthropic") {
+    const claude = new ClaudeLlm(r.apiKey ? new Anthropic({ apiKey: r.apiKey }) : void 0);
+    const llm = {
+      extract: (a) => claude.extract({ ...a, model: r.model(a.model) }),
+      readDocument: (a) => claude.readDocument({ ...a, model: r.model(a.model) })
+    };
+    return { llm, label: r.label, resolved: r };
+  }
+  return { llm: new ChatCompletionsLlm(r, f), label: r.label, resolved: r };
 }
-var RefusalError, ClaudeLlm;
+var RefusalError, ClaudeLlm, ChatCompletionsLlm, apiKeyEnvFor;
 var init_llm = __esm({
   "packages/understand/src/llm.ts"() {
     "use strict";
     init_sdk();
     init_zod2();
+    init_src();
     RefusalError = class extends Error {
     };
     ClaudeLlm = class {
@@ -91322,6 +91460,18 @@ var init_llm = __esm({
         return message.parsed_output;
       }
     };
+    ChatCompletionsLlm = class {
+      r;
+      f;
+      constructor(r, f) {
+        this.r = r;
+        this.f = f;
+      }
+      extract(args) {
+        return extractJson(this.r, args, this.f);
+      }
+    };
+    apiKeyEnvFor = (s) => s.apiKeyEnv ?? PROVIDERS[s.provider].apiKeyEnv;
   }
 });
 
@@ -116494,9 +116644,19 @@ async function createClaudeAsker(opts = {}) {
     }
   };
 }
+async function askerFor(s, env, f) {
+  const r = resolveLlm(s, env);
+  if (!r) return void 0;
+  if (r.provider === "anthropic") {
+    const claude = await createClaudeAsker({ apiKey: r.apiKey });
+    return { label: r.label, extract: (a) => claude.extract({ ...a, model: r.model(a.model) }) };
+  }
+  return { label: r.label, extract: (a) => extractJson(r, a, f) };
+}
 var init_claude = __esm({
   "packages/runtime/src/claude.ts"() {
     "use strict";
+    init_src();
   }
 });
 
@@ -116683,7 +116843,7 @@ async function cmdCi(project, opts, out = { log: (m) => console.log(m) }) {
   const cron = hours === 24 ? "17 3 * * *" : `17 */${hours} * * *`;
   const file3 = path6.join(project.dir, ".github", "workflows", "agenticweb-sync.yml");
   await mkdir4(path6.dirname(file3), { recursive: true });
-  await writeFile3(file3, WORKFLOW(cron, opts.target ?? config2.deploy.target));
+  await writeFile3(file3, WORKFLOW(cron, opts.target ?? config2.deploy.target, config2.llm.apiKeyEnv ?? PROVIDERS[config2.llm.provider].apiKeyEnv));
   out.log(`Wrote ${path6.relative(project.dir, file3)}. It rebuilds every ${hours} hour(s).`);
   out.log("Add the repository secrets it uses (Settings \u2192 Secrets and variables \u2192 Actions), then commit the file.");
 }
@@ -116691,10 +116851,11 @@ var WORKFLOW;
 var init_sync = __esm({
   "packages/cli/src/sync.ts"() {
     "use strict";
+    init_src();
     init_src7();
     init_project();
     init_commands();
-    WORKFLOW = (cron, target) => `# Keeps your agent branch in sync with your site. Generated by AgenticWeb.
+    WORKFLOW = (cron, target, aiKeyEnv) => `# Keeps your agent branch in sync with your site. Generated by AgenticWeb.
 name: Sync agent branch
 on:
   schedule:
@@ -116712,14 +116873,14 @@ jobs:
       - name: Rebuild the agent branch
         run: npx agenticweb-cli@latest build
         env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          ${aiKeyEnv}: \${{ secrets.${aiKeyEnv} }}
           # The contents of .agenticweb/signing-key.json, so every build is signed with the same key.
           AGENTICWEB_SIGNING_KEY: \${{ secrets.AGENTICWEB_SIGNING_KEY }}
       - name: Agent Readiness tests (a task that used to pass and now fails stops the deploy)
         if: hashFiles('agenticweb.tests.json') != ''
         run: npx agenticweb-cli@latest test --strict
         env:
-          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          ${aiKeyEnv}: \${{ secrets.${aiKeyEnv} }}
       - name: Keep the readiness report
         if: always() && hashFiles('agent-readiness/report.md') != ''
         uses: actions/upload-artifact@v4
@@ -119109,6 +119270,7 @@ __export(readiness_exports, {
   TasksFile: () => TasksFile,
   badgeSvg: () => badgeSvg,
   basicChecks: () => basicChecks,
+  chatCompletionsLoop: () => chatCompletionsLoop,
   claudeLoop: () => claudeLoop,
   cmdTest: () => cmdTest,
   crawlForAnswer: () => crawlForAnswer,
@@ -119266,7 +119428,7 @@ async function crawlForAnswer(site, expect, opts = {}) {
 }
 async function builtInAgentArm(task, branch) {
   if (task.action) {
-    if (!task.input) return { ran: false, success: false, requests: 0, tokens: 0, note: "needs Claude (set ANTHROPIC_API_KEY) or an `input` to run without it" };
+    if (!task.input) return { ran: false, success: false, requests: 0, tokens: 0, note: "needs an AI key (see llm.provider) or an `input` to run without it" };
     const res2 = await branch.fetcher(
       new Request(`${branch.baseUrl}/api/${task.action}`, {
         method: "POST",
@@ -119343,14 +119505,44 @@ async function claudeLoop(args) {
   }
   return done("", `stopped after ${args.maxTurns} turns`);
 }
-async function claudeAgentArm(task, ctx) {
+async function chatCompletionsLoop(args) {
+  const messages = [
+    { role: "system", content: args.system },
+    { role: "user", content: args.task }
+  ];
+  const tools = args.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.input_schema } }));
+  let tokens = 0;
+  const calls = [];
+  const results = [];
+  const done = (answer, note) => ({ answer, requests: calls.length, tokens, calls, results, note });
+  for (let turn = 0; turn < args.maxTurns; turn++) {
+    const res = await chatCompletion(args.r, { model: args.model, messages, tools, ...maxTokens(args.r, 8e3) }, args.fetch);
+    tokens += (res.usage?.prompt_tokens ?? 0) + (res.usage?.completion_tokens ?? 0);
+    const choice = res.choices[0];
+    if (!choice) return done("", `${args.r.label} returned no answer`);
+    const msg = choice.message;
+    if (msg.refusal || choice.finish_reason === "content_filter") return done(msg.content ?? "", `${args.r.label} declined the task`);
+    messages.push({ role: "assistant", content: msg.content ?? null, ...msg.tool_calls?.length ? { tool_calls: msg.tool_calls } : {} });
+    if (!msg.tool_calls?.length) return done((msg.content ?? "").trim(), choice.finish_reason === "length" ? "the answer was cut off" : void 0);
+    for (const call of msg.tool_calls) {
+      calls.push(call.function.name);
+      let out;
+      try {
+        out = await args.run(call.function.name, call.function.arguments ? JSON.parse(call.function.arguments) : {});
+      } catch (err) {
+        out = { text: `Error: ${err.message}`, isError: true };
+      }
+      results.push({ name: call.function.name, status: out.status, isError: out.isError });
+      messages.push({ role: "tool", tool_call_id: call.id, content: out.text.slice(0, 4e4) || "(empty)" });
+    }
+  }
+  return done("", `stopped after ${args.maxTurns} turns`);
+}
+async function aiAgentArm(task, ctx) {
   const mcp = await connectMcp(ctx.branch);
   try {
     const tools = (await mcp.listTools()).map((t) => ({ name: t.name, description: t.description ?? "", input_schema: t.inputSchema }));
-    const r = await claudeLoop({
-      client: ctx.client,
-      model: ctx.model,
-      effort: ctx.effort,
+    const r = await ctx.loop({
       maxTurns: ctx.maxTurns,
       system: SYSTEM(ctx.site, "agent"),
       task: task.task,
@@ -119372,13 +119564,10 @@ async function claudeAgentArm(task, ctx) {
     await mcp.close();
   }
 }
-async function claudeHumanArm(task, ctx) {
+async function aiHumanArm(task, ctx) {
   const f = ctx.fetch ?? fetch;
   const origin = new URL(ctx.site);
-  const r = await claudeLoop({
-    client: ctx.client,
-    model: ctx.model,
-    effort: ctx.effort,
+  const r = await ctx.loop({
     maxTurns: ctx.maxTurns,
     system: SYSTEM(ctx.site, "human"),
     task: task.task,
@@ -119428,7 +119617,7 @@ function reportMarkdown(r) {
   const lines = [
     `# Agent Readiness: ${r.score}/100`,
     "",
-    `${r.site}, tested ${r.ranAt.slice(0, 16).replace("T", " ")} UTC against ${r.target}. ${r.mode === "claude" ? `Tasks were done by Claude (${r.model}) using tools.` : "Built-in mode: no Claude. Lookups use /ask; actions run with the input in the tasks file."}`,
+    `${r.site}, tested ${r.ranAt.slice(0, 16).replace("T", " ")} UTC against ${r.target}. ${r.mode === "ai" ? `Tasks were done by ${r.provider ?? "an AI agent"} (${r.model}) using tools.` : "Built-in mode: no AI. Lookups use /ask; actions run with the input in the tasks file."}`,
     "",
     `- **Tasks:** ${t.passed} of ${t.total} done on the agent branch${t.humanRan ? `, ${t.humanPassed} of ${t.humanRan} on the human site` : ""}.`,
     `- **Basics:** ${r.checks.filter((c) => c.ok).length} of ${r.checks.length} checks pass.`,
@@ -119493,24 +119682,38 @@ ${parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n
   let tasks = parsed.data.tasks;
   if (opts.only) tasks = tasks.filter((t) => t.id === opts.only);
   if (!tasks.length) throw new UserError(opts.only ? `No task "${opts.only}" in ${TASKS_FILE}.` : `${TASKS_FILE} has no tasks.`);
-  const useClaude = !opts.noLlm && (Boolean(opts.client) || config2.llm.enabled && hasClaudeCredentials());
-  let client = opts.client;
-  if (useClaude && !client) {
-    const { default: Anthropic2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
-    client = new Anthropic2();
-  }
-  const llm = useClaude && !opts.client ? await createClaudeAsker() : void 0;
+  const ai = opts.noLlm ? void 0 : opts.client ? { provider: "anthropic", label: "Claude" } : resolveLlm(config2.llm, process.env);
+  const useAi = Boolean(ai);
+  let loop;
+  let model = config2.tests.model;
+  if (ai && (ai.provider === "anthropic" || opts.client)) {
+    let client = opts.client;
+    if (!client) {
+      const { default: Anthropic2 } = await Promise.resolve().then(() => (init_sdk(), sdk_exports));
+      const r = ai;
+      client = r.apiKey ? new Anthropic2({ apiKey: r.apiKey }) : new Anthropic2();
+      model = r.model(config2.tests.model);
+    }
+    const c = client;
+    const m = model;
+    loop = (a) => claudeLoop({ ...a, client: c, model: m, effort: config2.tests.effort });
+  } else if (ai) {
+    const r = ai;
+    model = r.model(config2.tests.model);
+    const m = model;
+    loop = (a) => chatCompletionsLoop({ ...a, r, model: m, fetch: opts.fetchLlm });
+  }
+  const llm = useAi && !opts.client ? await askerFor(config2.llm, process.env, opts.fetchLlm) : void 0;
   const branch = opts.url ? remoteAgentBranch(opts.url) : await localAgentBranch(graph, config2, { llm });
-  const model = config2.tests.model;
-  const ctx = { client, model, effort: config2.tests.effort, maxTurns: config2.tests.maxTurns, site: config2.site };
+  const ctx = { loop, maxTurns: config2.tests.maxTurns, site: config2.site };
   const enabled = graph.actions.filter((a) => a.enabled);
-  out.log(`Testing ${tasks.length} task(s) on ${opts.url ?? "a local copy of your agent branch"}${useClaude ? ` with Claude (${model})` : " in built-in mode (set ANTHROPIC_API_KEY to test with Claude)"}\u2026`);
+  out.log(`Testing ${tasks.length} task(s) on ${opts.url ?? "a local copy of your agent branch"}${useAi ? ` with ${ai.label} (${model})` : ` in built-in mode (set ${apiKeyEnvFor(config2.llm)} to test with an AI agent)`}\u2026`);
   const outcomes = [];
   for (const t of tasks) {
-    const agent = useClaude ? await claudeAgentArm(t, { ...ctx, branch, remote: Boolean(opts.url), actions: enabled }) : await builtInAgentArm(t, branch);
+    const agent = useAi ? await aiAgentArm(t, { ...ctx, branch, remote: Boolean(opts.url), actions: enabled }) : await builtInAgentArm(t, branch);
     let human;
     if (t.human && !t.action && t.expect.length) {
-      human = useClaude ? await claudeHumanArm(t, { ...ctx, fetch: opts.fetchHuman }) : await crawlForAnswer(config2.site, t.expect, { fetch: opts.fetchHuman });
+      human = useAi ? await aiHumanArm(t, { ...ctx, fetch: opts.fetchHuman }) : await crawlForAnswer(config2.site, t.expect, { fetch: opts.fetchHuman });
     } else if (t.action) human = { ran: false, success: false, requests: 0, tokens: 0, note: "not run: it would submit forms on your live site" };
     outcomes.push({ id: t.id, task: t.task, agent, human });
     out.log(`  ${agent.ran ? agent.success ? "\u2713" : "\u2717" : "-"} ${t.id}${agent.note ? `: ${agent.note}` : ""}`);
@@ -119526,8 +119729,8 @@ ${parsed.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n
   const report = {
     site: config2.site,
     target: opts.url ?? "a local copy of the agent branch",
-    mode: useClaude ? "claude" : "built-in",
-    ...useClaude ? { model } : {},
+    mode: useAi ? "ai" : "built-in",
+    ...useAi ? { provider: ai.label, model } : {},
     ranAt: (/* @__PURE__ */ new Date()).toISOString(),
     score: readinessScore(outcomes, checks),
     tasks: outcomes,
@@ -119568,6 +119771,7 @@ var init_readiness = __esm({
   "packages/cli/src/readiness.ts"() {
     "use strict";
     init_zod();
+    init_src();
     init_src7();
     init_src5();
     init_src3();
@@ -119746,7 +119950,7 @@ ${p.markdown}`).join("\n"));
   const gaps = (await findGaps(project, opts.days)).filter((x) => !known.has(normQ(x.question)) && !siteText.includes(normQ(x.question))).slice(0, 30);
   let llm;
   if (opts.llm) llm = opts.llm;
-  else if (opts.llm !== false && config2.llm.enabled && hasClaudeCredentials()) llm = new ClaudeLlm();
+  else if (opts.llm !== false) llm = llmFromSettings(config2.llm)?.llm;
   const added = gaps.length ? await draftSuggestions(g, gaps, { llm, model: config2.llm.askModel }) : [];
   const counts = new Map((await findGaps(project, opts.days)).map((x) => [normQ(x.question), x.asked]));
   const updated = existing.map((s) => ({ ...s, asked: Math.max(s.asked, [s.question, ...s.covers].reduce((n, q) => n + (counts.get(normQ(q)) ?? 0), 0)) }));
@@ -119852,7 +120056,7 @@ async function cmdServe(project, opts, out = { log: (m) => console.log(m) }) {
   const edge = opts.edge ? { ...config2.edge, origin: opts.edge === true ? config2.edge.origin ?? config2.site : opts.edge, publicUrl } : void 0;
   const baseUrl = edge ? `${publicUrl}${config2.edge.prefix}` : config2.deploy.baseUrl ?? publicUrl;
   let llm;
-  if (!opts.noLlm && config2.llm.enabled && hasClaudeCredentials()) llm = await createClaudeAsker();
+  if (!opts.noLlm) llm = await askerFor(config2.llm, process.env);
   const hookSecret = opts.hookSecret ?? process.env.AGENTICWEB_HOOK_SECRET;
   const onTraffic = serveHooks.traffic?.(project);
   const engine = await serveHooks.engine?.(project, graph, config2, baseUrl);
@@ -119894,7 +120098,7 @@ async function cmdServe(project, opts, out = { log: (m) => console.log(m) }) {
   out.log(`  Ask:       ${agentUrl}/ask?q=your+question`);
   out.log(`  MCP:       ${agentUrl}/mcp`);
   out.log(`  Actions:   ${engine ? engine.actions().map((a) => a.name).join(", ") || "none enabled" : "none enabled"}`);
-  out.log(`  /ask uses: ${llm ? `Claude (${config2.llm.askModel})` : "built-in search (set ANTHROPIC_API_KEY for written answers)"}`);
+  out.log(`  /ask uses: ${llm ? llm.label : `built-in search (set ${apiKeyEnvFor(config2.llm)} for written answers)`}`);
   if (opts.syncEveryMinutes) out.log(`  Sync:      every ${opts.syncEveryMinutes} minutes`);
   if (hookSecret) out.log(`  Webhook:   POST ${agentUrl}/hooks/refresh (header x-agenticweb-secret)`);
   out.log("Press Ctrl+C to stop.");
@@ -120207,8 +120411,13 @@ async function cmdBuild(project, opts = {}, out = stdout) {
   let llm;
   if (opts.llm !== false && config2.llm.enabled) {
     if (opts.llm) llm = opts.llm;
-    else if (hasClaudeCredentials()) llm = new ClaudeLlm();
-    else out.log("  No Anthropic credentials found: using built-in heuristics. Set ANTHROPIC_API_KEY for richer extraction.");
+    else {
+      const ai = llmFromSettings(config2.llm);
+      if (ai) {
+        llm = ai.llm;
+        out.log(`  Reading the site with ${ai.label}.`);
+      } else out.log(`  No AI key found: using built-in rules. Set ${apiKeyEnvFor(config2.llm)} for richer extraction.`);
+    }
   }
   const extra = opts.connectors ? await opts.connectors(config2) : await Promise.resolve().then(() => (init_actions_hook(), actions_hook_exports)).then((m) => m.defaultConnectors(config2, (msg) => out.log(`  ${msg}`)));
   let graph = await understand(c, {
@@ -120507,7 +120716,7 @@ function requiredEnv(graph, config2, target = "node") {
     for (const v of Object.values(c.headers ?? {})) if (v.startsWith("env:")) env.set(v.slice(4), `Header value for ${a.name}`);
   }
   if (config2.notifications.email === "resend") env.set(config2.notifications.apiKeyEnv, "Resend API key (confirmation emails)");
-  env.set("ANTHROPIC_API_KEY", "Optional: written answers on /ask");
+  if (config2.llm.enabled) env.set(config2.llm.apiKeyEnv ?? PROVIDERS[config2.llm.provider].apiKeyEnv, `Optional: ${PROVIDERS[config2.llm.provider].label} key for written answers on /ask`);
   env.set(config2.runtime.apiKeysEnv, 'Optional: agent API keys as "key:agent-name,key2:other"');
   return [...env];
 }
@@ -120659,6 +120868,7 @@ var runtimeTargets;
 var init_deploy_runtime = __esm({
   "packages/cli/src/deploy-runtime.ts"() {
     "use strict";
+    init_src();
     init_project();
     runtimeTargets = ["node", "docker", "cloudflare-worker", "edge"];
   }

package/dist/runtime/edge-worker.js

@@ -57878,9 +57878,9 @@ var init_client = __esm({
           }
           return url2.toString();
         }
-        _calculateNonstreamingTimeout(maxTokens) {
+        _calculateNonstreamingTimeout(maxTokens2) {
           const defaultTimeout = 10 * 60;
-          const expectedTimeout = 60 * 60 * maxTokens / 128e3;
+          const expectedTimeout = 60 * 60 * maxTokens2 / 128e3;
           if (expectedTimeout > defaultTimeout) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#streaming-responses for more details");
           }
@@ -58230,11 +58230,11 @@ var init_client = __esm({
           const jitter2 = 1 - Math.random() * 0.25;
           return sleepSeconds * jitter2 * 1e3;
         }
-        calculateNonstreamingTimeout(maxTokens, maxNonstreamingTokens) {
+        calculateNonstreamingTimeout(maxTokens2, maxNonstreamingTokens) {
           const maxTime = 60 * 60 * 1e3;
           const defaultTime = 60 * 10 * 1e3;
-          const expectedTime = maxTime * maxTokens / 128e3;
-          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens > maxNonstreamingTokens) {
+          const expectedTime = maxTime * maxTokens2 / 128e3;
+          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens2 > maxNonstreamingTokens) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#long-requests for more details");
           }
           return defaultTime;
@@ -59392,6 +59392,115 @@ function entityFileName(type) {
   return kebab + "s";
 }
 
+// packages/core/src/llm-providers.ts
+var PROVIDER_IDS = ["anthropic", "openai", "deepseek", "gemini", "openai-compatible"];
+var PROVIDERS = {
+  anthropic: { label: "Claude", apiKeyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", jsonMode: "schema", maxTokensParam: "max_tokens" },
+  openai: { label: "OpenAI", baseUrl: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", defaultModel: "gpt-6.1-sol", jsonMode: "schema", maxTokensParam: "max_completion_tokens" },
+  deepseek: { label: "DeepSeek", baseUrl: "https://api.deepseek.com", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-flash", jsonMode: "object", maxTokensParam: "max_tokens" },
+  gemini: {
+    label: "Gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    apiKeyEnv: "GEMINI_API_KEY",
+    defaultModel: "gemini-3-flash-preview",
+    jsonMode: "schema",
+    maxTokensParam: "max_tokens"
+  },
+  "openai-compatible": { label: "OpenAI-compatible API", apiKeyEnv: "LLM_API_KEY", defaultModel: "", jsonMode: "object", maxTokensParam: "max_tokens" }
+};
+function resolveLlm(s, env) {
+  if (!s.enabled) return void 0;
+  const info = PROVIDERS[s.provider];
+  const keyEnv = s.apiKeyEnv ?? info.apiKeyEnv;
+  const apiKey = env[keyEnv] || void 0;
+  if (s.provider === "anthropic") {
+    if (!apiKey && !env.ANTHROPIC_AUTH_TOKEN && !env.ANTHROPIC_PROFILE) return void 0;
+  } else if (!apiKey && !(s.provider === "openai-compatible" && s.baseUrl)) {
+    return void 0;
+  }
+  const baseUrl = s.baseUrl ?? info.baseUrl;
+  if (s.provider === "openai-compatible" && !baseUrl) throw new Error('llm.provider is "openai-compatible": set llm.baseUrl, e.g. "http://localhost:11434/v1".');
+  return {
+    provider: s.provider,
+    label: info.label,
+    apiKey,
+    baseUrl,
+    jsonMode: info.jsonMode,
+    maxTokensParam: info.maxTokensParam,
+    model: (configured) => {
+      if (s.model) return s.model;
+      if (s.provider === "anthropic") return configured || info.defaultModel;
+      if (configured && !configured.startsWith("claude-")) return configured;
+      if (!info.defaultModel) throw new Error(`Set llm.model to a model your ${info.label} serves.`);
+      return info.defaultModel;
+    }
+  };
+}
+async function chatCompletion(r, body, f = fetch) {
+  if (!r.baseUrl) throw new Error(`${r.label} has no API address.`);
+  const res = await f(`${r.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...r.apiKey ? { authorization: `Bearer ${r.apiKey}` } : {} },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`${r.label} returned HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  return await res.json();
+}
+var maxTokens = (r, n) => ({ [r.maxTokensParam]: n });
+function jsonSchemaOf(schema) {
+  const clean = (v) => {
+    if (Array.isArray(v)) return v.map(clean);
+    if (!v || typeof v !== "object") return v;
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (k === "$schema") continue;
+      if (k === "type" && Array.isArray(val)) {
+        const types = val.filter((t) => t !== "null");
+        out.type = types[0] ?? "string";
+        if (types.length < val.length) out.nullable = true;
+        continue;
+      }
+      out[k] = clean(val);
+    }
+    return out;
+  };
+  return clean(external_exports.toJSONSchema(schema, { unrepresentable: "any" }));
+}
+var parseJson = (text2) => JSON.parse(text2.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, ""));
+async function extractJson(r, args, f = fetch) {
+  const schemaJson = jsonSchemaOf(args.schema);
+  const system = r.jsonMode === "schema" ? args.system : `${args.system}
+
+Reply with one JSON object only, matching this JSON Schema:
+${JSON.stringify(schemaJson)}`;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: args.content }
+  ];
+  const format = r.jsonMode === "schema" ? { type: "json_schema", json_schema: { name: "result", schema: schemaJson, strict: false } } : { type: "json_object" };
+  let problem = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await chatCompletion(r, { model: r.model(args.model), messages, response_format: format, ...maxTokens(r, args.maxTokens ?? 8e3) }, f);
+    const choice = res.choices[0];
+    if (!choice) throw new Error(`${r.label} returned no answer.`);
+    if (choice.message.refusal || choice.finish_reason === "content_filter") throw new Error(`${r.label} declined to process this content.`);
+    const text2 = choice.message.content ?? "";
+    let value;
+    try {
+      value = parseJson(text2);
+    } catch {
+      problem = "The reply wasn't valid JSON.";
+      messages.push({ role: "assistant", content: text2 }, { role: "user", content: `${problem} Reply with the JSON object only.` });
+      continue;
+    }
+    const parsed = args.schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+    problem = parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    messages.push({ role: "assistant", content: text2 }, { role: "user", content: `That JSON doesn't match the schema (${problem}). Reply with corrected JSON only.` });
+  }
+  throw new Error(`${r.label} didn't return valid data: ${problem}`);
+}
+
 // packages/core/src/config.ts
 var ActionOverride = external_exports.object({
   name: external_exports.string(),
@@ -59408,6 +59517,7 @@ var ActionOverride = external_exports.object({
 var crawlDefaults = { maxPages: 200, include: [], exclude: [], render: "fetch", respectRobots: true, concurrency: 4 };
 var llmDefaults = {
   enabled: true,
+  provider: "anthropic",
   classifyModel: "claude-opus-5-5",
   extractModel: "claude-opus-5-5",
   actionsModel: "claude-opus-5-5",
@@ -59449,6 +59559,14 @@ var ProjectConfig = external_exports.object({
   actions: external_exports.array(ActionOverride).default([]),
   llm: external_exports.object({
     enabled: external_exports.boolean().default(true),
+    /** Which AI to use: Claude (default), OpenAI, DeepSeek, Gemini, or any OpenAI-compatible API (including local ones). */
+    provider: external_exports.enum(PROVIDER_IDS).default("anthropic"),
+    /** API address for "openai-compatible", e.g. http://localhost:11434/v1 for Ollama. */
+    baseUrl: external_exports.string().url().optional(),
+    /** Env var holding the API key, if not the provider's usual one (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY, LLM_API_KEY). */
+    apiKeyEnv: external_exports.string().optional(),
+    /** One model for every step. Without it, non-Claude providers use their own default model. */
+    model: external_exports.string().optional(),
     classifyModel: external_exports.string().default(llmDefaults.classifyModel),
     extractModel: external_exports.string().default(llmDefaults.extractModel),
     actionsModel: external_exports.string().default(llmDefaults.actionsModel),
@@ -67666,6 +67784,15 @@ async function createClaudeAsker(opts = {}) {
     }
   };
 }
+async function askerFor(s, env, f) {
+  const r = resolveLlm(s, env);
+  if (!r) return void 0;
+  if (r.provider === "anthropic") {
+    const claude = await createClaudeAsker({ apiKey: r.apiKey });
+    return { label: r.label, extract: (a) => claude.extract({ ...a, model: r.model(a.model) }) };
+  }
+  return { label: r.label, extract: (a) => extractJson(r, a, f) };
+}
 
 // packages/actions/src/types.ts
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
@@ -68628,7 +68755,7 @@ var edge_worker_default = {
       const { AGENTICWEB_KV, ...vars } = env;
       const store = AGENTICWEB_KV ? new KvStore(AGENTICWEB_KV) : new MemoryStore();
       const engine = graph.actions.some((a) => a.enabled) ? createEngine({ graph, config: config2, env: vars, store }) : void 0;
-      const llm = config2.llm.enabled && vars.ANTHROPIC_API_KEY ? await createClaudeAsker({ apiKey: vars.ANTHROPIC_API_KEY }) : void 0;
+      const llm = await askerFor(config2.llm, vars);
       edge = createEdge(
         {
           graph,

package/dist/runtime/server.mjs

@@ -57879,9 +57879,9 @@ var init_client = __esm({
           }
           return url2.toString();
         }
-        _calculateNonstreamingTimeout(maxTokens) {
+        _calculateNonstreamingTimeout(maxTokens2) {
           const defaultTimeout = 10 * 60;
-          const expectedTimeout = 60 * 60 * maxTokens / 128e3;
+          const expectedTimeout = 60 * 60 * maxTokens2 / 128e3;
           if (expectedTimeout > defaultTimeout) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#streaming-responses for more details");
           }
@@ -58231,11 +58231,11 @@ var init_client = __esm({
           const jitter2 = 1 - Math.random() * 0.25;
           return sleepSeconds * jitter2 * 1e3;
         }
-        calculateNonstreamingTimeout(maxTokens, maxNonstreamingTokens) {
+        calculateNonstreamingTimeout(maxTokens2, maxNonstreamingTokens) {
           const maxTime = 60 * 60 * 1e3;
           const defaultTime = 60 * 10 * 1e3;
-          const expectedTime = maxTime * maxTokens / 128e3;
-          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens > maxNonstreamingTokens) {
+          const expectedTime = maxTime * maxTokens2 / 128e3;
+          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens2 > maxNonstreamingTokens) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#long-requests for more details");
           }
           return defaultTime;
@@ -59398,6 +59398,115 @@ function entityFileName(type) {
   return kebab + "s";
 }
 
+// packages/core/src/llm-providers.ts
+var PROVIDER_IDS = ["anthropic", "openai", "deepseek", "gemini", "openai-compatible"];
+var PROVIDERS = {
+  anthropic: { label: "Claude", apiKeyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", jsonMode: "schema", maxTokensParam: "max_tokens" },
+  openai: { label: "OpenAI", baseUrl: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", defaultModel: "gpt-6.1-sol", jsonMode: "schema", maxTokensParam: "max_completion_tokens" },
+  deepseek: { label: "DeepSeek", baseUrl: "https://api.deepseek.com", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-flash", jsonMode: "object", maxTokensParam: "max_tokens" },
+  gemini: {
+    label: "Gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    apiKeyEnv: "GEMINI_API_KEY",
+    defaultModel: "gemini-3-flash-preview",
+    jsonMode: "schema",
+    maxTokensParam: "max_tokens"
+  },
+  "openai-compatible": { label: "OpenAI-compatible API", apiKeyEnv: "LLM_API_KEY", defaultModel: "", jsonMode: "object", maxTokensParam: "max_tokens" }
+};
+function resolveLlm(s, env2) {
+  if (!s.enabled) return void 0;
+  const info = PROVIDERS[s.provider];
+  const keyEnv = s.apiKeyEnv ?? info.apiKeyEnv;
+  const apiKey = env2[keyEnv] || void 0;
+  if (s.provider === "anthropic") {
+    if (!apiKey && !env2.ANTHROPIC_AUTH_TOKEN && !env2.ANTHROPIC_PROFILE) return void 0;
+  } else if (!apiKey && !(s.provider === "openai-compatible" && s.baseUrl)) {
+    return void 0;
+  }
+  const baseUrl = s.baseUrl ?? info.baseUrl;
+  if (s.provider === "openai-compatible" && !baseUrl) throw new Error('llm.provider is "openai-compatible": set llm.baseUrl, e.g. "http://localhost:11434/v1".');
+  return {
+    provider: s.provider,
+    label: info.label,
+    apiKey,
+    baseUrl,
+    jsonMode: info.jsonMode,
+    maxTokensParam: info.maxTokensParam,
+    model: (configured) => {
+      if (s.model) return s.model;
+      if (s.provider === "anthropic") return configured || info.defaultModel;
+      if (configured && !configured.startsWith("claude-")) return configured;
+      if (!info.defaultModel) throw new Error(`Set llm.model to a model your ${info.label} serves.`);
+      return info.defaultModel;
+    }
+  };
+}
+async function chatCompletion(r, body, f = fetch) {
+  if (!r.baseUrl) throw new Error(`${r.label} has no API address.`);
+  const res = await f(`${r.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...r.apiKey ? { authorization: `Bearer ${r.apiKey}` } : {} },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`${r.label} returned HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  return await res.json();
+}
+var maxTokens = (r, n) => ({ [r.maxTokensParam]: n });
+function jsonSchemaOf(schema) {
+  const clean = (v) => {
+    if (Array.isArray(v)) return v.map(clean);
+    if (!v || typeof v !== "object") return v;
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (k === "$schema") continue;
+      if (k === "type" && Array.isArray(val)) {
+        const types = val.filter((t) => t !== "null");
+        out.type = types[0] ?? "string";
+        if (types.length < val.length) out.nullable = true;
+        continue;
+      }
+      out[k] = clean(val);
+    }
+    return out;
+  };
+  return clean(external_exports.toJSONSchema(schema, { unrepresentable: "any" }));
+}
+var parseJson = (text2) => JSON.parse(text2.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, ""));
+async function extractJson(r, args, f = fetch) {
+  const schemaJson = jsonSchemaOf(args.schema);
+  const system = r.jsonMode === "schema" ? args.system : `${args.system}
+
+Reply with one JSON object only, matching this JSON Schema:
+${JSON.stringify(schemaJson)}`;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: args.content }
+  ];
+  const format = r.jsonMode === "schema" ? { type: "json_schema", json_schema: { name: "result", schema: schemaJson, strict: false } } : { type: "json_object" };
+  let problem = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await chatCompletion(r, { model: r.model(args.model), messages, response_format: format, ...maxTokens(r, args.maxTokens ?? 8e3) }, f);
+    const choice = res.choices[0];
+    if (!choice) throw new Error(`${r.label} returned no answer.`);
+    if (choice.message.refusal || choice.finish_reason === "content_filter") throw new Error(`${r.label} declined to process this content.`);
+    const text2 = choice.message.content ?? "";
+    let value;
+    try {
+      value = parseJson(text2);
+    } catch {
+      problem = "The reply wasn't valid JSON.";
+      messages.push({ role: "assistant", content: text2 }, { role: "user", content: `${problem} Reply with the JSON object only.` });
+      continue;
+    }
+    const parsed = args.schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+    problem = parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    messages.push({ role: "assistant", content: text2 }, { role: "user", content: `That JSON doesn't match the schema (${problem}). Reply with corrected JSON only.` });
+  }
+  throw new Error(`${r.label} didn't return valid data: ${problem}`);
+}
+
 // packages/core/src/config.ts
 var ActionOverride = external_exports.object({
   name: external_exports.string(),
@@ -59414,6 +59523,7 @@ var ActionOverride = external_exports.object({
 var crawlDefaults = { maxPages: 200, include: [], exclude: [], render: "fetch", respectRobots: true, concurrency: 4 };
 var llmDefaults = {
   enabled: true,
+  provider: "anthropic",
   classifyModel: "claude-opus-5-5",
   extractModel: "claude-opus-5-5",
   actionsModel: "claude-opus-5-5",
@@ -59455,6 +59565,14 @@ var ProjectConfig = external_exports.object({
   actions: external_exports.array(ActionOverride).default([]),
   llm: external_exports.object({
     enabled: external_exports.boolean().default(true),
+    /** Which AI to use: Claude (default), OpenAI, DeepSeek, Gemini, or any OpenAI-compatible API (including local ones). */
+    provider: external_exports.enum(PROVIDER_IDS).default("anthropic"),
+    /** API address for "openai-compatible", e.g. http://localhost:11434/v1 for Ollama. */
+    baseUrl: external_exports.string().url().optional(),
+    /** Env var holding the API key, if not the provider's usual one (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY, LLM_API_KEY). */
+    apiKeyEnv: external_exports.string().optional(),
+    /** One model for every step. Without it, non-Claude providers use their own default model. */
+    model: external_exports.string().optional(),
     classifyModel: external_exports.string().default(llmDefaults.classifyModel),
     extractModel: external_exports.string().default(llmDefaults.extractModel),
     actionsModel: external_exports.string().default(llmDefaults.actionsModel),
@@ -67672,6 +67790,15 @@ async function createClaudeAsker(opts = {}) {
     }
   };
 }
+async function askerFor(s, env2, f) {
+  const r = resolveLlm(s, env2);
+  if (!r) return void 0;
+  if (r.provider === "anthropic") {
+    const claude = await createClaudeAsker({ apiKey: r.apiKey });
+    return { label: r.label, extract: (a) => claude.extract({ ...a, model: r.model(a.model) }) };
+  }
+  return { label: r.label, extract: (a) => extractJson(r, a, f) };
+}
 
 // node_modules/@hono/node-server/dist/constants-BLSFu_RU.mjs
 var X_ALREADY_SENT = "x-hono-already-sent";
@@ -69991,7 +70118,7 @@ var env = process.env;
 var graph = SiteGraph.parse(JSON.parse(readFileSync2(path5.join(here, "site-graph.json"), "utf8")));
 var config2 = ProjectConfig.parse(JSON.parse(readFileSync2(path5.join(here, "config.json"), "utf8")));
 var engine = graph.actions.some((a) => a.enabled) ? createEngine({ graph, config: config2, env, store: new FileStore2(path5.join(env.DATA_DIR ?? here, "actions.json")) }) : void 0;
-var llm = config2.llm.enabled && (env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN) ? await createClaudeAsker() : void 0;
+var llm = await askerFor(config2.llm, env);
 var edgeOrigin = env.EDGE_ORIGIN || (env.EDGE_MODE === "1" ? config2.edge.origin : void 0);
 var server = await serveNode({
   graph,

package/dist/runtime/worker.js

@@ -57878,9 +57878,9 @@ var init_client = __esm({
           }
           return url2.toString();
         }
-        _calculateNonstreamingTimeout(maxTokens) {
+        _calculateNonstreamingTimeout(maxTokens2) {
           const defaultTimeout = 10 * 60;
-          const expectedTimeout = 60 * 60 * maxTokens / 128e3;
+          const expectedTimeout = 60 * 60 * maxTokens2 / 128e3;
           if (expectedTimeout > defaultTimeout) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#streaming-responses for more details");
           }
@@ -58230,11 +58230,11 @@ var init_client = __esm({
           const jitter2 = 1 - Math.random() * 0.25;
           return sleepSeconds * jitter2 * 1e3;
         }
-        calculateNonstreamingTimeout(maxTokens, maxNonstreamingTokens) {
+        calculateNonstreamingTimeout(maxTokens2, maxNonstreamingTokens) {
           const maxTime = 60 * 60 * 1e3;
           const defaultTime = 60 * 10 * 1e3;
-          const expectedTime = maxTime * maxTokens / 128e3;
-          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens > maxNonstreamingTokens) {
+          const expectedTime = maxTime * maxTokens2 / 128e3;
+          if (expectedTime > defaultTime || maxNonstreamingTokens != null && maxTokens2 > maxNonstreamingTokens) {
             throw new AnthropicError("Streaming is required for operations that may take longer than 10 minutes. See https://platform.claude.com/docs/en/cli-sdks-libraries/sdks/typescript#long-requests for more details");
           }
           return defaultTime;
@@ -59392,6 +59392,115 @@ function entityFileName(type) {
   return kebab + "s";
 }
 
+// packages/core/src/llm-providers.ts
+var PROVIDER_IDS = ["anthropic", "openai", "deepseek", "gemini", "openai-compatible"];
+var PROVIDERS = {
+  anthropic: { label: "Claude", apiKeyEnv: "ANTHROPIC_API_KEY", defaultModel: "claude-opus-5-5", jsonMode: "schema", maxTokensParam: "max_tokens" },
+  openai: { label: "OpenAI", baseUrl: "https://api.openai.com/v1", apiKeyEnv: "OPENAI_API_KEY", defaultModel: "gpt-6.1-sol", jsonMode: "schema", maxTokensParam: "max_completion_tokens" },
+  deepseek: { label: "DeepSeek", baseUrl: "https://api.deepseek.com", apiKeyEnv: "DEEPSEEK_API_KEY", defaultModel: "deepseek-flash", jsonMode: "object", maxTokensParam: "max_tokens" },
+  gemini: {
+    label: "Gemini",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    apiKeyEnv: "GEMINI_API_KEY",
+    defaultModel: "gemini-3-flash-preview",
+    jsonMode: "schema",
+    maxTokensParam: "max_tokens"
+  },
+  "openai-compatible": { label: "OpenAI-compatible API", apiKeyEnv: "LLM_API_KEY", defaultModel: "", jsonMode: "object", maxTokensParam: "max_tokens" }
+};
+function resolveLlm(s, env) {
+  if (!s.enabled) return void 0;
+  const info = PROVIDERS[s.provider];
+  const keyEnv = s.apiKeyEnv ?? info.apiKeyEnv;
+  const apiKey = env[keyEnv] || void 0;
+  if (s.provider === "anthropic") {
+    if (!apiKey && !env.ANTHROPIC_AUTH_TOKEN && !env.ANTHROPIC_PROFILE) return void 0;
+  } else if (!apiKey && !(s.provider === "openai-compatible" && s.baseUrl)) {
+    return void 0;
+  }
+  const baseUrl = s.baseUrl ?? info.baseUrl;
+  if (s.provider === "openai-compatible" && !baseUrl) throw new Error('llm.provider is "openai-compatible": set llm.baseUrl, e.g. "http://localhost:11434/v1".');
+  return {
+    provider: s.provider,
+    label: info.label,
+    apiKey,
+    baseUrl,
+    jsonMode: info.jsonMode,
+    maxTokensParam: info.maxTokensParam,
+    model: (configured) => {
+      if (s.model) return s.model;
+      if (s.provider === "anthropic") return configured || info.defaultModel;
+      if (configured && !configured.startsWith("claude-")) return configured;
+      if (!info.defaultModel) throw new Error(`Set llm.model to a model your ${info.label} serves.`);
+      return info.defaultModel;
+    }
+  };
+}
+async function chatCompletion(r, body, f = fetch) {
+  if (!r.baseUrl) throw new Error(`${r.label} has no API address.`);
+  const res = await f(`${r.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...r.apiKey ? { authorization: `Bearer ${r.apiKey}` } : {} },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`${r.label} returned HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  return await res.json();
+}
+var maxTokens = (r, n) => ({ [r.maxTokensParam]: n });
+function jsonSchemaOf(schema) {
+  const clean = (v) => {
+    if (Array.isArray(v)) return v.map(clean);
+    if (!v || typeof v !== "object") return v;
+    const out = {};
+    for (const [k, val] of Object.entries(v)) {
+      if (k === "$schema") continue;
+      if (k === "type" && Array.isArray(val)) {
+        const types = val.filter((t) => t !== "null");
+        out.type = types[0] ?? "string";
+        if (types.length < val.length) out.nullable = true;
+        continue;
+      }
+      out[k] = clean(val);
+    }
+    return out;
+  };
+  return clean(external_exports.toJSONSchema(schema, { unrepresentable: "any" }));
+}
+var parseJson = (text2) => JSON.parse(text2.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, ""));
+async function extractJson(r, args, f = fetch) {
+  const schemaJson = jsonSchemaOf(args.schema);
+  const system = r.jsonMode === "schema" ? args.system : `${args.system}
+
+Reply with one JSON object only, matching this JSON Schema:
+${JSON.stringify(schemaJson)}`;
+  const messages = [
+    { role: "system", content: system },
+    { role: "user", content: args.content }
+  ];
+  const format = r.jsonMode === "schema" ? { type: "json_schema", json_schema: { name: "result", schema: schemaJson, strict: false } } : { type: "json_object" };
+  let problem = "";
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const res = await chatCompletion(r, { model: r.model(args.model), messages, response_format: format, ...maxTokens(r, args.maxTokens ?? 8e3) }, f);
+    const choice = res.choices[0];
+    if (!choice) throw new Error(`${r.label} returned no answer.`);
+    if (choice.message.refusal || choice.finish_reason === "content_filter") throw new Error(`${r.label} declined to process this content.`);
+    const text2 = choice.message.content ?? "";
+    let value;
+    try {
+      value = parseJson(text2);
+    } catch {
+      problem = "The reply wasn't valid JSON.";
+      messages.push({ role: "assistant", content: text2 }, { role: "user", content: `${problem} Reply with the JSON object only.` });
+      continue;
+    }
+    const parsed = args.schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+    problem = parsed.error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    messages.push({ role: "assistant", content: text2 }, { role: "user", content: `That JSON doesn't match the schema (${problem}). Reply with corrected JSON only.` });
+  }
+  throw new Error(`${r.label} didn't return valid data: ${problem}`);
+}
+
 // packages/core/src/config.ts
 var ActionOverride = external_exports.object({
   name: external_exports.string(),
@@ -59408,6 +59517,7 @@ var ActionOverride = external_exports.object({
 var crawlDefaults = { maxPages: 200, include: [], exclude: [], render: "fetch", respectRobots: true, concurrency: 4 };
 var llmDefaults = {
   enabled: true,
+  provider: "anthropic",
   classifyModel: "claude-opus-5-5",
   extractModel: "claude-opus-5-5",
   actionsModel: "claude-opus-5-5",
@@ -59449,6 +59559,14 @@ var ProjectConfig = external_exports.object({
   actions: external_exports.array(ActionOverride).default([]),
   llm: external_exports.object({
     enabled: external_exports.boolean().default(true),
+    /** Which AI to use: Claude (default), OpenAI, DeepSeek, Gemini, or any OpenAI-compatible API (including local ones). */
+    provider: external_exports.enum(PROVIDER_IDS).default("anthropic"),
+    /** API address for "openai-compatible", e.g. http://localhost:11434/v1 for Ollama. */
+    baseUrl: external_exports.string().url().optional(),
+    /** Env var holding the API key, if not the provider's usual one (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY, LLM_API_KEY). */
+    apiKeyEnv: external_exports.string().optional(),
+    /** One model for every step. Without it, non-Claude providers use their own default model. */
+    model: external_exports.string().optional(),
     classifyModel: external_exports.string().default(llmDefaults.classifyModel),
     extractModel: external_exports.string().default(llmDefaults.extractModel),
     actionsModel: external_exports.string().default(llmDefaults.actionsModel),
@@ -67461,6 +67579,15 @@ async function createClaudeAsker(opts = {}) {
     }
   };
 }
+async function askerFor(s, env, f) {
+  const r = resolveLlm(s, env);
+  if (!r) return void 0;
+  if (r.provider === "anthropic") {
+    const claude = await createClaudeAsker({ apiKey: r.apiKey });
+    return { label: r.label, extract: (a) => claude.extract({ ...a, model: r.model(a.model) }) };
+  }
+  return { label: r.label, extract: (a) => extractJson(r, a, f) };
+}
 
 // packages/actions/src/types.ts
 var nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
@@ -68423,7 +68550,7 @@ var worker_default = {
       const { AGENTICWEB_KV, ...vars } = env;
       const store = AGENTICWEB_KV ? new KvStore(AGENTICWEB_KV) : new MemoryStore();
       const engine = graph.actions.some((a) => a.enabled) ? createEngine({ graph, config: config2, env: vars, store }) : void 0;
-      const llm = config2.llm.enabled && vars.ANTHROPIC_API_KEY ? await createClaudeAsker({ apiKey: vars.ANTHROPIC_API_KEY }) : void 0;
+      const llm = await askerFor(config2.llm, vars);
       app = createApp({
         graph,
         engine,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticweb-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Turn a website you own into an agent-ready site: llms.txt, schema.org data, an MCP server and safe actions.",
   "keywords": [
     "ai-agents",