pi-system-one 1.0.0 → 1.1.1

package/README.md

@@ -1,3 +1,10 @@
 # pi-system-one
 
-Reserved placeholder package.
+System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.
+
+```bash
+pi install npm:pi-system-one
+export SYSTEM_ONE_BASE_URL=http://localhost:8008
+```
+
+TypeSafe: `SYSTEM_ONE_BASE_URL=https://api.typesafe.ai SYSTEM_ONE_API_KEY=... SYSTEM_ONE_MODEL=jev-latest`.

package/package.json

@@ -1,13 +1,36 @@
 {
   "name": "pi-system-one",
-  "version": "1.0.0",
-  "description": "Reserved package name - pi-system-one",
-  "main": "index.js",
+  "version": "1.1.1",
+  "description": "System One decisions for Pi. Plug in TypeSafe Jev, Reflex, or your own provider.",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/extension.ts"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "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"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "commonjs"
+  "pi": {
+    "extensions": [
+      "./src/extension.ts"
+    ]
+  }
 }

package/src/config.ts

@@ -0,0 +1,23 @@
+// pi-system-one/src/config.ts
+export interface SystemOneEnv {
+  SYSTEM_ONE_BASE_URL?: string;
+  SYSTEM_ONE_API_KEY?: string;
+  SYSTEM_ONE_MODEL?: string;
+  SYSTEM_ONE_TIMEOUT_MS?: string;
+}
+export interface SystemOneExtConfig {
+  baseUrl: string;
+  apiKey?: string;
+  model?: string;
+  timeoutMs: number;
+}
+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 };
+}
+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");
+}

package/src/extension.ts

@@ -0,0 +1,19 @@
+// pi-system-one/src/extension.ts
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { HttpSystemOneProvider } from "system-one-core";
+import { loadSystemOneConfig } from "./config.ts";
+import { buildSystemOneTool } from "./tool.ts";
+
+export default function piSystemOneExtension(pi: ExtensionAPI) {
+  const cfg = loadSystemOneConfig();
+  const tool = buildSystemOneTool({
+    provider: new HttpSystemOneProvider({
+      id: "configured",
+      baseUrl: cfg.baseUrl,
+      apiKey: cfg.apiKey,
+      defaultModel: cfg.model,
+      timeoutMs: cfg.timeoutMs,
+    }),
+  });
+  pi.registerTool(tool);
+}

package/src/render.ts

@@ -0,0 +1,16 @@
+// pi-system-one/src/render.ts
+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}`);
+    } else if (a?.type === "noul") {
+      lines.push(`${id}:`, `  noul: ${a.noul}`);
+    } else {
+      lines.push(`${id}:`, `  score: ${a.score}`, `  confidence: ${a.confidence}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}

package/src/tool.ts

@@ -0,0 +1,50 @@
+// pi-system-one/src/tool.ts
+import { Type } from "typebox";
+import type { Static } from "typebox";
+import { SystemOne, type SystemOneProvider } from "system-one-core";
+import { renderSystemOneResult } from "./render.ts";
+
+const ChoiceQ = Type.Object({
+  type: Type.Literal("choice"),
+  instructions: Type.Any(),
+  criteria: Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()])),
+});
+const NoulQ = Type.Object({
+  type: Type.Literal("noul"),
+  instructions: Type.Any(),
+  criteria: Type.Optional(Type.Record(Type.String(), Type.Union([Type.Any(), Type.Null()]))),
+});
+const ScoreQ = Type.Object({
+  type: Type.Literal("score"),
+  instructions: Type.Any(),
+  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())]),
+  questions: Type.Record(Type.String(), Type.Union([ChoiceQ, NoulQ, ScoreQ])),
+  model: Type.Optional(Type.String()),
+});
+export type SystemOneParams = Static<typeof systemOneParams>;
+
+export function buildSystemOneTool(deps: { provider: SystemOneProvider }) {
+  const systemOne = new SystemOne({ provider: deps.provider });
+  return {
+    name: "system_one",
+    label: "System One",
+    description:
+      "Evaluate one or more bounded decision questions against shared state using the configured System One provider. " +
+      "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) {
+      // 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 }
+      );
+      const text = renderSystemOneResult(response as any);
+      return { content: [{ type: "text" as const, text }], details: { answers: response.answers, model: response.model, usage: response.usage } };
+    },
+  };
+}

package/tests/config.test.ts

@@ -0,0 +1,20 @@
+// 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";
+
+describe("config", () => {
+  it("loads from env with localhost default", () => {
+    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" }));
+    assert.doesNotMatch(shown, /sk-live-123/);
+    assert.match(shown, /configured/);
+  });
+  it("rejects missing baseUrl", () => {
+    assert.throws(() => loadSystemOneConfig({}), /SYSTEM_ONE_BASE_URL/);
+  });
+});

package/tests/render.test.ts

@@ -0,0 +1,20 @@
+// pi-system-one/tests/render.test.ts
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+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 },
+        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 },
+      },
+    } as any);
+    assert.match(text, /task:[\s\S]*choice: coding/);
+    assert.match(text, /probabilities:[\s\S]*coding: 0\.91/);
+    assert.match(text, /complex:[\s\S]*noul: 0\.82/);
+    assert.match(text, /difficulty:[\s\S]*score: 1\.7/);
+  });
+});

package/tests/tool.test.ts

@@ -0,0 +1,63 @@
+// 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 { MockSystemOneProvider } from "system-one-core";
+
+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 } } }),
+    });
+    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"); } },
+    });
+    await assert.rejects(
+      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 () => {
+    let seenRequest: any;
+    let seenOptions: any;
+    const stub = {
+      id: "stub",
+      async evaluate(req: any, opts: any) {
+        seenRequest = req;
+        seenOptions = opts;
+        return {
+          answers: {
+            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 },
+          },
+          usage: { inputTokens: 5, outputTokens: 2 },
+          metadata: { provider: "stub" },
+        };
+      },
+    };
+    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"] },
+      },
+    }, 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);
+    assert.deepEqual(res.details.usage, { inputTokens: 5, outputTokens: 2 });
+    assert.equal(seenRequest.model, "jev-latest");
+    assert.equal(seenOptions.signal, controller.signal);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/index.js

@@ -1,2 +0,0 @@
-// pi-system-one - reserved placeholder package
-module.exports = {};