pi-system-one 1.2.4 → 1.3.0

package/src/persistence.ts

@@ -0,0 +1,111 @@
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+import type { ConfigMode, StoredConfig } from "./config.ts";
+
+const MODES: ConfigMode[] = ["typesafe", "custom", "native"];
+
+function validate(value: unknown, path: string): StoredConfig {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error(`Invalid System One settings in ${path}: expected object`);
+  const v = value as Record<string, unknown>;
+  if (Object.hasOwn(v, "apiKey") || Object.hasOwn(v, "key"))
+    throw new Error(
+      `Invalid System One settings in ${path}: apiKey must stay in Pi credentials or environment`,
+    );
+  for (const key of Object.keys(v)) {
+    if (!["mode", "baseUrl", "model", "timeoutMs"].includes(key))
+      throw new Error(`Invalid System One settings in ${path}: unknown field`);
+  }
+  if (v.mode !== undefined && !MODES.includes(v.mode as ConfigMode))
+    throw new Error(
+      `Invalid System One settings in ${path}: mode must be typesafe, custom, or native`,
+    );
+  if (
+    v.baseUrl !== undefined &&
+    (typeof v.baseUrl !== "string" || !v.baseUrl.trim())
+  )
+    throw new Error(
+      `Invalid System One settings in ${path}: baseUrl must be a nonempty string`,
+    );
+  if (typeof v.baseUrl === "string") {
+    let url: URL;
+    try {
+      url = new URL(v.baseUrl);
+    } catch {
+      throw new Error(
+        `Invalid System One settings in ${path}: baseUrl must be an HTTP(S) URL`,
+      );
+    }
+    if (
+      !["http:", "https:"].includes(url.protocol) ||
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash
+    )
+      throw new Error(
+        `Invalid System One settings in ${path}: baseUrl must be an HTTP(S) URL without credentials, query, or fragment`,
+      );
+  }
+  if (v.model !== undefined && (typeof v.model !== "string" || !v.model.trim()))
+    throw new Error(
+      `Invalid System One settings in ${path}: model must be a nonempty string`,
+    );
+  if (
+    v.timeoutMs !== undefined &&
+    (typeof v.timeoutMs !== "number" ||
+      !Number.isFinite(v.timeoutMs) ||
+      v.timeoutMs <= 0)
+  )
+    throw new Error(
+      `Invalid System One settings in ${path}: timeoutMs must be positive`,
+    );
+  if (v.mode === "custom" && !v.baseUrl)
+    throw new Error(
+      `Invalid System One settings in ${path}: custom mode needs baseUrl`,
+    );
+  return v as StoredConfig;
+}
+
+export function loadStoredConfig(path: string): StoredConfig {
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+    throw error;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${path}`);
+  }
+  return validate(parsed, path);
+}
+
+export function saveStoredConfig(path: string, config: StoredConfig): void {
+  const safe = validate(config, path);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(safe, null, 2)}\n`, {
+      mode: 0o600,
+      flag: "wx",
+    });
+    renameSync(temp, path);
+  } catch (error) {
+    try {
+      unlinkSync(temp);
+    } catch {
+      /* no temporary file */
+    }
+    throw error;
+  }
+}

package/src/provider.ts

