@herbertgao/pi-extensions 2026.9.17 → 2026.9.19

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

@@ -1,300 +0,0 @@
-import { TypeSafeClient } from "@typesafe-ai/sdk";
-import type { McpExtensionState } from "./state.ts";
-import { isServerDisabled } from "./types.ts";
-import { combineAbortSignals } from "./runtime-owner.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 type { ResolvedJevSettings } from "./jev-contracts.ts";
-
-const DEFAULTS: ResolvedJevSettings = {
-  semanticSearch: false, scriptEvaluation: false, allowedServers: [], model: "jev-1.13.0",
-  requestTimeoutMs: 5_000, maxRetries: 0, maxStateBytes: 262_144,
-  maxQuestionsPerRequest: 64, maxEvaluationsPerScript: 8,
-  maxEvaluationBytesPerScript: 524_288, maxEvaluationTokensPerScript: 32_768, semanticCandidateLimit: 127,
-  semanticMinProbability: 0.2,
-};
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-
-type JevSettingsInput = Partial<ResolvedJevSettings>;
-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, CredentialCacheEntry>();
-
-/**
- * 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 && 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];
-    if (!settings.allowedServers.includes(source) || !server || isServerDisabled(server)) return false;
-  }
-  return true;
-}
-
-function record(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) throw new Error(`${label} must be a plain object`);
-  return value as Record<string, unknown>;
-}
-function boolean(value: unknown, fallback: boolean, label: string): boolean {
-  if (value === undefined) return fallback;
-  if (typeof value !== "boolean") throw new Error(`${label} must be a boolean`);
-  return value;
-}
-function integer(value: unknown, fallback: number, min: number, max: number, label: string): number {
-  if (value === undefined) return fallback;
-  if (!Number.isInteger(value) || (value as number) < min || (value as number) > max) throw new Error(`${label} must be an integer from ${min} to ${max}`);
-  return value as number;
-}
-
-export function validateJevSettings(value: unknown): ResolvedJevSettings {
-  if (value === undefined || value === false) return { ...DEFAULTS, allowedServers: [...DEFAULTS.allowedServers] };
-  const input = record(value, "settings.jev") as JevSettingsInput;
-  const allowed = new Set(Object.keys(DEFAULTS));
-  for (const key of Object.keys(input)) if (!allowed.has(key)) throw new Error(`settings.jev.${key} is not supported`);
-  if (input.allowedServers !== undefined && (!Array.isArray(input.allowedServers) || input.allowedServers.some(name => typeof name !== "string" || name.length === 0 || DANGEROUS_KEYS.has(name) || /[\u0000-\u001f\u007f]/.test(name)))) {
-    throw new Error("settings.jev.allowedServers must contain non-empty safe server names");
-  }
-  const model = input.model ?? DEFAULTS.model;
-  if (typeof model !== "string" || model.length === 0 || model.length > 128 || /(?:latest|preview)/i.test(model)) throw new Error("settings.jev.model must be a pinned model name");
-  const probability = input.semanticMinProbability ?? DEFAULTS.semanticMinProbability;
-  if (typeof probability !== "number" || !Number.isFinite(probability) || probability < 0 || probability > 1) throw new Error("settings.jev.semanticMinProbability must be from 0 to 1");
-  return {
-    semanticSearch: boolean(input.semanticSearch, DEFAULTS.semanticSearch, "settings.jev.semanticSearch"),
-    scriptEvaluation: boolean(input.scriptEvaluation, DEFAULTS.scriptEvaluation, "settings.jev.scriptEvaluation"),
-    allowedServers: [...new Set(input.allowedServers ?? DEFAULTS.allowedServers)], model,
-    requestTimeoutMs: integer(input.requestTimeoutMs, DEFAULTS.requestTimeoutMs, 100, 30_000, "settings.jev.requestTimeoutMs"),
-    maxRetries: integer(input.maxRetries, DEFAULTS.maxRetries, 0, 2, "settings.jev.maxRetries"),
-    maxStateBytes: integer(input.maxStateBytes, DEFAULTS.maxStateBytes, 1, 1_048_576, "settings.jev.maxStateBytes"),
-    maxQuestionsPerRequest: integer(input.maxQuestionsPerRequest, DEFAULTS.maxQuestionsPerRequest, 1, 128, "settings.jev.maxQuestionsPerRequest"),
-    maxEvaluationsPerScript: integer(input.maxEvaluationsPerScript, DEFAULTS.maxEvaluationsPerScript, 1, 32, "settings.jev.maxEvaluationsPerScript"),
-    maxEvaluationBytesPerScript: integer(input.maxEvaluationBytesPerScript, DEFAULTS.maxEvaluationBytesPerScript, 1, 4_194_304, "settings.jev.maxEvaluationBytesPerScript"),
-    maxEvaluationTokensPerScript: integer(input.maxEvaluationTokensPerScript, DEFAULTS.maxEvaluationTokensPerScript, 1, 1_000_000, "settings.jev.maxEvaluationTokensPerScript"),
-    semanticCandidateLimit: integer(input.semanticCandidateLimit, DEFAULTS.semanticCandidateLimit, 2, 127, "settings.jev.semanticCandidateLimit"),
-    semanticMinProbability: probability,
-  };
-}
-
-export function resolveSemanticJevSettings(
-  state: McpExtensionState,
-  credentialResolver?: () => JevCredentialResolution,
-): ResolvedJevSettings {
-  const configured = state.config.settings?.jev;
-  const settings = validateJevSettings(configured);
-  if (configured === false || configured?.semanticSearch === false) return settings;
-  const semanticSearch = settings.semanticSearch || (credentialResolver ? credentialResolver() : credentialForState(state)).status === "present";
-  const hasExplicitAllowlist = configured !== undefined && Object.hasOwn(configured, "allowedServers");
-  const allowedServers = hasExplicitAllowlist
-    ? settings.allowedServers
-    : Object.keys(state.config.mcpServers).filter((name) => !isServerDisabled(state.config.mcpServers[name]));
-  return { ...settings, semanticSearch, allowedServers };
-}
-
-function validateJson(value: unknown, path: string, seen = new Set<object>()): asserts value is JevJson {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return;
-  if (typeof value === "number") { if (Number.isFinite(value)) return; throw new Error(`${path} contains a non-finite number`); }
-  if (typeof value !== "object") throw new Error(`${path} is not JSON-compatible`);
-  if (seen.has(value)) throw new Error(`${path} contains a cycle`);
-  seen.add(value);
-  if (Array.isArray(value)) value.forEach((item, index) => validateJson(item, `${path}[${index}]`, seen));
-  else {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) throw new Error(`${path} contains a non-plain object`);
-    for (const [key, item] of Object.entries(value)) {
-      if (DANGEROUS_KEYS.has(key)) throw new Error(`${path} contains an unsafe key`);
-      validateJson(item, `${path}.${key}`, seen);
-    }
-  }
-  seen.delete(value);
-}
-function validateId(id: string, label: string): void {
-  if (id.length === 0 || id.length > 128 || DANGEROUS_KEYS.has(id) || /[\u0000-\u001f\u007f]/.test(id)) throw new Error(`${label} contains an invalid identifier`);
-}
-function validateSource(source: string): void {
-  if (source.length === 0 || DANGEROUS_KEYS.has(source) || /[\u0000-\u001f\u007f]/.test(source)) throw new Error("sources contains an invalid server name");
-}
-function exactKeys(value: Record<string, unknown>, allowed: string[], label: string): void {
-  if (Object.keys(value).some(key => !allowed.includes(key))) throw new Error(`${label} contains unsupported fields`);
-}
-
-export function validateJevEvaluateInput(value: unknown, limits: ResolvedJevSettings): JevEvaluateInput {
-  const input = record(value, "Jev evaluation input");
-  exactKeys(input, ["state", "questions", "sources"], "Jev evaluation input");
-  if (!("state" in input)) throw new Error("Jev evaluation input requires state");
-  validateJson(input.state, "state");
-  const stateBytes = Buffer.byteLength(JSON.stringify(input.state));
-  if (stateBytes > limits.maxStateBytes) throw new Error("Jev state exceeds maxStateBytes");
-  const questions = record(input.questions, "questions");
-  const entries = Object.entries(questions);
-  if (entries.length < 1 || entries.length > limits.maxQuestionsPerRequest) throw new Error("Jev question count is outside the configured limit");
-  for (const [id, raw] of entries) {
-    validateId(id, "questions");
-    const question = record(raw, `question ${id}`);
-    if (question.type === "choice") {
-      exactKeys(question, ["type", "instructions", "criteria"], `question ${id}`);
-      const criteria = record(question.criteria, `question ${id} criteria`);
-      const labels = Object.keys(criteria);
-      if (labels.length < 2 || labels.length > 128) throw new Error(`question ${id} choice criteria must have 2 to 128 labels`);
-      for (const label of labels) { validateId(label, `question ${id} criteria`); validateJson(criteria[label], `question ${id} criteria.${label}`); }
-    } else if (question.type === "score") {
-      exactKeys(question, ["type", "instructions", "criteria"], `question ${id}`);
-      if (!Array.isArray(question.criteria) || question.criteria.length < 2 || question.criteria.length > 16) throw new Error(`question ${id} score criteria must have 2 to 16 entries`);
-      validateJson(question.criteria, `question ${id} criteria`);
-    } else if (question.type === "noul") {
-      exactKeys(question, ["type", "instructions", "criteria"], `question ${id}`);
-      if (question.criteria !== undefined) {
-        const criteria = record(question.criteria, `question ${id} criteria`);
-        exactKeys(criteria, ["true", "false"], `question ${id} criteria`);
-        validateJson(criteria, `question ${id} criteria`);
-      }
-    } else throw new Error(`question ${id} has an invalid type`);
-    if (question.instructions !== undefined) validateJson(question.instructions, `question ${id} instructions`);
-  }
-  let sources: string[] | undefined;
-  if (input.sources !== undefined) {
-    if (!Array.isArray(input.sources)) throw new Error("sources must be an array");
-    sources = input.sources.map((source, index) => { if (typeof source !== "string") throw new Error(`sources[${index}] must be a string`); validateSource(source); return source; });
-    if (new Set(sources).size !== sources.length) throw new Error("sources must not contain duplicates");
-  }
-  const normalized = { state: input.state, questions: questions as Record<string, JevQuestion>, ...(sources ? { sources } : {}) } as JevEvaluateInput;
-  if (Buffer.byteLength(JSON.stringify(normalized)) > limits.maxEvaluationBytesPerScript) throw new Error("Jev request exceeds the configured byte limit");
-  return normalized;
-}
-
-function safeNumber(value: unknown, label: string, integerOnly = false): number {
-  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || (integerOnly && !Number.isInteger(value))) throw new Error(`Invalid ${label}`);
-  return value;
-}
-function probability(value: unknown, label: string): number {
-  const number = safeNumber(value, label);
-  if (number > 1) throw new Error(`Invalid ${label}`);
-  return number;
-}
-function sameKeys(actual: Record<string, unknown>, expected: string[]): boolean {
-  const keys = Object.keys(actual);
-  return keys.length === expected.length && expected.every(key => Object.hasOwn(actual, key));
-}
-function validateResponse(value: unknown, input: JevEvaluateInput): JevEvaluationData {
-  const response = record(value, "response");
-  exactKeys(response, ["model", "answers", "usage"], "response");
-  const answers = record(response.answers, "response answers");
-  const questionNames = Object.keys(input.questions);
-  if (!sameKeys(answers, questionNames)) throw new Error("Response answer keys do not match questions");
-  const validated: Record<string, JevAnswer> = {};
-  for (const name of questionNames) {
-    const question = input.questions[name]!;
-    const answer = record(answers[name], `answer ${name}`);
-    if (answer.type !== question.type) throw new Error(`Answer ${name} type does not match`);
-    if (question.type === "choice") {
-      exactKeys(answer, ["type", "choice", "confidence", "probabilities"], `answer ${name}`);
-      const labels = Object.keys(question.criteria);
-      if (typeof answer.choice !== "string" || !Object.hasOwn(question.criteria, answer.choice)) throw new Error(`Answer ${name} choice is invalid`);
-      const probabilities = record(answer.probabilities, `answer ${name} probabilities`);
-      if (!sameKeys(probabilities, labels)) throw new Error(`Answer ${name} probability keys are invalid`);
-      validated[name] = { type: "choice", choice: answer.choice, confidence: probability(answer.confidence, "confidence"), probabilities: Object.fromEntries(labels.map(label => [label, probability(probabilities[label], "probability")])) };
-    } else if (question.type === "score") {
-      exactKeys(answer, ["type", "score", "confidence", "probabilities", "legend"], `answer ${name}`);
-      const labels = question.criteria.map((_, index) => String(index));
-      const probabilities = record(answer.probabilities, `answer ${name} probabilities`);
-      if (!sameKeys(probabilities, labels)) throw new Error(`Answer ${name} probability keys are invalid`);
-      const score = safeNumber(answer.score, "score");
-      if (score > question.criteria.length - 1) throw new Error(`Answer ${name} score is invalid`);
-      validated[name] = { type: "score", score, confidence: probability(answer.confidence, "confidence"), probabilities: Object.fromEntries(labels.map(label => [label, probability(probabilities[label], "probability")])) };
-    } else {
-      exactKeys(answer, ["type", "noul"], `answer ${name}`);
-      validated[name] = { type: "noul", noul: probability(answer.noul, "noul") };
-    }
-  }
-  if (typeof response.model !== "string" || response.model.length === 0 || response.model.length > 128) throw new Error("Invalid response model");
-  const usage = record(response.usage, "response usage");
-  if (!sameKeys(usage, ["input_tokens", "output_tokens"])) throw new Error("Invalid response usage");
-  return { answers: validated, model: response.model, usage: { inputTokens: safeNumber(usage.input_tokens, "input tokens", true), outputTokens: safeNumber(usage.output_tokens, "output tokens", true) } };
-}
-
-/**
- * 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 && 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: 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: "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: "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 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: "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("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: "Jev returned an invalid response." } }; }
-  } catch (error) { return failure(error, signal, timedOut); }
-  finally { clearTimeout(timer); }
-}

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

@@ -1,53 +0,0 @@
-export type JevJson = null | boolean | number | string | JevJson[] | { [key: string]: JevJson };
-
-export type JevQuestion =
-  | { type: "choice"; instructions?: JevJson; criteria: Record<string, JevJson> }
-  | { type: "score"; instructions?: JevJson; criteria: [JevJson, JevJson, ...JevJson[]] }
-  | { type: "noul"; instructions?: JevJson; criteria?: { true?: JevJson; false?: JevJson } };
-
-export interface JevEvaluateInput {
-  state: JevJson;
-  questions: Record<string, JevQuestion>;
-  /** MCP servers whose metadata/results were copied into state. Empty/omitted means no MCP-derived data. */
-  sources?: string[];
-}
-
-export type JevAnswer =
-  | { type: "choice"; choice: string; confidence: number; probabilities: Record<string, number> }
-  | { type: "score"; score: number; confidence: number; probabilities: Record<string, number> }
-  | { type: "noul"; noul: number };
-
-export interface JevEvaluationData {
-  answers: Record<string, JevAnswer>;
-  model: string;
-  usage: { inputTokens: number; outputTokens: number };
-}
-
-export type JevErrorCode =
-  | "disabled" | "invalid_request" | "data_policy_denied" | "budget_exhausted"
-  | "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 }
-  | { ok: false; error: { code: JevErrorCode; message: string; retryable?: boolean } };
-
-export interface ResolvedJevSettings {
-  semanticSearch: boolean;
-  scriptEvaluation: boolean;
-  allowedServers: string[];
-  model: string;
-  requestTimeoutMs: number;
-  maxRetries: number;
-  maxStateBytes: number;
-  maxQuestionsPerRequest: number;
-  maxEvaluationsPerScript: number;
-  maxEvaluationBytesPerScript: number;
-  maxEvaluationTokensPerScript: number;
-  semanticCandidateLimit: number;
-  semanticMinProbability: number;
-}
-
-export interface JevBudget {
-  consume(bytes: number): boolean;
-}

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

