@tduyng/pi-commandcode 0.0.1 → 0.0.3

package/README.md

@@ -1,10 +1,16 @@
 # pi-commandcode
 
-Command Code models in Pi through the documented Provider API. Unofficial: this extension is not made or endorsed by Command Code.
+Command Code models in pi through the documented Provider API, with pi's own prompt, tools, and approvals. Unofficial: not made or endorsed by Command Code.
+
+## What it costs
+
+No tools, no prompt block, no schema. It is a model provider, so it adds nothing to the context and nothing to the cold start.
+
+Streaming, tool calls, and message conversion are pi's own adapters, so the transport adds no round trip of its own.
 
 ## Requirements
 
-- A Command Code API key from a plan with API access: GOAT, Pro, Max, Team or Provider. The Go and $1 plans have no API access.
+- An API key from a plan with API access: GOAT, Pro, Max, Team, or Provider. The Go and $1 plans have no API access.
 - Pi 1.4 or newer.
 
 ## Use
@@ -14,7 +20,7 @@ export COMMAND_CODE_API_KEY="user_..."
 pi --provider commandcode --model claude-opus-5
 ```
 
-Inside Pi, `/model` lists every `commandcode` model. The list is fetched from `https://api.commandcode.ai/provider/v1/models` at startup, and again each time the model selector opens.
+Inside pi, `/model` lists every `commandcode` model. The list is fetched from `https://api.commandcode.ai/provider/v1/models` at startup and again each time the selector opens.
 
 ## How it works
 
@@ -23,27 +29,41 @@ Inside Pi, `/model` lists every `commandcode` model. The list is fetched from `h
 | `claude-*` | Anthropic Messages, `/provider/v1/messages` | `https://api.commandcode.ai/provider` |
 | everything else | OpenAI Chat Completions, `/provider/v1/chat/completions` | `https://api.commandcode.ai/provider/v1` |
 
-Streaming, tool calls and message conversion are Pi's own adapters. The extension sends the key as a Bearer token for Chat Completions and as `x-api-key` for Messages, as the Provider API documents.
+The key goes as a Bearer token for Chat Completions and as `x-api-key` for Messages, as the Provider API documents. `typesafe/*` decision models are left out because they run on a separate endpoint and never stream.
 
-`typesafe/*` decision models are left out because they run on a separate endpoint and never stream.
+## Limits
 
-## Configuration
+- The catalog carries no image or price metadata, so every model is text-only and shows zero cost in pi.
 
-| Variable | Meaning |
-| --- | --- |
-| `COMMAND_CODE_API_KEY` | Provider API key. Required for requests. |
-| `CMD_ZDR=1` | Sends `x-cmd-zdr: 1`, so requests go only to zero-data-retention upstreams. A model without one fails with HTTP 422. |
+- Thinking is on for every model. Pi levels map to `reasoning_effort`, and `minimal` sends `low`. `off` is offered only for the DeepSeek ids that accept it, because a model that cannot stop thinking rejects `off` with HTTP 400.
 
-## Limits
+- Claude 4.6 and newer use adaptive thinking, and the 4.5 models take a thinking budget.
+
+- Every model gets a 32768 output limit, the smallest in the Command Code CLI catalog, because per-model limits are not in the Provider API.
 
-- The catalog has no reasoning, image or price metadata, so every model is text-only, without reasoning, and shows zero cost in Pi.
-- Every model gets a 32768 output limit, the smallest limit in the Command Code CLI catalog. Per-model limits are not in the Provider API.
 - Chat Completions is used for every non-Claude model, as the docs say. A model that rejects that wire returns its own error.
-- Messages requests carry Pi's `?beta=true` query string, added by the Anthropic SDK.
+
+- Messages requests carry pi's `?beta=true` query string, added by the Anthropic SDK.
+
 - If no models appear, check the network and the key, then open `/model` again.
 
+## Configure
+
+| Variable | Meaning |
+| --- | --- |
+| `COMMAND_CODE_API_KEY` | Provider API key, required for requests |
+| `CMD_ZDR=1` | Sends `x-cmd-zdr: 1`, so requests go only to zero-data-retention upstreams. A model without one fails with HTTP 422 |
+
+## Install
+
+```bash
+pi install npm:@tduyng/pi-commandcode
+```
+
+Local checkout: `pi install /path/to/dotfiles/pi/agent/extensions/pi-commandcode`
+
 ## Tests
 
 ```sh
-bunx vitest run extensions/pi-commandcode
+bun test extensions/pi-commandcode
 ```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tduyng/pi-commandcode",
