@herbertgao/pi-extensions 2026.9.17 → 2026.9.18

package/node_modules/pi-typesafe/dist/backends.js

@@ -3,7 +3,7 @@ import { TypeSafeIntegrationError } from "./errors.js";
 export const DEFAULT_BACKEND = "typesafe";
 /** The environment variable and login store that the default backend reads. */
 export const TYPESAFE_KEY_ENV = "TYPESAFE_API_KEY";
-/** Registry of known judgment backends. Extendable by callers. */
+/** Registry of known judgment backends. Callers pass a `BackendEndpoint` for a host this registry does not name. */
 export const DECISIONS_BACKENDS = {
     typesafe: { label: "TypeSafe", host: "https://api.typesafe.ai", keyEnv: TYPESAFE_KEY_ENV },
     openrouter: {
@@ -16,6 +16,16 @@ export const DECISIONS_BACKENDS = {
         modelsIdField: "id",
         modelsVerifyKey: false,
     },
+    commandcode: {
+        label: "Command Code",
+        host: "https://api.commandcode.ai",
+        keyEnv: "COMMANDCODE_API_KEY",
+        path: "/provider/v1/systemone",
+        modelsPath: "/provider/v1/models",
+        modelsField: "data",
+        modelsIdField: "id",
+        modelsVerifyKey: false,
+    },
 };
 /** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
 export function backendConfig(name) {
@@ -28,6 +38,7 @@ export function backendConfig(name) {
 const DEFAULT_MODEL = {
     typesafe: "jev-latest",
     openrouter: "typesafe/jev-1.13",
+    commandcode: "typesafe/jev",
 };
 /**
  * The model id to send for a caller's `model` on this backend. OpenRouter routes a bare Jev id under the `typesafe`
@@ -57,3 +68,86 @@ export function defaultModelId(backend) {
 export function usesTypesafeKey(backend) {
     return (backend.keyEnv ?? TYPESAFE_KEY_ENV) === TYPESAFE_KEY_ENV;
 }
+const KEY_ENV_MESSAGE = "Backend keyEnv must name an environment variable: letters, digits, and underscores, not starting with a digit.";
+const HOST_MESSAGE = "Backend host must be an absolute https: URL with no user info, path, query, or fragment (http: is allowed only for localhost, 127.0.0.0/8, and [::1]).";
+function refuse(message) {
+    throw new TypeSafeIntegrationError("configuration", message);
+}
+/** `https://gw.example.com?` and `https://gw.example.com#` parse clean, so the raw string itself must carry neither. */
+function hasRawQueryOrFragment(value) {
+    return value.includes("?") || value.includes("#");
+}
+/**
+ * Resolve a registry name or a caller-supplied endpoint into the validated form the client uses. A name resolves to
+ * its registry entry unchanged; an endpoint is validated field by field and returned as a fresh object whose `host`
+ * is origin-only. Messages never quote a caller value — a host can carry credentials in its user info — except the
+ * label, and only after it is validated. Validation runs on every call; nothing is cached.
+ */
+export function resolveBackend(backend) {
+    const spec = backend === undefined ? DEFAULT_BACKEND : backend;
+    if (typeof spec === "string") {
+        const entry = backendConfig(spec);
+        return {
+            ...entry,
+            name: spec,
+            host: entry.host,
+            keyEnv: entry.keyEnv ?? TYPESAFE_KEY_ENV,
+            defaultModel: defaultModelId(spec),
+            modelsVerifyKey: entry.modelsVerifyKey !== false,
+        };
+    }
+    if (spec === null || typeof spec !== "object") {
+        refuse("backend must be a registry name or a backend object.");
+    }
+    const label = typeof spec.label === "string" ? spec.label.trim() : "";
+    if (!label || label.length > 60)
+        refuse("Backend label must be a nonempty string of at most 60 characters.");
+    let host;
+    if (typeof spec.host !== "string" || hasRawQueryOrFragment(spec.host))
+        refuse(HOST_MESSAGE);
+    try {
+        host = new URL(spec.host);
+    }
+    catch {
+        refuse(HOST_MESSAGE);
+    }
+    const loopback = host.hostname === "localhost" || host.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(host.hostname);
+    if (host.protocol !== "https:" && !(host.protocol === "http:" && loopback))
+        refuse(HOST_MESSAGE);
+    if (host.username !== "" || host.password !== "" || host.pathname !== "/" || host.search !== "" || host.hash !== "")
+        refuse(HOST_MESSAGE);
+    for (const [field, message] of [["path", 'Backend path must be a string that starts with "/".'], ["modelsPath", 'Backend modelsPath must be a string that starts with "/".']]) {
+        const value = spec[field];
+        if (value !== undefined && (typeof value !== "string" || !value.startsWith("/") || hasRawQueryOrFragment(value)))
+            refuse(message);
+    }
+    if (spec.modelsField !== undefined && (typeof spec.modelsField !== "string" || !spec.modelsField))
+        refuse("Backend modelsField must be a nonempty string.");
+    if (spec.modelsIdField !== undefined && (typeof spec.modelsIdField !== "string" || !spec.modelsIdField))
+        refuse("Backend modelsIdField must be a nonempty string.");
+    if (spec.modelsVerifyKey !== undefined && typeof spec.modelsVerifyKey !== "boolean")
+        refuse("Backend modelsVerifyKey must be a boolean.");
+    if (typeof spec.keyEnv !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(spec.keyEnv))
+        refuse(KEY_ENV_MESSAGE);
+    if (spec.keyEnv.toUpperCase() === TYPESAFE_KEY_ENV) {
+        refuse("Backend keyEnv must not be TYPESAFE_API_KEY: the TypeSafe key is only sent to the typesafe backend. Give this endpoint its own variable.");
+    }
+    if (spec.defaultModel !== undefined && (typeof spec.defaultModel !== "string" || !spec.defaultModel.trim() || spec.defaultModel.length > 100)) {
+        refuse("Backend defaultModel must be a nonempty string of at most 100 characters.");
+    }
+    return {
+        label,
+        host: host.origin,
+        keyEnv: spec.keyEnv,
+        modelsVerifyKey: spec.modelsVerifyKey === true,
+        ...(spec.path === undefined ? {} : { path: spec.path }),
+        ...(spec.modelsPath === undefined ? {} : { modelsPath: spec.modelsPath }),
+        ...(spec.modelsField === undefined ? {} : { modelsField: spec.modelsField }),
+        ...(spec.modelsIdField === undefined ? {} : { modelsIdField: spec.modelsIdField }),
+        ...(spec.defaultModel === undefined ? {} : { defaultModel: spec.defaultModel }),
+    };
+}
+/** The destination host only — scheme, host, and port, e.g. `api.commandcode.ai` — for consent text. */
+export function backendHost(backend) {
+    return new URL(resolveBackend(backend).host).host;
+}

package/node_modules/pi-typesafe/dist/client.d.ts

@@ -1,14 +1,14 @@
 import type { Fetch, Questions, SystemOneRequest, SystemOneResult } from "@typesafe-ai/sdk";
-import type { TypeSafeBackend } from "./backends.js";
+import type { BackendSpec } from "./backends.js";
 import type { BatchEvaluation, BatchOptions } from "./batch.js";
 import type { BlockedCap, SpendCaps, UsageLedger, UsageReport } from "./usage.js";
-export { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
-export type { BackendConfig, TypeSafeBackend } from "./backends.js";
+export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export type { BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, TypeSafeBackend } from "./backends.js";
 export interface TypeSafeOptions {
     /** Defaults to TYPESAFE_API_KEY, then the key saved by `/typesafe login`; never returned. */
     apiKey?: string;
-    /** Judgment backend. When omitted, routes to the default TypeSafe host. */
-    backend?: TypeSafeBackend;
+    /** Judgment backend: a registry name or a caller-supplied endpoint. When omitted, routes to the default TypeSafe host. */
+    backend?: BackendSpec;
     /** Defaults to the backend's own default (`jev-latest`, `typesafe/jev-1.13` on OpenRouter); a bare Jev id is mapped to the backend's id form before sending. No model is inferred from submitted content. */
     model?: string;
     /** Per request. Default: 15 seconds. No automatic retries. */

package/node_modules/pi-typesafe/dist/client.js

@@ -1,12 +1,12 @@
 import { TypeSafeClient } from "@typesafe-ai/sdk";
 import { recordAuthFailure, recordAuthVerified } from "./auth.js";
-import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, backendConfig, backendModelId, defaultModelId, usesTypesafeKey } from "./backends.js";
+import { TYPESAFE_KEY_ENV, backendModelId, resolveBackend, usesTypesafeKey } from "./backends.js";
 import { evaluateAll, evaluateMany } from "./batch.js";
 import { keySituation } from "./credentials.js";
 import { TypeSafeIntegrationError, safeError } from "./errors.js";
 import { DEFAULT_MAX_INPUT_BYTES, assertWithinByteLimit, prepareEvaluationRequest } from "./schema.js";
 import { DEFAULT_USD_PER_MTOK, capsFromEnvironment, estimateUsd, mergeCaps, openUsageLedger } from "./usage.js";
-export { DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
+export { backendHost, resolveBackend, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./backends.js";
 /** The paths the SDK appends to whatever base URL it is given. */
 const SDK_PATH = "/v1/systemone";
 const SDK_MODELS_PATH = "/v1/models";
@@ -118,13 +118,14 @@ function capsDescription(caps) {
 }
 /** A bounded, server-side TypeSafe client independent of Pi's runtime. */
 export function createTypeSafe(options = {}) {
+    const backend = resolveBackend(options.backend);
     let apiKey = options.apiKey?.trim();
-    const backendName = options.backend ?? DEFAULT_BACKEND;
-    const backend = backendConfig(backendName);
     const baseURL = backend.host;
+    // Only a registry backend maps ids; a caller-supplied endpoint's model is sent as the caller wrote it.
+    const mapModel = (model) => (backend.name === undefined ? model : backendModelId(backend.name, model));
     if (!apiKey) {
         // The same resolution that authState() and ensureApiKey() report, so the status line and the request agree.
-        const situation = keySituation(backendName);
+        const situation = keySituation(options.backend);
         if (situation.kind === "unusable")
             throw new TypeSafeIntegrationError("configuration", situation.reason);
         if (situation.kind === "environment" || situation.kind === "stored")
@@ -148,10 +149,12 @@ export function createTypeSafe(options = {}) {
     const transport = backend.path !== undefined || backend.modelsPath !== undefined ? backendFetch(backend, options.fetch) : options.fetch;
     // The caller's input is validated as written, then mapped to the backend's id form; omitting it sends the backend's
     // own default, which the mapping leaves unchanged.
-    const requested = options.model ?? defaultModelId(backendName);
+    const requested = options.model ?? backend.defaultModel;
+    if (requested === undefined)
+        throw new TypeSafeIntegrationError("configuration", `Backend "${backend.label}" names no defaultModel; pass model to createTypeSafe.`);
     if (typeof requested !== "string" || !requested.trim() || requested.length > 100)
         throw new TypeSafeIntegrationError("configuration", "model must be a nonempty string of at most 100 characters.");
-    const model = backendModelId(backendName, requested);
+    const model = mapModel(requested);
     // Do not inherit SDK debug logging or alternate destinations from the environment.
     const client = new TypeSafeClient({
         apiKey,
@@ -187,7 +190,7 @@ export function createTypeSafe(options = {}) {
                 if (!Array.isArray(models))
                     throw new TypeSafeIntegrationError("response", "TypeSafe returned an unexpected model list.");
                 // A backend that serves its list publicly accepts any key, so a success there proves nothing about one.
-                if (backend.modelsVerifyKey !== false && !verificationRecorded) {
+                if (backend.modelsVerifyKey && !verificationRecorded) {
                     verificationRecorded = true;
                     recordAuthVerified();
                 }
@@ -200,7 +203,7 @@ export function createTypeSafe(options = {}) {
         async evaluate(input, callOptions = {}) {
             const validated = prepareEvaluationRequest(input, { maxInputBytes });
             // A per-request model meets the same mapping as the client default; the schema already limited the caller's own id.
-            const body = JSON.stringify({ ...validated, model: validated.model === undefined ? model : backendModelId(backendName, validated.model) });
+            const body = JSON.stringify({ ...validated, model: validated.model === undefined ? model : mapModel(validated.model) });
             assertWithinByteLimit(body, maxInputBytes);
             if (callOptions.signal?.aborted)
                 throw new TypeSafeIntegrationError("aborted", "TypeSafe request cancelled before submission.");

package/node_modules/pi-typesafe/dist/credentials.d.ts

@@ -1,6 +1,9 @@
-import type { TypeSafeBackend } from "./backends.js";
+import type { BackendSpec } from "./backends.js";
 export type KeySource = "environment" | "stored";
-/** The complete, never-throwing answer to "which key is in effect". */
+/**
+ * The complete answer to "which key is in effect" for a valid backend: it never throws. An invalid backend — an
+ * unknown name or an endpoint object that fails validation — throws the same `configuration` error as resolveBackend.
+ */
 export type KeySituation = 
 /** `keyEnv` names the variable that was read; absent means `TYPESAFE_API_KEY`. */
 {
@@ -30,21 +33,24 @@ export declare function normalizeApiKey(value: unknown): string;
  */
 export declare function readStoredApiKey(): string | undefined;
 /**
- * What the environment, the login store, and file permissions add up to right now for one judgment backend. Never
- * throws; the "unusable" kind carries the user-facing reason (a stored key that other local users can read).
+ * What the environment, the login store, and file permissions add up to right now for one judgment backend. A valid
+ * backend never throws: the "unusable" kind carries the user-facing reason (a stored key that other local users can
+ * read). An invalid backend — an unknown name or an endpoint object that fails validation — throws the same
+ * `configuration` error as resolveBackend(), so validate a user-supplied endpoint with resolveBackend() first.
  * The TypeSafe backend reads `TYPESAFE_API_KEY`, then the login store. Every other backend reads only its own
  * environment variable, because the store holds a TypeSafe key and a login verifies against api.typesafe.ai.
  */
-export declare function keySituation(backend?: TypeSafeBackend): KeySituation;
+export declare function keySituation(backend?: BackendSpec): KeySituation;
 /** Short phrase naming the source; full sentences stay with the caller. */
 export declare function keySourceLabel(situation: KeySituation): string;
 /**
  * The pre-0.4.0 key interface, frozen for existing callers: environment first so CI and scripts stay explicit, the
  * stored key as the interactive default, `undefined` when no key is configured, and a `configuration` error when a
- * store must not be read. New code should call keySituation() instead: same precedence, never throws, and the
- * "must not be read" case arrives as `unusable` with the reason.
+ * store must not be read. New code should call keySituation() instead: same precedence, never throws for a valid
+ * backend (an invalid one throws resolveBackend's `configuration` error), and the "must not be read" case arrives as
+ * `unusable` with the reason.
  */
-export declare function resolveApiKey(backend?: TypeSafeBackend): {
+export declare function resolveApiKey(backend?: BackendSpec): {
     key: string;
     source: KeySource;
 } | undefined;

package/node_modules/pi-typesafe/dist/credentials.js

@@ -1,7 +1,7 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, backendConfig, usesTypesafeKey } from "./backends.js";
+import { DEFAULT_BACKEND, TYPESAFE_KEY_ENV, resolveBackend, usesTypesafeKey } from "./backends.js";
 import { TypeSafeIntegrationError } from "./errors.js";
 /** Mirrors Pi's agent directory rule; every pi-typesafe file lives in this one directory. */
 export function piTypesafeDir() {
@@ -45,14 +45,16 @@ export function readStoredApiKey() {
     }
 }
 /**
- * What the environment, the login store, and file permissions add up to right now for one judgment backend. Never
- * throws; the "unusable" kind carries the user-facing reason (a stored key that other local users can read).
+ * What the environment, the login store, and file permissions add up to right now for one judgment backend. A valid
+ * backend never throws: the "unusable" kind carries the user-facing reason (a stored key that other local users can
+ * read). An invalid backend — an unknown name or an endpoint object that fails validation — throws the same
+ * `configuration` error as resolveBackend(), so validate a user-supplied endpoint with resolveBackend() first.
  * The TypeSafe backend reads `TYPESAFE_API_KEY`, then the login store. Every other backend reads only its own
  * environment variable, because the store holds a TypeSafe key and a login verifies against api.typesafe.ai.
  */
 export function keySituation(backend = DEFAULT_BACKEND) {
-    const config = backendConfig(backend);
-    const keyEnv = config.keyEnv ?? TYPESAFE_KEY_ENV;
+    const config = resolveBackend(backend);
+    const keyEnv = config.keyEnv;
     const fromEnvironment = process.env[keyEnv]?.trim();
     if (fromEnvironment)
         return { kind: "environment", key: fromEnvironment, keyEnv };
@@ -82,8 +84,9 @@ export function keySourceLabel(situation) {
 /**
  * The pre-0.4.0 key interface, frozen for existing callers: environment first so CI and scripts stay explicit, the
  * stored key as the interactive default, `undefined` when no key is configured, and a `configuration` error when a
- * store must not be read. New code should call keySituation() instead: same precedence, never throws, and the
- * "must not be read" case arrives as `unusable` with the reason.
+ * store must not be read. New code should call keySituation() instead: same precedence, never throws for a valid
+ * backend (an invalid one throws resolveBackend's `configuration` error), and the "must not be read" case arrives as
+ * `unusable` with the reason.
  */
 export function resolveApiKey(backend = DEFAULT_BACKEND) {
     const situation = keySituation(backend);

package/node_modules/pi-typesafe/dist/errors.d.ts

@@ -1,4 +1,4 @@
-import type { BackendConfig, TypeSafeBackend } from "./backends.js";
+import type { BackendConfig, BackendSpec } from "./backends.js";
 export type IntegrationErrorCode = "configuration" | "validation" | "budget" | "aborted" | "timeout" | "http" | "connection" | "response";
 /**
  * Safe to display: never contains upstream bodies, keys, or submitted state. The only header value a message can
@@ -14,4 +14,4 @@ export declare class TypeSafeIntegrationError extends Error {
  * Classify an error into a message safe to display. `backend` names the key variable the 401 advice tells the user
  * to check and selects the 402 wording; omitting it keeps the one-argument call and assumes the default TypeSafe key.
  */
-export declare function safeError(error: unknown, backend?: TypeSafeBackend | BackendConfig): TypeSafeIntegrationError;
+export declare function safeError(error: unknown, backend?: BackendSpec | BackendConfig): TypeSafeIntegrationError;

package/node_modules/pi-typesafe/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
-export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, } from "./client.js";
+export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export type { TypeSafe, TypeSafeOptions, EvaluationOptions, Evaluation, UsageSnapshot, SpendReport, TypeSafeBackend, BackendConfig, BackendEndpoint, BackendSpec, ResolvedBackend, } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export type { AskAnswer, AskOptions, Judge } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";

package/node_modules/pi-typesafe/dist/index.js

@@ -1,4 +1,4 @@
-export { createTypeSafe, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
+export { createTypeSafe, backendHost, resolveBackend, DEFAULT_MAX_REQUESTS, DECISIONS_BACKENDS, DEFAULT_BACKEND } from "./client.js";
 export { ask, DEFAULT_ASK_TIMEOUT_MS } from "./ask.js";
 export { fanOut, DEFAULT_CONCURRENCY, evaluateMany, evaluateAll, chunkEvaluationRequest } from "./batch.js";
 export { authState, authStatePath, clearAuthState, describeAuth, recordAuthFailure, recordAuthVerified } from "./auth.js";

package/node_modules/pi-typesafe/dist/login.d.ts

@@ -1,5 +1,5 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import type { TypeSafeBackend } from "./backends.js";
+import type { BackendSpec } from "./backends.js";
 import type { KeySource } from "./credentials.js";
 export interface LoginResult {
     /** Where the verified key was saved. */
@@ -29,5 +29,5 @@ export type EnsureApiKeyResult = {
  * the prompt would verify the key against the wrong service and store it where the TypeSafe key lives.
  */
 export declare function ensureApiKey(ctx: ExtensionCommandContext, options?: {
-    backend?: TypeSafeBackend;
+    backend?: BackendSpec;
 }): Promise<EnsureApiKeyResult | undefined>;

package/node_modules/pi-typesafe/dist/login.js

@@ -1,4 +1,4 @@
-import { DEFAULT_BACKEND, backendConfig, usesTypesafeKey } from "./backends.js";
+import { DEFAULT_BACKEND, resolveBackend, usesTypesafeKey } from "./backends.js";
 import { createTypeSafe } from "./client.js";
 import { keySituation, normalizeApiKey, storeApiKey } from "./credentials.js";
 import { TypeSafeIntegrationError } from "./errors.js";
@@ -38,7 +38,7 @@ export async function ensureApiKey(ctx, options = {}) {
         return { source: situation.kind };
     if (situation.kind === "unusable")
         throw new TypeSafeIntegrationError("configuration", situation.reason);
-    const config = backendConfig(backend);
+    const config = resolveBackend(backend);
     if (!usesTypesafeKey(config)) {
         throw new TypeSafeIntegrationError("configuration", `No ${config.label} key. Set ${config.keyEnv} in the environment; /typesafe login stores a TypeSafe key only.`);
     }

package/node_modules/pi-typesafe/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-typesafe",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "TypeSafe AI (Jev) decisions for Pi: batched Choice/Score/Noul evaluation tool, terminal playground, and a typed API other extensions build on.",
   "type": "module",
   "license": "MIT",
@@ -64,12 +64,12 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@typesafe-ai/sdk": "^0.6.0",
-    "typebox": "^1.3.31"
+    "@typesafe-ai/sdk": "^0.6.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.85.1 <1",
-    "@earendil-works/pi-tui": ">=0.85.1 <1"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {

package/node_modules/pi-web-access/package.json

@@ -60,14 +60,14 @@
     "p-limit": "^6.1.0",
     "promise.try": "^2.0.1",
     "turndown": "^7.2.0",
-    "typebox": "^1.1.38",
     "unpdf": "^1.6.2",
     "undici": "^8.9.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "pi": {
     "extensions": [

package/node_modules/remote-pi/package.json

@@ -81,8 +81,12 @@
     "@noble/ed25519": "^3.1.0",
     "croner": "^10.0.1",
     "qrcode-terminal": "^0.12.0",
-    "typebox": "^1.1.38",
     "ws": "^8.21.0",
     "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/pi-extensions",
-  "version": "2026.9.17",
+  "version": "2026.9.18",
   "description": "Aggregate installer for HerbertGao-maintained Pi extensions.",
   "keywords": [
     "extensions",
@@ -38,20 +38,13 @@
     "@ast-grep/napi": "^0.45.0",
     "@bufbuild/protobuf": "^2.14.0",
     "@dietrichgebert/ponytail": "4.10.0",
-    "@earendil-works/pi-ai": "^0.87.1",
-    "@earendil-works/pi-coding-agent": "^0.87.1",
-    "@earendil-works/pi-tui": "^0.87.1",
-    "@herbertgao/pi-bark": "0.1.3",
-    "@herbertgao/pi-cc-extensions": "0.9.5",
-    "@herbertgao/pi-subagents": "0.18.3",
-    "@herbertgao/resume-from": "0.2.3",
-    "@herbertgao/sol-pi": "0.3.3",
+    "@herbertgao/pi-bark": "0.1.4",
+    "@herbertgao/pi-cc-extensions": "0.9.6",
+    "@herbertgao/pi-subagents": "0.18.4",
+    "@herbertgao/resume-from": "0.2.4",
+    "@herbertgao/sol-pi": "0.3.4",
     "@juicesharp/rpiv-ask-user-question": "2.11.0",
     "@juicesharp/rpiv-config": "^2.11.0",
-    "@modelcontextprotocol/client": "2.0.0",
-    "@modelcontextprotocol/core": "2.0.0",
-    "@modelcontextprotocol/ext-apps": "^1.2.2",
-    "@modelcontextprotocol/ext-tasks": "^0.1.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@mozilla/readability": "^0.6.0",
     "@napi-rs/keyring": "^2.1.0",
@@ -61,20 +54,16 @@
     "@noble/ed25519": "^3.1.0",
     "@pi-plugins/fast-mode": "0.1.12",
     "@shikijs/cli": "^4.0.2",
-    "@sinclair/typebox": "^0.34.49",
     "@tifan/pi-copy-response": "0.2.7",
-    "@tifan/pi-handoff": "2.2.1",
+    "@tifan/pi-handoff": "2.2.2",
     "@tifan/pi-inline-skills": "1.0.6",
     "@tifan/pi-mermaid-open": "0.2.1",
     "@tifan/pi-preferred-thinking": "1.0.2",
     "@tifan/pi-recap": "0.4.7",
     "@tifan/pi-rename": "0.6.0",
     "@typesafe-ai/sdk": "0.6.0",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
     "chalk": "^6.0.0",
     "croner": "^10.0.1",
-    "cross-spawn": "^7.0.6",
     "dbus-native": "^0.15.2",
     "defuddle": "0.19.3",
     "gpt-tokenizer": "^3.4.0",
@@ -84,27 +73,21 @@
     "linkedom": "^0.16.0",
     "minimatch": "^10.2.6",
     "nanoid": "^5.0.0",
-    "open": "^10.2.0",
     "p-limit": "^6.1.0",
     "pi-antigravity": "0.7.2",
     "pi-footer": "0.5.1",
     "pi-jev-auto-mode": "0.5.0",
     "pi-lens": "4.3.0",
-    "pi-mcp-adapter": "2.38.0",
     "pi-multi-account": "1.23.2",
     "pi-next-cue": "1.0.7",
-    "pi-typesafe": "0.7.4",
+    "pi-typesafe": "0.8.0",
     "pi-web-access": "0.31.0",
     "pidusage": "^4.0.1",
     "promise.try": "^2.0.1",
     "proper-lockfile": "4.1.2",
     "qrcode-terminal": "^0.12.0",
-    "recheck": "4.6.0-beta.3",
     "remote-pi": "0.7.0",
-    "smol-toml": "^1.6.1",
-    "strip-json-comments": "^5.0.3",
     "turndown": "^7.2.0",
-    "typebox": "^1.1.38",
     "unbash": "4.0.10",
     "undici": "^8.9.0",
     "unpdf": "^1.6.2",
@@ -112,6 +95,14 @@
     "ws": "^8.21.0",
     "zod": "^3.25.0 || ^4.0.0"
   },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "@sinclair/typebox": "*",
+    "typebox": "*"
+  },
   "optionalDependencies": {
     "web-tree-sitter": "0.25.10"
   },
@@ -138,7 +129,6 @@
     "pi-footer",
     "pi-jev-auto-mode",
     "pi-lens",
-    "pi-mcp-adapter",
     "pi-multi-account",
     "pi-next-cue",
     "pi-typesafe",
@@ -168,7 +158,6 @@
       "./node_modules/@narumitw/pi-btw/dist/index.ts",
       "./node_modules/@narumitw/pi-caffeinate/dist/index.ts",
       "./node_modules/@pi-plugins/fast-mode/dist/index.mjs",
-      "./node_modules/pi-mcp-adapter/index.ts",
       "./node_modules/pi-jev-auto-mode/index.ts",
       "./node_modules/pi-multi-account/index.ts",
       "./node_modules/pi-next-cue/index.ts",
@@ -185,7 +174,6 @@
     ],
     "skills": [
       "./node_modules/@dietrichgebert/ponytail/skills",
-      "./node_modules/pi-mcp-adapter/skills",
       "./node_modules/pi-lens/skills"
     ]
   }