pi-t3-bridge 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-t3-bridge",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Pi extension adapter for t3-pstack inside T3 Code.",
   "keywords": [
     "pi-extension",
@@ -50,6 +50,7 @@
     "typecheck": "tsc --project tsconfig.json && tsc --project pstack/skills/poteto-mode/scripts/watch-pr/tsconfig.json && tsc --project pstack/skills/statechart/scripts/tsconfig.json"
   },
   "dependencies": {
+    "@earendil-works/pi-schema": "1.5.0",
     "commander": "^15.0.0",
     "marked": "18.0.11",
     "pele": "1.13.0"
@@ -61,14 +62,12 @@
     "oxfmt": "^0.74.0",
     "oxlint": "^1.89.0",
     "testcontainers": "^12.2.1",
-    "typebox": "1.3.27",
     "typescript": "^7.0.2",
     "ultracite": "^8.0.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
+    "@earendil-works/pi-coding-agent": "*"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {

package/src/amplike/btw.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
+import { compile, nullable, obj, opt, str } from "@earendil-works/pi-schema";
 
 import { callT3Tool } from "../bridge/t3-http.ts";
 import type { LoadModeSpec } from "./package.ts";
@@ -14,10 +13,9 @@ import type { SelectionChange } from "./selection.ts";
 
 type Command = Parameters<ExtensionAPI["registerCommand"]>[1];
 
-const DelegatedSchema = Type.Object({
-  link: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-  taskId: Type.String(),
-});
+const isDelegated = compile(
+  obj({ link: opt(nullable(str())), taskId: str() }, { open: true })
+).check;
 
 const TITLE_LENGTH = 80;
 
@@ -76,7 +74,7 @@ export const btwCommand = (loadModeSpec: LoadModeSpec): Command => ({
             target: await targetFor(change),
           });
 
-      if (!Value.Check(DelegatedSchema, delegated)) {
+      if (!isDelegated(delegated)) {
         throw new Error("delegate_task returned no task.");
       }
 

package/src/amplike/handoff.ts

@@ -8,8 +8,8 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
+import { compile, nullable, obj, opt, str } from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import { callT3Tool } from "../bridge/t3-http.ts";
 import type { LoadModeSpec } from "./package.ts";
@@ -39,10 +39,28 @@ Output only the prompt, with no preamble.`;
 
 const TITLE_LENGTH = 80;
 
-const LaunchSchema = Type.Object({
-  link: Type.Optional(Type.Union([Type.String(), Type.Null()])),
-  threadId: Type.String(),
-});
+const isLaunched = compile(
+  obj({ link: opt(nullable(str())), threadId: str() }, { open: true })
+).check;
+
+const HandoffSchema = obj(
+  {
+    goal: str({ description: "The goal/task for the new thread" }),
+    mode: opt(
+      str({
+        description:
+          "Amplike mode name to start the new thread with (e.g. 'rush', 'smart', 'deep')",
+      })
+    ),
+    model: opt(
+      str({
+        description:
+          "Model to start the new thread with, as provider/modelId (e.g. 'anthropic/claude-haiku-4-5')",
+      })
+    ),
+  },
+  { open: true }
+);
 
 const summarize = async (
   ctx: ExtensionContext,
@@ -123,7 +141,7 @@ const handoff = async (
         modelSelection: { ...applyChange(await currentSelection(), change) },
       });
 
-  if (!Value.Check(LaunchSchema, launched)) {
+  if (!isLaunched(launched)) {
     throw new Error("t3_thread_launch returned no thread.");
   }
 
@@ -134,7 +152,13 @@ export const handoffTool = (loadModeSpec: LoadModeSpec) =>
   defineTool({
     description:
       "Transfer context to a new focused T3 thread. ONLY use this when the user explicitly asks for a handoff. Provide a goal describing what the new thread should focus on. The result is the new thread's link, which you show the user verbatim.",
-    execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
+    execute: async (
+      _toolCallId,
+      params: Static<typeof HandoffSchema>,
+      signal,
+      _onUpdate,
+      ctx
+    ) => {
       const link = await handoff(
         ctx,
         params.goal,
@@ -150,21 +174,7 @@ export const handoffTool = (loadModeSpec: LoadModeSpec) =>
     },
     label: "Handoff",
     name: "handoff",
-    parameters: Type.Object({
-      goal: Type.String({ description: "The goal/task for the new thread" }),
-      mode: Type.Optional(
-        Type.String({
-          description:
-            "Amplike mode name to start the new thread with (e.g. 'rush', 'smart', 'deep')",
-        })
-      ),
-      model: Type.Optional(
-        Type.String({
-          description:
-            "Model to start the new thread with, as provider/modelId (e.g. 'anthropic/claude-haiku-4-5')",
-        })
-      ),
-    }),
+    parameters: HandoffSchema,
   });
 
 export const handoffCommand = (loadModeSpec: LoadModeSpec): Command => ({

package/src/amplike/package.ts

@@ -10,27 +10,38 @@ import type {
   ExtensionFactory,
   ResolvedResource,
 } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import { compile, obj, opt, str, unknown } from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 const PACKAGE_NAME = "pi-amplike";
 
-const ManifestSchema = Type.Object({ name: Type.String() });
+const isManifest = compile(obj({ name: str() }, { open: true })).check;
 
-const FactoryModuleSchema = Type.Object({
-  default: Type.Function([Type.Unknown()], Type.Unknown()),
-});
+// JSON Schema has no function type, so these check that the export exists and
+// isFunction checks that it is a function. Like TypeBox's Type.Function, the
+// check can't see the function's parameters, so the caller names them.
+const isFunction = <F extends (...args: never[]) => void>(
+  value: unknown
+): value is F => typeof value === "function";
 
-const ModeUtilsSchema = Type.Object({
-  loadModeSpec: Type.Function([Type.String(), Type.String()], Type.Unknown()),
-});
+const isFactoryModule = compile(
+  obj({ default: unknown() }, { open: true })
+).check;
 
-const ModeSpecSchema = Type.Object({
-  modelId: Type.Optional(Type.String()),
-  provider: Type.Optional(Type.String()),
-  thinkingLevel: Type.Optional(Type.String()),
-});
+const isModeUtils = compile(
+  obj({ loadModeSpec: unknown() }, { open: true })
+).check;
+
+const ModeSpecSchema = obj(
+  {
+    modelId: opt(str()),
+    provider: opt(str()),
+    thinkingLevel: opt(str()),
+  },
+  { open: true }
+);
+
+const isModeSpec = compile(ModeSpecSchema).check;
 
 export type ModeSpec = Static<typeof ModeSpecSchema>;
 
@@ -53,9 +64,7 @@ const isAmplikeRoot = (root: string): boolean => {
       readFileSync(path.join(root, "package.json"), "utf-8")
     );
 
-    return (
-      Value.Check(ManifestSchema, manifest) && manifest.name === PACKAGE_NAME
-    );
+    return isManifest(manifest) && manifest.name === PACKAGE_NAME;
   } catch {
     return false;
   }
@@ -97,12 +106,14 @@ export const findAmplike = async (
 export const loadFactory = async (file: string): Promise<ExtensionFactory> => {
   const module: unknown = await import(file);
 
-  if (!Value.Check(FactoryModuleSchema, module)) {
+  if (
+    !isFactoryModule(module) ||
+    !isFunction<ExtensionFactory>(module.default)
+  ) {
     throw new TypeError(`${file} has no default extension factory.`);
   }
 
-  // SAFETY: amplike's extension files default-export a Pi extension factory.
-  return module.default as ExtensionFactory;
+  return module.default;
 };
 
 // amplike's handoff and subagent read -mode through this helper, so the T3
@@ -111,13 +122,15 @@ export const loadModeSpecFrom = async (root: string): Promise<LoadModeSpec> => {
   const file = path.join(root, "extensions", "lib", "mode-utils.ts");
   const module: unknown = await import(file);
 
-  if (!Value.Check(ModeUtilsSchema, module)) {
+  if (!isModeUtils(module) || !isFunction<LoadModeSpec>(module.loadModeSpec)) {
     throw new TypeError(`${file} has no loadModeSpec export.`);
   }
 
+  const { loadModeSpec } = module;
+
   return async (cwd, name) => {
-    const spec = await module.loadModeSpec(cwd, name);
+    const spec: unknown = await loadModeSpec(cwd, name);
 
-    return Value.Check(ModeSpecSchema, spec) ? spec : undefined;
+    return isModeSpec(spec) ? spec : undefined;
   };
 };

package/src/amplike/selection.ts

@@ -1,22 +1,34 @@
-import { Type } from "typebox";
-import type { Static } from "typebox";
-import { Value } from "typebox/value";
+import {
+  arr,
+  bool,
+  compile,
+  obj,
+  opt,
+  str,
+  union,
+} from "@earendil-works/pi-schema";
+import type { Static } from "@earendil-works/pi-schema";
 
 import { callT3Tool } from "../bridge/t3-http.ts";
 import type { LoadModeSpec } from "./package.ts";
 
-const OptionSchema = Type.Object({
-  id: Type.String(),
-  value: Type.Union([Type.String(), Type.Boolean()]),
-});
+const OptionSchema = obj(
+  { id: str(), value: union([str(), bool()]) },
+  { open: true }
+);
 
-const SelectionSchema = Type.Object({
-  instanceId: Type.Optional(Type.String()),
-  model: Type.String(),
-  options: Type.Optional(Type.Array(OptionSchema)),
-});
+const SelectionSchema = obj(
+  {
+    instanceId: opt(str()),
+    model: str(),
+    options: opt(arr(OptionSchema)),
+  },
+  { open: true }
+);
 
-const ConfigureSchema = Type.Object({ modelSelection: SelectionSchema });
+const isConfigured = compile(
+  obj({ modelSelection: SelectionSchema }, { open: true })
+).check;
 
 // T3's modelSelection for a Pi thread: model is "provider/modelId", and the
 // thinking level is the "thinking" option.
@@ -45,7 +57,7 @@ export const isEmptyChange = (change: SelectionChange): boolean =>
 export const currentSelection = async (): Promise<Selection> => {
   const result = await callT3Tool("t3_thread_configure", {});
 
-  if (!Value.Check(ConfigureSchema, result)) {
+  if (!isConfigured(result)) {
     throw new Error("t3_thread_configure returned no modelSelection.");
   }
 

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 = {