@@ -0,0 +1,184 @@
+import type { ExtensionToolContext } from "@earendil-works/pi-coding-agent";
+import {
+  HttpSystemOneProvider,
+  type QuestionMap,
+  type SystemOneCallOptions,
+  type SystemOneProvider,
+  type SystemOneRequest,
+  type SystemOneResponse,
+  validateResponse,
+} from "system-one-core";
+import {
+  type SessionConfig,
+  TYPESAFE_BASE_URL,
+  TYPESAFE_MODEL,
+} from "./config.ts";
+
+export function isTypeSafeEndpoint(baseUrl: string): boolean {
+  try {
+    const url = new URL(baseUrl);
+    return (
+      url.origin === TYPESAFE_BASE_URL &&
+      url.pathname === "/" &&
+      !url.search &&
+      !url.hash &&
+      !url.username &&
+      !url.password
+    );
+  } catch {
+    return false;
+  }
+}
+
+function nativeFailure(aborted: boolean): Error {
+  return new Error(
+    aborted
+      ? "Pi native classifier request aborted."
+      : "Pi native classifier failed. Check /login typesafe and Pi logs.",
+  );
+}
+
+class PiNativeProvider implements SystemOneProvider {
+  readonly id = "pi-native";
+  private readonly ctx: ExtensionToolContext;
+  private readonly timeoutMs: number;
+  constructor(ctx: ExtensionToolContext, timeoutMs: number) {
+    this.ctx = ctx;
+    this.timeoutMs = timeoutMs;
+  }
+
+  async evaluate<Q extends QuestionMap>(
+    request: SystemOneRequest<Q>,
+    options?: SystemOneCallOptions,
+  ): Promise<SystemOneResponse<Q>> {
+    const model = this.ctx.modelRegistry?.findOfType?.(
+      "classifier",
+      "typesafe",
+      "jev-latest",
+    );
+    if (!model)
+      throw new Error(
+        "Pi classifier jev-latest unavailable. Use /so config to select TypeSafe HTTP instead.",
+      );
+    const questions: Record<string, unknown> = Object.create(null);
+    for (const [id, question] of Object.entries(request.questions)) {
+      if (question.type === "score")
+        throw new Error(
+          "Pi native classifier omits Score probabilities. Use /so config to select TypeSafe HTTP for Score questions.",
+        );
+      if (typeof question.instructions !== "string")
+        throw new Error(
+          "Pi native classifier requires string instructions. Use TypeSafe HTTP for structured instructions.",
+        );
+      if (question.type === "choice") {
+        const criteria: Record<string, string> = Object.create(null);
+        for (const [key, meaning] of Object.entries(question.criteria)) {
+          if (meaning !== null && typeof meaning !== "string")
+            throw new Error(
+              "Pi native classifier requires string Choice criteria. Use TypeSafe HTTP for structured criteria.",
+            );
+          criteria[key] = meaning ?? key;
+        }
+        questions[id] = {
+          type: "choice",
+          instructions: question.instructions,
+          criteria,
+        };
+      } else {
+        const values = question.criteria;
+        if (
+          values &&
+          (typeof values.true !== "string" || typeof values.false !== "string")
+        )
+          throw new Error(
+            "Pi native classifier requires string yes/no criteria. Use TypeSafe HTTP for structured criteria.",
+          );
+        questions[id] = {
+          type: "bool",
+          instructions: question.instructions,
+          criteria: {
+            true: values?.true ?? "Yes",
+            false: values?.false ?? "No",
+          },
+        };
+      }
+    }
+    const state =
+      typeof request.state === "object" &&
+      request.state !== null &&
+      !Array.isArray(request.state)
+        ? request.state
+        : { state: request.state };
+    let result: Awaited<
+      ReturnType<ExtensionToolContext["modelRegistry"]["classify"]>
+    >;
+    try {
+      result = await this.ctx.modelRegistry.classify(
+        model,
+        { state, questions } as never,
+        { signal: options?.signal, timeoutMs: this.timeoutMs },
+      );
+    } catch {
+      // Pi and its provider may include untrusted response bodies in errors.
+      throw nativeFailure(options?.signal?.aborted === true);
+    }
+    if (result.stopReason !== "stop")
+      throw nativeFailure(
+        result.stopReason === "aborted" || options?.signal?.aborted === true,
+      );
+    try {
+      const answers: Record<string, unknown> = Object.create(null);
+      for (const [id, answer] of Object.entries(result.answers))
+        answers[id] =
+          answer.type === "bool"
+            ? { type: "noul", noul: answer.probability }
+            : answer;
+      return validateResponse(
+        request.questions,
+        {
+          model: result.model,
+          answers,
+          usage: result.usage
+            ? {
+                inputTokens: result.usage.input,
+                outputTokens: result.usage.output,
+              }
+            : undefined,
+        },
+        this.id,
+      );
+    } catch {
+      // Core validation can quote provider-controlled values; hide its detail.
+      throw nativeFailure(false);
+    }
+  }
+}
+
+/** Resolve credentials at call time. Never forward Pi's TypeSafe key to a custom origin. */
+export async function resolveSessionProvider(
+  session: SessionConfig,
+  ctx: ExtensionToolContext,
+): Promise<SystemOneProvider> {
+  if (session.mode === "native")
+    return new PiNativeProvider(ctx, session.current.timeoutMs);
+  const config = session.current;
+  if (!config.baseUrl)
+    throw new Error("Custom endpoint missing. Run /so config.");
+  const typeSafe = isTypeSafeEndpoint(config.baseUrl);
+  const key =
+    config.apiKey ??
+    (typeSafe
+      ? await ctx.modelRegistry?.getApiKeyForProvider?.("typesafe")
+      : undefined);
+  if (typeSafe && !key)
+    throw new Error(
+      "TypeSafe key missing. Run /login typesafe or set SYSTEM_ONE_API_KEY.",
+    );
+  return new HttpSystemOneProvider({
+    id: typeSafe ? "typesafe" : "configured",
+    baseUrl: config.baseUrl,
+    apiKey: key,
+    defaultModel: config.model ?? (typeSafe ? TYPESAFE_MODEL : undefined),
+    timeoutMs: config.timeoutMs,
+  });
+}

