pi-commandcode-provider 0.4.3 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## Unreleased
+
+## 0.5.1 - 2026-08-11
+
+- Add model-specific image input capabilities from the `command-code@1.15.1` catalog and forward user and tool-result images using the current Command Code wire format.
+- Update the Command Code client version header to `1.15.1`.
+
+### Contributors
+
+- @DiyarD — reported missing vision support for GPT-5.6 Luna, Muse Spark 1.2, and other vision-capable models.
+
+## 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.

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:
-
-```txt
-/reload
-```
-
-## Setup
-
-Set your Command Code API key using one of these methods:
-
-### 1. Browser login (recommended)
-
-In pi, run:
+Restart OMP or run `/reload`, then use `/login` and select **Use a subscription** followed by **Command Code**.
 
-```txt
-/login
-```
+## Authentication
 
-Then select **Command Code** from the provider list.
+### Browser login
 
-<img width="1520" height="554" alt="image" src="https://github.com/user-attachments/assets/071e929a-6f49-4803-bfec-7a31368fb12a" />
+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.
 
-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.
+<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" />
 
-> Note: `/login commandcode` is not supported by pi currently; use interactive `/login` and select Command Code.
+If automatic transfer from the browser fails, copy the API key shown by Command Code and paste it into the terminal prompt.
 
-### 2. Environment variable
+### Environment variable
 
 ```sh
 export COMMANDCODE_API_KEY="user_..."
 ```
 
-### 3. Auth file
+### Auth file
+
+The provider also reads existing credentials from:
 
-Create `~/.commandcode/auth.json`:
+- `~/.commandcode/auth.json`
+- `~/.pi/agent/auth.json`
+- `~/.omp/agent/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,55 +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 and offline behavior
 
-## Model discovery
-
-On startup, the provider fetches:
+The provider fetches the current model catalog from:
 
 ```txt
 https://api.commandcode.ai/provider/v1/models
 ```
 
-The last successfully fetched catalog is cached at `<agent-dir>/commandcode-models.json` (`~/.pi/agent/commandcode-models.json` by default). The agent directory follows pi's `PI_CODING_AGENT_DIR` setting, so compatible hosts such as OMP keep the cache in their own agent directory. If model discovery is temporarily unavailable, the provider uses this cached catalog so previously discovered Command Code models remain selectable. On a first offline start without a cache, pi still loads, but Command Code models remain unavailable until the connection is restored and `/reload` succeeds.
+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
+
+The provider advertises image input only for models marked with the `image` input modality in the official Command Code CLI model catalog. The capability snapshot currently follows `command-code@1.15.1`; unknown models default to text-only until their upstream metadata is reviewed.
+
+For vision-capable models, image blocks from user messages and tool results are forwarded in Command Code's current data-URL wire format. Text-only models reject image content before making a network request instead of silently dropping it.
+
+## 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:
 
-For tests or local mocks, override the endpoint with `COMMANDCODE_MODELS_URL` and the cache file with `COMMANDCODE_MODELS_CACHE`.
+```sh
+pi remove npm:pi-commandcode-provider
+```
 
-## Pricing
+For OMP:
 
-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.
+```sh
+omp plugin upgrade pi-commandcode-provider
+omp plugin uninstall pi-commandcode-provider
+```
+
+## Development
 
-- 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.
+Start an isolated pi instance with only the current checkout installed and no existing Command Code credentials:
 
-To add or update a price, edit the `MODEL_COSTS` record in `index.ts` and update the corresponding test in `tests/test-pricing.ts`.
+```sh
+npm run pi:isolated
+```
 
-## Contributing
+Run `/login` inside pi. Temporary credentials, configuration, and sessions are deleted when pi exits.
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, PR expectations, and commit message rules.
+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,96 +2,45 @@
  * 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 { getAgentDir, 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 { calculateCommandCodeCost } from "./src/cost.ts"
-import { DEFAULT_MODELS_URL, loadCommandCodeModels } 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
-const MODELS_CACHE_PATH =
-  process.env.COMMANDCODE_MODELS_CACHE ?? join(getAgentDir(), "commandcode-models.json")
-
-type CommandCodeModelCost = {
-  input: number
-  output: number
-  cacheRead: number
-  cacheWrite: number
-}
-
-const ZERO_MODEL_COST: CommandCodeModelCost = {
-  input: 0,
-  output: 0,
-  cacheRead: 0,
-  cacheWrite: 0,
-}
+import {
+  DEFAULT_MODELS_URL,
+  getModelsTimeoutMs,
+  inputModalitiesForModel,
+  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"
 
-// 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 },
-}
-
-const streamCommandCode = createStreamCommandCode({
-  createStream: () => new AssistantMessageEventStream(),
-  calculateCost: calculateCommandCodeCost,
-  apiBase: API_BASE,
-})
-
-// ---------------------------------------------------------------------------
-// Extension entry point
-// ---------------------------------------------------------------------------
-
-export default async function (pi: ExtensionAPI) {
-  const { models, warning } = await loadCommandCodeModels({
-    url: MODELS_URL,
-    cachePath: MODELS_CACHE_PATH,
-  })
-
-  if (warning) console.warn(`[commandcode] ${warning}`)
-
-  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",
@@ -104,16 +53,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: inputModalitiesForModel(model.id),
+    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.3",
+  "version": "0.5.1",
   "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
+})