@herbertgao/pi-extensions 2026.9.13 → 2026.9.14

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

@@ -56,6 +56,18 @@ const INIT_WAIT_TIMEOUT_MS = 30_000;
 const INIT_FAILURE_MESSAGE_MAX_CHARS = 1_000;
 const INIT_WAIT_TIMED_OUT: unique symbol = Symbol("init-wait-timed-out");
 
+function hasEnabledServerWithoutValidMetadata(
+  config: McpConfig,
+  cache: MetadataCache | null,
+  directSpecs: readonly DirectToolSpec[] = [],
+): boolean {
+  return Object.entries(config.mcpServers).some(([serverName, definition]) => {
+    if (isServerDisabled(definition) || directSpecs.some((spec) => spec.serverName === serverName)) return false;
+    const entry = cache?.servers[serverName];
+    return entry === undefined || !isServerCacheValid(entry, definition);
+  });
+}
+
 export interface McpServerRegistration {
   dispose(): Promise<void>;
 }
@@ -320,17 +332,8 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   const envRaw = process.env.MCP_DIRECT_TOOLS;
   const envDirectToolOverride = parseEnvDirectToolOverride(envRaw);
   const namespaceEnvOverride = resolveNamespaceEnvOverride(envRaw, envDirectToolOverride);
-  const enabledEarlyServers = Object.entries(earlyConfig.mcpServers)
-    .filter(([, definition]) => !isServerDisabled(definition));
-  const hasStartupServer = enabledEarlyServers.some(([, definition]) =>
-    definition.lifecycle === "eager" || definition.lifecycle === "keep-alive");
-  const hasUsableCachedMetadata = earlyCache !== null && enabledEarlyServers.every(([serverName, definition]) => {
-    const entry = earlyCache.servers[serverName];
-    return entry !== undefined && isServerCacheValid(entry, definition);
-  });
-  const hasColdEnvironmentDirectTools = envRaw !== undefined && envRaw !== "__none__"
-    && getMissingConfiguredDirectToolServers(earlyConfig, earlyCache, envDirectToolOverride).length > 0;
-  const deferSessionRuntime = !hasStartupServer && hasUsableCachedMetadata && !hasColdEnvironmentDirectTools;
+  const hasStartupServer = Object.values(earlyConfig.mcpServers).some((definition) =>
+    !isServerDisabled(definition) && (definition.lifecycle === "eager" || definition.lifecycle === "keep-alive"));
   const registeredDirectTools = new Map<string, string>();
   const registeredDirectToolServers = new Map<string, string>();
   const registeredDirectToolVersions = new Map<string, number>();
@@ -341,8 +344,6 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   const fallbackDeactivatedTools = new Set<string>();
   // directTools: "search" — registered inactive, activated by mcp({ search }).
   const lazyDirectTools = new Set<string>();
-  // The lazy tools a search has activated; every other lazy tool is held out
-  // of the active set. Per process: nothing here survives a restart.
   const searchActivatedTools = new Set<string>();
   const toolRenderOptions = resolveMcpToolRenderOptions(earlyConfig.settings);
   const toolRenderShell = toolRenderOptions.resultRendering === "compact" ? "self" : "default";
@@ -657,29 +658,20 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
 
   function getDeferredSessionSnapshot(cwd: string | undefined): {
     config: McpConfig;
-    specs: DirectToolSpec[];
+    cache: MetadataCache | null;
     enabledServerCount: number;
   } | undefined {
     const config = programmaticConfig
       ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(sessionConfig), cwd ?? process.cwd())
       : loadMcpConfig(earlyConfigPath, cwd);
     const cache = loadMetadataCache();
-    const enabledServers = Object.entries(config.mcpServers)
-      .filter(([, definition]) => !isServerDisabled(definition));
-    if (enabledServers.some(([, definition]) => definition.lifecycle === "eager" || definition.lifecycle === "keep-alive")) {
-      return undefined;
-    }
-    if (!cache || !enabledServers.every(([serverName, definition]) => {
-      const entry = cache.servers[serverName];
-      return entry !== undefined && isServerCacheValid(entry, definition);
-    })) return undefined;
+    const enabledServers = Object.values(config.mcpServers).filter((definition) => !isServerDisabled(definition));
+    if (enabledServers.some((definition) => definition.lifecycle === "eager" || definition.lifecycle === "keep-alive")) return undefined;
     if (envRaw !== undefined && envRaw !== "__none__"
       && getMissingConfiguredDirectToolServers(config, cache, envDirectToolOverride).length > 0) return undefined;
-    return {
-      config,
-      specs: resolveCurrentDirectTools(config, cache),
-      enabledServerCount: enabledServers.length,
-    };
+    if (config.settings?.deferWithMissingMetadata !== true
+      && (cache === null || hasEnabledServerWithoutValidMetadata(config, cache))) return undefined;
+    return { config, cache, enabledServerCount: enabledServers.length };
   }
 
   function syncNamespaceTools(
@@ -742,8 +734,6 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       .flatMap(([, prompts]) => prompts));
   }
 
