omni-pi 0.1.0 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 Omni-Pi: Guided software delivery for everyone.
 
-Omni-Pi is an opinionated Pi package and branded launcher that helps people move from a blank repo to a structured plan, implemented work, and explicit verification without having to assemble the workflow themselves.
+Omni-Pi is an opinionated Pi package and branded launcher published on npm as `omni-pi`. It helps people move from a blank repo to a structured plan, implemented work, and explicit verification without having to assemble the workflow themselves.
 
 Requires Node.js 22 or newer.
 
@@ -19,12 +19,73 @@ Requires Node.js 22 or newer.
 
 ## Quick Start
 
+Install Omni-Pi from npm, then run it in your project:
+
+```bash
+npm install -g omni-pi
+cd your-project
+omni
+```
+
+## Install
+
+Install the published package globally with npm:
+
 ```bash
 npm install -g omni-pi
+```
+
+Confirm the launcher is available:
+
+```bash
+omni --help
+```
+
+Then open any project directory and start Omni-Pi:
+
+```bash
 cd your-project
 omni
 ```
 
+To upgrade later:
+
+```bash
+npm install -g omni-pi@latest
+```
+
+Omni-Pi launches the bundled Pi runtime and loads the Omni-Pi package automatically, so you do not need to manually wire extensions, skills, or prompts after installing from npm.
+
+## Model Providers
+
+Omni-Pi now ships the upstream provider mix needed for practical multi-provider use on top of Pi.
+
+- Built into the underlying Pi runtime: `anthropic`, `openai`, `openai-codex`, `google`, `google-vertex`, `amazon-bedrock`, `azure-openai-responses`, `openrouter`, `xai`, `zai`, `mistral`, `groq`, `cerebras`, `huggingface`, `github-copilot`, `kimi-coding`, `minimax`, `minimax-cn`, `opencode`, `opencode-go`
+- Added by Omni-Pi: `nvidia`, `together`, `synthetic`, `nanogpt`, `xiaomi`, `moonshot`, `venice`, `kilo`, `gitlab-duo`, `qwen-portal`, `qianfan`, `cloudflare-ai-gateway`
+- Auto-discovered when running locally: `ollama`, `lm-studio`, `llama.cpp`, `litellm`, `vllm`
+
+For users who do not want to rely on Anthropic OAuth inside Pi, Omni-Pi also exposes opt-in Claude Agent SDK model aliases:
+
+- `claude-agent/claude-sonnet-4-6`
+- `claude-agent/claude-opus-4-6`
+
+These are intended for Omni-Pi's worker and expert subagents. Configure a role with `/omni-model` and Omni-Pi will run that subagent through the Claude Agent SDK instead of Pi's normal Anthropic provider path.
+
+Common provider env vars:
+
+- `NVIDIA_API_KEY`, `TOGETHER_API_KEY`, `SYNTHETIC_API_KEY`, `NANO_GPT_API_KEY`
+- `XIAOMI_API_KEY`, `MOONSHOT_API_KEY`, `VENICE_API_KEY`, `KILO_API_KEY`
+- `GITLAB_TOKEN`, `QWEN_OAUTH_TOKEN` or `QWEN_PORTAL_API_KEY`, `QIANFAN_API_KEY`
+- `CLOUDFLARE_AI_GATEWAY_API_KEY` and `CLOUDFLARE_AI_GATEWAY_BASE_URL`
+
+For local providers, Omni-Pi registers models only when the endpoint is reachable:
+
+- `OLLAMA_BASE_URL` / `OLLAMA_API_KEY`
+- `LM_STUDIO_BASE_URL` / `LM_STUDIO_API_KEY`
+- `LLAMA_CPP_BASE_URL` / `LLAMA_CPP_API_KEY`
+- `LITELLM_BASE_URL` / `LITELLM_API_KEY`
+- `VLLM_BASE_URL` / `VLLM_API_KEY`
+
 ## Commands
 
 | Command | Description |
@@ -36,7 +97,7 @@ omni
 | `/omni-sync` | Update durable memory files from recent progress |
 | `/omni-skills` | Inspect installed, recommended, deferred, and rejected skills |
 | `/omni-explain` | Explain what Omni-Pi is doing in simple language |
-| `/omni-model` | Interactively select the model for a specific agent role |
+| `/omni-model` | Interactively select the model for a specific agent role, or enter any canonical `provider/model` reference |
 | `/omni-commit` | Create a branch and commit for the last completed task |
 | `/omni-doctor` | Run diagnostic health checks and detect stuck tasks |
 
@@ -46,6 +107,8 @@ Omni-Pi follows a simple agent pipeline: Brain, Planner, Worker, Expert. The Bra
 
 When the Worker gets stuck or verification fails repeatedly, the Expert role steps in to recover the task, adapt the approach, or surface the blocker clearly instead of letting the session stall.
 
