@herbertgao/pi-extensions 2026.9.17 → 2026.9.19

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

@@ -1,6 +1,6 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { 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 { credentialsPath, keySituation, keySourceLabel, piTypesafeDir } from "./credentials.js";
 import { TypeSafeIntegrationError } from "./errors.js";
 const AUTH_VERSION = 1;
@@ -50,7 +50,11 @@ function writeState(path, state) {
         catch { /* best-effort cleanup only */ }
     }
 }
-/** What the key situation, the last outcome, and the clock add up to for one backend. Never throws. */
+/**
+ * What the key situation, the last outcome, and the clock add up to for a valid backend; it never throws for one. An
+ * invalid backend throws the same `configuration` error as resolveBackend(), so validate a user-supplied endpoint
+ * with resolveBackend() first.
+ */
 export function authState(options = {}) {
     const path = options.path ?? authStatePath();
     const backend = options.backend ?? DEFAULT_BACKEND;
@@ -99,7 +103,7 @@ export function clearAuthState() {
  * state instead of reporting "enabled".
  */
 export function describeAuth(state = authState()) {
-    const config = backendConfig(state.backend ?? DEFAULT_BACKEND);
+    const config = resolveBackend(state.backend);
     const label = `${config.label} key`;
     const since = state.lastFailure ? ` Last failure: ${state.lastFailure.message}${state.lastFailure.at ? ` (${state.lastFailure.at})` : ""}` : "";
     if (state.kind === "missing") {

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

@@ -1,6 +1,6 @@
-export type TypeSafeBackend = "typesafe" | "openrouter";
+export type TypeSafeBackend = "typesafe" | "openrouter" | "commandcode";
 export interface BackendConfig {
-    /** Human name for status lines: "TypeSafe", "OpenRouter". */
+    /** Human name for status lines: "TypeSafe", "OpenRouter", "Command Code". */
     label: string;
     host: string;
     /** The environment variable that carries this backend's key. Absent means the TypeSafe key resolution applies. */
@@ -16,11 +16,32 @@ export interface BackendConfig {
     /** Whether the model list checks the key. A public list accepts any key, so it proves nothing. Absent means it does. */
     modelsVerifyKey?: boolean;
 }
+/** A caller-supplied endpoint that serves the Jev decisions protocol. Passed per call; never added to the registry. */
+export interface BackendEndpoint extends BackendConfig {
+    /** Required. The environment variable with this endpoint's key. Must not be TYPESAFE_API_KEY. */
+    readonly keyEnv: string;
+    /** Model sent when the caller names none. Without it, `model` must be passed to createTypeSafe. */
+    readonly defaultModel?: string;
+}
+/** A registry name or a caller-supplied endpoint. */
+export type BackendSpec = TypeSafeBackend | BackendEndpoint;
+/** A backend resolved and validated: what the client will actually use. */
+export interface ResolvedBackend extends BackendConfig {
+    /** Registry name, absent for a caller-supplied endpoint. */
+    readonly name?: TypeSafeBackend;
+    /** Origin only: scheme, host, and port. */
+    readonly host: string;
+    readonly keyEnv: string;
+    /** The model id sent when the caller names none, already in the backend's form. Absent when the endpoint names none. */
+    readonly defaultModel?: string;
+    /** Always explicit after resolution. */
+    readonly modelsVerifyKey: boolean;
+}
 /** The backend every key and auth function assumes when none is named. */
 export declare const DEFAULT_BACKEND: TypeSafeBackend;
 /** The environment variable and login store that the default backend reads. */
 export declare 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 declare const DECISIONS_BACKENDS: Record<TypeSafeBackend, BackendConfig>;
 /** The registry entry for a backend name; a `configuration` error for a name the registry does not know. */
 export declare function backendConfig(name: TypeSafeBackend): BackendConfig;
@@ -39,3 +60,12 @@ export declare function defaultModelId(backend: TypeSafeBackend): string;
  * its own environment variable. Only the TypeSafe backend has a login store; every other backend is environment-only.
  */
 export declare function usesTypesafeKey(backend: BackendConfig): boolean;
+/**
+ * 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 declare function resolveBackend(backend?: BackendSpec): ResolvedBackend;
+/** The destination host only — scheme, host, and port, e.g. `api.commandcode.ai` — for consent text. */
+export declare function backendHost(backend?: BackendSpec): string;

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.1",
   "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": {
@@ -84,6 +84,7 @@
     "@earendil-works/pi-tui": "^0.86.1",
     "@types/node": "^22.0.0",
     "tsx": "^4.23.13",
+    "typebox": "^1.3.31",
     "typescript": "^7.0.2"
   }
 }

package/node_modules/pi-web-access/CHANGELOG.md

@@ -4,6 +4,78 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.34.0] - 2026-09-30
+
+### Highlights
+
+- Turning on web tools no longer costs a prompt-cache miss on models like DeepSeek. New sessions now pick the activation style that suits the model.
+- Search with Z.ai's GLM Coding Plan and use your plan quota instead of paying per call.
+- `fetch_content` now gets past Cloudflare "Just a moment..." pages by handing off to your other fetch providers.
+- Fetching works on networks where only your configured proxy can resolve hostnames.
+- `undici` is updated to pick up fixes for known security advisories.
+
+### Added
+
+- Search with Z.ai's GLM Coding Plan web search when you select `provider: "zai"`. Set `ZAI_API_KEY` or `zaiApiKey` to your plan key, and set `zaiEndpoint: "china"` if your key comes from bigmodel.cn. Searches use your plan quota instead of per-call billing. Thanks to [@nailuoGG](https://github.com/nailuoGG) for [issue #475](https://github.com/nicobailon/pi-web-access/issues/475) and for live-testing the China endpoint in [issue #479](https://github.com/nicobailon/pi-web-access/issues/479).
+
+### Changed
+
+- `toolActivation` now defaults to `"auto"`. On models that can take tools added mid-conversation, new sessions start with `web_enable` as before. On other models, such as DeepSeek, every enabled web tool is available from the first request, so turning them on no longer makes Pi resend the whole conversation and miss the prompt cache. Set `"dynamic"` to always start with `web_enable`, or `"eager"` to never use it. Resumed sessions keep the tools they already had. The README's Tool activation section explains the trade-off. Thanks to [@tinoy1336](https://github.com/tinoy1336) for [issue #484](https://github.com/nicobailon/pi-web-access/issues/484) and [@jordi9](https://github.com/jordi9) for [issue #481](https://github.com/nicobailon/pi-web-access/issues/481).
+- Keyed Exa searches with default options or `numResults: 5` now call Exa's `/search` endpoint instead of `/answer`, like every other keyed Exa search. Their answer text now comes from the search results instead of Exa's generated answer. If you route Exa through a custom `exaBaseUrl` gateway, it must support `/search`. Thanks to [@SuTang-vain](https://github.com/SuTang-vain) for [issue #470](https://github.com/nicobailon/pi-web-access/issues/470).
+- When `fetch_content` can't get a page, its list of fallback options now explains how to turn on the keyless Jina Reader fallback. It names only the setting you still need and keeps your current or default provider order. The hint doesn't appear if Jina already ran for that fetch, and it warns that Jina's servers fetch the target URLs. Thanks to [@SuTang-vain](https://github.com/SuTang-vain) for [PR #471](https://github.com/nicobailon/pi-web-access/pull/471).
+
+### Fixed
+
+- `fetch_content` now treats a Cloudflare "Just a moment..." challenge page returned with HTTP 200 as a failed fetch, so your configured fallback providers can retrieve the real page. Detection needs Cloudflare's `cf-mitigated: challenge` header or its challenge-page scripts, so a page that only says "Just a moment..." is unaffected. Raw mode still returns the response unchanged, and authenticated fetches report the challenge without falling back to other providers. Thanks to [@SuTang-vain](https://github.com/SuTang-vain) for [issue #472](https://github.com/nicobailon/pi-web-access/issues/472).
+- With `ssrf.trustEnvProxy: true`, the `proxy` configured in `web-search.json` now resolves hostnames for web tools instead of your local DNS, so `fetch_content` works where only the proxy can resolve names. A per-call `proxy` with a different value is still checked against local DNS. When local resolution fails for a request going through the configured proxy, the error now names this setting. Thanks to [@ChenAuCarre](https://github.com/ChenAuCarre) for [issue #476](https://github.com/nicobailon/pi-web-access/issues/476).
+- Exa results without a title are now labeled with their site's hostname, such as `cdn.jsdelivr.net`, instead of `Source N`. Results whose URL has no hostname, such as `mailto:` or `file:` links, still use `Source N`. Thanks to [@SuTang-vain](https://github.com/SuTang-vain) for [PR #469](https://github.com/nicobailon/pi-web-access/pull/469).
+- `undici` is updated to 8.11.2. Earlier 8.x releases, including the 8.10.0 this package previously installed, have known security advisories such as decompression denial of service and a TLS certificate validation bypass. Thanks to [@setanta00](https://github.com/setanta00) for [issue #483](https://github.com/nicobailon/pi-web-access/issues/483).
+
+## [0.33.0] - 2026-09-27
+
+### Highlights
+
+- Keep every web tool available from the first message with `"toolActivation": "eager"`, for models that rarely call `web_enable` on their own.
+- Search with You.com when you select it explicitly.
+- Give each Pi process its own fetched-page cache so parallel sessions stop evicting each other's pages.
+- Model allowlists in `enabledModels` or `--models` now work with every pattern Pi accepts.
+- Resumed older sessions keep the tools they had instead of gaining `web_enable`.
+
+### Added
+
+- Set `"toolActivation": "eager"` in `web-search.json` to skip `web_enable` and keep every enabled web tool available from the first message. With the default `"dynamic"` setting, `web_enable` now tells the model to call it first whenever current, external, or linked information could help. Thanks to [@ackalker](https://github.com/ackalker) for [issue #458](https://github.com/nicobailon/pi-web-access/issues/458).
+- Set `PI_WEB_ACCESS_CACHE_ROOT` to a directory to give a Pi process its own fetched-page cache. The cache goes in a `web-search-cache` folder inside that directory, and `web-search.json` stays where it is. Parallel sessions then stop evicting each other's cached pages. Thanks to [@goodman-b](https://github.com/goodman-b) for [issue #457](https://github.com/nicobailon/pi-web-access/issues/457).
+- You.com is available as an optional search provider. Set `youApiKey` or `YDC_API_KEY`, then select `provider: "you"`, add it to a provider list, or list it in `searchRouting`. It also appears in the Curator. `auto` and `provider: "all"` never pick it. Thanks to [@mouse-value-add](https://github.com/mouse-value-add) for [PR #461](https://github.com/nicobailon/pi-web-access/pull/461).
+
+### Fixed
+
+- Resuming a session that never had `web_enable`, for example one started before pi-web-access was installed or upgraded, no longer adds it partway through the conversation. The session keeps the tools it already had. Thanks to [@nilsoskar](https://github.com/nilsoskar) for [issue #462](https://github.com/nicobailon/pi-web-access/issues/462).
+- Answer mode, query rewrite, and summaries now follow the model list Pi builds from `enabledModels` or `--models`, so every pattern Pi accepts works here too, including patterns such as `@(!(openai-codex))/*` and partial names such as `sonnet`. Before, an allowlist made of those patterns blocked every model. Thanks to [@IdrisGit](https://github.com/IdrisGit) for [issue #463](https://github.com/nicobailon/pi-web-access/issues/463) and [PR #464](https://github.com/nicobailon/pi-web-access/pull/464).
+- `web_enable` now depends on the version of Pi you are running, not an older Pi package that may be installed next to the extension, so those setups no longer lose it. It needs Pi 0.86.0 or newer. On older Pi, every enabled web tool stays available from the start. Thanks to [@PhrZer](https://github.com/PhrZer) for [PR #456](https://github.com/nicobailon/pi-web-access/pull/456) and [@nguyenchiencong](https://github.com/nguyenchiencong) for [issue #444](https://github.com/nicobailon/pi-web-access/issues/444).
+
+## [0.32.0] - 2026-09-26
+
+### Highlights
+
+- Spread Tavily searches across up to 20 API keys, with automatic failover when one runs out of quota.
+- Use Gemini Web browser cookies on KDE Linux, where Chrome keeps its password in KWallet.
+- Search with OpenAI through OpenCode and `opencode-go` without session errors or the wrong model.
+- See full search queries and URLs in tool-call labels.
+- Globally installed Pi no longer shows false version or duplicate TypeBox warnings.
+
+### Added
+
+- Tavily can use a pool of up to 20 API keys. Set `TAVILY_API_KEY_1` through `TAVILY_API_KEY_20`, and when a key hits a quota or auth error the search moves on to the next one. `TAVILY_API_KEY_INDEX` picks the key to try first, and `TAVILY_API_KEY` / `tavilyApiKey` is tried last. Thanks to [@apoapostolov](https://github.com/apoapostolov) for [PR #430](https://github.com/nicobailon/pi-web-access/pull/430).
+
+### Fixed
+
+- On KDE Linux, Chrome and Chromium cookies for Gemini Web now decrypt with the password stored in KWallet when Secret Service doesn't have it. Thanks to [@dianzuan](https://github.com/dianzuan) for [issue #436](https://github.com/nicobailon/pi-web-access/issues/436).
+- OpenAI search requests to `opencode.ai` now include OpenCode's session headers, fixing `400 MissingSessionID` errors. Other destinations never receive these headers. Thanks to [@juliocc](https://github.com/juliocc) for [PR #445](https://github.com/nicobailon/pi-web-access/pull/445).
+- When `openaiSearchModel` isn't set, OpenAI search through gateways such as `opencode-go` now picks the newest GPT model instead of a non-OpenAI model.
+- Globally installed Pi no longer shows a false "requires Pi 0.86.1 or newer" warning, and dynamic tool activation now works there. Thanks to [@samsimsom](https://github.com/samsimsom) for [issue #428](https://github.com/nicobailon/pi-web-access/issues/428).
+- TypeBox now comes from Pi instead of being installed separately, which avoids duplicate copies and Pi startup warnings. Thanks to [@ksreenivasan](https://github.com/ksreenivasan) for [issue #442](https://github.com/nicobailon/pi-web-access/issues/442) and [PR #443](https://github.com/nicobailon/pi-web-access/pull/443).
+- Tool-call labels show full search queries and fetch URLs when the terminal is wide enough, instead of cutting them off at 60 characters. Thanks to [@TheBestPessimist](https://github.com/TheBestPessimist) for [issue #440](https://github.com/nicobailon/pi-web-access/issues/440).
+
 ## [0.31.0] - 2026-09-22
 
 ### Highlights