pi-commandcode-provider 0.4.2 → 0.5.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 0.5.0 - 2026-08-07
+
+- Stop replaying completed assistant reasoning traces to Command Code while preserving visible text and completed tool calls in follow-up request history.
+- Add `/commandcode-refresh` and `/commandcode-status` commands for safe model-catalog refreshes and redacted diagnostics.
+- Bound model discovery to a configurable 10-second timeout so a slow Provider API cannot block pi startup; timed-out discovery uses the validated cache when available.
+- Normalize Command Code context overflow failures so pi can auto-compact and retry, while leaving unrelated rate-limit and capacity errors unchanged.
+- Keep the legacy `/alpha/generate` integration explicitly text-only: image input and image tool results are rejected instead of being silently dropped, and models do not claim image capability until the protocol exposes documented support and limits.
+- Replace blanket reasoning metadata with model-specific Command Code effort support. Known models expose a `thinkingLevelMap`, and selected supported Pi levels are forwarded as `params.reasoning_effort`; unsupported or unknown models do not receive reasoning request fields.
+- Add repository commands for testing the current checkout either in a logged-out, automatically cleaned-up pi environment or with existing credentials and only Command Code models enabled.
+- Refresh display pricing for the current Command Code model catalog, remove expired Qwen promotional rates, add current free and discounted models, and require review when temporary prices expire.
+- Use the host-provided `pi-ai` and `pi-coding-agent` core packages instead of installing private runtime copies, including for local and out-of-store development checkouts.
+- Fix cached input tokens being counted twice.
+
+### Contributors
+
+- @IfkumRfnl — fixed cached input token accounting.
+
+## 0.4.3 - 2026-08-02
+
+- Allow pi to start when model discovery is unavailable. The provider now caches the last successfully fetched model catalog so previously discovered Command Code models remain selectable offline; a first offline start without a cache keeps Command Code unavailable until `/reload` succeeds.
+
+### Contributors
+
+- @k3-2o — reported that the model-list fetch blocked pi startup when offline.
+
 ## 0.4.2 - 2026-07-05
 
 - Fix Oh My Pi extension validation by avoiding the missing `calculateCost` export from OMP's legacy `pi-ai` shim.

package/CONTRIBUTING.md

@@ -21,9 +21,27 @@ npm run test:models
 npm run test:oauth
 npm run test:abort
 npm run test:stream
+npm run test:pi-isolated
+npm run test:pi-authenticated
 npm run test:pi-local
 ```
 
+Start an isolated pi instance with only the current checkout installed and no existing Command Code credentials:
+
+```sh
+npm run pi:isolated
+```
+
+Run `/login` inside pi. Temporary credentials, configuration, and sessions are deleted when pi exits.
+
+Start the current checkout with your existing pi credentials and only Command Code models in the model picker:
+
+```sh
+npm run pi:authenticated
+```
+
+Both commands accept additional pi arguments after `--`, for example `npm run pi:authenticated -- --model claude-sonnet-4-6`.
+
 Before opening a PR, run:
 
 ```sh

package/README.md

@@ -1,22 +1,11 @@
 # pi-commandcode-provider
 
