@pi-vault/pi-custom-providers 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lanh Hoang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# @pi-vault/pi-custom-providers
+
+A [Pi](https://pi.dev) custom provider package for adding third-party model providers to Pi.
+
+> **Disclaimer:** This is an unofficial, community-maintained package. Individual providers included here may be backed by third-party services that are not affiliated with this package.
+
+> **Note:** This package only provides model providers. It does **not** include provider API keys or subscriptions.
+
+## Providers
+
+Current providers included in this package:
+
+- Command Code
+
+More providers can be added over time without changing the package structure Pi installs.
+
+## Models
+
+Available models change over time. See the official Command Code model list:
+
+- [Command Code Supported Models](https://commandcode.ai/docs/resources/pricing-limits#models)
+
+## Install
+
+```sh
+pi install npm:@pi-vault/pi-custom-providers
+```
+
+Then reload Pi:
+
+```txt
+/reload
+```
+
+## Setup
+
+Set up the provider you want to use in Pi.
+
+For Command Code, use one of these methods:
+
+### 1. Pi login (recommended)
+
+In Pi, run:
+
+```txt
+/login
+```
+
+Then select **Command Code** from the provider list.
+
+### 2. Environment variable
+
+```sh
+export COMMAND_CODE_API_KEY="user_..."
+```
+
+Legacy compatibility:
+
+```sh
+export COMMANDCODE_API_KEY="user_..."
+```
+
+### 3. Auth file
+
+Create `~/.commandcode/auth.json`:
+
+```json
+{
+  "apiKey": "user_..."
+}
+```
+
+Or use Pi's auth file at `~/.pi/agent/auth.json`:
+
+```json
+{
+  "commandcode": "user_..."
+}
+```
+
+## Usage
+
+After installing and setting up a provider, select one of its models in Pi.
+
+For Command Code, an example is:
+
+```txt
+/model deepseek/deepseek-v4-flash
+```
+
+Any query will then use the Command Code API.
+
+You can list available models in Pi:
+
+```txt
+/models
+```
+
+## Publish
+
+```sh
+npm login
+npm publish --access public
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@pi-vault/pi-custom-providers",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Pi extension that enables custom providers for Pi",
+  "author": "Lanh Hoang <lanhhoang@users.noreply.github.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/pi-vault/pi-custom-providers#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pi-vault/pi-custom-providers.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pi-vault/pi-custom-providers/issues"
+  },
+  "keywords": [
+    "pi",
+    "pi-package",
+    "pi-extension",
+    "pi-custom-providers",
+    "pi-providers"
+  ],
+  "scripts": {
+    "format": "biome format --write .",
+    "lint": "biome lint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run --exclude tests/**/*.smoke.test.ts",
+    "test:smoke": "vitest --run tests/command-code.smoke.test.ts",
+    "check": "biome lint . && tsc --noEmit && vitest --run --exclude tests/**/*.smoke.test.ts",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "@earendil-works/pi-ai": "^0.75.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.15",
+    "@earendil-works/pi-coding-agent": "^0.75.5",
+    "@types/node": "^25.9.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerProviders } from "./providers/index.js";
+
+export default async function customProvidersExtension(pi: ExtensionAPI) {
+  console.log("custom-providers extension loaded");
+
+  await registerProviders(pi);
+}

package/src/providers/command-code/auth.ts

@@ -0,0 +1,133 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import {
+  COMMAND_CODE_API_KEY_ENV,
+  LEGACY_COMMAND_CODE_API_KEY_ENV,
+} from "./constants.js";
+
+type Deps = {
+  getEnv?: (name: string) => string | undefined;
+  getHomeDir?: () => string;
+  readFileUtf8?: (path: string) => Promise<string>;
+};
+
+function normalizeApiKey(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function parseJsonObject(value: string): Record<string, unknown> | undefined {
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (
+      typeof parsed === "object" &&
+      parsed !== null &&
+      !Array.isArray(parsed)
+    ) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+async function readJsonObjectFile(
+  path: string,
+  readFileUtf8: (path: string) => Promise<string>,
+): Promise<Record<string, unknown> | undefined> {
+  try {
+    const content = await readFileUtf8(path);
+    return parseJsonObject(content);
+  } catch {
+    return undefined;
+  }
+}
+
+async function readLegacyCommandCodeAuthFile(
+  home: string,
+  readFileUtf8: (path: string) => Promise<string>,
+): Promise<string | undefined> {
+  const doc = await readJsonObjectFile(
+    join(home, ".commandcode", "auth.json"),
+    readFileUtf8,
+  );
+  return normalizeApiKey(doc?.apiKey);
+}
+
+async function readLegacyPiAgentAuthFile(
+  home: string,
+  readFileUtf8: (path: string) => Promise<string>,
+): Promise<string | undefined> {
+  const doc = await readJsonObjectFile(
+    join(home, ".pi", "agent", "auth.json"),
+    readFileUtf8,
+  );
+  if (!doc) {
+    return undefined;
+  }
+
+  const direct = normalizeApiKey(doc.commandcode);
+  if (direct) {
+    return direct;
+  }
+
+  const cc = doc.commandcode;
+  if (typeof cc === "object" && cc !== null && !Array.isArray(cc)) {
+    return normalizeApiKey((cc as Record<string, unknown>).access);
+  }
+
+  return undefined;
+}
+
+export async function resolveCommandCodeApiKey(
+  resolvedApiKey: string | undefined,
+  deps?: Deps,
+): Promise<string | undefined> {
+  const getEnv = deps?.getEnv ?? ((name: string) => process.env[name]);
+  const getHomeDir = deps?.getHomeDir ?? homedir;
+  const readFileUtf8 =
+    deps?.readFileUtf8 ?? ((path: string) => readFile(path, "utf8"));
+
+  const fromOptions = normalizeApiKey(resolvedApiKey);
+  if (fromOptions) {
+    return fromOptions;
+  }
+
+  const fromPreferredEnv = normalizeApiKey(getEnv(COMMAND_CODE_API_KEY_ENV));
+  if (fromPreferredEnv) {
+    return fromPreferredEnv;
+  }
+
+  const fromLegacyEnv = normalizeApiKey(
+    getEnv(LEGACY_COMMAND_CODE_API_KEY_ENV),
+  );
+  if (fromLegacyEnv) {
+    return fromLegacyEnv;
+  }
+
+  const home = getHomeDir();
+
+  const fromLegacyCommandCodeFile = await readLegacyCommandCodeAuthFile(
+    home,
+    readFileUtf8,
+  );
+  if (fromLegacyCommandCodeFile) {
+    return fromLegacyCommandCodeFile;
+  }
+
+  const fromLegacyPiAgentFile = await readLegacyPiAgentAuthFile(
+    home,
+    readFileUtf8,
+  );
+  if (fromLegacyPiAgentFile) {
+    return fromLegacyPiAgentFile;
+  }
+
+  return undefined;
+}

package/src/providers/command-code/constants.ts

@@ -0,0 +1,13 @@
+export const COMMAND_CODE_PROVIDER_ID = "command-code";
+export const COMMAND_CODE_PROVIDER_NAME = "Command Code";
+export const COMMAND_CODE_API_KEY_ENV = "COMMAND_CODE_API_KEY";
+export const LEGACY_COMMAND_CODE_API_KEY_ENV = "COMMANDCODE_API_KEY";
+
+export const COMMAND_CODE_API_ID = "commandcode-custom";
+export const COMMAND_CODE_BASE_URL = "https://api.commandcode.ai";
+export const COMMAND_CODE_CLI_VERSION = "0.26.25";
+export const COMMAND_CODE_GENERATE_PATH = "/alpha/generate";
+export const COMMAND_CODE_MAX_REQUEST_MAX_TOKENS = 200_000;
+// Live catalog endpoint used to refresh model name/context window on startup.
+export const COMMAND_CODE_MODELS_ENDPOINT =
+  "https://api.commandcode.ai/provider/v1/models";

package/src/providers/command-code/index.ts

@@ -0,0 +1,3 @@
+export {
+  registerCommandCodeProvider,
+} from "./register.js";

package/src/providers/command-code/models.ts

@@ -0,0 +1,244 @@
+import { COMMAND_CODE_MODELS_ENDPOINT } from "./constants.js";
+import type { LiveModelsResponse, ProviderModel } from "../shared/types.js";
+
+const MODEL_METADATA: Record<
+  string,
+  Pick<ProviderModel, "reasoning" | "maxTokens" | "cost">
+> = {
+  "claude-sonnet-4-6": {
+    reasoning: true,
+    maxTokens: 64000,
+    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  },
+  "claude-opus-4-7": {
+    reasoning: true,
+    maxTokens: 64000,
+    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  },
+  "claude-haiku-4-5-20251001": {
+    reasoning: true,
+    maxTokens: 64000,
+    cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  },
+  "gpt-5.5": {
+    reasoning: true,
+    maxTokens: 128000,
+    cost: { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 },
+  },
+  "gpt-5.4": {
+    reasoning: true,
+    maxTokens: 128000,
+    cost: { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
+  },
+  "gpt-5.3-codex": {
+    reasoning: true,
+    maxTokens: 65536,
+    cost: { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
+  },
+  "gpt-5.4-mini": {
+    reasoning: true,
+    maxTokens: 65536,
+    cost: { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
+  },
+  "moonshotai/Kimi-K2.6": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 },
+  },
+  "moonshotai/Kimi-K2.5": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
+  },
+  "zai-org/GLM-5.1": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
+  },
+  "zai-org/GLM-5": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 1, output: 3.2, cacheRead: 0.2, cacheWrite: 0 },
+  },
+  "MiniMaxAI/MiniMax-M2.7": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
+  },
+  "MiniMaxAI/MiniMax-M2.5": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.27, output: 0.95, cacheRead: 0.03, cacheWrite: 0 },
+  },
+  "deepseek/deepseek-v4-pro": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.435, output: 0.87, cacheRead: 0.003625, cacheWrite: 0 },
+  },
+  "deepseek/deepseek-v4-flash": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.14, output: 0.28, cacheRead: 0.01, cacheWrite: 0 },
+  },
+  "Qwen/Qwen3.6-Max-Preview": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 1.3, output: 7.8, cacheRead: 0.26, cacheWrite: 1.63 },
+  },
+  "Qwen/Qwen3.6-Plus": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.5, output: 3, cacheRead: 0.1, cacheWrite: 0 },
+  },
+  "Qwen/Qwen3.7-Max": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 1.25, output: 3.75, cacheRead: 0.25, cacheWrite: 1.56 },
+  },
+  "stepfun/Step-3.5-Flash": {
+    reasoning: true,
+    maxTokens: 32768,
+    cost: { input: 0.1, output: 0.3, cacheRead: 0.02, cacheWrite: 0 },
+  },
+  "google/gemini-3.5-flash": {
+    reasoning: true,
+    maxTokens: 65536,
+    cost: { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 },
+  },
+  "google/gemini-3.1-flash-lite": {
+    reasoning: false,
+    maxTokens: 8192,
+    cost: { input: 0.25, output: 1.5, cacheRead: 0.03, cacheWrite: 0 },
+  },
+};
+
+function makeModel(id: string, name: string, contextWindow: number): ProviderModel {
+  const metadata = MODEL_METADATA[id] ?? {
+    reasoning: false,
+    maxTokens: 8192,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+  };
+
+  return {
+    id,
+    name,
+    reasoning: metadata.reasoning,
+    input: ["text"],
+    cost: metadata.cost,
+    contextWindow,
+    maxTokens: metadata.maxTokens,
+    compat: {
+      supportsUsageInStreaming: true,
+    },
+  };
+}
+
+export const COMMAND_CODE_MODELS: ProviderModel[] = [
+  makeModel("claude-sonnet-4-6", "Claude Sonnet 4.6", 1000000),
+  makeModel("claude-opus-4-7", "Claude Opus 4.7", 1000000),
+  makeModel("claude-haiku-4-5-20251001", "Claude Haiku 4.5", 200000),
+  makeModel("gpt-5.5", "GPT-5.5", 200000),
+  makeModel("gpt-5.4", "GPT-5.4", 400000),
+  makeModel("gpt-5.3-codex", "GPT-5.3 Codex", 400000),
+  makeModel("gpt-5.4-mini", "GPT-5.4 Mini", 400000),
+  makeModel("moonshotai/Kimi-K2.6", "Kimi K2.6", 256000),
+  makeModel("moonshotai/Kimi-K2.5", "Kimi K2.5", 256000),
+  makeModel("zai-org/GLM-5.1", "GLM-5.1", 200000),
+  makeModel("zai-org/GLM-5", "GLM-5", 200000),
+  makeModel("MiniMaxAI/MiniMax-M2.7", "MiniMax M2.7", 200000),
+  makeModel("MiniMaxAI/MiniMax-M2.5", "MiniMax M2.5", 200000),
+  makeModel("deepseek/deepseek-v4-pro", "DeepSeek V4 Pro", 1000000),
+  makeModel("deepseek/deepseek-v4-flash", "DeepSeek V4 Flash", 1000000),
+  makeModel("Qwen/Qwen3.6-Max-Preview", "Qwen 3.6 Max Preview", 200000),
+  makeModel("Qwen/Qwen3.6-Plus", "Qwen 3.6 Plus", 200000),
+  makeModel("Qwen/Qwen3.7-Max", "Qwen 3.7 Max", 1000000),
+  makeModel("stepfun/Step-3.5-Flash", "Step 3.5 Flash", 1000000),
+  makeModel("google/gemini-3.5-flash", "Gemini 3.5 Flash", 1000000),
+  makeModel("google/gemini-3.1-flash-lite", "Gemini 3.1 Flash Lite", 1000000),
+];
+
+// Manual catalog refresh helper. Phase 6 runtime registration must not depend on this.
+export async function fetchCommandCodeModels(
+  fetchImpl: typeof fetch = fetch,
+): Promise<LiveModelsResponse | null> {
+  try {
+    const response = await fetchImpl(COMMAND_CODE_MODELS_ENDPOINT, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    return (await response.json()) as LiveModelsResponse;
+  } catch {
+    return null;
+  }
+}
+
+export function mergeLiveCommandCodeModels(
+  bakedModels: ProviderModel[],
+  live: LiveModelsResponse,
+): ProviderModel[] {
+  if (!Array.isArray(live.data) || live.data.length === 0) {
+    return bakedModels;
+  }
+
+  const bakedById = new Map(bakedModels.map((model) => [model.id, model]));
+  const merged: ProviderModel[] = [];
+
+  for (const entry of live.data) {
+    if (!entry?.id) {
+      continue;
+    }
+
+    const baked = bakedById.get(entry.id);
+    if (baked) {
+      merged.push({
+        ...baked,
+        name: typeof entry.name === "string" ? entry.name : baked.name,
+        contextWindow:
+          typeof entry.context_length === "number" && Number.isFinite(entry.context_length)
+            ? entry.context_length
+            : baked.contextWindow,
+      });
+      continue;
+    }
+
+    merged.push(
+      makeModel(
+        entry.id,
+        typeof entry.name === "string" ? entry.name : entry.id,
+        typeof entry.context_length === "number" && Number.isFinite(entry.context_length)
+          ? entry.context_length
+          : 8192,
+      ),
+    );
+  }
+
+  return merged.length > 0 ? merged : bakedModels;
+}
+
+export async function resolveRuntimeCommandCodeModels(
+  fetchImpl: typeof fetch = fetch,
+  bakedModels: ProviderModel[] = COMMAND_CODE_MODELS,
+): Promise<ProviderModel[]> {
+  const liveModels = await fetchCommandCodeModels(fetchImpl);
+  return liveModels ? mergeLiveCommandCodeModels(bakedModels, liveModels) : bakedModels;
+}
+
+export async function fetchMergedCommandCodeModels(
+  fetchImpl: typeof fetch = fetch,
+  bakedModels: ProviderModel[] = COMMAND_CODE_MODELS,
+): Promise<ProviderModel[]> {
+  const liveModels = await fetchCommandCodeModels(fetchImpl);
+  return liveModels ? mergeLiveCommandCodeModels(bakedModels, liveModels) : bakedModels;
+}

package/src/providers/command-code/register.ts

@@ -0,0 +1,27 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  COMMAND_CODE_API_ID,
+  COMMAND_CODE_API_KEY_ENV,
+  COMMAND_CODE_BASE_URL,
+  COMMAND_CODE_PROVIDER_ID,
+  COMMAND_CODE_PROVIDER_NAME,
+} from "./constants.js";
+import { COMMAND_CODE_MODELS, resolveRuntimeCommandCodeModels } from "./models.js";
+import { streamCommandCode } from "./stream.js";
+
+export async function registerCommandCodeProvider(
+  pi: ExtensionAPI,
+  deps?: { fetchImpl?: typeof fetch },
+): Promise<void> {
+  const models = await resolveRuntimeCommandCodeModels(deps?.fetchImpl, COMMAND_CODE_MODELS);
+
+  pi.registerProvider(COMMAND_CODE_PROVIDER_ID, {
+    name: COMMAND_CODE_PROVIDER_NAME,
+    apiKey: COMMAND_CODE_API_KEY_ENV,
+    api: COMMAND_CODE_API_ID,
+    authHeader: true,
+    baseUrl: COMMAND_CODE_BASE_URL,
+    streamSimple: streamCommandCode,
+    models,
+  });
+}

package/src/providers/command-code/stream.ts

@@ -0,0 +1,582 @@
+import {
+  calculateCost,
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type Context,
+  type Model,
+  type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resolveCommandCodeApiKey } from "./auth.js";
+import {
+  COMMAND_CODE_CLI_VERSION,
+  COMMAND_CODE_GENERATE_PATH,
+  COMMAND_CODE_MAX_REQUEST_MAX_TOKENS,
+} from "./constants.js";
+
+type StreamSimple = NonNullable<
+  Parameters<ExtensionAPI["registerProvider"]>[1]["streamSimple"]
+>;
+type StreamResult = ReturnType<StreamSimple>;
+
+type CommandCodeMessage = {
+  role: "user" | "assistant" | "tool";
+  content: unknown;
+};
+
+type CommandCodeTool = {
+  type: "function";
+  name: string;
+  description: string;
+  input_schema: Record<string, unknown>;
+};
+
+type CommandCodeFinish = {
+  finishReason?: string;
+  totalUsage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    inputTokenDetails?: {
+      cacheReadTokens?: number;
+      cacheWriteTokens?: number;
+    };
+  };
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function booleanValue(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function recordArray(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+
+function recordOrEmpty(value: unknown): Record<string, unknown> {
+  if (isRecord(value)) {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+    } catch {
+      return {};
+    }
+  }
+
+  return {};
+}
+
+function textContent(message: { content?: unknown }): string {
+  return recordArray(message.content)
+    .filter((part) => part.type === "text")
+    .map((part) => stringValue(part.text) ?? "")
+    .join("\n");
+}
+
+function getEnvironmentInfo(): string {
+  return `${process.platform}-${process.arch}, Node.js ${process.version}`;
+}
+
+function toJsonSchema(schema: unknown): unknown {
+  if (!isRecord(schema)) {
+    return {};
+  }
+
+  const kind = stringValue(schema.kind) ?? stringValue(schema.type);
+  const enumValues = Array.isArray(schema.enum) ? schema.enum : undefined;
+  if (enumValues) {
+    return { type: typeof enumValues[0], enum: enumValues };
+  }
+
+  switch (kind) {
+    case "string":
+    case "String":
+      return { type: "string" };
+    case "number":
+    case "Number":
+      return { type: "number" };
+    case "boolean":
+    case "Boolean":
+      return { type: "boolean" };
+    case "object":
+    case "Object": {
+      const properties: Record<string, unknown> = {};
+      const inferredRequired: string[] = [];
+      const sourceProperties = isRecord(schema.properties) ? schema.properties : undefined;
+      const optional = Array.isArray(schema.optional)
+        ? schema.optional.filter((item): item is string => typeof item === "string")
+        : [];
+
+      if (sourceProperties) {
+        for (const [key, value] of Object.entries(sourceProperties)) {
+          properties[key] = toJsonSchema(value);
+          const valueRecord = isRecord(value) ? value : undefined;
+          if (booleanValue(valueRecord?.optional) !== true && !optional.includes(key)) {
+            inferredRequired.push(key);
+          }
+        }
+      }
+
+      const explicitRequired = Array.isArray(schema.required)
+        ? schema.required.filter((item): item is string => typeof item === "string")
+        : undefined;
+      const required = explicitRequired ?? inferredRequired;
+      const out: Record<string, unknown> = { type: "object" };
+      if (Object.keys(properties).length > 0) {
+        out.properties = properties;
+      }
+      if (required.length > 0) {
+        out.required = required;
+      }
+      return out;
+    }
+    case "array":
+    case "Array":
+      return {
+        type: "array",
+        items: toJsonSchema(schema.items ?? schema.element),
+      };
+    case "union":
+    case "Union": {
+      const variants = Array.isArray(schema.variants)
+        ? schema.variants
+        : Array.isArray(schema.anyOf)
+          ? schema.anyOf
+          : [];
+      for (const variant of variants) {
+        const converted = toJsonSchema(variant);
+        if (isRecord(converted) && Object.keys(converted).length > 0) {
+          return converted;
+        }
+      }
+      return {};
+    }
+    case "optional":
+    case "Optional":
+      return toJsonSchema(schema.wrapped ?? schema.inner);
+    default:
+      return {};
+  }
+}
+
+function parseStreamEventLine(line: string): Record<string, unknown> | undefined {
+  let trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith(":") || trimmed.startsWith("event:")) {
+    return undefined;
+  }
+
+  if (trimmed.startsWith("data:")) {
+    trimmed = trimmed.slice(5).trim();
+  }
+
+  if (!trimmed || trimmed === "[DONE]") {
+    return undefined;
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    return isRecord(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function convertCommandCodeMessages(context: Context): CommandCodeMessage[] {
+  const completedToolCalls = new Set(
+    context.messages
+      .filter(
+        (message): message is Extract<Context["messages"][number], { role: "toolResult" }> =>
+          message.role === "toolResult",
+      )
+      .map((message) => message.toolCallId),
+  );
+
+  const converted: CommandCodeMessage[] = [];
+
+  for (const message of context.messages) {
+    if (message.role === "user") {
+      converted.push({
+        role: "user",
+        content: typeof message.content === "string" ? message.content : message.content,
+      });
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      const content: Array<Record<string, unknown>> = [];
+
+      for (const block of message.content) {
+        if (block.type === "text") {
+          content.push({ type: "text", text: block.text });
+        } else if (block.type === "thinking") {
+          content.push({ type: "reasoning", text: block.thinking });
+        } else if (block.type === "toolCall" && completedToolCalls.has(block.id)) {
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: recordOrEmpty(block.arguments),
+          });
+        }
+      }
+
+      if (content.length > 0) {
+        converted.push({ role: "assistant", content });
+      }
+      continue;
+    }
+
+    if (!completedToolCalls.has(message.toolCallId)) {
+      continue;
+    }
+
+    converted.push({
+      role: "tool",
+      content: [
+        {
+          type: "tool-result",
+          toolCallId: message.toolCallId,
+          toolName: message.toolName,
+          output: message.isError
+            ? { type: "error-text", value: textContent(message) }
+            : { type: "text", value: textContent(message) },
+        },
+      ],
+    });
+  }
+
+  return converted;
+}
+
+export function convertCommandCodeTools(context: Context): CommandCodeTool[] {
+  return (context.tools ?? []).map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.parameters
+      ? (toJsonSchema(tool.parameters) as Record<string, unknown>)
+      : {},
+  }));
+}
+
+export function buildCommandCodeRequestBody(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+) {
+  const maxTokens = Math.min(
+    options?.maxTokens ?? model.maxTokens,
+    COMMAND_CODE_MAX_REQUEST_MAX_TOKENS,
+  );
+  return {
+    config: {
+      workingDir: process.cwd(),
+      date: new Date().toISOString().slice(0, 10),
+      environment: getEnvironmentInfo(),
+      structure: [],
+      isGitRepo: false,
+      currentBranch: "",
+      mainBranch: "",
+      gitStatus: "",
+      recentCommits: [],
+    },
+    memory: "",
+    taste: "",
+    skills: null,
+    permissionMode: "standard",
+    params: {
+      model: model.id,
+      messages: convertCommandCodeMessages(context),
+      tools: convertCommandCodeTools(context),
+      system: context.systemPrompt ?? "",
+      max_tokens: maxTokens,
+      stream: true,
+    },
+  };
+}
+
+function mapFinishReason(reason?: string): "stop" | "length" | "toolUse" {
+  if (
+    reason === "max_tokens" ||
+    reason === "max_output_tokens" ||
+    reason === "max-tokens" ||
+    reason === "length"
+  ) {
+    return "length";
+  }
+  if (reason === "tool-calls") {
+    return "toolUse";
+  }
+  return "stop";
+}
+
+export function streamCommandCode(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+) : StreamResult {
+  const stream = createAssistantMessageEventStream();
+
+  (async () => {
+    const output: AssistantMessage = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+
+    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    let finished = false;
+
+    try {
+      const apiKey = await resolveCommandCodeApiKey(options?.apiKey);
+      if (!apiKey) {
+        throw new Error(
+          "Missing Command Code API key. Save one via /login or set COMMAND_CODE_API_KEY.",
+        );
+      }
+
+      const requestBody = buildCommandCodeRequestBody(model, context, options);
+      const sessionId = crypto.randomUUID();
+      const response = await fetch(`${model.baseUrl}${COMMAND_CODE_GENERATE_PATH}`, {
+        method: "POST",
+        signal: options?.signal,
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${apiKey}`,
+          "x-command-code-version": COMMAND_CODE_CLI_VERSION,
+          "x-cli-environment": "production",
+          "x-project-slug": "pi-cc",
+          "x-taste-learning": "false",
+          "x-co-flag": "false",
+          "x-session-id": sessionId,
+        },
+        body: JSON.stringify(requestBody),
+      });
+
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Command Code API error (${response.status}): ${body || response.statusText}`);
+      }
+
+      if (!response.body) {
+        throw new Error("Command Code API error: empty response body");
+      }
+
+      stream.push({ type: "start", partial: output });
+
+      reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let textIndex: number | null = null;
+      let thinkingIndex: number | null = null;
+
+      const ensureText = () => {
+        if (textIndex !== null) {
+          return textIndex;
+        }
+        output.content.push({ type: "text", text: "" });
+        textIndex = output.content.length - 1;
+        stream.push({ type: "text_start", contentIndex: textIndex, partial: output });
+        return textIndex;
+      };
+
+      const ensureThinking = () => {
+        if (thinkingIndex !== null) {
+          return thinkingIndex;
+        }
+        output.content.push({ type: "thinking", thinking: "" });
+        thinkingIndex = output.content.length - 1;
+        stream.push({ type: "thinking_start", contentIndex: thinkingIndex, partial: output });
+        return thinkingIndex;
+      };
+
+      const closeThinking = () => {
+        if (thinkingIndex === null) {
+          return;
+        }
+        const block = output.content[thinkingIndex];
+        if (block?.type === "thinking") {
+          stream.push({
+            type: "thinking_end",
+            contentIndex: thinkingIndex,
+            content: block.thinking,
+            partial: output,
+          });
+        }
+        thinkingIndex = null;
+      };
+
+      const applyFinish = (finish: CommandCodeFinish | undefined) => {
+        output.stopReason = mapFinishReason(finish?.finishReason);
+        output.usage.input = finish?.totalUsage?.inputTokens ?? 0;
+        output.usage.output = finish?.totalUsage?.outputTokens ?? 0;
+        output.usage.cacheRead = finish?.totalUsage?.inputTokenDetails?.cacheReadTokens ?? 0;
+        output.usage.cacheWrite = finish?.totalUsage?.inputTokenDetails?.cacheWriteTokens ?? 0;
+        output.usage.totalTokens =
+          output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+        calculateCost(model, output.usage);
+      };
+
+      const processLine = (line: string) => {
+        const parsed = parseStreamEventLine(line);
+        if (!parsed) {
+          return;
+        }
+
+        const type = parsed.type;
+        if (type === "text-delta" && typeof parsed.text === "string") {
+          const index = ensureText();
+          const block = output.content[index];
+          if (block?.type === "text") {
+            block.text += parsed.text;
+            stream.push({ type: "text_delta", contentIndex: index, delta: parsed.text, partial: output });
+          }
+          return;
+        }
+
+        if (type === "reasoning-delta" && typeof parsed.text === "string") {
+          const index = ensureThinking();
+          const block = output.content[index];
+          if (block?.type === "thinking") {
+            block.thinking += parsed.text;
+            stream.push({
+              type: "thinking_delta",
+              contentIndex: index,
+              delta: parsed.text,
+              partial: output,
+            });
+          }
+          return;
+        }
+
+        if (type === "reasoning-end") {
+          closeThinking();
+          return;
+        }
+
+        if (type === "tool-call") {
+          const toolCallId =
+            typeof parsed.toolCallId === "string" ? parsed.toolCallId : crypto.randomUUID();
+          const toolName = typeof parsed.toolName === "string" ? parsed.toolName : "unknown";
+          const argumentsObject = recordOrEmpty(parsed.input);
+
+          output.content.push({
+            type: "toolCall",
+            id: toolCallId,
+            name: toolName,
+            arguments: argumentsObject,
+          });
+          const index = output.content.length - 1;
+          stream.push({ type: "toolcall_start", contentIndex: index, partial: output });
+          stream.push({
+            type: "toolcall_end",
+            contentIndex: index,
+            toolCall: output.content[index] as Extract<typeof output.content[number], { type: "toolCall" }>,
+            partial: output,
+          });
+          return;
+        }
+
+        if (type === "finish") {
+          applyFinish(parsed as CommandCodeFinish);
+          finished = true;
+          return;
+        }
+
+        if (type === "error") {
+          const errorRecord = isRecord(parsed.error) ? parsed.error : undefined;
+          const message = stringValue(errorRecord?.message) ?? stringValue(parsed.error) ?? "Command Code provider error";
+          throw new Error(message);
+        }
+      };
+
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex >= 0) {
+          const line = buffer.slice(0, newlineIndex);
+          buffer = buffer.slice(newlineIndex + 1);
+          processLine(line);
+          if (finished) {
+            break;
+          }
+          newlineIndex = buffer.indexOf("\n");
+        }
+
+        if (finished) {
+          break;
+        }
+      }
+
+      buffer += decoder.decode();
+      if (!finished && buffer.trim().length > 0) {
+        processLine(buffer);
+      }
+
+      closeThinking();
+      if (textIndex !== null) {
+        const block = output.content[textIndex];
+        if (block?.type === "text") {
+          stream.push({
+            type: "text_end",
+            contentIndex: textIndex,
+            content: block.text,
+            partial: output,
+          });
+        }
+      }
+
+      const doneReason: "stop" | "length" | "toolUse" =
+        output.stopReason === "length" || output.stopReason === "toolUse"
+          ? output.stopReason
+          : "stop";
+      stream.push({ type: "done", reason: doneReason, message: output });
+      stream.end();
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = options?.signal?.aborted
+        ? "Request aborted"
+        : error instanceof Error
+          ? error.message
+          : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    } finally {
+      if (reader) {
+        await reader.cancel().catch(() => undefined);
+      }
+    }
+  })();
+
+  return stream as unknown as StreamResult;
+}

package/src/providers/index.ts

@@ -0,0 +1,11 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ProviderRegistrationFn } from "./shared/types.js";
+import { registerCommandCodeProvider } from "./command-code/index.js";
+
+const PROVIDER_REGISTRARS: ProviderRegistrationFn[] = [registerCommandCodeProvider];
+
+export async function registerProviders(pi: ExtensionAPI): Promise<void> {
+  for (const registerProvider of PROVIDER_REGISTRARS) {
+    await registerProvider(pi);
+  }
+}

package/src/providers/shared/types.ts

@@ -0,0 +1,29 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+export type ProviderModel = {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: ("text" | "image")[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  compat?: {
+    supportsUsageInStreaming?: boolean;
+  };
+};
+
+export type LiveModelsResponse = {
+  data?: Array<{
+    id?: string;
+    name?: string;
+    context_length?: number;
+  }>;
+};
+
+export type ProviderRegistrationFn = (pi: ExtensionAPI) => Promise<void>;