@@ -1,192 +0,0 @@
-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";
-/** 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: 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(`Jev API key secure credential store unavailable during ${operation}. Configure or unlock the OS credential store and retry.`, { cause });
-    this.name = "JevCredentialStoreError";
-  }
-}
-
-export type JevCredentialResolution =
-  | { status: "present"; source: "environment" | "keyring"; apiKey: string }
-  | { status: "missing" }
-  | { status: "unavailable"; message: string };
-
-function validateApiKey(value: unknown): string {
-  if (typeof value !== "string" || value.trim().length === 0 || /[\u0000-\u001f\u007f]/.test(value)) {
-    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 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.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,
-  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;
-  }
-  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, 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(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/json-schema-validator.ts

@@ -1,83 +0,0 @@
-import { Ajv } from "ajv";
-import Ajv2020Import from "ajv/dist/2020.js";
-import addFormatsImport from "ajv-formats";
-import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
-import type {
-  JsonSchemaType,
-  JsonSchemaValidator,
-  jsonSchemaValidator as JsonSchemaValidatorProvider,
-} from "@modelcontextprotocol/client";
-
-// ajv-formats types target its bundled ajv; the runtime accepts both instances.
-const addFormats = addFormatsImport as unknown as (instance: Ajv) => void;
-
-// Rust servers built with schemars annotate numbers with these formats. The
-// `type`, `minimum`, and `maximum` keywords already carry the constraint, so
-// registering them as always-valid only stops Ajv's "unknown format" warnings.
-// int32, int64, float, and double are omitted: ajv-formats validates them.
-const SCHEMARS_NUMERIC_FORMATS = [
-  "int", "int8", "int16", "int128",
-  "uint", "uint8", "uint16", "uint32", "uint64", "uint128",
-];
-
-function addKnownFormats(ajv: Ajv): void {
-  addFormats(ajv);
-  for (const format of SCHEMARS_NUMERIC_FORMATS) ajv.addFormat(format, true);
-}
-
-type SchemaDialect =
-  | { status: "unstamped" }
-  | { status: "stamped"; uri: string };
-
-const DRAFT_07_SCHEMA_URIS: ReadonlySet<string> = new Set([
-  "http://json-schema.org/draft-07/schema",
-  "https://json-schema.org/draft-07/schema",
-]);
-const DRAFT_2020_12_SCHEMA_URIS: ReadonlySet<string> = new Set([
-  "https://json-schema.org/draft/2020-12/schema",
-]);
-
-function schemaDialect(schema: JsonSchemaType): SchemaDialect {
-  if (!("$schema" in schema) || typeof schema.$schema !== "string") {
-    return { status: "unstamped" };
-  }
-  return {
-    status: "stamped",
-    uri: schema.$schema.endsWith("#") ? schema.$schema.slice(0, -1) : schema.$schema,
-  };
-}
-
-export function createJsonSchemaValidator(): JsonSchemaValidatorProvider {
-  let draft07Validator: AjvJsonSchemaValidator | undefined;
-  let draft2020Validator: AjvJsonSchemaValidator | undefined;
-
-  return {
-    getValidator<T>(schema: JsonSchemaType): JsonSchemaValidator<T> {
-      const dialect = schemaDialect(schema);
-      if (dialect.status === "unstamped" || DRAFT_2020_12_SCHEMA_URIS.has(dialect.uri)) {
-        draft2020Validator ??= (() => {
-          const Ajv2020 = Ajv2020Import as unknown as typeof Ajv;
-          const ajv = new Ajv2020({ strict: false, allErrors: true });
-          addKnownFormats(ajv);
-          return new AjvJsonSchemaValidator(ajv);
-        })();
-        return draft2020Validator.getValidator<T>(schema);
-      }
-      if (!DRAFT_07_SCHEMA_URIS.has(dialect.uri)) {
-        throw new Error(`Unsupported JSON Schema dialect: ${dialect.uri}`);
-      }
-
-      draft07Validator ??= (() => {
-        const ajv = new Ajv({
-          strict: false,
-          validateFormats: true,
-          validateSchema: false,
-          allErrors: true,
-        });
-        addKnownFormats(ajv);
-        return new AjvJsonSchemaValidator(ajv);
-      })();
-      return draft07Validator.getValidator<T>(schema);
-    },
-  };
-}

package/node_modules/pi-mcp-adapter/lazy-loader.ts

@@ -1,7 +0,0 @@
-export function createRetryableLoader<T>(load: () => Promise<T>): () => Promise<T> {
-  let pending: Promise<T> | null = null;
-  return () => pending ??= load().catch((error) => {
-    pending = null;
-    throw error;
-  });
-}