package/src/tool.ts

@@ -1,4 +1,7 @@
-import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionToolContext,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import {
   type QuestionMap,
   SystemOne,
@@ -982,6 +985,42 @@ function normalizeArgs(args: unknown, drops?: string[]): SystemOneParams {
   return out as SystemOneParams;
 }
 
+// Keep codemode's result small and question-name keyed; each answer carries
+// its own kind-specific fields without requiring a per-kind schema union.
+const systemOneOutput = Type.Object({
+  answers: Type.Object(
+    {},
+    {
+      additionalProperties: Type.Object(
+        {
+          type: Type.String(),
+          noul: Type.Optional(Type.Number()),
+          choice: Type.Optional(Type.String()),
+          score: Type.Optional(Type.Number()),
+          probabilities: Type.Optional(
+            Type.Object({}, { additionalProperties: Type.Number() }),
+          ),
+          legend: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+          confidence: Type.Optional(Type.Number()),
+        },
+        { additionalProperties: true },
+      ),
+    },
+  ),
+  model: Type.Optional(Type.String()),
+  usage: Type.Optional(
+    Type.Object({
+      inputTokens: Type.Optional(Type.Number()),
+      outputTokens: Type.Optional(Type.Number()),
+    }),
+  ),
+  requestId: Type.Optional(Type.String()),
+  metadata: Type.Object({
+    provider: Type.String(),
+    latencyMs: Type.Optional(Type.Number()),
+  }),
+});
+
 export interface SystemOneDetails {
   answers: Record<string, unknown>;
   model?: string;
@@ -1066,11 +1105,11 @@ function assertAnswerableQuestions(questions: unknown): void {
 }
 
 export function buildSystemOneTool(deps: {
-  provider: SystemOneProvider;
+  provider?: SystemOneProvider;
+  resolveProvider?: (ctx: ExtensionToolContext) => Promise<SystemOneProvider>;
 }): ToolDefinition<typeof systemOneParams, SystemOneDetails> {
-  const systemOne = new SystemOne({
-    provider: deps.provider,
-  });
+  if (!deps.provider && !deps.resolveProvider)
+    throw new Error("system_one requires a provider resolver");
 
   return {
     name: "system_one",
@@ -1088,6 +1127,7 @@ export function buildSystemOneTool(deps: {
       "score criteria is an ordered array of at least two levels.",
 
     parameters: systemOneParams,
+    outputSchema: systemOneOutput,
 
     promptSnippet:
       "Use system_one for bounded judgments over supplied evidence, including classification, routing, and selecting among plausible tools, skills, strategies, implementations, models, or providers",
@@ -1114,7 +1154,7 @@ export function buildSystemOneTool(deps: {
 
     prepareArguments: (args) => prepareSystemOneArgs(args),
 
-    async execute(_toolCallId, params, signal, _onUpdate, _ctx) {
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       /*
        * The LLM-facing TypeBox schema is intentionally separate from the
        * provider protocol types. Cast only at this boundary instead of
@@ -1146,7 +1186,11 @@ export function buildSystemOneTool(deps: {
 
       assertAnswerableQuestions(normalized.questions);
 
-      const response = await systemOne.evaluate(
+      const provider = deps.resolveProvider
+        ? await deps.resolveProvider(ctx)
+        : deps.provider;
+      if (!provider) throw new Error("system_one provider unavailable");
+      const response = await new SystemOne({ provider }).evaluate(
         {
           state: normalized.state as SystemOneState,
           questions: normalized.questions as QuestionMap,
@@ -1165,6 +1209,18 @@ export function buildSystemOneTool(deps: {
           },
         ],
 
+        // Core responses can contain undefined optional fields. Omit those
+        // from the script-facing JSON value without changing direct details.
+        structuredContent: {
+          answers: response.answers,
+          metadata: response.metadata,
+          ...(response.model !== undefined ? { model: response.model } : {}),
+          ...(response.usage !== undefined ? { usage: response.usage } : {}),
+          ...(response.requestId !== undefined
+            ? { requestId: response.requestId }
+            : {}),
+        } as unknown as SystemOneState,
+
         details: {
           answers: response.answers,
           model: response.model,