-A [pi](https://github.com/badlogic/pi-mono) custom provider that connects pi to the [Command Code](https://commandcode.ai) API.
+[![CI](https://github.com/patlux/pi-commandcode-provider/actions/workflows/ci.yml/badge.svg)](https://github.com/patlux/pi-commandcode-provider/actions/workflows/ci.yml)
+[![Memory benchmark](https://github.com/patlux/pi-commandcode-provider/actions/workflows/memory-benchmark.yml/badge.svg)](https://github.com/patlux/pi-commandcode-provider/actions/workflows/memory-benchmark.yml)
 
-> **Disclaimer:** This is an unofficial, community-maintained package. I am not affiliated with, endorsed by, or connected to Command Code in any way. This provider simply forwards requests to the public Command Code API using your own API key.
+A custom provider for [pi](https://github.com/earendil-works/pi) that connects to the [Command Code](https://commandcode.ai) Provider API.
 
-> **Note:** This package only provides a model _provider_. It does **not** include an API key. You must bring your own Command Code API key or subscription.
-
-> 💰 **Current offers:** Command Code offers [4× usage of DeepSeek V4 Pro](https://commandcode.ai/docs/resources/pricing-limits#deepseek-v4-pro-4x-usage) and [2× usage of Qwen 3.7 Max](https://commandcode.ai/docs/resources/pricing-limits#qwen-3.7-max-2x-usage).
-
-## Models
-
-Models are fetched live from Command Code's Provider API at startup, so new models like Qwen 3.7 Max show up without a package release.
-
-You can list the current Command Code models with:
-
-```sh
-pi -e index.ts --list-models
-```
+> **Disclaimer:** This is an unofficial, community-maintained integration. It is not affiliated with, endorsed by, or supported by Command Code. You need your own Command Code account and API key or subscription. Command Code's terms, availability, and pricing apply.
 
 ## Install
 
@@ -24,59 +13,49 @@ pi -e index.ts --list-models
 pi install npm:pi-commandcode-provider
 ```
 
-Or shorthand:
+Start or reload pi, then authenticate:
 
-```sh
-pi install pi-commandcode-provider
+```txt
+/login
 ```
 
-Then reload pi:
+Select **Use a subscription**, then **Command Code**. Complete the browser flow and choose a model with `/model`.
 
-```txt
-/reload
-```
+## Oh My Pi
 
-### Oh My Pi
+Install the same package in [Oh My Pi](https://github.com/can1357/oh-my-pi):
 
 ```sh
 omp plugin install pi-commandcode-provider
 ```
 
-Then restart OMP or run:
+Restart OMP or run `/reload`, then use `/login` and select **Use a subscription** followed by **Command Code**.
 
-```txt
-/reload
-```
+## Authentication
 
-## Setup
+### Browser login
 
-Set your Command Code API key using one of these methods:
+Run `/login` in pi or OMP. Select **Use a subscription**, then **Command Code**. The browser flow stores the returned credential in the host's auth file.
 
-### 1. Browser login (recommended)
+<img width="1520" height="554" alt="Select Command Code in pi's login dialog" src="https://github.com/user-attachments/assets/071e929a-6f49-4803-bfec-7a31368fb12a" />
 
-In pi, run:
+If automatic transfer from the browser fails, copy the API key shown by Command Code and paste it into the terminal prompt.
 
-```txt
-/login
-```
-
-Then select **Command Code** from the provider list.
-
-<img width="1520" height="554" alt="image" src="https://github.com/user-attachments/assets/071e929a-6f49-4803-bfec-7a31368fb12a" />
-
-This opens Command Code in your browser and stores the returned API key in pi's auth file. If the browser shows "Copy your API key" because automatic transfer failed, copy that key and paste it into the pi terminal prompt.
-
-> Note: `/login commandcode` is not supported by pi currently; use interactive `/login` and select Command Code.
-
-### 2. Environment variable
+### Environment variable
 
 ```sh
 export COMMANDCODE_API_KEY="user_..."
 ```
 
-### 3. Auth file
+### Auth file
+
+The provider also reads existing credentials from:
+
+- `~/.commandcode/auth.json`
+- `~/.pi/agent/auth.json`
+- `~/.omp/agent/auth.json`
 
-Create `~/.commandcode/auth.json`:
+Supported examples:
 
 ```json
 {
@@ -84,8 +63,6 @@ Create `~/.commandcode/auth.json`:
 }
 ```
 
-The official Command Code CLI auth shape is also supported:
-
 ```json
 {
   "command-code": {
@@ -95,8 +72,6 @@ The official Command Code CLI auth shape is also supported:
 }
 ```
 
-Or use a pi/OMP auth file at `~/.pi/agent/auth.json` or `~/.omp/agent/auth.json`:
-
 ```json
 {
   "commandcode": "user_..."
@@ -105,53 +80,108 @@ Or use a pi/OMP auth file at `~/.pi/agent/auth.json` or `~/.omp/agent/auth.json`
 
 ## Usage
 
-After installing and setting your API key, select a Command Code model in pi:
+Open `/model` and select one of the models provided by Command Code. Model availability changes over time and is refreshed from the Provider API when the extension loads.
 
-```txt
-/model deepseek/deepseek-v4-flash
+### Reasoning support
+
+Reasoning metadata is enriched only for models whose Command Code effort support is known. Those models register a model-specific `thinkingLevelMap`, so pi and OMP expose only supported levels. A selected supported level is sent as the documented `params.reasoning_effort` field; `off`, unsupported levels, and newly discovered models without metadata do not add reasoning fields to the request. No prompt instructions are injected.
+
+Reasoning blocks from completed assistant turns remain visible in pi's local session, but are not replayed to Command Code in later requests. Only the assistant's user-visible text and completed tool calls are sent back as history. This matches the current Command Code CLI behavior and prevents prior private reasoning traces from interfering with reasoning on follow-up turns.
+
+List Command Code models from the terminal:
+
+```sh
+pi --list-models commandcode
 ```
 
-Any query will then use the Command Code API. You can list available models:
+In OMP, use:
 
 ```sh
-pi -e index.ts --list-models   # or /models within pi
-omp -e index.ts --list-models
+omp models
 ```
 
-In OMP, use the provider-qualified model name:
+For non-interactive OMP requests, use a provider-qualified model ID shown by `omp models`. For example:
 
 ```sh
 omp -p "hello" --model commandcode/deepseek/deepseek-v4-flash
 ```
 
-OMP currently resolves `--provider commandcode --model ...` before extension providers are loaded, so prefer `--model commandcode/<model-id>`. <!-- TODO: remove this note once OMP fixes provider resolution order for extension-loaded providers -->
-
-## Model discovery
+## Model discovery and offline behavior
 
-On startup, the provider fetches:
+The provider fetches the current model catalog from:
 
 ```txt
 https://api.commandcode.ai/provider/v1/models
 ```
 
-For tests or local mocks, override it with `COMMANDCODE_MODELS_URL`.
+The last successful catalog is cached at `<agent-dir>/commandcode-models.json`. For pi this is `~/.pi/agent/commandcode-models.json` by default. Compatible hosts such as OMP use their own agent directory.
+
+If the endpoint is temporarily unavailable, the provider uses the cached catalog. On a first offline start without a cache, pi still loads, but Command Code models remain unavailable until the connection is restored and `/commandcode-refresh` succeeds.
+
+While pi is running, use these provider commands without restarting:
+
+- `/commandcode-refresh` fetches and re-registers the current model catalog. Overlapping refreshes are coalesced, and a failed refresh keeps the last valid catalog active.
+- `/commandcode-status` shows redacted discovery diagnostics, including the source, model count, timestamps, cache path, endpoint, and warning.
+
+The following environment variables are intended for tests, local mocks, and compatible API endpoints:
+
+- `COMMANDCODE_API_BASE`
+- `COMMANDCODE_MODELS_URL`
+- `COMMANDCODE_MODELS_CACHE`
+- `COMMANDCODE_MODELS_TIMEOUT_MS` (defaults to 10 seconds; invalid or non-positive values use the default)
+
+## Image input
+
+This provider currently advertises and accepts **text input only**. The extension uses Command Code's legacy `/alpha/generate` protocol, while the public Provider API documentation describes image parts for its documented `/provider/v1` endpoints. The legacy request path has no documented image-part contract, and the model catalog fixture exposes model IDs and context lengths but no image capability or limit fields.
+
+To avoid silently dropping or changing image data, the provider rejects image content in user messages and tool results before making a network request. It does not claim image capability or define image-size/count limits. This limitation can be revisited when Command Code documents image parts and limits for the protocol used here.
+
+## Pricing display
+
+The Command Code Provider API does not currently include prices in its model catalog. This extension therefore keeps a static table for models with known prices so pi can display estimated request costs.
+
+Models missing from that table display zero cost in pi. This does **not** mean that Command Code will bill the request at zero. Check the current [Command Code pricing](https://commandcode.ai/docs/resources/pricing-limits) before relying on the displayed value.
+
+## Update and remove
+
+Update installed pi packages:
+
+```sh
+pi update --extensions
+```
+
+Remove the provider:
 
-## Pricing
+```sh
+pi remove npm:pi-commandcode-provider
+```
 
-Command Code does not yet expose model pricing through its Provider API. The provider ships a static cost table (`MODEL_COSTS` in `index.ts`) for known models so that pi can display per-model pricing.
+For OMP:
 
-- Models present in `MODEL_COSTS` show their real per-million-token rates (including promotional deals like the DeepSeek V4 Pro 4× discount and Qwen 3.7 Max 2× discount).
-- Models **not** in the table fall back to zero cost. When the Provider API adds a `cost` field, the static table can be removed.
+```sh
+omp plugin upgrade pi-commandcode-provider
+omp plugin uninstall pi-commandcode-provider
+```
 
-To add or update a price, edit the `MODEL_COSTS` record in `index.ts` and update the corresponding test in `tests/test-pricing.ts`.
+## Development
 
-## Contributing
+Start an isolated pi instance with only the current checkout installed and no existing Command Code credentials:
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, PR expectations, and commit message rules.
+```sh
+npm run pi:isolated
+```
+
+Run `/login` inside pi. Temporary credentials, configuration, and sessions are deleted when pi exits.
+
+Start the current checkout with your existing pi credentials and only Command Code models in the model picker:
+
+```sh
+npm run pi:authenticated
+```
 
-## Release
+Both commands accept additional pi arguments after `--`, for example `npm run pi:authenticated -- --model claude-sonnet-4-6`.
 
-See [RELEASE.md](RELEASE.md) for the prerelease, npm smoke-test, stable publish, git tag, and GitHub follow-up checklist.
+See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup and tests. See [RELEASE.md](RELEASE.md) for the release process.
 
 ## License
 

package/index.ts

@@ -2,88 +2,49 @@
  * Command Code provider for pi.
  *
  * Connects pi to Command Code's API (https://api.commandcode.ai/alpha/generate).
- *
- * Authentication (pick one):
- *   1. Run `/login`, then select Command Code — opens browser to commandcode.ai, auto-stores API key
- *   2. Set COMMANDCODE_API_KEY environment variable
- *   3. Place API key in `~/.commandcode/auth.json` or `~/.pi/agent/auth.json`
- *      as {"apiKey": "user_..."} or {"commandcode": "user_..."}
- *
- * Models are fetched from Command Code's Provider API at startup.
+ * The provider uses pi's legacy extension registration surface because the
+ * current pi host exposes `registerProvider(name, config)`, including OMP.
  */
 
 import { AssistantMessageEventStream } from "@earendil-works/pi-ai"
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent"
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ProviderConfig,
+} from "@earendil-works/pi-coding-agent"
+import { join } from "node:path"
 
-import { COMMAND_CODE_CLI_VERSION, createStreamCommandCode, DEFAULT_API_BASE } from "./src/core.ts"
+import {
+  COMMAND_CODE_CLI_VERSION,
+  COMMAND_CODE_INPUT_TYPES,
+  createStreamCommandCode,
+  DEFAULT_API_BASE,
+} from "./src/core.ts"
 import { calculateCommandCodeCost } from "./src/cost.ts"
-import { DEFAULT_MODELS_URL, fetchCommandCodeModels } from "./src/models.ts"
-import { getApiKey, login, refreshToken } from "./src/oauth.ts"
-
-const API_BASE = process.env.COMMANDCODE_API_BASE ?? DEFAULT_API_BASE
-const MODELS_URL = process.env.COMMANDCODE_MODELS_URL ?? DEFAULT_MODELS_URL
-
-type CommandCodeModelCost = {
-  input: number
-  output: number
-  cacheRead: number
-  cacheWrite: number
-}
-
-const ZERO_MODEL_COST: CommandCodeModelCost = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-}
-
-// The Provider API supplies the current model list. Keep known display pricing
-// here until the Provider API exposes prices directly.
-const MODEL_COSTS: Record<string, CommandCodeModelCost> = {
-  "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-  "claude-haiku-4-5-20251001": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-  "gpt-5.5": { input: 5, output: 30, cacheRead: 0.5, cacheWrite: 0 },
-  "gpt-5.4": { input: 2.5, output: 15, cacheRead: 0.25, cacheWrite: 0 },
-  "gpt-5.3-codex": { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
-  "gpt-5.4-mini": { input: 0.75, output: 4.5, cacheRead: 0.075, cacheWrite: 0 },
-  "google/gemini-3.5-flash": { input: 1.5, output: 9, cacheRead: 0.15, cacheWrite: 0 },
-  "google/gemini-3.1-flash-lite": { input: 0.25, output: 1.5, cacheRead: 0.03, cacheWrite: 0 },
-  // 4× usage deal: 75% off (permanent, no expiry)
-  "deepseek/deepseek-v4-pro": { input: 0.435, output: 0.87, cacheRead: 0.003625, cacheWrite: 0 },
-  "deepseek/deepseek-v4-flash": { input: 0.14, output: 0.28, cacheRead: 0.028, cacheWrite: 0 },
-  "moonshotai/Kimi-K2.6": { input: 0.95, output: 4, cacheRead: 0.16, cacheWrite: 0 },
-  "moonshotai/Kimi-K2.5": { input: 0.6, output: 3, cacheRead: 0.1, cacheWrite: 0 },
-  "zai-org/GLM-5.1": { input: 1.4, output: 4.4, cacheRead: 0.26, cacheWrite: 0 },
-  "zai-org/GLM-5": { input: 1, output: 3.2, cacheRead: 0.2, cacheWrite: 0 },
-  "MiniMaxAI/MiniMax-M2.7": { input: 0.3, output: 1.2, cacheRead: 0.06, cacheWrite: 0 },
-  "MiniMaxAI/MiniMax-M2.5": { input: 0.27, output: 0.95, cacheRead: 0.03, cacheWrite: 0 },
-  "Qwen/Qwen3.6-Max-Preview": { input: 1.3, output: 7.8, cacheRead: 0.26, cacheWrite: 1.63 },
-  "Qwen/Qwen3.6-Plus": { input: 0.5, output: 3, cacheRead: 0.1, cacheWrite: 0 },
-  // 2× usage deal: 50% off through June 22, 2026
-  "Qwen/Qwen3.7-Max": { input: 1.25, output: 3.75, cacheRead: 0.25, cacheWrite: 1.56 },
-  "stepfun/Step-3.5-Flash": { input: 0.1, output: 0.3, cacheRead: 0.02, cacheWrite: 0 },
-  "xiaomi/mimo-v2.5-pro": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-  "xiaomi/mimo-v2.5": { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-}
+import {
+  DEFAULT_MODELS_URL,
+  getModelsTimeoutMs,
+  loadCommandCodeModels,
+  thinkingMetadataForModel,
+  type CommandCodeModel,
+} from "./src/models.ts"
+import { getApiKey as getOAuthApiKey, login, refreshToken } from "./src/oauth.ts"
+import { MODEL_COSTS, ZERO_MODEL_COST } from "./src/pricing.ts"
+import { createCommandCodeRuntime } from "./src/runtime.ts"
+import { normalizeCommandCodeMessage } from "./src/overflow.ts"
 
-const streamCommandCode = createStreamCommandCode({
-  createStream: () => new AssistantMessageEventStream(),
-  calculateCost: calculateCommandCodeCost,
-  apiBase: API_BASE,
-})
-
-// ---------------------------------------------------------------------------
-// Extension entry point
-// ---------------------------------------------------------------------------
-
-export default async function (pi: ExtensionAPI) {
-  const models = await fetchCommandCodeModels({ url: MODELS_URL })
-
-  pi.registerProvider("commandcode", {
+function createProviderConfig(
+  models: readonly CommandCodeModel[],
+  apiBase: string,
+  streamCommandCode: ProviderConfig["streamSimple"],
+): ProviderConfig {
+  return {
     name: "Command Code",
-    baseUrl: API_BASE,
+    baseUrl: apiBase,
+    // Keep environment authentication dynamic. OAuth credentials are resolved
+    // by pi's oauth registration, while the custom stream retains its own
+    // request-time legacy-file fallback for older compatible hosts.
     apiKey: "$COMMANDCODE_API_KEY",
     authHeader: true,
     api: "commandcode-custom",
@@ -96,16 +57,60 @@ export default async function (pi: ExtensionAPI) {
       name: "Command Code",
       login,
       refreshToken,
-      getApiKey,
+      getApiKey: getOAuthApiKey,
     },
-    models: models.map((model) => ({
-      id: model.id,
-      name: model.name,
-      reasoning: model.reasoning,
-      input: ["text"] as const,
-      cost: MODEL_COSTS[model.id] ?? ZERO_MODEL_COST,
-      contextWindow: model.contextWindow,
-      maxTokens: model.maxTokens,
-    })),
+    models: models.map(createProviderModel),
+  }
+}
+
+function createProviderModel(model: {
+  id: string
+  name: string
+  reasoning: boolean
+  contextWindow: number
+  maxTokens: number
+}) {
+  return {
+    id: model.id,
+    name: model.name,
+    reasoning: model.reasoning,
+    ...(thinkingMetadataForModel(model.id) ?? {}),
+    input: COMMAND_CODE_INPUT_TYPES,
+    cost: MODEL_COSTS[model.id] ?? ZERO_MODEL_COST,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+  } as const
+}
+
+export default async function (pi: ExtensionAPI) {
+  const apiBase = process.env.COMMANDCODE_API_BASE ?? DEFAULT_API_BASE
+  const modelsUrl = process.env.COMMANDCODE_MODELS_URL ?? DEFAULT_MODELS_URL
+  const modelsTimeoutMs = getModelsTimeoutMs()
+  const modelsCachePath =
+    process.env.COMMANDCODE_MODELS_CACHE ?? join(getAgentDir(), "commandcode-models.json")
+  const streamCommandCode = createStreamCommandCode({
+    createStream: () => new AssistantMessageEventStream(),
+    calculateCost: calculateCommandCodeCost,
+    apiBase,
   })
+
+  pi.on("message_end", async (event, ctx) => {
+    if (event.message.role !== "assistant") return
+    const normalized = normalizeCommandCodeMessage(event.message, ctx.model?.provider)
+    return normalized ? { message: normalized.message } : undefined
+  })
+
+  const runtime = createCommandCodeRuntime<ProviderConfig, ExtensionCommandContext>(pi, {
+    endpoint: modelsUrl,
+    cachePath: modelsCachePath,
+    loadModels: () =>
+      loadCommandCodeModels({
+        url: modelsUrl,
+        cachePath: modelsCachePath,
+        timeoutMs: modelsTimeoutMs,
+      }),
+    createProviderConfig: (models) => createProviderConfig(models, apiBase, streamCommandCode),
+  })
+
+  await runtime.initialize()
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-commandcode-provider",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "pi custom provider for Command Code API (commandcode.ai)",
   "type": "module",
   "keywords": [
@@ -21,6 +21,7 @@
   "files": [
     "index.ts",
     "src/",
+    "scripts/",
     "README.md",
     "CHANGELOG.md",
     "CONTRIBUTING.md",
@@ -28,19 +29,26 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "npm run typecheck && tsx tests/test-pure-functions.ts && tsx tests/test-models.ts && tsx tests/test-pricing.ts && tsx tests/test-cost.ts && tsx tests/test-oauth.ts && tsx tests/test-abort.ts && tsx tests/test-stream.ts && tsx tests/test-retry.ts && node tests/test-pi-local.mjs && node tests/test-omp-compat.mjs",
+    "test": "npm run typecheck && tsx tests/test-package-manifest.ts && tsx tests/test-pure-functions.ts && tsx tests/test-models.ts && tsx tests/test-runtime.ts && tsx tests/test-pricing.ts && tsx tests/test-cost.ts && tsx tests/test-oauth.ts && tsx tests/test-abort.ts && tsx tests/test-overflow.ts && tsx tests/test-stream.ts && tsx tests/test-retry.ts && node tests/test-pi-isolated.mjs && node tests/test-pi-authenticated.mjs && node tests/test-pi-local.mjs && node tests/test-omp-compat.mjs",
     "typecheck": "tsc --noEmit",
     "format:check": "prettier --check '**/*.{ts,mjs,json,md}'",
     "format": "prettier --write '**/*.{ts,mjs,json,md}'",
+    "pi:isolated": "node scripts/pi-isolated.mjs",
+    "pi:authenticated": "node scripts/pi-authenticated.mjs",
     "test:unit": "tsx tests/test-pure-functions.ts",
     "test:models": "tsx tests/test-models.ts",
+    "test:runtime": "tsx tests/test-runtime.ts",
     "test:pricing": "tsx tests/test-pricing.ts",
     "test:oauth": "tsx tests/test-oauth.ts",
     "test:abort": "tsx tests/test-abort.ts",
+    "test:overflow": "tsx tests/test-overflow.ts",
     "test:stream": "tsx tests/test-stream.ts",
     "test:retry": "tsx tests/test-retry.ts",
+    "test:pi-isolated": "node tests/test-pi-isolated.mjs",
+    "test:pi-authenticated": "node tests/test-pi-authenticated.mjs",
     "test:pi-local": "node tests/test-pi-local.mjs",
     "test:smoke": "node tests/test-smoke.mjs",
+    "test:e2e:live": "node tests/test-live-e2e.mjs",
     "test:cost": "tsx tests/test-cost.ts"
   },
   "pi": {
@@ -54,13 +62,14 @@
     "tsx": "4.22.4",
     "typescript": "6.0.3"
   },
-  "dependencies": {
-    "@earendil-works/pi-ai": "0.75.5"
-  },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.75.5"
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
   },
   "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
     "@earendil-works/pi-coding-agent": {
       "optional": true
     }

package/scripts/pi-authenticated.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process"
+import { dirname, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const extensionPath = resolve(repoRoot, "index.ts")
+
+const env = {
+  ...process.env,
+  PI_SKIP_VERSION_CHECK: "1",
+}
+delete env.COMMANDCODE_API_KEY
+
+const child = spawn(
+  "pi",
+  [
+    "--no-extensions",
+    "--extension",
+    extensionPath,
+    "--provider",
+    "commandcode",
+    "--model",
+    "gpt-5.6-luna",
+    "--models",
+    "commandcode/*",
+    ...process.argv.slice(2),
+  ],
+  {
+    cwd: repoRoot,
+    env,
+    stdio: "inherit",
+  },
+)
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => child.kill(signal))
+}
+
+child.once("error", (error) => {
+  console.error(`Could not start pi: ${error.message}`)
+  process.exitCode = 1
+})
+
+child.once("exit", (status, signal) => {
+  if (signal) process.kill(process.pid, signal)
+  process.exitCode = status ?? 1
+})