pi-system-one 1.1.0 → 1.1.2

package/package.json

@@ -1,22 +1,41 @@
 {
   "name": "pi-system-one",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.",
   "type": "module",
   "license": "MIT",
-  "exports": { ".": "./src/extension.ts" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamaamir/system-one.git",
+    "directory": "pi-system-one"
+  },
+  "exports": {
+    ".": "./src/extension.ts"
+  },
   "scripts": {
     "test": "node --test --experimental-strip-types \"tests/*.test.ts\"",
     "typecheck": "tsc --noEmit"
   },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "model-router",
+    "model-routing",
+    "developer-tools",
+    "llm",
+    "ai",
+    "coding-agent"
+  ],
   "dependencies": {
-    "system-one-core": "^0.1.1"
+    "system-one-core": "^0.2.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },
   "pi": {
-    "extensions": ["./src/extension.ts"]
+    "extensions": [
+      "./src/extension.ts"
+    ]
   }
 }

package/src/config.ts

@@ -11,13 +11,31 @@ export interface SystemOneExtConfig {
   model?: string;
   timeoutMs: number;
 }
-export function loadSystemOneConfig(env: SystemOneEnv = process.env): SystemOneExtConfig {
+export function loadSystemOneConfig(
+  env: SystemOneEnv = process.env,
+): SystemOneExtConfig {
   const baseUrl = env.SYSTEM_ONE_BASE_URL;
-  if (!baseUrl) throw new Error("SYSTEM_ONE_BASE_URL is required (e.g. http://localhost:8008 or https://api.typesafe.ai)");
-  const timeoutMs = env.SYSTEM_ONE_TIMEOUT_MS ? Number(env.SYSTEM_ONE_TIMEOUT_MS) : 10_000;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new Error("SYSTEM_ONE_TIMEOUT_MS must be a positive number");
-  return { baseUrl, apiKey: env.SYSTEM_ONE_API_KEY || undefined, model: env.SYSTEM_ONE_MODEL || undefined, timeoutMs };
+  if (!baseUrl)
+    throw new Error(
+      "SYSTEM_ONE_BASE_URL is required (e.g. http://localhost:8008 or https://api.typesafe.ai)",
+    );
+  const timeoutMs = env.SYSTEM_ONE_TIMEOUT_MS
+    ? Number(env.SYSTEM_ONE_TIMEOUT_MS)
+    : 10_000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("SYSTEM_ONE_TIMEOUT_MS must be a positive number");
+  return {
+    baseUrl,
+    apiKey: env.SYSTEM_ONE_API_KEY || undefined,
+    model: env.SYSTEM_ONE_MODEL || undefined,
+    timeoutMs,
+  };
 }
 export function describeConfig(cfg: SystemOneExtConfig): string {
-  return [`Provider endpoint: ${cfg.baseUrl}`, `API key: ${cfg.apiKey ? "configured" : "absent"}`, `Model: ${cfg.model ?? "server default"}`, `Timeout: ${cfg.timeoutMs}ms`].join("\n");
+  return [
+    `Provider endpoint: ${cfg.baseUrl}`,
+    `API key: ${cfg.apiKey ? "configured" : "absent"}`,
+    `Model: ${cfg.model ?? "server default"}`,
+    `Timeout: ${cfg.timeoutMs}ms`,
+  ].join("\n");
 }

package/src/render.ts

@@ -1,14 +1,27 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: intentional dynamic boundary over JSON protocol values
 // pi-system-one/src/render.ts
-export function renderSystemOneResult(response: { answers: Record<string, any> }): string {
+export function renderSystemOneResult(response: {
+  answers: Record<string, any>;
+}): string {
   const lines = ["System One result", ""];
   for (const [id, a] of Object.entries(response.answers)) {
     if (a?.type === "choice") {
-      lines.push(`${id}:`, `  choice: ${a.choice}`, `  confidence: ${a.confidence}`, `  probabilities:`);
-      for (const [k, v] of Object.entries(a.probabilities ?? {})) lines.push(`    ${k}: ${v}`);
+      lines.push(
+        `${id}:`,
+        `  choice: ${a.choice}`,
+        `  confidence: ${a.confidence}`,
+        `  probabilities:`,
+      );
+      for (const [k, v] of Object.entries(a.probabilities ?? {}))
+        lines.push(`    ${k}: ${v}`);
     } else if (a?.type === "noul") {
       lines.push(`${id}:`, `  noul: ${a.noul}`);
     } else {
-      lines.push(`${id}:`, `  score: ${a.score}`, `  confidence: ${a.confidence}`);
+      lines.push(
+        `${id}:`,
+        `  score: ${a.score}`,
+        `  confidence: ${a.confidence}`,
+      );
     }
     lines.push("");
   }

package/src/tool.ts

@@ -1,7 +1,9 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: intentional dynamic boundary over JSON protocol values
 // pi-system-one/src/tool.ts
-import { Type } from "typebox";
-import type { Static } from "typebox";
+
 import { SystemOne, type SystemOneProvider } from "system-one-core";
+import type { Static } from "typebox";
+import { Type } from "typebox";
 import { renderSystemOneResult } from "./render.ts";
 
 const ChoiceQ = Type.Object({
@@ -12,7 +14,9 @@ const ChoiceQ = Type.Object({
 const NoulQ = Type.Object({
   type: Type.Literal("noul"),
   instructions: Type.Any(),
-  criteria: Type.Optional(Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()]))),
+  criteria: Type.Optional(
+    Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()])),
+  ),
 });
 const ScoreQ = Type.Object({
   type: Type.Literal("score"),
@@ -20,7 +24,11 @@ const ScoreQ = Type.Object({
   criteria: Type.Array(Type.Any()),
 });
 export const systemOneParams = Type.Object({
-  state: Type.Union([Type.String(), Type.Record(Type.String(), Type.Any()), Type.Array(Type.Any())]),
+  state: Type.Union([
+    Type.String(),
+    Type.Record(Type.String(), Type.Any()),
+    Type.Array(Type.Any()),
+  ]),
   questions: Type.Record(Type.String(), Type.Union([ChoiceQ, NoulQ, ScoreQ])),
   model: Type.Optional(Type.String()),
 });
@@ -36,15 +44,30 @@ export function buildSystemOneTool(deps: { provider: SystemOneProvider }) {
       "Use this when the answer space is known and a fast probabilistic decision is preferable to generating free-form text. " +
       "Multiple independent choice, noul, and score questions should be batched into one call when they share the same state.",
     parameters: systemOneParams,
-    async execute(_toolCallId: string, params: SystemOneParams, signal: AbortSignal | undefined) {
+    async execute(
+      _toolCallId: string,
+      params: SystemOneParams,
+      signal: AbortSignal | undefined,
+    ) {
       // Throw on failure per Pi contract — never encode errors in content.
       // Safe to propagate unwrapped: core error messages/codes never contain secrets.
       const response = await systemOne.evaluate(
-        { state: params.state as any, questions: params.questions as any, ...(params.model ? { model: params.model } : {}) },
-        { signal }
+        {
+          state: params.state as any,
+          questions: params.questions as any,
+          ...(params.model ? { model: params.model } : {}),
+        },
+        { signal },
       );
       const text = renderSystemOneResult(response as any);
-      return { content: [{ type: "text" as const, text }], details: { answers: response.answers, model: response.model, usage: response.usage } };
+      return {
+        content: [{ type: "text" as const, text }],
+        details: {
+          answers: response.answers,
+          model: response.model,
+          usage: response.usage,
+        },
+      };
     },
   };
 }

package/tests/config.test.ts

@@ -1,16 +1,24 @@
 // pi-system-one/tests/config.test.ts
-import { describe, it } from "node:test";
+
 import assert from "node:assert/strict";
-import { loadSystemOneConfig, describeConfig } from "../src/config.ts";
+import { describe, it } from "node:test";
+import { describeConfig, loadSystemOneConfig } from "../src/config.ts";
 
 describe("config", () => {
   it("loads from env with localhost default", () => {
-    const cfg = loadSystemOneConfig({ SYSTEM_ONE_BASE_URL: "http://localhost:8008" });
+    const cfg = loadSystemOneConfig({
+      SYSTEM_ONE_BASE_URL: "http://localhost:8008",
+    });
     assert.equal(cfg.baseUrl, "http://localhost:8008");
     assert.equal(cfg.timeoutMs, 10_000);
   });
   it("never exposes the key", () => {
-    const shown = describeConfig(loadSystemOneConfig({ SYSTEM_ONE_BASE_URL: "https://api.typesafe.ai", SYSTEM_ONE_API_KEY: "sk-live-123" }));
+    const shown = describeConfig(
+      loadSystemOneConfig({
+        SYSTEM_ONE_BASE_URL: "https://api.typesafe.ai",
+        SYSTEM_ONE_API_KEY: "sk-live-123",
+      }),
+    );
     assert.doesNotMatch(shown, /sk-live-123/);
     assert.match(shown, /configured/);
   });

package/tests/render.test.ts

@@ -1,15 +1,27 @@
 // pi-system-one/tests/render.test.ts
-import { describe, it } from "node:test";
+
 import assert from "node:assert/strict";
+import { describe, it } from "node:test";
 import { renderSystemOneResult } from "../src/render.ts";
 
 describe("render", () => {
   it("renders mixed answers human-readably with full distributions", () => {
     const text = renderSystemOneResult({
       answers: {
-        task: { type: "choice", choice: "coding", probabilities: { coding: 0.91, research: 0.06, writing: 0.03 }, confidence: 0.91 },
+        task: {
+          type: "choice",
+          choice: "coding",
+          probabilities: { coding: 0.91, research: 0.06, writing: 0.03 },
+          confidence: 0.91,
+        },
         complex: { type: "noul", noul: 0.82 },
-        difficulty: { type: "score", score: 1.7, probabilities: { "0": 0.1, "1": 0.2, "2": 0.7 }, legend: { "0": "easy", "1": "medium", "2": "hard" }, confidence: 0.84 },
+        difficulty: {
+          type: "score",
+          score: 1.7,
+          probabilities: { "0": 0.1, "1": 0.2, "2": 0.7 },
+          legend: { "0": "easy", "1": "medium", "2": "hard" },
+          confidence: 0.84,
+        },
       },
     } as any);
     assert.match(text, /task:[\s\S]*choice: coding/);

package/tests/tool.test.ts

@@ -1,26 +1,61 @@
 // pi-system-one/tests/tool.test.ts
-import { describe, it } from "node:test";
+
 import assert from "node:assert/strict";
-import { buildSystemOneTool } from "../src/tool.ts";
+import { describe, it } from "node:test";
 import { MockSystemOneProvider } from "system-one-core";
+import { buildSystemOneTool } from "../src/tool.ts";
 
 describe("system_one tool", () => {
   it("delegates a mixed batch and preserves details", async () => {
     const tool: any = buildSystemOneTool({
-      provider: new MockSystemOneProvider({ answers: { t: { type: "choice", choice: "a", probabilities: { a: 1 }, confidence: 1 } } }),
+      provider: new MockSystemOneProvider({
+        answers: {
+          t: {
+            type: "choice",
+            choice: "a",
+            probabilities: { a: 1 },
+            confidence: 1,
+          },
+        },
+      }),
     });
-    const res = await tool.execute("id-1", { state: "hi", questions: { t: { type: "choice", instructions: "W?", criteria: { a: null } } } }, undefined, undefined, {});
+    const res = await tool.execute(
+      "id-1",
+      {
+        state: "hi",
+        questions: {
+          t: { type: "choice", instructions: "W?", criteria: { a: null } },
+        },
+      },
+      undefined,
+      undefined,
+      {},
+    );
     const text = JSON.stringify(res);
     assert.match(text, /"a"/);
     assert.equal(res.details.answers.t.choice, "a");
   });
   it("propagates provider errors by throwing (never error-results)", async () => {
     const tool: any = buildSystemOneTool({
-      provider: { id: "boom", async evaluate() { throw new Error("down"); } },
+      provider: {
+        id: "boom",
+        async evaluate() {
+          throw new Error("down");
+        },
+      },
     });
     await assert.rejects(
-      tool.execute("id-2", { state: "x", questions: { q: { type: "noul", instructions: "Is it?" } } }, undefined, undefined, {}),
-      /down/
+      tool.execute(
+        "id-2",
+        {
+          state: "x",
+          questions: { q: { type: "noul", instructions: "Is it?" } },
+        },
+        undefined,
+        undefined,
+        {},
+      ),
+      /down/,
     );
   });
   it("mixed heterogeneous batch with model+signal+usage", async () => {
@@ -33,9 +68,20 @@ describe("system_one tool", () => {
         seenOptions = opts;
         return {
           answers: {
-            c: { type: "choice", choice: "a", probabilities: { a: 0.9, b: 0.1 }, confidence: 0.9 },
+            c: {
+              type: "choice",
+              choice: "a",
+              probabilities: { a: 0.9, b: 0.1 },
+              confidence: 0.9,
+            },
             n: { type: "noul", noul: 0.8 },
-            s: { type: "score", score: 1.5, probabilities: { "0": 0.5, "1": 0.5 }, legend: { "0": "easy", "1": "hard" }, confidence: 0.9 },
+            s: {
+              type: "score",
+              score: 1.5,
+              probabilities: { "0": 0.5, "1": 0.5 },
+              legend: { "0": "easy", "1": "hard" },
+              confidence: 0.9,
+            },
           },
           usage: { inputTokens: 5, outputTokens: 2 },
           metadata: { provider: "stub" },
@@ -44,15 +90,27 @@ describe("system_one tool", () => {
     };
     const tool: any = buildSystemOneTool({ provider: stub as any });
     const controller = new AbortController();
-    const res = await tool.execute("id-3", {
-      state: "hi",
-      model: "jev-latest",
-      questions: {
-        c: { type: "choice", instructions: "W?", criteria: { a: null, b: null } },
-        n: { type: "noul", instructions: "Is it?" },
-        s: { type: "score", instructions: "How hard?", criteria: ["easy", "hard"] },
+    const res = await tool.execute(
+      "id-3",
+      {
+        state: "hi",
+        model: "jev-latest",
+        questions: {
+          c: {
+            type: "choice",
+            instructions: "W?",
+            criteria: { a: null, b: null },
+          },
+          n: { type: "noul", instructions: "Is it?" },
+          s: {
+            type: "score",
+            instructions: "How hard?",
+            criteria: ["easy", "hard"],
+          },
+        },
       },
-    }, controller.signal);
+      controller.signal,
+    );
     assert.equal(res.details.answers.c.choice, "a");
     assert.equal(res.details.answers.n.noul, 0.8);
     assert.equal(res.details.answers.s.score, 1.5);