@tduyng/pi-commandcode 0.0.1 → 0.0.2

package/README.md

@@ -36,7 +36,9 @@ Streaming, tool calls and message conversion are Pi's own adapters. The extensio
 
 ## Limits
 
-- The catalog has no reasoning, image or price metadata, so every model is text-only, without reasoning, and shows zero cost in Pi.
+- The catalog has no image or price metadata, so every model is text-only and shows zero cost in Pi.
+- Thinking is on for every model. Pi levels map to the gateway's `reasoning_effort` values, `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 and leaves the level out everywhere else.
+- Claude 4.6 and newer use adaptive thinking, the 4.5 models take a thinking budget.
 - 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.
@@ -45,5 +47,5 @@ Streaming, tool calls and message conversion are Pi's own adapters. The extensio
 ## Tests
 
 ```sh
-bunx vitest run extensions/pi-commandcode
+bun test extensions/pi-commandcode
 ```

package/package.json

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

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)))
+}