-  "version": "0.0.1",
-  "description": "Use Command Code models in Pi through the documented Provider API, with Pi's own prompt and tools.",
+  "version": "0.0.3",
+  "description": "Command Code models in Pi through the documented Provider API, with Pi's own prompt and tools.",
   "keywords": [
     "pi",
     "pi-package",

package/src/catalog.ts

@@ -1,5 +1,9 @@
-import { Type } from 'typebox'
-import { Parse } from 'typebox/value'
+import { readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { getAgentDir } from '@earendil-works/pi-coding-agent'
+import { Type, type Static } from 'typebox'
+import { Check, Parse } from 'typebox/value'
 
 import { COMMAND_CODE_ROOT } from './models.js'
 
@@ -11,22 +15,58 @@ export interface CatalogModel {
 
 const DECISION_MODEL_PREFIX = 'typesafe/'
 const CATALOG_URL = `${COMMAND_CODE_ROOT}/v1/models`
+const CACHE_FILE = 'commandcode-models.json'
+
+const ModelEntry = Type.Object({
+    id: Type.String({ minLength: 1 }),
+    name: Type.Optional(Type.String()),
+    context_length: Type.Number({ exclusiveMinimum: 0 })
+})
 
 const CatalogResponse = Type.Object({
-    data: Type.Array(
+    data: Type.Array(Type.Unknown())
+})
+
+const CacheFile = Type.Object({
+    fetchedAt: Type.Number(),
+    models: Type.Array(
         Type.Object({
-            id: Type.String(),
-            name: Type.Optional(Type.String()),
-            context_length: Type.Number({ exclusiveMinimum: 0 })
+            id: Type.String({ minLength: 1 }),
+            name: Type.String(),
+            contextWindow: Type.Number({ exclusiveMinimum: 1 })
         })
     )
 })
 
+function cachePath(): string {
+    return join(getAgentDir(), CACHE_FILE)
+}
+
+export function readCachedCatalog(): CatalogModel[] | undefined {
+    try {
+        const parsed: unknown = JSON.parse(readFileSync(cachePath(), 'utf8'))
+        if (!Check(CacheFile, parsed)) return undefined
+        return parsed.models
+    } catch {
+        return undefined
+    }
+}
+
+export function writeCachedCatalog(models: CatalogModel[]): void {
+    const target = cachePath()
+    const temporary = `${target}.${process.pid}.tmp`
+    try {
+        writeFileSync(temporary, `${JSON.stringify({ fetchedAt: Date.now(), models }, null, 2)}\n`)
+        renameSync(temporary, target)
+    } catch {}
+}
+
 export async function fetchCatalog(signal: AbortSignal): Promise<CatalogModel[]> {
     const response = await fetch(CATALOG_URL, { headers: { accept: 'application/json' }, signal })
     if (!response.ok) throw new Error(`Command Code model list failed with HTTP ${response.status}`)
     const body = Parse(CatalogResponse, await response.json())
     return body.data
+        .filter((entry): entry is Static<typeof ModelEntry> => Check(ModelEntry, entry))
         .filter((model) => !model.id.startsWith(DECISION_MODEL_PREFIX))
         .map((model) => ({ id: model.id, name: model.name ?? model.id, contextWindow: model.context_length }))
 }

package/src/index.ts

@@ -1,18 +1,24 @@
 import type { ExtensionAPI, ProviderModelConfig } from '@earendil-works/pi-coding-agent'
 
-import { fetchCatalog } from './catalog.js'
+import { fetchCatalog, readCachedCatalog, writeCachedCatalog } from './catalog.js'
 import { COMMAND_CODE_ROOT, toProviderModels } from './models.js'
 
 const PROVIDER_ID = 'commandcode'
 const FETCH_TIMEOUT_MS = 10_000
 
-function fetchModels(): Promise<ProviderModelConfig[]> {
-    return fetchCatalog(AbortSignal.timeout(FETCH_TIMEOUT_MS)).then(toProviderModels)
+async function fetchModels(
+    signal: AbortSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS)
+): Promise<ProviderModelConfig[]> {
+    const catalog = await fetchCatalog(signal)
+    writeCachedCatalog(catalog)
+    return toProviderModels(catalog)
 }
 
 export default async function piCommandCode(pi: ExtensionAPI): Promise<void> {
     const zdr = process.env['CMD_ZDR'] === '1'
-    const models = await fetchModels().catch((): ProviderModelConfig[] => [])
+    const cached = readCachedCatalog()
+    const models =
+        cached !== undefined ? toProviderModels(cached) : await fetchModels().catch((): ProviderModelConfig[] => [])
 
     pi.registerProvider(PROVIDER_ID, {
         name: 'Command Code',
@@ -20,6 +26,12 @@ export default async function piCommandCode(pi: ExtensionAPI): Promise<void> {
         apiKey: '$COMMAND_CODE_API_KEY',
         headers: zdr ? { 'x-cmd-zdr': '1' } : undefined,
         models,
-        refreshModels: fetchModels
+        refreshModels: async ({ signal, allowNetwork }) => {
+            if (!allowNetwork) {
+                const offline = readCachedCatalog()
+                return offline === undefined ? models : toProviderModels(offline)
+            }
+            return fetchModels(signal)
+        }
     })
 }

package/src/models.ts

@@ -0,0 +1,74 @@
+import type { ThinkingLevelMap } from '@earendil-works/pi-ai'
+import type { ProviderModelConfig } from '@earendil-works/pi-coding-agent'
+
+import type { CatalogModel } from './catalog.js'
+
+export const COMMAND_CODE_ROOT = 'https://api.commandcode.ai/provider'
+
+const MAX_OUTPUT_TOKENS = 32768
+const OPENAI_COMPAT = {
+    supportsStore: false,
+    supportsDeveloperRole: false,
+    supportsLongCacheRetention: false,
+    maxTokensField: 'max_tokens'
+} as const
+
+// The gateway accepts off, low, medium, high, xhigh and max. A model that cannot stop
+// thinking rejects off with HTTP 400, so off is offered only for these ids.
+const OFF_LEVEL_MODELS = new Set([
+    'deepseek/deepseek-v4-pro',
+    'deepseek/deepseek-v4-flash',
+    'deepseek/deepseek-v4-flash-vision-exp',
+    'deepseek/deepseek-v4.1-flash',
+    'deepseek/deepseek-v4.1-flash-fast'
+])
+
+function thinkingLevels(offAllowed: boolean): ThinkingLevelMap {
+    return {
+        off: offAllowed ? 'off' : null,
+        minimal: 'low',
+        low: 'low',
+        medium: 'medium',
+        high: 'high',
+        xhigh: 'xhigh',
+        max: 'max'
+    }
+}
+
+function chatFields(model: CatalogModel) {
+    return {
+        type: 'chat' as const,
+        id: model.id,
+        name: model.name,
+        input: ['text' as const],
+        reasoning: true,
+        contextWindow: model.contextWindow,
+        maxTokens: MAX_OUTPUT_TOKENS,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+    }
+}
+
+// Claude 4.6 and newer reject the budget form and require adaptive thinking; only the 4.5
+// models still take a thinking budget.
+function anthropicModel(model: CatalogModel): ProviderModelConfig {
+    return {
+        ...chatFields(model),
+        api: 'anthropic-messages',
+        baseUrl: COMMAND_CODE_ROOT,
+        compat: model.id.includes('-4-5') ? undefined : { forceAdaptiveThinking: true }
+    }
+}
+
+function openAIModel(model: CatalogModel): ProviderModelConfig {
+    return {
+        ...chatFields(model),
+        api: 'openai-completions',
+        baseUrl: `${COMMAND_CODE_ROOT}/v1`,
+        compat: OPENAI_COMPAT,
+        thinkingLevelMap: thinkingLevels(OFF_LEVEL_MODELS.has(model.id))
+    }
+}
+
+export function toProviderModels(catalog: CatalogModel[]): ProviderModelConfig[] {
+    return catalog.map((model) => (model.id.startsWith('claude-') ? anthropicModel(model) : openAIModel(model)))
+}