+On first use inside a project, Omni-Pi creates and updates `.omni/` state so plans, task progress, verification steps, and recovery context persist across sessions.
+
 ## Features
 
 - Core workflow with durable `.omni/` project memory, typed planning and execution contracts, filesystem-backed init/planning/status, and retry-aware task execution.
@@ -61,7 +124,7 @@ When the Worker gets stuck or verification fails repeatedly, the Expert role ste
 
 ## Development
 
-For contributor setup, see [CONTRIBUTING.md](CONTRIBUTING.md).
+For local checkout development, see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ```bash
 git clone https://github.com/EdGy2k/Omni-Pi.git

package/extensions/omni-providers/index.ts

@@ -0,0 +1,9 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+import { registerOmniProviders } from "../../src/providers.js";
+
+export default async function omniProvidersExtension(
+  api: ExtensionAPI,
+): Promise<void> {
+  await registerOmniProviders(api);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-pi",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Opinionated Pi package for guided, beginner-friendly planning and implementation workflows.",
   "type": "module",
   "license": "MIT",
@@ -56,6 +56,7 @@
     "extensions": [
       "./node_modules/pi-subagents/index.ts",
       "./node_modules/pi-subagents/notify.ts",
+      "./extensions/omni-providers/index.ts",
       "./extensions/omni-core/index.ts",
       "./extensions/omni-memory/index.ts",
       "./extensions/omni-skills/index.ts",
@@ -69,7 +70,9 @@
     ]
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.2.84",
     "@mariozechner/pi-coding-agent": "^0.62.0",
-    "pi-subagents": "^0.11.11"
+    "pi-subagents": "^0.11.11",
+    "zod": "^4.3.6"
   }
 }

package/src/commands.ts

@@ -449,6 +449,7 @@ export function createOmniCommands(): AppCommandDefinition[] {
         const modelOptions = AVAILABLE_MODELS.map((model) =>
           model === currentModel ? `${model} (current)` : model,
         );
+        modelOptions.push("Enter custom provider/model");
 
         const selectedModelDisplay = await ui.select(
           `Select model for ${selectedAgent}:`,
@@ -458,7 +459,18 @@ export function createOmniCommands(): AppCommandDefinition[] {
           return "Model selection cancelled.";
         }
 
-        const selectedModel = selectedModelDisplay.replace(" (current)", "");
+        let selectedModel = selectedModelDisplay.replace(" (current)", "");
+        if (selectedModel === "Enter custom provider/model") {
+          const customModel = await ui.input(
+            "Enter model as provider/model",
+            "e.g., openrouter/anthropic/claude-sonnet-4",
+          );
+          if (!customModel?.includes("/")) {
+            return "Custom model cancelled. Use the canonical provider/model format.";
+          }
+          selectedModel = customModel.trim();
+        }
+
         await updateModelConfig(cwd, selectedAgent, selectedModel);
 
         return `Updated ${selectedAgent} model to ${selectedModel}. Configuration saved to .omni/CONFIG.md`;

package/src/config.ts

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 import type { OmniConfig } from "./contracts.js";
+import { AVAILABLE_MODELS } from "./providers.js";
 
 export const DEFAULT_CONFIG: OmniConfig = {
   models: {
@@ -138,17 +139,4 @@ export async function updateModelConfig(
   return config;
 }
 
-export const AVAILABLE_MODELS = [
-  "anthropic/claude-sonnet-4-6",
-  "anthropic/claude-opus-4-6",
-  "anthropic/claude-sonnet-4-5",
-  "anthropic/claude-opus-4-1",
-  "openai/gpt-5.4",
-  "openai/gpt-5",
-  "openai/gpt-4.1",
-  "openai/gpt-4o",
-  "openai/o3-mini",
-  "openai/o1",
-  "google/gemini-2.5-pro",
-  "google/gemini-2.5-flash",
-];
+export { AVAILABLE_MODELS };

package/src/providers.ts

@@ -0,0 +1,682 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+type ModelApi =
+  | "anthropic-messages"
+  | "openai-completions"
+  | "openai-responses";
+
+interface OmniProviderModel {
+  id: string;
+  name: string;
+  api: ModelApi;
+  reasoning: boolean;
+  input: Array<"text" | "image">;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+}
+
+interface StaticProviderDefinition {
+  name: string;
+  apiKey: string;
+  models: OmniProviderModel[];
+}
+
+interface LocalDiscoveryDefinition {
+  name: string;
+  api: ModelApi;
+  baseUrl: string;
+  apiKeyEnv?: string;
+  discover: () => Promise<OmniProviderModel[]>;
+}
+
+const ZERO_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+} as const;
+
+function model(
+  id: string,
+  name: string,
+  api: ModelApi,
+  reasoning: boolean,
+  input: Array<"text" | "image">,
+  contextWindow: number,
+  maxTokens: number,
+): OmniProviderModel {
+  return {
+    id,
+    name,
+    api,
+    reasoning,
+    input,
+    cost: ZERO_COST,
+    contextWindow,
+    maxTokens,
+  };
+}
+
+const STATIC_PROVIDERS: StaticProviderDefinition[] = [
+  {
+    name: "nvidia",
+    apiKey: "NVIDIA_API_KEY",
+    models: [
+      model(
+        "deepseek-ai/deepseek-v3.2",
+        "DeepSeek V3.2",
+        "openai-completions",
+        true,
+        ["text"],
+        163840,
+        65536,
+      ),
+      model(
+        "deepseek-ai/deepseek-r1-0528",
+        "DeepSeek R1 0528",
+        "openai-completions",
+        true,
+        ["text"],
+        128000,
+        4096,
+      ),
+      model(
+        "meta/llama-3.3-70b-instruct",
+        "Llama 3.3 70B Instruct",
+        "openai-completions",
+        false,
+        ["text"],
+        128000,
+        4096,
+      ),
+    ],
+  },
+  {
+    name: "together",
+    apiKey: "TOGETHER_API_KEY",
+    models: [
+      model(
+        "deepseek-ai/DeepSeek-R1",
+        "DeepSeek R1",
+        "openai-completions",
+        true,
+        ["text"],
+        131072,
+        8192,
+      ),
+      model(
+        "moonshotai/Kimi-K2.5",
+        "Kimi K2.5",
+        "openai-completions",
+        true,
+        ["text", "image"],
+        262144,
+        32768,
+      ),
+      model(
+        "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        "Llama 3.3 70B Instruct Turbo",
+        "openai-completions",
+        false,
+        ["text"],
+        131072,
+        8192,
+      ),
+    ],
+  },
+  {
+    name: "synthetic",
+    apiKey: "SYNTHETIC_API_KEY",
+    models: [
+      model(
+        "hf:deepseek-ai/DeepSeek-V3.2",
+        "DeepSeek V3.2",
+        "openai-completions",
+        false,
+        ["text"],
+        162816,
+        8192,
+      ),
+      model(
+        "hf:moonshotai/Kimi-K2-Instruct-0905",
+        "Kimi K2 Instruct 0905",
+        "openai-completions",
+        false,
+        ["text"],
+        262144,
+        8192,
+      ),
+      model(
+        "hf:meta-llama/Llama-3.3-70B-Instruct",
+        "Llama 3.3 70B Instruct",
+        "openai-completions",
+        false,
+        ["text"],
+        131072,
+        8192,
+      ),
+    ],
+  },
+  {
+    name: "nanogpt",
+    apiKey: "NANO_GPT_API_KEY",
+    models: [
+      model(
+        "anthropic/claude-sonnet-4.6",
+        "Claude Sonnet 4.6",
+        "openai-completions",
+        true,
+        ["text"],
+        222222,
+        8888,
+      ),
+      model(
+        "anthropic/claude-opus-4.6",
+        "Claude Opus 4.6",
+        "openai-completions",
+        true,
+        ["text"],
+        222222,
+        8888,
+      ),
+      model(
+        "baseten/Kimi-K2-Instruct-FP4",
+        "Kimi K2 Instruct FP4",
+        "openai-completions",
+        false,
+        ["text"],
+        222222,
+        8888,
+      ),
+    ],
+  },
+  {
+    name: "xiaomi",
+    apiKey: "XIAOMI_API_KEY",
+    models: [
+      model(
+        "mimo-v2-flash",
+        "MiMo-V2-Flash",
+        "anthropic-messages",
+        true,
+        ["text"],
+        256000,
+        64000,
+      ),
+      model(
+        "mimo-v2-omni",
+        "MiMo-V2-Omni",
+        "anthropic-messages",
+        true,
+        ["text", "image"],
+        256000,
+        128000,
+      ),
+      model(
+        "mimo-v2-pro",
+        "MiMo-V2-Pro",
+        "anthropic-messages",
+        true,
+        ["text"],
+        1000000,
+        128000,
+      ),
+    ],
+  },
+  {
+    name: "moonshot",
+    apiKey: "MOONSHOT_API_KEY",
+    models: [
+      model(
+        "kimi-k2.5",
+        "Kimi K2.5",
+        "openai-completions",
+        true,
+        ["text", "image"],
+        262144,
+        65536,
+      ),
+    ],
+  },
+  {
+    name: "venice",
+    apiKey: "VENICE_API_KEY",
+    models: [
+      model(
+        "claude-sonnet-4-6",
+        "Claude Sonnet 4.6",
+        "openai-completions",
+        true,
+        ["text", "image"],
+        1000000,
+        64000,
+      ),
+      model(
+        "claude-opus-4-6",
+        "Claude Opus 4.6",
+        "openai-completions",
+        true,
+        ["text", "image"],
+        1000000,
+        128000,
+      ),
+      model(
+        "deepseek-v3.2",
+        "DeepSeek V3.2",
+        "openai-completions",
+        true,
+        ["text"],
+        160000,
+        8192,
+      ),
+    ],
+  },
+  {
+    name: "kilo",
+    apiKey: "KILO_API_KEY",
+    models: [
+      model(
+        "anthropic/claude-sonnet-4.6",
+        "Claude Sonnet 4.6",
+        "openai-completions",
+        true,
+        ["text"],
+        222222,
+        8888,
+      ),
+      model(
+        "deepseek/deepseek-r1",
+        "DeepSeek R1",
+        "openai-completions",
+        false,
+        ["text"],
+        222222,
+        8888,
+      ),
+      model(
+        "arcee-ai/coder-large",
+        "Arcee Coder Large",
+        "openai-completions",
+        false,
+        ["text"],
+        222222,
+        8888,
+      ),
+    ],
+  },
+  {
+    name: "gitlab-duo",
+    apiKey: "GITLAB_TOKEN",
+    models: [
+      model(
+        "duo-chat-sonnet-4-6",
+        "Duo Chat Sonnet 4.6",
+        "anthropic-messages",
+        true,
+        ["text", "image"],
+        200000,
+        64000,
+      ),
+      model(
+        "duo-chat-opus-4-6",
+        "Duo Chat Opus 4.6",
+        "anthropic-messages",
+        true,
+        ["text", "image"],
+        200000,
+        64000,
+      ),
+      model(
+        "duo-chat-gpt-5-2-codex",
+        "Duo Chat GPT-5.2 Codex",
+        "openai-responses",
+        true,
+        ["text", "image"],
+        272000,
+        128000,
+      ),
+    ],
+  },
+  {
+    name: "qwen-portal",
+    apiKey: process.env.QWEN_OAUTH_TOKEN
+      ? "QWEN_OAUTH_TOKEN"
+      : "QWEN_PORTAL_API_KEY",
+    models: [
+      model(
+        "coder-model",
+        "Qwen Coder",
+        "openai-completions",
+        false,
+        ["text"],
+        128000,
+        8192,
+      ),
+      model(
+        "vision-model",
+        "Qwen Vision",
+        "openai-completions",
+        false,
+        ["text", "image"],
+        128000,
+        8192,
+      ),
+    ],
+  },
+  {
+    name: "qianfan",
+    apiKey: "QIANFAN_API_KEY",
+    models: [
+      model(
+        "deepseek-v3.2",
+        "DeepSeek V3.2",
+        "openai-completions",
+        false,
+        ["text"],
+        98304,
+        32768,
+      ),
+    ],
+  },
+  {
+    name: "cloudflare-ai-gateway",
+    apiKey: "CLOUDFLARE_AI_GATEWAY_API_KEY",
+    models: [
+      model(
+        "anthropic/claude-sonnet-4-6",
+        "Claude Sonnet 4.6",
+        "anthropic-messages",
+        true,
+        ["text", "image"],
+        200000,
+        64000,
+      ),
+      model(
+        "anthropic/claude-opus-4-6",
+        "Claude Opus 4.6",
+        "anthropic-messages",
+        true,
+        ["text", "image"],
+        200000,
+        32000,
+      ),
+      model(
+        "openai/gpt-5.1",
+        "GPT-5.1",
+        "openai-completions",
+        true,
+        ["text", "image"],
+        400000,
+        128000,
+      ),
+    ].map((entry) => ({
+      ...entry,
+      // Cloudflare requires the Anthropic/OpenAI provider path in the base URL.
+      // The canonical endpoint must be supplied by environment in real usage.
+    })),
+  },
+];
+
+const LOCAL_PROVIDERS: LocalDiscoveryDefinition[] = [
+  {
+    name: "ollama",
+    api: "openai-completions",
+    baseUrl: withV1(process.env.OLLAMA_BASE_URL ?? "http://127.0.0.1:11434"),
+    apiKeyEnv: "OLLAMA_API_KEY",
+    discover: async () => discoverOllamaModels(),
+  },
+  {
+    name: "lm-studio",
+    api: "openai-completions",
+    baseUrl: process.env.LM_STUDIO_BASE_URL ?? "http://127.0.0.1:1234/v1",
+    apiKeyEnv: "LM_STUDIO_API_KEY",
+    discover: async () =>
+      discoverOpenAICompatibleModels(
+        "lm-studio",
+        process.env.LM_STUDIO_BASE_URL ?? "http://127.0.0.1:1234/v1",
+        "openai-completions",
+      ),
+  },
+  {
+    name: "llama.cpp",
+    api: "openai-responses",
+    baseUrl: process.env.LLAMA_CPP_BASE_URL ?? "http://127.0.0.1:8080",
+    apiKeyEnv: "LLAMA_CPP_API_KEY",
+    discover: async () =>
+      discoverOpenAICompatibleModels(
+        "llama.cpp",
+        process.env.LLAMA_CPP_BASE_URL ?? "http://127.0.0.1:8080",
+        "openai-responses",
+      ),
+  },
+  {
+    name: "litellm",
+    api: "openai-completions",
+    baseUrl: process.env.LITELLM_BASE_URL ?? "http://localhost:4000/v1",
+    apiKeyEnv: "LITELLM_API_KEY",
+    discover: async () =>
+      discoverOpenAICompatibleModels(
+        "litellm",
+        process.env.LITELLM_BASE_URL ?? "http://localhost:4000/v1",
+        "openai-completions",
+      ),
+  },
+  {
+    name: "vllm",
+    api: "openai-completions",
+    baseUrl: process.env.VLLM_BASE_URL ?? "http://127.0.0.1:8000/v1",
+    apiKeyEnv: "VLLM_API_KEY",
+    discover: async () =>
+      discoverOpenAICompatibleModels(
+        "vllm",
+        process.env.VLLM_BASE_URL ?? "http://127.0.0.1:8000/v1",
+        "openai-completions",
+      ),
+  },
+];
+
+export const AVAILABLE_MODELS = [
+  "claude-agent/claude-sonnet-4-6",
+  "claude-agent/claude-opus-4-6",
+  "anthropic/claude-sonnet-4-6",
+  "anthropic/claude-opus-4-6",
+  "anthropic/claude-sonnet-4-5",
+  "anthropic/claude-opus-4-1",
+  "openai/gpt-5.4",
+  "openai/gpt-5",
+  "openai/gpt-4.1",
+  "openai/gpt-4o",
+  "openai/o3-mini",
+  "openai/o1",
+  "google/gemini-2.5-pro",
+  "google/gemini-2.5-flash",
+  "amazon-bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0",
+  "azure-openai-responses/gpt-5.2",
+  "openrouter/anthropic/claude-sonnet-4",
+  "xai/grok-code-fast-1",
+  "zai/glm-4.6",
+  "openai-codex/gpt-5-codex",
+  "github-copilot/claude-sonnet-4",
+  "google-vertex/gemini-2.5-pro",
+  "together/moonshotai/Kimi-K2.5",
+  "moonshot/kimi-k2.5",
+  "nvidia/deepseek-ai/deepseek-v3.2",
+  "venice/claude-sonnet-4-6",
+  "qianfan/deepseek-v3.2",
+  "qwen-portal/coder-model",
+  "cloudflare-ai-gateway/anthropic/claude-sonnet-4-6",
+  "gitlab-duo/duo-chat-gpt-5-2-codex",
+  "xiaomi/mimo-v2-pro",
+  "synthetic/hf:deepseek-ai/DeepSeek-V3.2",
+  "nanogpt/anthropic/claude-sonnet-4.6",
+  "kilo/anthropic/claude-sonnet-4.6",
+];
+
+export async function registerOmniProviders(api: ExtensionAPI): Promise<void> {
+  for (const provider of STATIC_PROVIDERS) {
+    const baseUrl =
+      provider.name === "cloudflare-ai-gateway"
+        ? (process.env.CLOUDFLARE_AI_GATEWAY_BASE_URL ??
+          "https://gateway.ai.cloudflare.com/v1/<account>/<gateway>/anthropic")
+        : undefined;
+
+    api.registerProvider(provider.name, {
+      ...(baseUrl ? { baseUrl } : {}),
+      apiKey: provider.apiKey,
+      models: provider.models.map((entry) => ({
+        ...entry,
+        ...(baseUrl ? { baseUrl } : {}),
+      })),
+    });
+  }
+
+  const discovered = await Promise.all(
+    LOCAL_PROVIDERS.map(async (provider) => {
+      const models = await provider.discover();
+      return { provider, models };
+    }),
+  );
+
+  for (const { provider, models } of discovered) {
+    if (models.length === 0) {
+      continue;
+    }
+
+    api.registerProvider(provider.name, {
+      baseUrl: provider.baseUrl,
+      apiKey: provider.apiKeyEnv ?? "omni-local",
+      api: provider.api,
+      models,
+    });
+  }
+}
+
+function withV1(baseUrl: string): string {
+  const trimmed = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return trimmed.endsWith("/v1") ? trimmed : `${trimmed}/v1`;
+}
+
+function withoutV1(baseUrl: string): string {
+  return baseUrl.endsWith("/v1") ? baseUrl.slice(0, -3) : baseUrl;
+}
+
+async function fetchJson(
+  input: string,
+  init?: RequestInit,
+): Promise<unknown | null> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 750);
+
+  try {
+    const response = await fetch(input, {
+      ...init,
+      signal: controller.signal,
+      headers: {
+        Accept: "application/json",
+        ...(init?.headers ?? {}),
+      },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    return await response.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function discoverOllamaModels(): Promise<OmniProviderModel[]> {
+  const baseUrl = withV1(
+    process.env.OLLAMA_BASE_URL ?? "http://127.0.0.1:11434",
+  );
+  const nativeBaseUrl = withoutV1(baseUrl);
+  const payload = (await fetchJson(`${nativeBaseUrl}/api/tags`)) as {
+    models?: Array<{ model?: string; name?: string }>;
+  } | null;
+
+  return (payload?.models ?? [])
+    .map((entry) => {
+      const id = entry.model ?? entry.name;
+      if (!id) {
+        return null;
+      }
+
+      return model(
+        id,
+        entry.name ?? id,
+        "openai-completions",
+        inferReasoning(id),
+        inferInput(id),
+        128000,
+        8192,
+      );
+    })
+    .filter((entry): entry is OmniProviderModel => entry !== null)
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+async function discoverOpenAICompatibleModels(
+  provider: string,
+  baseUrl: string,
+  api: ModelApi,
+): Promise<OmniProviderModel[]> {
+  const normalizedBaseUrl = baseUrl.endsWith("/")
+    ? baseUrl.slice(0, -1)
+    : baseUrl;
+  const headerKey = apiKeyEnvForProvider(provider);
+  const headerValue = headerKey ? process.env[headerKey] : undefined;
+  const payload = (await fetchJson(`${normalizedBaseUrl}/models`, {
+    headers: headerValue
+      ? {
+          Authorization: `Bearer ${headerValue}`,
+        }
+      : undefined,
+  })) as { data?: Array<{ id?: string }> } | Array<{ id?: string }> | null;
+
+  const entries = Array.isArray(payload) ? payload : (payload?.data ?? []);
+
+  return entries
+    .map((entry) => entry.id?.trim())
+    .filter((id): id is string => Boolean(id))
+    .map((id) =>
+      model(id, id, api, inferReasoning(id), inferInput(id), 128000, 8192),
+    )
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function inferReasoning(id: string): boolean {
+  return /(reason|thinking|r1|o1|o3|o4|qwq|gpt-oss|sonnet|opus|kimi-k2\.5)/iu.test(
+    id,
+  );
+}
+
+function inferInput(id: string): Array<"text" | "image"> {
+  return /(vision|vl|omni|llava|gemma-3|mimo-v2-omni)/iu.test(id)
+    ? ["text", "image"]
+    : ["text"];
+}
+
+function apiKeyEnvForProvider(provider: string): string | undefined {
+  switch (provider) {
+    case "lm-studio":
+      return "LM_STUDIO_API_KEY";
+    case "llama.cpp":
+      return "LLAMA_CPP_API_KEY";
+    case "litellm":
+      return "LITELLM_API_KEY";
+    case "vllm":
+      return "VLLM_API_KEY";
+    default:
+      return undefined;
+  }
+}

package/src/subagents.ts

@@ -69,6 +69,54 @@ interface SubagentDeps {
   loadRunsForAgent?: (agent: string) => RunHistoryEntry[];
 }
 
+interface ClaudeAgentTextBlock {
+  type: string;
+  text?: string;
+}
+
+interface ClaudeAgentAssistantMessage {
+  type: "assistant";
+  message?: {
+    content?: ClaudeAgentTextBlock[];
+  };
+}
+
+interface ClaudeAgentResultMessage {
+  type: "result";
+  result?: string;
+  subtype?: string;
+  errors?: string[];
+}
+
+interface ClaudeAgentProgressMessage {
+  type: "tool_progress" | "session_state_changed";
+  title?: string;
+  data?: {
+    toolName?: string;
+    status?: string;
+  };
+}
+
+type ClaudeAgentMessage =
+  | ClaudeAgentAssistantMessage
+  | ClaudeAgentResultMessage
+  | ClaudeAgentProgressMessage
+  | { type: string };
+
+interface ClaudeAgentDeps {
+  query: (input: {
+    prompt: string;
+    options: {
+      cwd: string;
+      model: string;
+      permissionMode: "bypassPermissions";
+      allowDangerouslySkipPermissions: boolean;
+      canUseTool: () => Promise<{ behavior: "allow" }>;
+      env: Record<string, string | undefined>;
+    };
+  }) => AsyncIterable<ClaudeAgentMessage>;
+}
+
 export interface RunHistoryEntry {
   agent: string;
   task: string;
@@ -195,6 +243,13 @@ export async function loadSubagentDeps(
   } as SubagentDeps;
 }
 
+export async function loadClaudeAgentDeps(): Promise<ClaudeAgentDeps> {
+  const sdkModule = await import("@anthropic-ai/claude-agent-sdk");
+  return {
+    query: sdkModule.query,
+  };
+}
+
 export async function loadRunHistory(
   packageDir = omniPackageDir(),
 ): Promise<{ loadRunsForAgent: (agent: string) => RunHistoryEntry[] } | null> {
@@ -711,6 +766,145 @@ function findAgent(
   return fallback;
 }
 
+function getAgentConfig(
+  agents: SubagentConfig[],
+  preferred: string,
+  fallback: string,
+): SubagentConfig | undefined {
+  return (
+    agents.find((agent) => agent.name === preferred) ??
+    agents.find((agent) => agent.name === fallback)
+  );
+}
+
+function isClaudeAgentModel(model: string | undefined): boolean {
+  return model?.startsWith("claude-agent/") ?? false;
+}
+
+function stripClaudeAgentPrefix(model: string): string {
+  return model.replace(/^claude-agent\//u, "");
+}
+
+function isClaudeAgentResultMessage(
+  message: ClaudeAgentMessage,
+): message is ClaudeAgentResultMessage {
+  return message.type === "result";
+}
+
+function isClaudeAgentAssistantMessage(
+  message: ClaudeAgentMessage,
+): message is ClaudeAgentAssistantMessage {
+  return message.type === "assistant";
+}
+
+function isClaudeAgentProgressMessage(
+  message: ClaudeAgentMessage,
+): message is ClaudeAgentProgressMessage {
+  return (
+    message.type === "tool_progress" || message.type === "session_state_changed"
+  );
+}
+
+function extractClaudeAgentRawOutput(messages: ClaudeAgentMessage[]): string {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (
+      isClaudeAgentResultMessage(message) &&
+      typeof message.result === "string" &&
+      message.result.trim().length > 0
+    ) {
+      return message.result;
+    }
+  }
+
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (
+      isClaudeAgentResultMessage(message) &&
+      Array.isArray(message.errors) &&
+      message.errors.length > 0
+    ) {
+      return message.errors.join("\n");
+    }
+  }
+
+  const assistantText = messages
+    .flatMap((message) =>
+      isClaudeAgentAssistantMessage(message)
+        ? (message.message?.content
+            ?.filter(
+              (block): block is ClaudeAgentTextBlock & { text: string } =>
+                typeof block.text === "string" && block.text.trim().length > 0,
+            )
+            .map((block) => block.text) ?? [])
+        : [],
+    )
+    .join("\n\n")
+    .trim();
+
+  return assistantText;
+}
+
+async function runClaudeAgentTask(
+  rootDir: string,
+  ctx: ExtensionCommandContext,
+  claudeDeps: ClaudeAgentDeps,
+  agentName: string,
+  agentModel: string,
+  prompt: string,
+): Promise<SubagentSingleResult> {
+  const messages: ClaudeAgentMessage[] = [];
+
+  try {
+    const query = claudeDeps.query({
+      prompt,
+      options: {
+        cwd: rootDir,
+        model: stripClaudeAgentPrefix(agentModel),
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        canUseTool: async () => ({ behavior: "allow" }),
+        env: {
+          ...process.env,
+          CLAUDE_AGENT_SDK_CLIENT_APP: "omni-pi",
+        },
+      },
+    });
+
+    for await (const message of query) {
+      messages.push(message);
+      if (
+        isClaudeAgentProgressMessage(message) &&
+        message.type === "tool_progress"
+      ) {
+        const toolName = message.data?.toolName ?? message.title ?? "working";
+        ctx.ui.setStatus("omni", `${agentName}: ${toolName}`);
+      } else if (
+        isClaudeAgentProgressMessage(message) &&
+        message.type === "session_state_changed"
+      ) {
+        const status = message.data?.status;
+        if (status) {
+          ctx.ui.setStatus("omni", `${agentName}: ${status}`);
+        }
+      }
+    }
+
+    return {
+      agent: agentName,
+      exitCode: 0,
+      messages,
+    };
+  } catch (error) {
+    return {
+      agent: agentName,
+      exitCode: 1,
+      messages,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
 const AGENT_ROLE_MAP: Record<string, keyof OmniConfig["models"]> = {
   "omni-worker": "worker",
   "omni-expert": "expert",
@@ -740,13 +934,25 @@ export async function createSubagentWorkEngine(
   ctx: ExtensionCommandContext,
   deps?: SubagentDeps,
   verificationExecutor?: VerificationExecutor,
+  claudeDeps?: ClaudeAgentDeps,
 ): Promise<WorkEngine> {
   const subagentDeps = deps ?? (await loadSubagentDeps());
+  const resolvedClaudeDeps = claudeDeps;
   const config = await readConfig(rootDir);
   const discovery = subagentDeps.discoverAgents(rootDir, "both");
   const agentsWithOverrides = applyModelOverrides(discovery.agents, config);
   const workerAgent = findAgent(agentsWithOverrides, "omni-worker", "worker");
   const expertAgent = findAgent(agentsWithOverrides, "omni-expert", "reviewer");
+  const workerAgentConfig = getAgentConfig(
+    agentsWithOverrides,
+    "omni-worker",
+    "worker",
+  );
+  const expertAgentConfig = getAgentConfig(
+    agentsWithOverrides,
+    "omni-expert",
+    "reviewer",
+  );
   const sessionDir = path.join(rootDir, ".omni", "subagent-sessions");
   const packageDir = omniPackageDir();
   const skillTriggers = await loadSkillTriggers(
@@ -768,37 +974,51 @@ export async function createSubagentWorkEngine(
     runWorkerTask: async (task, attempt) => {
       const verificationPlan = await readVerificationPlan(rootDir, task);
       const preReadContext = await gatherTaskContext(rootDir, task, 4000);
+      const workerPrompt = buildWorkerPrompt(
+        task,
+        verificationPlan,
+        getSkillContext(task),
+        preReadContext,
+      );
       ctx.ui.setStatus(
         "omni",
         `Worker ${workerAgent} is handling ${task.id} (attempt ${attempt})`,
       );
       const startTime = Date.now();
-      const result = await subagentDeps.runSync(
-        rootDir,
-        agentsWithOverrides,
-        workerAgent,
-        buildWorkerPrompt(
-          task,
-          verificationPlan,
-          getSkillContext(task),
-          preReadContext,
-        ),
-        {
-          cwd: rootDir,
-          runId: randomUUID(),
-          sessionDir,
-          onUpdate: (update) => {
-            const progress = update.details?.progress?.[0];
-            if (progress) {
-              ctx.ui.setStatus(
-                "omni",
-                `${progress.agent}: ${progress.currentTool ?? "working"}${progress.toolCount ? ` (${progress.toolCount} tools)` : ""}`,
-              );
-            }
-          },
-        },
-      );
-      const raw = subagentDeps.getFinalOutput(result.messages);
+      const result =
+        workerAgentConfig?.model && isClaudeAgentModel(workerAgentConfig.model)
+          ? await runClaudeAgentTask(
+              rootDir,
+              ctx,
+              resolvedClaudeDeps ?? (await loadClaudeAgentDeps()),
+              workerAgent,
+              workerAgentConfig.model,
+              workerPrompt,
+            )
+          : await subagentDeps.runSync(
+              rootDir,
+              agentsWithOverrides,
+              workerAgent,
+              workerPrompt,
+              {
+                cwd: rootDir,
+                runId: randomUUID(),
+                sessionDir,
+                onUpdate: (update) => {
+                  const progress = update.details?.progress?.[0];
+                  if (progress) {
+                    ctx.ui.setStatus(
+                      "omni",
+                      `${progress.agent}: ${progress.currentTool ?? "working"}${progress.toolCount ? ` (${progress.toolCount} tools)` : ""}`,
+                    );
+                  }
+                },
+              },
+            );
+      const raw =
+        workerAgentConfig?.model && isClaudeAgentModel(workerAgentConfig.model)
+          ? extractClaudeAgentRawOutput(result.messages as ClaudeAgentMessage[])
+          : subagentDeps.getFinalOutput(result.messages);
       const rawOutputPath = path.join(
         rootDir,
         ".omni",
@@ -871,34 +1091,48 @@ export async function createSubagentWorkEngine(
         `Escalating ${task.id} to expert after ${escalation.priorAttempts} failed attempts. Failed checks: ${failedChecksSummary}`,
       );
       const preReadContext = await gatherTaskContext(rootDir, task, 6000);
-      const expertStartTime = Date.now();
-      const result = await subagentDeps.runSync(
-        rootDir,
-        agentsWithOverrides,
-        expertAgent,
-        buildExpertPrompt(
-          task,
-          escalation,
-          verificationPlan,
-          getSkillContext(task),
-          preReadContext,
-        ),
-        {
-          cwd: rootDir,
-          runId: randomUUID(),
-          sessionDir,
-          onUpdate: (update) => {
-            const progress = update.details?.progress?.[0];
-            if (progress) {
-              ctx.ui.setStatus(
-                "omni",
-                `${progress.agent}: ${progress.currentTool ?? "resolving"}${progress.toolCount ? ` (${progress.toolCount} tools)` : ""}`,
-              );
-            }
-          },
-        },
+      const expertPrompt = buildExpertPrompt(
+        task,
+        escalation,
+        verificationPlan,
+        getSkillContext(task),
+        preReadContext,
       );
-      const raw = subagentDeps.getFinalOutput(result.messages);
+      const expertStartTime = Date.now();
+      const result =
+        expertAgentConfig?.model && isClaudeAgentModel(expertAgentConfig.model)
+          ? await runClaudeAgentTask(
+              rootDir,
+              ctx,
+              resolvedClaudeDeps ?? (await loadClaudeAgentDeps()),
+              expertAgent,
+              expertAgentConfig.model,
+              expertPrompt,
+            )
+          : await subagentDeps.runSync(
+              rootDir,
+              agentsWithOverrides,
+              expertAgent,
+              expertPrompt,
+              {
+                cwd: rootDir,
+                runId: randomUUID(),
+                sessionDir,
+                onUpdate: (update) => {
+                  const progress = update.details?.progress?.[0];
+                  if (progress) {
+                    ctx.ui.setStatus(
+                      "omni",
+                      `${progress.agent}: ${progress.currentTool ?? "resolving"}${progress.toolCount ? ` (${progress.toolCount} tools)` : ""}`,
+                    );
+                  }
+                },
+              },
+            );
+      const raw =
+        expertAgentConfig?.model && isClaudeAgentModel(expertAgentConfig.model)
+          ? extractClaudeAgentRawOutput(result.messages as ClaudeAgentMessage[])
+          : subagentDeps.getFinalOutput(result.messages);
       const rawOutputPath = path.join(
         rootDir,
         ".omni",