pi-t3-bridge 0.6.0 → 0.7.0

package/src/bridge/ask.ts

@@ -4,103 +4,79 @@ import type {
   ExtensionUIContext,
   ExtensionUIDialogOptions,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import {
+  arr,
+  compile,
+  int,
+  lit,
+  obj,
+  oneOf,
+  opt,
+  str,
+  union,
+} from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import { registerUnlessTaken } from "./claim.ts";
 import { insideT3 } from "./t3-http.ts";
 
 const OWN_ANSWER = "Type my own answer";
 
-const ChoiceSchema = Type.Object(
-  {
-    description: Type.Optional(
-      Type.String({
-        description: "Why to pick it, shown under the question.",
-        minLength: 1,
-      })
-    ),
-    label: Type.String({ description: "The choice.", minLength: 1 }),
-  },
-  { additionalProperties: false }
-);
-
-const QuestionSchema = Type.Object(
-  {
-    body: Type.Optional(
-      Type.String({
-        description: "More context, shown under the title.",
-        minLength: 1,
-      })
-    ),
-    choices: Type.Optional(
-      Type.Array(ChoiceSchema, {
-        description: "Choices to pick from. Leave out for free text.",
-        minItems: 1,
-      })
-    ),
-    title: Type.String({ description: "The question.", minLength: 1 }),
-  },
-  { additionalProperties: false }
-);
-
-const AskInputSchema = Type.Object(
-  {
-    questions: Type.Array(QuestionSchema, {
-      description: "Questions to ask in order, one card each.",
-      minItems: 1,
-    }),
-    timeoutSeconds: Type.Optional(
-      Type.Integer({
-        description: "Seconds to wait for all answers before giving up.",
-        minimum: 10,
-      })
-    ),
-  },
-  { additionalProperties: false }
-);
+const ChoiceSchema = obj({
+  description: opt(
+    str({
+      description: "Why to pick it, shown under the question.",
+      minLength: 1,
+    })
+  ),
+  label: str({ description: "The choice.", minLength: 1 }),
+});
 
-const AnswerSchema = Type.Union([
-  Type.Object(
-    {
-      index: Type.Integer(),
-      kind: Type.Literal("chose"),
-      label: Type.String(),
-      question: Type.Integer(),
-    },
-    { additionalProperties: false }
+const QuestionSchema = obj({
+  body: opt(
+    str({
+      description: "More context, shown under the title.",
+      minLength: 1,
+    })
   ),
-  Type.Object(
-    {
-      kind: Type.Literal("typed"),
-      question: Type.Integer(),
-      text: Type.String(),
-    },
-    { additionalProperties: false }
+  choices: opt(
+    arr(ChoiceSchema, {
+      description: "Choices to pick from. Leave out for free text.",
+      minItems: 1,
+    })
   ),
-  Type.Object(
-    { kind: Type.Literal("rephrase"), question: Type.Integer() },
-    { additionalProperties: false }
+  title: str({ description: "The question.", minLength: 1 }),
+});
+
+const AskInputSchema = obj({
+  questions: arr(QuestionSchema, {
+    description: "Questions to ask in order, one card each.",
+    minItems: 1,
+  }),
+  timeoutSeconds: opt(
+    int({
+      description: "Seconds to wait for all answers before giving up.",
+      minimum: 10,
+    })
   ),
+});
+
+const AnswerSchema = union([
+  obj({ index: int(), kind: lit("chose"), label: str(), question: int() }),
+  obj({ kind: lit("typed"), question: int(), text: str() }),
+  obj({ kind: lit("rephrase"), question: int() }),
 ]);
 
-const StopSchema = Type.Object(
-  {
-    kind: Type.Union([Type.Literal("dismissed"), Type.Literal("timed_out")]),
-    question: Type.Integer(),
-    unasked: Type.Integer(),
-  },
-  { additionalProperties: false }
-);
+const StopSchema = obj({
+  kind: oneOf(["dismissed", "timed_out"]),
+  question: int(),
+  unasked: int(),
+});
 
-const AskDetailsSchema = Type.Object(
-  {
-    answers: Type.Array(AnswerSchema),
-    stop: Type.Optional(StopSchema),
-  },
-  { additionalProperties: false }
-);
+const AskDetailsSchema = obj({
+  answers: arr(AnswerSchema),
+  stop: opt(StopSchema),
+});
 
 type Question = Static<typeof QuestionSchema>;
 
@@ -115,15 +91,19 @@ type AskDetails = Static<typeof AskDetailsSchema>;
 type Surface = "t3" | "terminal";
 
 // The call as the model sent it, before AskInputSchema rejects extra fields.
-const RawChoiceSchema = Type.Object({});
+const RawChoiceSchema = obj({}, { open: true });
 
-const RawQuestionSchema = Type.Object({
-  choices: Type.Optional(Type.Array(RawChoiceSchema)),
-});
+const RawQuestionSchema = obj(
+  { choices: opt(arr(RawChoiceSchema)) },
+  { open: true }
+);
 
-const RawAskSchema = Type.Object({
-  questions: Type.Optional(Type.Array(RawQuestionSchema)),
-});
+const RawAskSchema = obj(
+  { questions: opt(arr(RawQuestionSchema)) },
+  { open: true }
+);
+
+const isRawAsk = compile(RawAskSchema).check;
 
 type RawCall =
   | Static<typeof RawAskSchema>
@@ -294,7 +274,7 @@ const askTool = defineTool({
   annotations: { readOnlyHint: true },
   description:
     'Ask the user and wait for the answer. Each question becomes one card, asked in order. Put your recommendation first and mark it in the label, e.g. "SQLite (recommended)". Put the reason in `description`, which is shown under the question. The user can always type their own answer instead of picking. To let them pick several, say so in `body`. They will type something like "1 and 3" or "all". Leave out `choices` for free text. If a typed answer is a question or pushback, reply to it before you act. If the user dismisses a card, stop and wait for their next message.',
-  execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
+  execute: async (_toolCallId, params: AskInput, signal, _onUpdate, ctx) => {
     if (!ctx.hasUI) {
       throw new Error(
         "ask needs an interactive client, such as T3 Code or the Pi terminal."
@@ -373,7 +353,7 @@ const askTool = defineTool({
   outputSchema: AskDetailsSchema,
   parameters: AskInputSchema,
   prepareArguments: (args) => {
-    if (Value.Check(RawAskSchema, args)) {
+    if (isRawAsk(args)) {
       checkFields(args);
     }
 

package/src/bridge/bash-timeout.ts

@@ -1,6 +1,12 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
+import {
+  compile,
+  num,
+  obj,
+  opt,
+  str,
+  unknown,
+} from "@earendil-works/pi-schema";
 
 import { readConfig } from "./config.ts";
 
@@ -13,10 +19,11 @@ const DEFAULT_SECONDS = 300;
 export const bashTimeoutSeconds = (): number =>
   readConfig().bashTimeoutSeconds ?? DEFAULT_SECONDS;
 
-const BashInputSchema = Type.Object({
-  command: Type.String(),
-  timeout: Type.Optional(Type.Unknown()),
-});
+const isBashInput = compile(
+  obj({ command: str(), timeout: opt(unknown()) }, { open: true })
+).check;
+
+const isNumber = compile(num()).check;
 
 const TIMED_OUT = /Command timed out after \d+ seconds/u;
 
@@ -24,14 +31,14 @@ export const registerBashTimeout = (pi: ExtensionAPI): void => {
   pi.on("tool_call", (event) => {
     const { input } = event;
 
-    if (event.toolName !== "bash" || !Value.Check(BashInputSchema, input)) {
+    if (event.toolName !== "bash" || !isBashInput(input)) {
       return;
     }
 
     const cap = bashTimeoutSeconds();
 
     input.timeout =
-      Value.Check(Type.Number(), input.timeout) && input.timeout > 0
+      isNumber(input.timeout) && input.timeout > 0
         ? Math.min(input.timeout, cap)
         : cap;
   });

package/src/bridge/config.ts

@@ -3,24 +3,33 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { Static, TSchema } from "typebox";
-import { Value } from "typebox/value";
+import {
+  compile,
+  map,
+  num,
+  oneOf,
+  str,
+  unknown,
+} from "@earendil-works/pi-schema";
+import type { Static, Validator } from "@earendil-works/pi-schema";
 
 // The bridge's settings, one JSON file per machine. Each key is checked on its
 // own, so one bad value falls back to its default and leaves the rest alone.
 // The file is read on every call, so an edit applies on the next prompt.
 
-const SteerSchema = Type.Union([
-  Type.Literal("on"),
-  Type.Literal("off"),
-  Type.Literal("shadow"),
-]);
+const SteerSchema = oneOf(["on", "off", "shadow"]);
 
-const ChildSandboxSchema = Type.Union([
-  Type.Literal("on"),
-  Type.Literal("off"),
-]);
+const ChildSandboxSchema = oneOf(["on", "off"]);
+
+const configFile = compile(map(unknown()));
+
+const fields = {
+  bashTimeoutSeconds: compile(num({ exclusiveMinimum: 0 })),
+  childSandbox: compile(ChildSandboxSchema),
+  classifierModel: compile(str({ pattern: "^[^/\\s]+/.+$" })),
+  mcpUrl: compile(str({ minLength: 1 })),
+  steer: compile(SteerSchema),
+};
 
 export interface Config {
   readonly bashTimeoutSeconds: number | undefined;
@@ -60,19 +69,16 @@ const parse = (text: string): Loaded => {
     return { config: EMPTY, problems: [`${file} is not valid JSON.`] };
   }
 
-  if (!Value.Check(Type.Record(Type.String(), Type.Unknown()), parsed)) {
+  if (!configFile.check(parsed)) {
     return { config: EMPTY, problems: [`${file} is not a JSON object.`] };
   }
 
   const problems: string[] = [];
 
-  const field = <S extends TSchema>(
-    key: string,
-    schema: S
-  ): Static<S> | undefined => {
+  const field = <T>(key: string, validator: Validator<T>): T | undefined => {
     const value = parsed[key];
 
-    if (value === undefined || Value.Check(schema, value)) {
+    if (value === undefined || validator.check(value)) {
       return value;
     }
 
@@ -87,15 +93,12 @@ const parse = (text: string): Loaded => {
     config: {
       bashTimeoutSeconds: field(
         "bashTimeoutSeconds",
-        Type.Number({ exclusiveMinimum: 0 })
-      ),
-      childSandbox: field("childSandbox", ChildSandboxSchema),
-      classifierModel: field(
-        "classifierModel",
-        Type.String({ pattern: "^[^/\\s]+/.+$" })
+        fields.bashTimeoutSeconds
       ),
-      mcpUrl: field("mcpUrl", Type.String({ minLength: 1 })),
-      steer: field("steer", SteerSchema),
+      childSandbox: field("childSandbox", fields.childSandbox),
+      classifierModel: field("classifierModel", fields.classifierModel),
+      mcpUrl: field("mcpUrl", fields.mcpUrl),
+      steer: field("steer", fields.steer),
     },
     problems,
   };

package/src/bridge/plan.ts

@@ -3,7 +3,8 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { obj, opt, str } from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import {
   escapeHtml,
@@ -117,15 +118,16 @@ const planCard = (title: string, plan: string): PlanCard => {
   };
 };
 
-const PlanSchema = Type.Object({
-  plan: Type.String({
-    description: "The plan in Markdown, as numbered steps.",
-    minLength: 1,
-  }),
-  title: Type.Optional(
-    Type.String({ description: "Short plan title.", minLength: 1 })
-  ),
-});
+const PlanSchema = obj(
+  {
+    plan: str({
+      description: "The plan in Markdown, as numbered steps.",
+      minLength: 1,
+    }),
+    title: opt(str({ description: "Short plan title.", minLength: 1 })),
+  },
+  { open: true }
+);
 
 interface PlanToolDetails {
   readonly choice: PlanChoice | "dismissed";
@@ -177,7 +179,13 @@ export const registerPlanGate = (pi: ExtensionAPI): void => {
       annotations: { readOnlyHint: true },
       description:
         "Ask the user to approve a plan before any file changes. Until the user approves, only read-only tools run. On Revise, change the plan and call this tool again. On Cancel, stop: only read-only tools run until the user's next message.",
-      execute: async (toolCallId, params, _signal, _onUpdate, ctx) => {
+      execute: async (
+        toolCallId,
+        params: Static<typeof PlanSchema>,
+        _signal,
+        _onUpdate,
+        ctx
+      ) => {
         if (!ctx.hasUI) {
           throw new Error(
             "Plan approval needs an interactive client, such as T3 Code or the Pi terminal."

package/src/bridge/resume.ts

@@ -2,9 +2,8 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import { compile, obj, oneOf, opt, str } from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import type { Classified } from "./failures.ts";
 import { callT3Tool, insideT3 } from "./t3-http.ts";
@@ -24,13 +23,20 @@ const AFTER_RESET_MS = 2 * 60_000;
 
 const MARKER = /\[pi-t3-resume (?<marker>[\w-]+)\]/u;
 
-const ResumeSchema = Type.Object({
-  marker: Type.String(),
-  scheduledTaskId: Type.Optional(Type.String()),
-  state: Type.Union([Type.Literal("scheduled"), Type.Literal("done")]),
-});
+const ResumeSchema = obj(
+  {
+    marker: str(),
+    scheduledTaskId: opt(str()),
+    state: oneOf(["scheduled", "done"]),
+  },
+  { open: true }
+);
 
-const ScheduledSchema = Type.Object({ scheduledTaskId: Type.String() });
+const isResume = compile(ResumeSchema).check;
+
+const isScheduled = compile(
+  obj({ scheduledTaskId: str() }, { open: true })
+).check;
 
 const resumes = (ctx: ExtensionContext) =>
   ctx.sessionManager
@@ -38,7 +44,7 @@ const resumes = (ctx: ExtensionContext) =>
     .flatMap((entry) =>
       entry.type === "custom" &&
       entry.customType === RESUME_ENTRY &&
-      Value.Check(ResumeSchema, entry.data)
+      isResume(entry.data)
         ? [entry.data]
         : []
     );
@@ -94,7 +100,7 @@ export const scheduleResume = async (
       state: "scheduled",
     };
 
-    if (Value.Check(ScheduledSchema, result)) {
+    if (isScheduled(result)) {
       scheduled.scheduledTaskId = result.scheduledTaskId;
     }
 

package/src/bridge/state.ts

@@ -9,9 +9,19 @@ import {
 import { homedir } from "node:os";
 import path from "node:path";
 
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import {
+  compile,
+  lit,
+  map,
+  nullable,
+  num,
+  obj,
+  oneOf,
+  opt,
+  str,
+  union,
+} from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 // Machine-wide bridge state, shared by every Pi session: which model families
 // are out of usage, and one ledger line per delegated brief.
@@ -38,24 +48,29 @@ export const moveOldState = (): void => {
   }
 };
 
-const FamilyRecordSchema = Type.Union([
-  Type.Object({
-    reason: Type.Union([Type.Literal("exhausted"), Type.Literal("unhealthy")]),
-    resetAt: Type.Optional(Type.String()),
-    since: Type.String(),
-    source: Type.Union([Type.Literal("delegate"), Type.Literal("user")]),
-    state: Type.Literal("exhausted"),
-  }),
-  Type.Object({
-    childThreadId: Type.String(),
-    since: Type.String(),
-    state: Type.Literal("probing"),
-  }),
+const FamilyRecordSchema = union([
+  obj(
+    {
+      reason: oneOf(["exhausted", "unhealthy"]),
+      resetAt: opt(str()),
+      since: str(),
+      source: oneOf(["delegate", "user"]),
+      state: lit("exhausted"),
+    },
+    { open: true }
+  ),
+  obj(
+    { childThreadId: str(), since: str(), state: lit("probing") },
+    { open: true }
+  ),
 ]);
 
-const AccountsFileSchema = Type.Object({
-  families: Type.Record(Type.String(), FamilyRecordSchema),
-});
+const AccountsFileSchema = obj(
+  { families: map(FamilyRecordSchema) },
+  { open: true }
+);
+
+const isAccountsFile = compile(AccountsFileSchema).check;
 
 export type FamilyRecord = Static<typeof FamilyRecordSchema>;
 
@@ -67,7 +82,7 @@ export const readFamilies = (): AccountsFile["families"] => {
   try {
     const parsed: unknown = JSON.parse(readFileSync(accountsPath(), "utf-8"));
 
-    return Value.Check(AccountsFileSchema, parsed) ? parsed.families : {};
+    return isAccountsFile(parsed) ? parsed.families : {};
   } catch {
     return {};
   }
@@ -132,19 +147,24 @@ export const appendSteerLog = (line: {
   }
 };
 
-const LedgerLineSchema = Type.Object({
-  cacheRead: Type.Optional(Type.Number()),
-  cacheWrite: Type.Optional(Type.Number()),
-  cost: Type.Optional(Type.Number()),
-  input: Type.Optional(Type.Number()),
-  job: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-  minutes: Type.Optional(Type.Number()),
-  model: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-  report: Type.Optional(Type.String()),
-  status: Type.Optional(Type.String()),
-  threadId: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-  tokens: Type.Optional(Type.Number()),
-});
+const LedgerLineSchema = obj(
+  {
+    cacheRead: opt(num()),
+    cacheWrite: opt(num()),
+    cost: opt(num()),
+    input: opt(num()),
+    job: opt(nullable(str())),
+    minutes: opt(num()),
+    model: opt(nullable(str())),
+    report: opt(str()),
+    status: opt(str()),
+    threadId: opt(nullable(str())),
+    tokens: opt(num()),
+  },
+  { open: true }
+);
+
+const isLedgerLine = compile(LedgerLineSchema).check;
 
 export type LedgerLine = Static<typeof LedgerLineSchema>;
 
@@ -156,7 +176,7 @@ export const readLedger = (): LedgerLine[] => {
         try {
           const parsed: unknown = JSON.parse(line);
 
-          return Value.Check(LedgerLineSchema, parsed) ? [parsed] : [];
+          return isLedgerLine(parsed) ? [parsed] : [];
         } catch {
           return [];
         }