pi-t3-bridge 0.5.0 → 0.7.0

package/src/amplike/t3-view.ts

@@ -0,0 +1,88 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { btwCommand } from "./btw.ts";
+import { handoffCommand, handoffTool } from "./handoff.ts";
+import type { LoadModeSpec } from "./package.ts";
+import { applyChange, configureThread, currentSelection } from "./selection.ts";
+import type { SelectionChange } from "./selection.ts";
+
+type Tool = Parameters<ExtensionAPI["registerTool"]>[0];
+
+type Command = Parameters<ExtensionAPI["registerCommand"]>[1];
+
+// What a T3 thread gets for each name amplike registers. A missing name is
+// registered as amplike wrote it. null drops it.
+interface Rules {
+  readonly commands: Readonly<Record<string, Command | null>>;
+  readonly tools: Readonly<Record<string, Tool | null>>;
+}
+
+const t3Rules = (loadModeSpec: LoadModeSpec): Rules => ({
+  commands: {
+    btw: btwCommand(loadModeSpec),
+    handoff: handoffCommand(loadModeSpec),
+  },
+  tools: {
+    handoff: handoffTool(loadModeSpec),
+    // T3's delegate_task runs subagents as T3 threads.
+    subagent: null,
+  },
+});
+
+// T3 owns the thread's model. When amplike's /mode switches Pi's model or
+// thinking level, the same change goes to T3, so T3's model picker matches and
+// T3's next set_model keeps it. amplike awaits setModel before it sets the
+// thinking level, so the two calls reach T3 in order.
+const mirror = async (change: SelectionChange): Promise<void> => {
+  await configureThread(applyChange(await currentSelection(), change));
+};
+
+const mirrorThinking = async (thinking: string): Promise<void> => {
+  try {
+    await mirror({ thinking });
+  } catch (error) {
+    console.error(`pi-t3: T3 kept its thinking level: ${String(error)}`);
+  }
+};
+
+// Pi's extension API is a plain object of closures, so a copy with some
+// methods replaced behaves like the original for everything else.
+export const t3View = (
+  pi: ExtensionAPI,
+  loadModeSpec: LoadModeSpec
+): ExtensionAPI => {
+  const rules = t3Rules(loadModeSpec);
+
+  return {
+    ...pi,
+    registerCommand: (name, options) => {
+      const rule = rules.commands[name];
+
+      if (rule !== null) {
+        pi.registerCommand(name, rule ?? options);
+      }
+    },
+    // T3 sends Pi no key presses.
+    registerShortcut: () => null,
+    registerTool: (tool) => {
+      const rule = rules.tools[tool.name];
+
+      if (rule !== null) {
+        pi.registerTool(rule ?? tool);
+      }
+    },
+    setModel: async (model) => {
+      const ok = await pi.setModel(model);
+
+      if (ok) {
+        await mirror({ model: `${model.provider}/${model.id}` });
+      }
+
+      return ok;
+    },
+    setThinkingLevel: (level) => {
+      pi.setThinkingLevel(level);
+      void mirrorThinking(level);
+    },
+  };
+};

package/src/bridge/accounts.ts

