pi-system-one 1.3.1 → 1.3.2

package/src/provider.ts

@@ -9,29 +9,36 @@ import {
   validateResponse,
 } from "system-one-core";
 import {
+  isTypeSafeEndpoint,
   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;
+export type NativeFailureCategory =
+  | "native model unavailable"
+  | "native Score unsupported"
+  | "native input incompatible"
+  | "native classify threw"
+  | "native classifier returned error"
+  | "invalid native response"
+  | "native request aborted";
+
+/** Fixed diagnostic category only; never include Pi/provider error text. */
+export class PiNativeDiagnosticError extends Error {
+  readonly category: NativeFailureCategory;
+  constructor(category: NativeFailureCategory, message: string) {
+    super(message);
+    this.category = category;
   }
 }
 
-function nativeFailure(aborted: boolean): Error {
-  return new Error(
+function nativeFailure(
+  category: NativeFailureCategory,
+  aborted: boolean,
+): PiNativeDiagnosticError {
+  return new PiNativeDiagnosticError(
+    aborted ? "native request aborted" : category,
     aborted
       ? "Pi native classifier request aborted."
       : "Pi native classifier failed. Check /login typesafe and Pi logs.",
@@ -42,9 +49,15 @@ class PiNativeProvider implements SystemOneProvider {
   readonly id = "pi-native";
   private readonly ctx: ExtensionToolContext;
   private readonly timeoutMs: number;
-  constructor(ctx: ExtensionToolContext, timeoutMs: number) {
+  private readonly onDispatch?: () => void;
+  constructor(
+    ctx: ExtensionToolContext,
+    timeoutMs: number,
+    onDispatch?: () => void,
+  ) {
     this.ctx = ctx;
     this.timeoutMs = timeoutMs;
+    this.onDispatch = onDispatch;
   }
 
   async evaluate<Q extends QuestionMap>(
@@ -57,24 +70,28 @@ class PiNativeProvider implements SystemOneProvider {
       "jev-latest",
     );
     if (!model)
-      throw new Error(
+      throw new PiNativeDiagnosticError(
+        "native model unavailable",
         "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(
+        throw new PiNativeDiagnosticError(
+          "native Score unsupported",
           "Pi native classifier omits Score probabilities. Use /so config to select TypeSafe HTTP for Score questions.",
         );
       if (typeof question.instructions !== "string")
-        throw new Error(
+        throw new PiNativeDiagnosticError(
+          "native input incompatible",
           "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(
+            throw new PiNativeDiagnosticError(
+              "native input incompatible",
               "Pi native classifier requires string Choice criteria. Use TypeSafe HTTP for structured criteria.",
             );
           criteria[key] = meaning ?? key;
@@ -90,7 +107,8 @@ class PiNativeProvider implements SystemOneProvider {
           values &&
           (typeof values.true !== "string" || typeof values.false !== "string")
         )
-          throw new Error(
+          throw new PiNativeDiagnosticError(
+            "native input incompatible",
             "Pi native classifier requires string yes/no criteria. Use TypeSafe HTTP for structured criteria.",
           );
         questions[id] = {
@@ -113,6 +131,7 @@ class PiNativeProvider implements SystemOneProvider {
       ReturnType<ExtensionToolContext["modelRegistry"]["classify"]>
     >;
     try {
+      this.onDispatch?.();
       result = await this.ctx.modelRegistry.classify(
         model,
         { state, questions } as never,
@@ -120,10 +139,14 @@ class PiNativeProvider implements SystemOneProvider {
       );
     } catch {
       // Pi and its provider may include untrusted response bodies in errors.
-      throw nativeFailure(options?.signal?.aborted === true);
+      throw nativeFailure(
+        "native classify threw",
+        options?.signal?.aborted === true,
+      );
     }
     if (result.stopReason !== "stop")
       throw nativeFailure(
+        "native classifier returned error",
         result.stopReason === "aborted" || options?.signal?.aborted === true,
       );
     try {
@@ -149,22 +172,123 @@ class PiNativeProvider implements SystemOneProvider {
       );
     } catch {
       // Core validation can quote provider-controlled values; hide its detail.
-      throw nativeFailure(false);
+      throw nativeFailure("invalid native response", false);
     }
   }
 }
 
+function supportsNative(request: SystemOneRequest<QuestionMap>): boolean {
+  return Object.values(request.questions).every((question) => {
+    if (question.type === "score" || typeof question.instructions !== "string")
+      return false;
+    if (question.type === "choice")
+      return Object.values(question.criteria).every(
+        (value) => value === null || typeof value === "string",
+      );
+    return (
+      !question.criteria ||
+      (Object.keys(question.criteria).every(
+        (key) => key === "true" || key === "false",
+      ) &&
+        typeof question.criteria.true === "string" &&
+        typeof question.criteria.false === "string")
+    );
+  });
+}
+
+export type RouteObserver = (
+  provider: "pi-native" | "typesafe" | "configured",
+  reason:
+    | "compatible request"
+    | "contains Score"
+    | "native-incompatible input"
+    | "classifier unavailable"
+    | "selected mode",
+) => void;
+
+class AutoSystemOneProvider implements SystemOneProvider {
+  readonly id = "auto";
+  private readonly session: SessionConfig;
+  private readonly ctx: ExtensionToolContext;
+  private readonly onRoute?: RouteObserver;
+  private readonly onDispatch?: () => void;
+  constructor(
+    session: SessionConfig,
+    ctx: ExtensionToolContext,
+    onRoute?: RouteObserver,
+    onDispatch?: () => void,
+  ) {
+    this.session = session;
+    this.ctx = ctx;
+    this.onRoute = onRoute;
+    this.onDispatch = onDispatch;
+  }
+
+  async evaluate<Q extends QuestionMap>(
+    request: SystemOneRequest<Q>,
+    options?: SystemOneCallOptions,
+  ): Promise<SystemOneResponse<Q>> {
+    const compatible = supportsNative(request);
+    if (
+      compatible &&
+      this.ctx.modelRegistry?.findOfType?.(
+        "classifier",
+        "typesafe",
+        "jev-latest",
+      )
+    ) {
+      this.onRoute?.("pi-native", "compatible request");
+      return new PiNativeProvider(
+        this.ctx,
+        this.session.current.timeoutMs,
+        this.onDispatch,
+      ).evaluate(request, options);
+    }
+    this.onRoute?.(
+      "typesafe",
+      compatible
+        ? "classifier unavailable"
+        : Object.values(request.questions).some(
+              (question) => question.type === "score",
+            )
+          ? "contains Score"
+          : "native-incompatible input",
+    );
+    const http = await resolveSessionProvider(
+      {
+        ...this.session,
+        mode: "typesafe",
+        current: {
+          ...this.session.current,
+          baseUrl: TYPESAFE_BASE_URL,
+          model: TYPESAFE_MODEL,
+        },
+      },
+      this.ctx,
+    );
+    this.onDispatch?.();
+    return http.evaluate(request, options);
+  }
+}
+
 /** Resolve credentials at call time. Never forward Pi's TypeSafe key to a custom origin. */
 export async function resolveSessionProvider(
   session: SessionConfig,
   ctx: ExtensionToolContext,
+  onRoute?: RouteObserver,
+  onDispatch?: () => void,
 ): Promise<SystemOneProvider> {
-  if (session.mode === "native")
-    return new PiNativeProvider(ctx, session.current.timeoutMs);
+  if (session.mode === "native") {
+    onRoute?.("pi-native", "selected mode");
+    return new PiNativeProvider(ctx, session.current.timeoutMs, onDispatch);
+  }
+  if (session.mode === "auto")
+    return new AutoSystemOneProvider(session, ctx, onRoute, onDispatch);
   const config = session.current;
   if (!config.baseUrl)
     throw new Error("Custom endpoint missing. Run /so config.");
   const typeSafe = isTypeSafeEndpoint(config.baseUrl);
+  onRoute?.(typeSafe ? "typesafe" : "configured", "selected mode");
   const key =
     config.apiKey ??
     (typeSafe

package/tests/commands.test.ts

@@ -11,9 +11,21 @@ import {
 } from "../src/commands.ts";
 import { createSessionConfig } from "../src/config.ts";
 import { resolveSessionProvider } from "../src/provider.ts";
+import type { buildSystemOneTool } from "../src/tool.ts";
+
+type OverlayFactory = (
+  tui: { requestRender: () => void },
+  theme: { fg: (key: string, text: string) => string },
+  keys: unknown,
+  done: () => void,
+) => {
+  render: (width: number) => string[];
+  handleInput: (data: string) => void;
+};
 
 interface Captured {
   tools: string[];
+  tool?: ReturnType<typeof buildSystemOneTool>;
   handler: ((args: string, ctx: never) => Promise<void>) | undefined;
   completions: ((prefix: string) => { value: string }[]) | undefined;
   notices: string[];
@@ -29,8 +41,9 @@ function harness() {
     selections: [],
   };
   const pi = {
-    registerTool: (t: { name: string }) => {
+    registerTool: (t: ReturnType<typeof buildSystemOneTool>) => {
       cap.tools.push(t.name);
+      cap.tool = t;
     },
     registerCommand: (
       _n: string,
@@ -72,6 +85,93 @@ function ctxFor(
 }
 
 describe("so command", () => {
+  it("opens /so debug as a dismissible TUI overlay without changing settings", async () => {
+    const { pi, cap } = harness();
+    const store: SessionStore = { session: createSessionConfig({}) };
+    registerSystemOneCommands(pi, store);
+    let overlay = false;
+    let closed = false;
+    await cap.handler?.("debug", {
+      mode: "tui",
+      ui: {
+        custom: async (
+          factory: OverlayFactory,
+          options: { overlay: boolean },
+        ) => {
+          overlay = options.overlay;
+          const component = factory(
+            { requestRender: () => {} },
+            { fg: (_color: string, text: string) => text },
+            {},
+            () => {
+              closed = true;
+            },
+          );
+          assert.match(
+            component.render(72).join("\n"),
+            /No system_one calls yet/,
+          );
+          component.handleInput("\u001b");
+        },
+        notify: () => {},
+      },
+    } as never);
+    assert.ok(overlay);
+    assert.ok(closed);
+    assert.equal(store.session?.mode, "typesafe");
+    assert.ok(cap.completions?.("de").some((item) => item.value === "debug"));
+  });
+  it("shows actual provider for a completed tool call in /so debug overlay", async () => {
+    const { pi, cap } = harness();
+    registerSystemOneCommands(pi, {
+      session: createSessionConfig({}, { mode: "native" }),
+    }).applyProvider();
+    assert.ok(cap.tool);
+    const result = await cap.tool.execute(
+      "native-debug",
+      {
+        state: "private-state",
+        questions: { q: { type: "noul", instructions: "private-instruction" } },
+      },
+      undefined,
+      undefined,
+      {
+        modelRegistry: {
+          findOfType: () => ({ id: "jev-latest" }),
+          classify: async () => ({
+            stopReason: "stop",
+            answers: { q: { type: "bool", probability: 0.7 } },
+          }),
+        },
+      } as never,
+    );
+    assert.equal(result.details.metadata.provider, "pi-native");
+    await cap.handler?.("debug", {
+      mode: "tui",
+      ui: {
+        custom: async (factory: OverlayFactory) => {
+          const component = factory(
+            { requestRender: () => {} },
+            { fg: (_key: string, text: string) => text },
+            {},
+            () => {},
+          );
+          const text = component.render(76).join("\n");
+          assert.match(text, /Provider: pi-native/);
+          assert.doesNotMatch(text, /private-state|private-instruction/);
+        },
+      },
+    } as never);
+  });
+  it("summarizes debug calls without custom UI in RPC mode", async () => {
+    const { pi, cap } = harness();
+    registerSystemOneCommands(pi, { session: createSessionConfig({}) });
+    await cap.handler?.("debug", {
+      mode: "rpc",
+      ui: { notify: (message: string) => cap.notices.push(message) },
+    } as never);
+    assert.match(cap.notices.at(-1) ?? "", /No system_one calls yet/);
+  });
   it("shows selectable provider modes for /so and /so config", async () => {
     const { pi, cap } = harness();
     const store: SessionStore = { session: createSessionConfig({}) };
@@ -81,11 +181,45 @@ describe("so command", () => {
     await cap.handler?.("config", ctxFor(["typesafe"], cap));
     assert.equal(store.session?.mode, "typesafe");
     assert.equal(cap.selections.length, 2);
-    assert.equal(cap.selections[0].options.length, 3);
+    assert.equal(cap.selections[0].options.length, 4);
     assert.match(cap.selections[0].options[0], /typesafe.*current/i);
     assert.match(cap.selections[1].options[0], /native.*current/i);
   });
 
+  it("selects auto and persists policy without an inherited custom endpoint", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "so-auto-command-"));
+    const previousUrl = process.env.SYSTEM_ONE_BASE_URL;
+    const previousKey = process.env.SYSTEM_ONE_API_KEY;
+    try {
+      process.env.SYSTEM_ONE_BASE_URL = "https://custom.example";
+      process.env.SYSTEM_ONE_API_KEY = "custom-secret";
+      const path = join(dir, "pi-system-one.json");
+      const { pi, cap } = harness();
+      const store: SessionStore = {
+        session: createSessionConfig({
+          SYSTEM_ONE_BASE_URL: "https://custom.example",
+          SYSTEM_ONE_API_KEY: "custom-secret",
+        }),
+      };
+      registerSystemOneCommands(pi, store, path);
+      await cap.handler?.("config", ctxFor(["auto"], cap));
+      assert.equal(store.session?.mode, "auto");
+      assert.equal(store.session?.current.baseUrl, "https://api.typesafe.ai");
+      assert.equal(store.session?.current.apiKey, undefined);
+      assert.equal(JSON.parse(readFileSync(path, "utf8")).mode, "auto");
+      assert.doesNotMatch(readFileSync(path, "utf8"), /custom.example|secret/);
+      assert.ok(
+        cap.selections[0].options.some((option) => option.startsWith("auto")),
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+      if (previousUrl === undefined) delete process.env.SYSTEM_ONE_BASE_URL;
+      else process.env.SYSTEM_ONE_BASE_URL = previousUrl;
+      if (previousKey === undefined) delete process.env.SYSTEM_ONE_API_KEY;
+      else process.env.SYSTEM_ONE_API_KEY = previousKey;
+    }
+  });
+
   it("cancels selection without changing mode or saved settings", async () => {
     const dir = mkdtempSync(join(tmpdir(), "so-select-"));
     try {
@@ -268,12 +402,12 @@ describe("so command", () => {
       rmSync(dir, { recursive: true, force: true });
     }
   });
-  it("completes config + status, case-insensitively", () => {
+  it("completes config + status + debug, case-insensitively", () => {
     const { pi, cap } = harness();
     registerSystemOneCommands(pi, {});
     assert.deepEqual(
       cap.completions?.("").map((c) => c.value),
-      ["config", "status"],
+      ["config", "status", "debug"],
     );
     assert.deepEqual(
       cap.completions?.("S").map((c) => c.value),

package/tests/config.test.ts

@@ -22,6 +22,28 @@ describe("config", () => {
     assert.equal(s.current.model, "jev-latest");
     assert.match(describeConfig(s), /api key: managed by Pi/);
   });
+  it("status identifies saved native mode and ignored endpoint without exposing keys", () => {
+    const s = createSessionConfig(
+      {
+        SYSTEM_ONE_BASE_URL: "https://custom.example",
+        SYSTEM_ONE_API_KEY: "secret",
+      },
+      { mode: "native" },
+    );
+    const status = describeConfig(s);
+    assert.match(status, /mode: native \(saved\)/);
+    assert.match(status, /environment endpoint ignored/i);
+    assert.doesNotMatch(status, /custom.example|secret/);
+  });
+  it("status explains auto policy rather than claiming a fixed provider", () => {
+    const s = createSessionConfig({}, { mode: "auto" });
+    assert.match(describeConfig(s), /mode: auto \(saved\)/);
+    assert.match(describeConfig(s), /per request/i);
+    assert.match(
+      describeConfig(s),
+      /HTTP fallback endpoint: https:\/\/api\.typesafe\.ai/,
+    );
+  });
   it("defaults to TypeSafe Jev without environment configuration", () => {
     const s = createSessionConfig({});
     assert.equal(s.mode, "typesafe");
@@ -29,23 +51,57 @@ describe("config", () => {
     assert.equal(s.current.model, "jev-latest");
     assert.equal(s.current.apiKey, undefined);
   });
-  it("keeps environment endpoint ahead of saved custom config", () => {
+  it("keeps a TypeSafe environment model bound to the canonical endpoint", () => {
+    for (const stored of [{}, { mode: "typesafe" as const }]) {
+      const s = createSessionConfig(
+        { SYSTEM_ONE_MODEL: "jev-custom", SYSTEM_ONE_API_KEY: "typesafe-key" },
+        stored,
+      );
+      assert.equal(s.mode, "typesafe");
+      assert.equal(s.current.model, "jev-custom");
+      assert.equal(s.current.apiKey, "typesafe-key");
+    }
+  });
+  it("keeps saved native mode despite inherited HTTP environment", () => {
     const s = createSessionConfig(
       { SYSTEM_ONE_BASE_URL: "http://existing/", SYSTEM_ONE_MODEL: "old" },
       { mode: "native", model: "new", timeoutMs: 5000 },
     );
-    assert.equal(s.mode, "custom");
-    assert.equal(s.current.baseUrl, "http://existing/");
-    assert.equal(s.current.model, "old");
+    assert.equal(s.mode, "native");
+    assert.equal(s.current.baseUrl, "");
+    assert.equal(s.current.model, "jev-latest");
     assert.equal(s.current.timeoutMs, 5000);
   });
-  it("does not carry a saved model to a different environment endpoint", () => {
+  it("saved TypeSafe and auto ignore custom endpoint keys and models", () => {
+    for (const mode of ["typesafe", "auto"] as const) {
+      const s = createSessionConfig(
+        {
+          SYSTEM_ONE_BASE_URL: "http://custom/",
+          SYSTEM_ONE_API_KEY: "custom-secret",
+          SYSTEM_ONE_MODEL: "custom-model",
+        },
+        { mode },
+      );
+      assert.equal(s.mode, mode);
+      assert.equal(s.current.baseUrl, "https://api.typesafe.ai");
+      assert.equal(s.current.model, "jev-latest");
+      assert.equal(s.current.apiKey, undefined);
+      assert.equal(s.ignoredEnvironmentEndpoint, true);
+    }
+  });
+  it("keeps saved custom endpoint and model, not unrelated environment credentials", () => {
     const s = createSessionConfig(
-      { SYSTEM_ONE_BASE_URL: "http://new/" },
+      {
+        SYSTEM_ONE_BASE_URL: "http://new/",
+        SYSTEM_ONE_MODEL: "new-model",
+        SYSTEM_ONE_API_KEY: "key-for-new",
+      },
       { mode: "custom", baseUrl: "http://old/", model: "old-model" },
     );
-    assert.equal(s.current.model, undefined);
-    assert.equal(s.current.baseUrl, "http://new/");
+    assert.equal(s.mode, "custom");
+    assert.equal(s.current.baseUrl, "http://old/");
+    assert.equal(s.current.model, "old-model");
+    assert.equal(s.current.apiKey, undefined);
   });
   it("keeps saved model when environment endpoint matches saved endpoint", () => {
     const s = createSessionConfig(