@herbertgao/pi-extensions 2026.9.12 → 2026.9.14

package/node_modules/pi-mcp-adapter/jev-client.ts

@@ -2,10 +2,9 @@ import { TypeSafeClient } from "@typesafe-ai/sdk";
 import type { McpExtensionState } from "./state.ts";
 import { isServerDisabled } from "./types.ts";
 import { combineAbortSignals } from "./runtime-owner.ts";
-import { resolveJevCredential, TYPESAFE_API_ORIGIN, type JevCredentialResolution } from "./jev-key-store.ts";
+import { JEV_SDK_PATH, resolveJevCredential, resolveJevEndpoint, type JevCredentialResolution, type ResolvedJevEndpoint } from "./jev-key-store.ts";
 import type { JevAnswer, JevBudget, JevEvaluateInput, JevEvaluationData, JevEvaluationEnvelope, JevJson, JevQuestion, ResolvedJevSettings } from "./jev-contracts.ts";
 
-export { TYPESAFE_API_ORIGIN };
 export type { ResolvedJevSettings } from "./jev-contracts.ts";
 
 const DEFAULTS: ResolvedJevSettings = {
@@ -18,18 +17,28 @@ const DEFAULTS: ResolvedJevSettings = {
 const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
 type JevSettingsInput = Partial<ResolvedJevSettings>;
-type Host = { client: TypeSafeClient };
+type Host = { endpoint: ResolvedJevEndpoint; client: TypeSafeClient };
+type CredentialCacheEntry = { endpoint: string; credential: Extract<JevCredentialResolution, { status: "present" }> };
 const hosts = new WeakMap<McpExtensionState, Host>();
-const credentials = new WeakMap<McpExtensionState, Extract<JevCredentialResolution, { status: "present" }>>();
+const credentials = new WeakMap<McpExtensionState, CredentialCacheEntry>();
 
-function resolveCredential(state: McpExtensionState): JevCredentialResolution {
+/**
+ * Cached per endpoint so a changed `SYSTEMONE_ENDPOINT` cannot reuse another provider's credential. Callers
+ * re-resolve the endpoint on every operation so a switched or newly invalid endpoint takes effect immediately.
+ */
+function resolveCredential(state: McpExtensionState, endpoint: ResolvedJevEndpoint): JevCredentialResolution {
   const existing = credentials.get(state);
-  if (existing) return existing;
-  const credential = resolveJevCredential();
-  if (credential.status === "present") credentials.set(state, credential);
+  if (existing && existing.endpoint === endpoint.href) return existing.credential;
+  const credential = resolveJevCredential(process.env, endpoint);
+  if (credential.status === "present") credentials.set(state, { endpoint: endpoint.href, credential });
   return credential;
 }
 
+function credentialForState(state: McpExtensionState): JevCredentialResolution {
+  const resolution = resolveJevEndpoint();
+  return resolution.status === "unavailable" ? resolution : resolveCredential(state, resolution.endpoint);
+}
+
 export function areJevSourcesAllowed(state: McpExtensionState, settings: ResolvedJevSettings, sources: Iterable<string>): boolean {
   for (const source of sources) {
     const server = state.config.mcpServers[source];
@@ -90,7 +99,7 @@ export function resolveSemanticJevSettings(
   const configured = state.config.settings?.jev;
   const settings = validateJevSettings(configured);
   if (configured === false || configured?.semanticSearch === false) return settings;
-  const semanticSearch = settings.semanticSearch || (credentialResolver ? credentialResolver() : resolveCredential(state)).status === "present";
+  const semanticSearch = settings.semanticSearch || (credentialResolver ? credentialResolver() : credentialForState(state)).status === "present";
   const hasExplicitAllowlist = configured !== undefined && Object.hasOwn(configured, "allowedServers");
   const allowedServers = hasExplicitAllowlist
     ? settings.allowedServers
@@ -219,55 +228,73 @@ function validateResponse(value: unknown, input: JevEvaluateInput): JevEvaluatio
   return { answers: validated, model: response.model, usage: { inputTokens: safeNumber(usage.input_tokens, "input tokens", true), outputTokens: safeNumber(usage.output_tokens, "output tokens", true) } };
 }
 
-function fixedOriginFetch(input: string, init?: RequestInit): Promise<Response> {
-  const url = new URL(input);
-  if (url.origin !== TYPESAFE_API_ORIGIN) throw new Error("TypeSafe request origin rejected");
-  return fetch(input, { ...init, redirect: "error" });
+/**
+ * Pins every request to the configured endpoint: the SDK appends its own fixed path to the base URL, so this
+ * rewrites that path onto the configured one and then rejects anything that does not match the endpoint exactly.
+ * Redirects stay refused, so a provider cannot bounce a request carrying the API key somewhere else.
+ */
+function createPinnedEndpointFetch(endpoint: ResolvedJevEndpoint): (input: string, init?: RequestInit) => Promise<Response> {
+  return (input, init) => {
+    // A replacer function keeps `$&`, `$$`, and friends in the configured path literal.
+    const target = input.replace(JEV_SDK_PATH, () => endpoint.path);
+    const url = new URL(target);
+    if (url.origin !== endpoint.origin || url.pathname !== endpoint.path || url.search !== "" || url.hash !== "") {
+      throw new Error("Jev request endpoint rejected");
+    }
+    return fetch(target, { ...init, redirect: "error" });
+  };
 }
 function getHost(state: McpExtensionState, settings: ResolvedJevSettings): Host | JevEvaluationEnvelope {
+  const resolution = resolveJevEndpoint();
+  if (resolution.status === "unavailable") return { ok: false, error: { code: "endpoint_unavailable", message: resolution.message } };
+  const { endpoint } = resolution;
   const existing = hosts.get(state);
-  if (existing) return existing;
-  const credential = resolveCredential(state);
-  if (credential.status === "missing") return { ok: false, error: { code: "credential_missing", message: "TypeSafe API key is not configured." } };
+  if (existing && existing.endpoint.href === endpoint.href) return existing;
+  const credential = resolveCredential(state, endpoint);
+  if (credential.status === "missing") return { ok: false, error: { code: "credential_missing", message: "Jev API key is not configured." } };
   if (credential.status === "unavailable") return { ok: false, error: { code: "credential_unavailable", message: credential.message } };
-  const host = { client: new TypeSafeClient({ apiKey: credential.apiKey, baseURL: TYPESAFE_API_ORIGIN, defaultModel: settings.model, logLevel: "off", retry: { maxRetries: settings.maxRetries }, timeout: settings.requestTimeoutMs, defaultHeaders: {}, fetch: fixedOriginFetch }) };
+  const host: Host = { endpoint, client: new TypeSafeClient({ apiKey: credential.apiKey, baseURL: endpoint.origin, defaultModel: settings.model, logLevel: "off", retry: { maxRetries: settings.maxRetries }, timeout: settings.requestTimeoutMs, defaultHeaders: {}, fetch: createPinnedEndpointFetch(endpoint) }) };
   hosts.set(state, host);
   return host;
 }
 function failure(error: unknown, signal: AbortSignal | undefined, timedOut: boolean): JevEvaluationEnvelope {
-  if (timedOut) return { ok: false, error: { code: "timeout", message: "TypeSafe evaluation timed out.", retryable: true } };
-  if (signal?.aborted || (error instanceof Error && error.name === "APIUserAbortError")) return { ok: false, error: { code: "aborted", message: "TypeSafe evaluation was aborted." } };
+  if (timedOut) return { ok: false, error: { code: "timeout", message: "Jev evaluation timed out.", retryable: true } };
+  if (signal?.aborted || (error instanceof Error && error.name === "APIUserAbortError")) return { ok: false, error: { code: "aborted", message: "Jev evaluation was aborted." } };
+  // Provider and gateway bodies are never echoed; only the status is used to classify the failure.
   const status = typeof error === "object" && error !== null && "status" in error ? (error as { status?: unknown }).status : undefined;
-  if (status === 401 || status === 403) return { ok: false, error: { code: "authentication_failed", message: "TypeSafe authentication failed." } };
-  if (status === 408) return { ok: false, error: { code: "timeout", message: "TypeSafe evaluation timed out.", retryable: true } };
-  if (status === 429) return { ok: false, error: { code: "rate_limited", message: "TypeSafe rate limit exceeded.", retryable: true } };
-  if (typeof status === "number" && status >= 500) return { ok: false, error: { code: "service_unavailable", message: "TypeSafe service is unavailable.", retryable: true } };
-  if (status === 400 || status === 422) return { ok: false, error: { code: "invalid_request", message: "TypeSafe rejected the evaluation request." } };
-  if (error instanceof Error && (error.name === "APIConnectionError" || error.name === "APITimeoutError")) return { ok: false, error: { code: "service_unavailable", message: "TypeSafe service is unavailable.", retryable: true } };
-  return { ok: false, error: { code: "invalid_response", message: "TypeSafe returned an invalid response." } };
+  if (status === 401 || status === 403) return { ok: false, error: { code: "authentication_failed", message: "Jev authentication failed." } };
+  if (status === 402) return { ok: false, error: { code: "payment_required", message: "Jev provider requires payment for this account." } };
+  // A configurable endpoint makes a wrong path a configuration error, not a malformed response.
+  if (status === 404 || status === 405 || status === 410) return { ok: false, error: { code: "endpoint_unavailable", message: "Jev endpoint was not found; check SYSTEMONE_ENDPOINT." } };
+  if (status === 408) return { ok: false, error: { code: "timeout", message: "Jev evaluation timed out.", retryable: true } };
+  if (status === 429) return { ok: false, error: { code: "rate_limited", message: "Jev rate limit exceeded.", retryable: true } };
+  if (typeof status === "number" && status >= 500) return { ok: false, error: { code: "service_unavailable", message: "Jev service is unavailable.", retryable: true } };
+  if (typeof status === "number" && status >= 400) return { ok: false, error: { code: "invalid_request", message: `Jev rejected the evaluation request (HTTP ${status}).` } };
+  if (error instanceof Error && (error.name === "APIConnectionError" || error.name === "APITimeoutError")) return { ok: false, error: { code: "service_unavailable", message: "Jev service is unavailable.", retryable: true } };
+  return { ok: false, error: { code: "invalid_response", message: "Jev returned an invalid response." } };
 }
 
 export async function evaluateJev(state: McpExtensionState, value: JevEvaluateInput, options: { purpose: "script" | "semantic-search"; signal?: AbortSignal; budget?: JevBudget; observedSources?: readonly string[] }): Promise<JevEvaluationEnvelope> {
   let settings: ResolvedJevSettings;
   let input: JevEvaluateInput;
   try { settings = options.purpose === "semantic-search" ? resolveSemanticJevSettings(state) : validateJevSettings(state.config.settings?.jev); input = validateJevEvaluateInput(value, settings); }
-  catch { return { ok: false, error: { code: "invalid_request", message: "Invalid TypeSafe evaluation request or settings." } }; }
-  if ((options.purpose === "script" && !settings.scriptEvaluation) || (options.purpose === "semantic-search" && !settings.semanticSearch)) return { ok: false, error: { code: "disabled", message: "TypeSafe evaluation is disabled." } };
+  catch { return { ok: false, error: { code: "invalid_request", message: "Invalid Jev evaluation request or settings." } }; }
+  if ((options.purpose === "script" && !settings.scriptEvaluation) || (options.purpose === "semantic-search" && !settings.semanticSearch)) return { ok: false, error: { code: "disabled", message: "Jev evaluation is disabled." } };
   const sources = new Set([...(input.sources ?? []), ...(options.observedSources ?? [])]);
   if (!areJevSourcesAllowed(state, settings, sources)) return { ok: false, error: { code: "data_policy_denied", message: "Evaluation sources are not allowed by policy." } };
   const bytes = Buffer.byteLength(JSON.stringify(input));
-  if (options.budget && !options.budget.consume(bytes)) return { ok: false, error: { code: "budget_exhausted", message: "TypeSafe evaluation budget exhausted." } };
+  if (options.budget && !options.budget.consume(bytes)) return { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation budget exhausted." } };
   const resolved = getHost(state, settings);
   if (!("client" in resolved)) return resolved;
   const deadline = new AbortController();
   let timedOut = false;
-  const timer = setTimeout(() => { timedOut = true; deadline.abort(new Error("TypeSafe evaluation deadline exceeded")); }, settings.requestTimeoutMs);
+  const timer = setTimeout(() => { timedOut = true; deadline.abort(new Error("Jev evaluation deadline exceeded")); }, settings.requestTimeoutMs);
   const signal = combineAbortSignals(options.signal, state.owner.signal, deadline.signal);
   try {
     const request = { state: input.state, questions: input.questions, model: settings.model };
     const raw = await resolved.client.systemOne(request as Parameters<TypeSafeClient["systemOne"]>[0], { ...(signal ? { signal } : {}), timeout: settings.requestTimeoutMs, retry: { maxRetries: settings.maxRetries } });
     try { return { ok: true, data: validateResponse(raw, input) }; }
-    catch { return { ok: false, error: { code: "invalid_response", message: "TypeSafe returned an invalid response." } }; }
+    catch { return { ok: false, error: { code: "invalid_response", message: "Jev returned an invalid response." } }; }
   } catch (error) { return failure(error, signal, timedOut); }
   finally { clearTimeout(timer); }
 }

package/node_modules/pi-mcp-adapter/jev-contracts.ts

@@ -25,8 +25,8 @@ export interface JevEvaluationData {
 
 export type JevErrorCode =
   | "disabled" | "invalid_request" | "data_policy_denied" | "budget_exhausted"
-  | "credential_missing" | "credential_unavailable" | "authentication_failed"
-  | "timeout" | "aborted" | "rate_limited" | "service_unavailable" | "invalid_response";
+  | "endpoint_unavailable" | "credential_missing" | "credential_unavailable" | "authentication_failed"
+  | "payment_required" | "timeout" | "aborted" | "rate_limited" | "service_unavailable" | "invalid_response";
 
 export type JevEvaluationEnvelope =
   | { ok: true; data: JevEvaluationData }

package/node_modules/pi-mcp-adapter/jev-key-store.ts

@@ -1,20 +1,44 @@
 import { createSecureKeyringStore, type SecureKeyringStore } from "./secure-keyring.ts";
 
+/** The Jev decisions endpoint used when `SYSTEMONE_ENDPOINT` is not set. */
+export const JEV_DEFAULT_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+const SYSTEMONE_ENDPOINT_ENV = "SYSTEMONE_ENDPOINT";
+const SYSTEMONE_API_KEY_ENV = "SYSTEMONE_API_KEY";
+/** TypeSafe-issued key: honored only for the default endpoint and never sent anywhere else. */
+const LEGACY_TYPESAFE_API_KEY_ENV = "TYPESAFE_API_KEY";
+/** Origin recorded in version 1 credential records. */
 export const TYPESAFE_API_ORIGIN = "https://api.typesafe.ai";
-export const JEV_KEYRING_SERVICE = "pi-mcp-adapter.service-key";
+/** Version 1 credential account, still read for the default endpoint. */
 export const JEV_KEYRING_ACCOUNT = "typesafe@sha256(https://api.typesafe.ai)";
+export const JEV_KEYRING_SERVICE = "pi-mcp-adapter.service-key";
+
+const MAX_ENDPOINT_LENGTH = 512;
+/** The path `@typesafe-ai/sdk` appends to whatever base URL it is given. */
+export const JEV_SDK_PATH = "/v1/systemone";
+
+export interface ResolvedJevEndpoint {
+  /** Canonical absolute URL sent to the provider, for example `https://opencode.ai/zen/v1/systemone`. */
+  readonly href: string;
+  /** URL origin, used as the SDK base URL. */
+  readonly origin: string;
+  /** URL path, rewritten onto the SDK's fixed path by the pinned fetch. */
+  readonly path: string;
+}
+
+export type JevEndpointResolution =
+  | { status: "resolved"; source: "environment" | "default"; endpoint: ResolvedJevEndpoint }
+  | { status: "unavailable"; message: string };
 
 interface StoredJevKey {
-  version: 1;
-  provider: "typesafe";
-  origin: typeof TYPESAFE_API_ORIGIN;
+  version: 2;
+  endpoint: string;
   apiKey: string;
 }
 
 export class JevCredentialStoreError extends Error {
   readonly code = "JEV_CREDENTIAL_STORE_UNAVAILABLE";
   constructor(readonly operation: "read" | "write" | "remove", cause: unknown) {
-    super(`TypeSafe API key secure credential store unavailable during ${operation}. Configure or unlock the OS credential store and retry.`, { cause });
+    super(`Jev API key secure credential store unavailable during ${operation}. Configure or unlock the OS credential store and retry.`, { cause });
     this.name = "JevCredentialStoreError";
   }
 }
@@ -26,54 +50,143 @@ export type JevCredentialResolution =
 
 function validateApiKey(value: unknown): string {
   if (typeof value !== "string" || value.trim().length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
-    throw new Error("TypeSafe API key must be a non-empty string without control characters");
+    throw new Error("Jev API key must be a non-empty string without control characters");
   }
   return value;
 }
 
+/**
+ * Constrains the operator-supplied endpoint to an absolute HTTPS URL without credentials, query, or fragment, so
+ * the pinned fetch can match it exactly and a stray value cannot redirect requests or smuggle a query string.
+ */
+function parseEndpoint(raw: string, label: string): ResolvedJevEndpoint {
+  if (typeof raw !== "string" || raw.trim().length === 0) throw new Error(`${label} must be a non-empty URL`);
+  if (raw.length > MAX_ENDPOINT_LENGTH) throw new Error(`${label} must be at most ${MAX_ENDPOINT_LENGTH} characters`);
+  if (/[\u0000-\u001f\u007f\s]/.test(raw)) throw new Error(`${label} must not contain whitespace or control characters`);
+  let url: URL;
+  try { url = new URL(raw); }
+  catch { throw new Error(`${label} must be an absolute URL`); }
+  if (url.protocol !== "https:") throw new Error(`${label} must use https`);
+  if (url.username !== "" || url.password !== "") throw new Error(`${label} must not embed credentials`);
+  if (url.search !== "") throw new Error(`${label} must not include a query string`);
+  if (url.hash !== "") throw new Error(`${label} must not include a fragment`);
+  if (url.pathname === "" || url.pathname === "/") throw new Error(`${label} must include a path such as ${JEV_SDK_PATH}`);
+  return { href: `${url.origin}${url.pathname}`, origin: url.origin, path: url.pathname };
+}
+
+/**
+ * Resolves the Jev endpoint. An invalid `SYSTEMONE_ENDPOINT` resolves to `unavailable` instead of silently falling
+ * back to the default: sending an operator's judgment payload to a provider they did not ask for would be a data leak.
+ */
+export function resolveJevEndpoint(env: NodeJS.ProcessEnv = process.env): JevEndpointResolution {
+  if (Object.hasOwn(env, SYSTEMONE_ENDPOINT_ENV)) {
+    try { return { status: "resolved", source: "environment", endpoint: parseEndpoint(env[SYSTEMONE_ENDPOINT_ENV] as string, SYSTEMONE_ENDPOINT_ENV) }; }
+    catch (error) { return { status: "unavailable", message: error instanceof Error ? error.message : `${SYSTEMONE_ENDPOINT_ENV} is invalid.` }; }
+  }
+  return { status: "resolved", source: "default", endpoint: parseEndpoint(JEV_DEFAULT_ENDPOINT, "the default Jev endpoint") };
+}
+
+/** Keyring account for an endpoint, so keys for different providers coexist instead of overwriting each other. */
+export function jevKeyringAccount(endpoint: ResolvedJevEndpoint): string {
+  return `systemone@sha256(${endpoint.href})`;
+}
+
 function store(): SecureKeyringStore {
   return createSecureKeyringStore(JEV_KEYRING_SERVICE);
 }
 
-function readStoredKey(secretStore: SecureKeyringStore = store()): string | undefined {
-  let payload: string | undefined;
-  try { payload = secretStore.read(JEV_KEYRING_ACCOUNT); }
-  catch (error) { throw new JevCredentialStoreError("read", error); }
-  if (payload === undefined) return undefined;
-  try {
-    const value: unknown = JSON.parse(payload);
-    if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid record");
-    const record = value as Partial<StoredJevKey>;
-    const keys = Object.keys(record);
+function requireEndpoint(endpoint: ResolvedJevEndpoint | undefined): ResolvedJevEndpoint {
+  if (endpoint) return endpoint;
+  const resolution = resolveJevEndpoint();
+  if (resolution.status === "unavailable") throw new Error(resolution.message);
+  return resolution.endpoint;
+}
+
+/**
+ * Version 1 records were written before the endpoint was configurable, so they are accepted only for the default
+ * endpoint.
+ */
+function parseStoredKey(payload: string, endpoint: ResolvedJevEndpoint): string {
+  let value: unknown;
+  try { value = JSON.parse(payload); }
+  catch { throw new Error("invalid record"); }
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid record");
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record);
+  if (record.version === 2) {
+    if (keys.length !== 3 || !["version", "endpoint", "apiKey"].every(key => Object.hasOwn(record, key))) throw new Error("invalid record fields");
+    if (record.endpoint !== endpoint.href) throw new Error("invalid or mismatched record");
+    return validateApiKey(record.apiKey);
+  }
+  if (record.version === 1) {
     if (keys.length !== 4 || !["version", "provider", "origin", "apiKey"].every(key => Object.hasOwn(record, key))) throw new Error("invalid record fields");
-    if (record.version !== 1 || record.provider !== "typesafe" || record.origin !== TYPESAFE_API_ORIGIN) throw new Error("invalid or mismatched record");
+    if (record.provider !== "typesafe" || record.origin !== TYPESAFE_API_ORIGIN) throw new Error("invalid or mismatched record");
+    if (endpoint.href !== JEV_DEFAULT_ENDPOINT) throw new Error("invalid or mismatched record");
     return validateApiKey(record.apiKey);
+  }
+  throw new Error("invalid record version");
+}
+
+function readStoredKey(secretStore: SecureKeyringStore, endpoint: ResolvedJevEndpoint): string | undefined {
+  try {
+    let payload = secretStore.read(jevKeyringAccount(endpoint));
+    if (payload === undefined && endpoint.href === JEV_DEFAULT_ENDPOINT) payload = secretStore.read(JEV_KEYRING_ACCOUNT);
+    return payload === undefined ? undefined : parseStoredKey(payload, endpoint);
   } catch (error) {
     throw new JevCredentialStoreError("read", error);
   }
 }
 
-export function resolveJevCredential(env: NodeJS.ProcessEnv = process.env, secretStore?: SecureKeyringStore): JevCredentialResolution {
-  if (Object.hasOwn(env, "TYPESAFE_API_KEY")) {
-    try { return { status: "present", source: "environment", apiKey: validateApiKey(env.TYPESAFE_API_KEY) }; }
-    catch { return { status: "unavailable", message: "TYPESAFE_API_KEY is present but invalid." }; }
+export function resolveJevCredential(
+  env: NodeJS.ProcessEnv = process.env,
+  endpoint?: ResolvedJevEndpoint,
+  secretStore: SecureKeyringStore = store(),
+): JevCredentialResolution {
+  let target: ResolvedJevEndpoint;
+  if (endpoint) target = endpoint;
+  else {
+    const resolution = resolveJevEndpoint(env);
+    if (resolution.status === "unavailable") return resolution;
+    target = resolution.endpoint;
   }
-  try {
-    const apiKey = readStoredKey(secretStore ?? store());
-    return apiKey === undefined ? { status: "missing" } : { status: "present", source: "keyring", apiKey };
-  } catch (error) {
+  if (Object.hasOwn(env, SYSTEMONE_API_KEY_ENV)) {
+    try { return { status: "present", source: "environment", apiKey: validateApiKey(env[SYSTEMONE_API_KEY_ENV]) }; }
+    catch { return { status: "unavailable", message: `${SYSTEMONE_API_KEY_ENV} is present but invalid.` }; }
+  }
+  const legacySet = Object.hasOwn(env, LEGACY_TYPESAFE_API_KEY_ENV);
+  if (legacySet && target.href === JEV_DEFAULT_ENDPOINT) {
+    try { return { status: "present", source: "environment", apiKey: validateApiKey(env[LEGACY_TYPESAFE_API_KEY_ENV]) }; }
+    catch { return { status: "unavailable", message: `${LEGACY_TYPESAFE_API_KEY_ENV} is present but invalid.` }; }
+  }
+  let stored: string | undefined;
+  try { stored = readStoredKey(secretStore, target); }
+  catch (error) {
     if (!(error instanceof JevCredentialStoreError)) throw error;
     return { status: "unavailable", message: error.message };
   }
+  if (stored !== undefined) return { status: "present", source: "keyring", apiKey: stored };
+  // A TypeSafe-issued credential is never sent to another endpoint, but it must not mask a credential stored for
+  // this endpoint either, so it is only reported once nothing for this endpoint resolves.
+  if (legacySet) {
+    return {
+      status: "unavailable",
+      message: `${LEGACY_TYPESAFE_API_KEY_ENV} is a TypeSafe credential and is not sent to ${target.href}; set ${SYSTEMONE_API_KEY_ENV} for that endpoint.`,
+    };
+  }
+  return { status: "missing" };
 }
 
-export function saveJevApiKey(apiKey: string, secretStore: SecureKeyringStore = store()): void {
-  const record: StoredJevKey = { version: 1, provider: "typesafe", origin: TYPESAFE_API_ORIGIN, apiKey: validateApiKey(apiKey) };
-  try { secretStore.write(JEV_KEYRING_ACCOUNT, JSON.stringify(record)); }
+export function saveJevApiKey(apiKey: string, endpoint?: ResolvedJevEndpoint, secretStore: SecureKeyringStore = store()): void {
+  const target = requireEndpoint(endpoint);
+  const record: StoredJevKey = { version: 2, endpoint: target.href, apiKey: validateApiKey(apiKey) };
+  try { secretStore.write(jevKeyringAccount(target), JSON.stringify(record)); }
   catch (error) { throw new JevCredentialStoreError("write", error); }
 }
 
-export function removeJevApiKey(secretStore: SecureKeyringStore = store()): void {
-  try { secretStore.remove(JEV_KEYRING_ACCOUNT); }
-  catch (error) { throw new JevCredentialStoreError("remove", error); }
+export function removeJevApiKey(endpoint?: ResolvedJevEndpoint, secretStore: SecureKeyringStore = store()): void {
+  const target = requireEndpoint(endpoint);
+  try {
+    secretStore.remove(jevKeyringAccount(target));
+    if (target.href === JEV_DEFAULT_ENDPOINT) secretStore.remove(JEV_KEYRING_ACCOUNT);
+  } catch (error) { throw new JevCredentialStoreError("remove", error); }
 }

package/node_modules/pi-mcp-adapter/mcp-auth-flow.ts

@@ -1191,9 +1191,8 @@ export async function getValidToken(
     }
   }
 
-  // No expiration info or no refresh token, assume valid
   authority()
-  return entry.tokens
+  return null
 }
 
 /**

package/node_modules/pi-mcp-adapter/mcp-code.ts

@@ -213,7 +213,7 @@ export async function runMcpScript(
   let evaluationAttempts = 0;
   let evaluationBytes = 0;
   let evaluationTokensRemaining = jevSettings.maxEvaluationTokensPerScript;
-  const tokenBudgetExhausted = (): JevEvaluationEnvelope => ({ ok: false, error: { code: "budget_exhausted", message: "TypeSafe evaluation token budget exhausted." } });
+  const tokenBudgetExhausted = (): JevEvaluationEnvelope => ({ ok: false, error: { code: "budget_exhausted", message: "Jev evaluation token budget exhausted." } });
   const chargeEvaluationTokens = (envelope: JevEvaluationEnvelope): JevEvaluationEnvelope => {
     if (!envelope.ok) return envelope;
     const used = envelope.data.usage.inputTokens + envelope.data.usage.outputTokens;
@@ -226,16 +226,16 @@ export async function runMcpScript(
   };
   const admitEvaluation = (input: unknown): JevEvaluationEnvelope | undefined => {
     if (++evaluationAttempts > jevSettings.maxEvaluationsPerScript) {
-      return { ok: false, error: { code: "budget_exhausted", message: "TypeSafe evaluation count budget exhausted." } };
+      return { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation count budget exhausted." } };
     }
     if (evaluationTokensRemaining === 0) return tokenBudgetExhausted();
     let serialized: string | undefined;
     try { serialized = JSON.stringify(input); }
-    catch { return { ok: false, error: { code: "invalid_request", message: "Invalid TypeSafe evaluation request." } }; }
-    if (serialized === undefined) return { ok: false, error: { code: "invalid_request", message: "Invalid TypeSafe evaluation request." } };
+    catch { return { ok: false, error: { code: "invalid_request", message: "Invalid Jev evaluation request." } }; }
+    if (serialized === undefined) return { ok: false, error: { code: "invalid_request", message: "Invalid Jev evaluation request." } };
     const bytes = Buffer.byteLength(serialized, "utf8");
     if (bytes > jevSettings.maxEvaluationBytesPerScript - evaluationBytes) {
-      return { ok: false, error: { code: "budget_exhausted", message: "TypeSafe evaluation byte budget exhausted." } };
+      return { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation byte budget exhausted." } };
     }
     evaluationBytes += bytes;
     return undefined;
@@ -257,7 +257,7 @@ export async function runMcpScript(
     envelope = chargeEvaluationTokens(envelope);
     throwIfAborted(callSignal);
     if (!reserveIntermediateBytes(JSON.stringify(envelope))) {
-      envelope = { ok: false, error: { code: "budget_exhausted", message: "TypeSafe evaluation exceeds the remaining mcpScript intermediate transfer budget (16 MiB per script)." } };
+      envelope = { ok: false, error: { code: "budget_exhausted", message: "Jev evaluation exceeds the remaining mcpScript intermediate transfer budget (16 MiB per script)." } };
     }
     calls[index] = envelope.ok
       ? {

package/node_modules/pi-mcp-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.36.0",
+  "version": "2.37.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "types": "./index.ts",
@@ -185,7 +185,7 @@
     "zod": "^3.25.0 || ^4.0.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "^0.84.1 || ^0.85.0 || ^0.86.0",
+    "@earendil-works/pi-ai": "^0.84.1 || ^0.85.0 || ^0.86.0 || ^0.87.0",
     "@earendil-works/pi-tui": "*",
     "typebox": "*",
     "zod": "^3.25.0 || ^4.0.0"
@@ -202,9 +202,9 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.86.0",
-    "@earendil-works/pi-coding-agent": "0.86.0",
-    "@earendil-works/pi-tui": "0.86.0",
+    "@earendil-works/pi-ai": "0.87.0",
+    "@earendil-works/pi-coding-agent": "0.87.0",
+    "@earendil-works/pi-tui": "0.87.0",
     "@modelcontextprotocol/conformance": "0.1.16",
     "@types/bun": "^1.0.0",
     "@types/cross-spawn": "6.0.6",

package/node_modules/pi-mcp-adapter/semantic-search.ts

@@ -114,10 +114,10 @@ export async function semanticSearch(
   try {
     settings = resolveSemanticJevSettings(state);
   } catch {
-    return { ok: false, error: { code: "invalid_request", message: "Invalid TypeSafe semantic search settings." } };
+    return { ok: false, error: { code: "invalid_request", message: "Invalid Jev semantic search settings." } };
   }
   if (!settings.semanticSearch) {
-    return { ok: false, error: { code: "disabled", message: "TypeSafe semantic search is disabled." } };
+    return { ok: false, error: { code: "disabled", message: "Jev semantic search is disabled." } };
   }
   if (settings.allowedServers.length === 0) {
     return { ok: false, error: { code: "data_policy_denied", message: "Semantic search is enabled, but settings.jev.allowedServers is empty. Run /mcp jev setup or allow specific MCP servers." } };
@@ -166,7 +166,7 @@ export async function semanticSearch(
   }
   const answer = envelope.data.answers.match;
   if (!answer || answer.type !== "choice") {
-    return { ok: false, error: { code: "invalid_response", message: "TypeSafe returned an invalid semantic search response." } };
+    return { ok: false, error: { code: "invalid_response", message: "Jev returned an invalid semantic search response." } };
   }
   const ranked = candidates
     .map(candidate => ({ candidate, probability: answer.probabilities[candidate.id] ?? 0 }))

package/node_modules/pi-mcp-adapter/types.ts

@@ -589,6 +589,8 @@ export type { JevAnswer, JevErrorCode, JevEvaluateInput, JevEvaluationData, JevE
 
 export interface McpSettings {
   toolPrefix?: ToolPrefix;
+  /** Allow agents to persist remote MCP endpoints with the install action. Defaults to true. */
+  allowInstall?: boolean;
   /** Show the plug prefix in MCP status and connection text (default: true). Set to false to disable it. */
   showStatusIcon?: boolean;
   /** Footer status verbosity: full details, compact connected/enabled count, or no footer status. Defaults to full. */
@@ -603,6 +605,8 @@ export interface McpSettings {
   agentPluginPaths?: string[];
   idleTimeout?: number; // minutes, default 10, 0 to disable
   requestTimeoutMs?: number; // milliseconds, overrides the SDK request timeout when > 0
+  /** Defer lazy runtime startup even when persisted metadata is missing or invalid. Defaults to false. */
+  deferWithMissingMetadata?: boolean;
   directTools?: boolean | "search";
   /** Register per-server mcp__<server> namespace proxies. Defaults to true. */
   namespaceProxyTools?: boolean;
@@ -620,7 +624,9 @@ export interface McpSettings {
   warnOnLargeDirectTools?: boolean;
   /** Register the trusted MCP-only JavaScript scripting tool. Defaults to true; set false to hide it. */
   scriptMode?: boolean;
-  /** Optional TypeSafe Jev integrations. A valid key enables semantic search; script evaluation remains disabled by default. */
+  /** Expose MCP resources as tools (default: true). Set to false to disable globally across all servers. */
+  exposeResources?: boolean;
+  /** Optional Jev (System One) integrations. A valid key enables semantic search; script evaluation remains disabled by default. */
   jev?: false | {
     semanticSearch?: boolean;
     scriptEvaluation?: boolean;

package/node_modules/pi-multi-account/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.23.1] — 2026-09-23
+
+### Fixed
+
+- Restore `pi-ai` as an installed runtime dependency for the OAuth/catalog bridge (#75). Pi-managed npm, bun and pnpm extension installs deliberately omit peer dependencies; v1.23.0 made pi-ai peer-only, so a fresh install could not log into a numbered subscription account. Native provider transports remain bound to the running Pi host, not this bridge copy. The package check now rejects future peer-only regressions.
+
+## [1.23.0] — 2026-09-23
+
+### Added
+
+- `/multi-account pick` offers only the current account's models without filtering the shared registry or changing Pi core. `/multi-account save-default` saves the current model and effective thinking level together for new sessions, without making automatic failover overwrite startup preferences.
+- Added `resumeAfterAllAccountsRecover` (default `true`) as a separate live-session liveness control. A real quota/rate-limit wall across every compatible account remains armed even when immediate `autoContinue` is disabled, polls recovery independently of footer visibility, and resumes on the first account that is genuinely usable.
+
+### Compatibility
+
+- Pi and pi-ai are peer dependencies in the tested range >=0.85.1, <0.88.0. Transport imports bind to the running host rather than an extension-local 0.85 copy. CI covers Pi 0.85.1, 0.86.1 and 0.87.1; standalone SDK callers must use their installed pi-ai context format.
+
+### Fixed
+
+- Native provider wrappers preserve system instructions and tool definitions on Pi's transcript-based context, avoiding tool-free Anthropic requests and old token-estimator crashes (#65, #66).
+- Partial Codex usage headers preserve account/plan display metadata for the same credential without refreshing old serviceability, credits or missing quota windows. Includes a routing regression for stale `serviceable: true` plus fresh 100% quota (adapted from #67, thanks @HerbertGao).
+- Kimi OAuth and unauthenticated spare slots remain in the login picker but are no longer published as unusable static aliases. Only authenticated API-key aliases are published; existing user models.json entries remain untouched (#68).
+- Updated the Anthropic billing-header Claude Code version to 2.1.280 (#64).
+- A continuation that exhausted its newly selected fallback no longer stops after one hop: the next quota-driven switch receives its own continuation.
+- Asynchronous rejection of Pi's injected follow-up no longer loses the interrupted task; the selected fallback remains armed for a bounded retry.
+- `neverFailoverProviders` now also bypasses foreground startup/input preflights for unmanaged providers. Stale cooldowns, invalidations, or unknown auth no longer silently replace an opted-out route before its request. Automatic switch and pending-resume boundaries enforce the same exemption; explicit manual switches remain available.
+- A bodyless `429 status code (no body)` from an unmanaged provider now retries the same route instead of being treated as provider-wide credit exhaustion. The retry honors `Retry-After` when available and otherwise uses the transient delay, avoiding both an unrelated-provider failover and a false six-hour bench for providers such as Cerebras.
+- Numbered Codex OAuth slots no longer fall back to the public ChatGPT endpoint while the child proxy is enabled. A numbered alias is always registered against the loopback route that swaps in the real credential, from extension load onward, so the child-facing placeholder can never be sent to a provider that cannot read it (`Could not parse your authentication token`). Registration now requires an explicit route, so a future call site cannot silently reintroduce the public fallback.
+
 ## [1.22.0] — 2026-09-17
 
 ### Compatibility