@@ -3,9 +3,19 @@ import type {
   ExtensionContext,
   ExtensionToolContext,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import {
+  arr,
+  bool,
+  compile,
+  lit,
+  nullable,
+  num,
+  obj,
+  opt,
+  str,
+  union,
+} from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import { classifyFailure } from "./failures.ts";
 import type { Classified } from "./failures.ts";
@@ -62,15 +72,16 @@ const NO_RESET_MS = 60 * 60_000;
 
 const USAGE_LIMIT_TITLE = "Usage limit reached";
 
-const AccountEventSchema = Type.Union([
-  Type.Object({
-    childThreadId: Type.String(),
-    family: Type.String(),
-    kind: Type.Literal("delegated"),
-  }),
-  Type.Object({ childThreadId: Type.String(), kind: Type.Literal("settled") }),
+const AccountEventSchema = union([
+  obj(
+    { childThreadId: str(), family: str(), kind: lit("delegated") },
+    { open: true }
+  ),
+  obj({ childThreadId: str(), kind: lit("settled") }, { open: true }),
 ]);
 
+const isAccountEvent = compile(AccountEventSchema).check;
+
 type AccountEvent = Static<typeof AccountEventSchema>;
 
 export interface Accounts {
@@ -100,7 +111,7 @@ export const readAccounts = (ctx: ExtensionContext): Accounts => {
     if (
       entry.type === "custom" &&
       entry.customType === ACCOUNT_ENTRY &&
-      Value.Check(AccountEventSchema, entry.data)
+      isAccountEvent(entry.data)
     ) {
       const event: AccountEvent = entry.data;
 
@@ -186,19 +197,23 @@ export const recordFailure = (
   updateFamily(modelFamily, record);
 };
 
-const ThreadReadSchema = Type.Object({
-  hasMore: Type.Boolean(),
-  items: Type.Array(
-    Type.Object({
-      text: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-      title: Type.Union([Type.String(), Type.Null()]),
-      type: Type.String(),
-    })
-  ),
-  nextPosition: Type.Union([Type.Number(), Type.Null()]),
-  recentRuns: Type.Optional(Type.Array(Type.Object({ status: Type.String() }))),
-  thread: Type.Object({ status: Type.String() }),
-});
+const ThreadReadSchema = obj(
+  {
+    hasMore: bool(),
+    items: arr(
+      obj(
+        { text: opt(nullable(str())), title: nullable(str()), type: str() },
+        { open: true }
+      )
+    ),
+    nextPosition: nullable(num()),
+    recentRuns: opt(arr(obj({ status: str() }, { open: true }))),
+    thread: obj({ status: str() }, { open: true }),
+  },
+  { open: true }
+);
+
+const threadRead = compile(ThreadReadSchema);
 
 type ThreadRead = Static<typeof ThreadReadSchema>;
 
@@ -217,16 +232,14 @@ const bridgeReader =
   async (params) => {
     const outcome = await ctx.executeTool(toolName, params);
 
-    return outcome.isError
-      ? undefined
-      : t3Json(ThreadReadSchema, outcome.result);
+    return outcome.isError ? undefined : t3Json(threadRead, outcome.result);
   };
 
 // A tool_result handler gets no ctx.executeTool, so it reads through T3 directly.
 export const httpReader: PageReader = async (params) => {
   const read = await callT3Tool("t3_thread_read", { ...params });
 
-  return Value.Check(ThreadReadSchema, read) ? read : undefined;
+  return threadRead.check(read) ? read : undefined;
 };
 
 type ChildOutcome =
@@ -358,27 +371,33 @@ const STATUS_TOOLS: ReadonlySet<string> = new Set([
   "mcp__t3__task_status",
 ]);
 
-const StatusSchema = Type.Object({
-  childThreadId: Type.String(),
-  status: Type.Optional(Type.String()),
-  workState: Type.Optional(Type.String()),
-});
+const taskStatus = compile(
+  obj(
+    { childThreadId: str(), status: opt(str()), workState: opt(str()) },
+    { open: true }
+  )
+);
 
-const DelegateInputSchema = Type.Object({
-  target: Type.Optional(Type.Object({ model: Type.String() })),
-});
+const isDelegateInput = compile(
+  obj({ target: opt(obj({ model: str() }, { open: true })) }, { open: true })
+).check;
 
-const DelegateResultSchema = Type.Object({ childThreadId: Type.String() });
+const delegateResult = compile(obj({ childThreadId: str() }, { open: true }));
 
 const sessionFamily = (ctx: ExtensionContext): string | undefined =>
   ctx.model === undefined ? undefined : family(ctx.model.id);
 
-const AssistantErrorSchema = Type.Object({
-  errorMessage: Type.Optional(Type.String()),
-  model: Type.String(),
-  role: Type.Literal("assistant"),
-  stopReason: Type.String(),
-});
+const isAssistantError = compile(
+  obj(
+    {
+      errorMessage: opt(str()),
+      model: str(),
+      role: lit("assistant"),
+      stopReason: str(),
+    },
+    { open: true }
+  )
+).check;
 
 // Recovery takes any family accounts.json records, such as kimi. Marking one
 // out takes only a family of a model Pi knows, so a typo cannot add one.
@@ -410,7 +429,7 @@ export const registerAccounts = (pi: ExtensionAPI): void => {
       return;
     }
 
-    const status = t3Json(StatusSchema, event);
+    const status = t3Json(taskStatus, event);
 
     const childFamily =
       status === undefined
@@ -437,11 +456,9 @@ export const registerAccounts = (pi: ExtensionAPI): void => {
       return;
     }
 
-    const result = t3Json(DelegateResultSchema, event);
+    const result = t3Json(delegateResult, event);
 
-    const input = Value.Check(DelegateInputSchema, event.input)
-      ? event.input
-      : undefined;
+    const input = isDelegateInput(event.input) ? event.input : undefined;
 
     const childFamily =
       input?.target === undefined
@@ -493,7 +510,7 @@ export const registerAccounts = (pi: ExtensionAPI): void => {
       (message) => (message as { role?: string }).role === "assistant"
     );
 
-    if (!Value.Check(AssistantErrorSchema, last)) {
+    if (!isAssistantError(last)) {
       lastRun = undefined;
     } else if (last.stopReason === "error") {
       lastRun = {

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."