-  registerPromptCommands(resolveCachedPrompts(earlyConfig));
-
   const registerRuntimeServer = (name: string, definition: ServerEntry): McpServerRegistration => {
     if (typeof name !== "string" || name.trim() === "") {
       throw new Error("MCP server name must be a non-empty string");
@@ -1081,6 +1071,9 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
   });
 
   pi.on("session_start", async (_event, ctx) => {
+    // Reset before any await so replacement sessions cannot inherit activation.
+    searchActivatedTools.clear();
+    holdLazyToolsInactive();
     const generation = ++lifecycleGeneration;
     largeDirectToolsAdvisoryDelivered = false;
     const previousState = state;
@@ -1111,15 +1104,24 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     if (state) return;
 
     if (!initPromise) {
-      const deferredSnapshot = deferSessionRuntime ? getDeferredSessionSnapshot(ctx.cwd) : undefined;
+      const deferredSnapshot = getDeferredSessionSnapshot(ctx.cwd);
       if (deferredSnapshot) {
-        deliverLargeDirectToolsAdvisory(ctx, deferredSnapshot.config, deferredSnapshot.specs);
+        const { config, cache, enabledServerCount } = deferredSnapshot;
+        const directResult = syncDirectTools(config, cache);
+        syncProxyTool(config, cache, directResult.specs);
+        syncNamespaceTools(config, cache, directResult.reservedDirectNames, directResult.activeDirectNames);
+        // Pi cannot unregister commands. Wait until cwd is authoritative, and
+        // under the opt-in wait for live metadata, before exposing prompts.
+        if (config.settings?.deferWithMissingMetadata !== true) {
+          registerPromptCommands(resolveCachedPrompts(config));
+        }
+        deliverLargeDirectToolsAdvisory(ctx, config, directResult.specs);
         if (generation !== lifecycleGeneration || !owner.isActive() || currentOwner !== owner) return;
-        const serverCount = Object.keys(deferredSnapshot.config.mcpServers).length;
+        const serverCount = Object.keys(config.mcpServers).length;
         const formattedStatus = formatMcpFooterStatus(
-          deferredSnapshot.config,
-          deferredSnapshot.enabledServerCount,
-          serverCount - deferredSnapshot.enabledServerCount,
+          config,
+          enabledServerCount,
+          serverCount - enabledServerCount,
           0,
         );
         const theme = ctx.ui?.theme;
@@ -1148,6 +1150,9 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
     await initializationStarted;
   });
 
+  // Other extensions can reactivate registered tools after session_start.
+  pi.on("before_agent_start", holdLazyToolsInactive);
+
   pi.on("session_tree", (_event, ctx) => {
     const currentState = state;
     const owner = currentOwner;
@@ -1589,6 +1594,12 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         details: { mode: "install", error: "programmatic_config" },
       };
     }
+    if (targetState.config.settings?.allowInstall === false) {
+      return {
+        content: [{ type: "text" as const, text: "MCP install is disabled by configuration." }],
+        details: { mode: "install", error: "install_disabled" },
+      };
+    }
     if (target !== undefined && target !== "global" && target !== "project") {
       return {
         content: [{ type: "text" as const, text: "MCP install target must be 'global' or 'project'." }],
@@ -1787,7 +1798,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         describe: Type.Optional(Type.String({ description: "Tool name to describe (shows parameters)" })),
         instructions: Type.Optional(Type.String({ description: "Server name to show that server's usage instructions" })),
         search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
-        searchMode: Type.Optional(Type.String({ enum: ["lexical", "semantic"], description: "Search backend (default: lexical; semantic is available when a TypeSafe key is configured)" })),
+        searchMode: Type.Optional(Type.String({ enum: ["lexical", "semantic"], description: "Search backend (default: lexical; semantic is available when a System One key is configured)" })),
         regex: Type.Optional(Type.Boolean({ description: "Treat search as regex (default: substring match)" })),
         includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
         limit: optionalNumber({ minimum: 1, description: "Maximum search results to return (default: 12)" }),
@@ -1941,6 +1952,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         }
         if (params.search !== undefined) {
           const result = await proxyModes.executeSearch(proxyState, params.search, params.regex, params.server, params.includeSchemas, params.limit, params.offset, params.searchMode, signal);
+          assertRuntimeGuard(proxyGuard);
           if (lazyDirectTools.size === 0) return result;
           holdLazyToolsInactive();
           const matches = (result.details as { matches?: Array<{ server: string; tool: string }> } | undefined)?.matches ?? [];
@@ -1978,7 +1990,8 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       config.settings?.disableProxyTool !== true
       || directSpecs.length === 0
       || hasSearchModeSpecs
-      || missingConfiguredDirectToolServers.length > 0;
+      || missingConfiguredDirectToolServers.length > 0
+      || hasEnabledServerWithoutValidMetadata(config, cache, directSpecs);
 
     if (shouldRegisterProxyTool) {
       const description = buildProxyDescription(config);

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
       ? {