@staix/agent-hub 0.5.0 → 0.6.0

package/src/models/relay.ts

@@ -0,0 +1,334 @@
+import { randomUUID } from "node:crypto";
+import { isIP } from "node:net";
+import type { OmniRoute, ChatMessage } from "../omniroute/client.ts";
+import { ensureMlx, type MlxHandle, type MlxOptions, type MlxStatus } from "./mlx.ts";
+
+export type ModelBackend = { kind: "mlx"; alias?: string } | { kind: "dgx"; alias: string };
+
+export interface RelayRequest {
+  model?: string;
+  messages: ChatMessage[];
+  tools?: unknown[];
+  max_tokens?: number;
+  [key: string]: unknown;
+}
+
+export interface RelayBackendStatus {
+  alias: string;
+  kind: ModelBackend["kind"];
+  state: "idle" | "starting" | "ready" | "error";
+  requestedModel?: string;
+  actualModel?: string;
+  provider?: string;
+  active: number;
+  lastError?: string;
+}
+
+export interface ModelRelayStatus {
+  url: string;
+  models: string[];
+  backends: RelayBackendStatus[];
+}
+
+export interface ModelRelayOptions {
+  omni: OmniRoute;
+  host?: string;
+  port?: number;
+  token?: string;
+  defaultBackend?: ModelBackend;
+  selectBackend?: (request: RelayRequest) => ModelBackend | Promise<ModelBackend>;
+  allowedDGXmodels: Record<string, string>;
+  dgxMaxInputTokens?: number;
+  mlx?: MlxOptions;
+  mlxAlias?: string;
+  mlxModel?: string;
+  fallbackDGXAlias?: string;
+}
+
+export interface ModelRelay {
+  readonly url: string;
+  readonly token: string;
+  readonly models: string[];
+  readonly status: () => ModelRelayStatus;
+  readonly close: () => Promise<void>;
+}
+
+interface ActiveRequest {
+  controller: AbortController;
+  release?: () => void;
+  cancel?: (reason?: unknown) => Promise<void>;
+  cleanup: () => void;
+}
+
+const safeHeader = (value: string | null): string | undefined => value && value.length < 256 ? value : undefined;
+
+function assertLoopback(host: string): void {
+  const value = host.toLowerCase();
+  if (value !== "localhost" && value !== "::1" && !(isIP(value) === 4 && value.startsWith("127."))) throw new Error("model relay host must be loopback");
+}
+
+function estimateInputTokens(messages: ChatMessage[], tools?: unknown[]): number {
+  return Math.ceil(JSON.stringify({ messages, tools }).length / 4);
+}
+
+function bearer(request: Request): string | undefined {
+  const value = request.headers.get("authorization");
+  return value?.startsWith("Bearer ") ? value.slice("Bearer ".length) : undefined;
+}
+
+function aliasOf(backend: ModelBackend, mlxAlias: string): string {
+  return backend.kind === "mlx" ? backend.alias ?? mlxAlias : backend.alias;
+}
+
+function bodyForUpstream(body: RelayRequest, model: string): Record<string, unknown> {
+  const allowed = ["temperature", "top_p", "max_tokens", "stop", "tools", "tool_choice", "response_format"];
+  return {
+    model,
+    messages: body.messages,
+    stream: true,
+    ...Object.fromEntries(allowed.filter((key) => body[key] !== undefined).map((key) => [key, body[key]])),
+  };
+}
+
+function sseResponse(response: Response, release: () => void, onModel?: (model: string) => void, registerCancel?: (cancel: (reason?: unknown) => Promise<void>) => void): Response {
+  if (!response.body) {
+    release();
+    return new Response("upstream returned no stream", { status: 502 });
+  }
+  const reader = response.body.getReader();
+  const cancel = async (reason?: unknown) => {
+    try { await reader.cancel(reason); } catch { /* the upstream may already be closed */ }
+  };
+  registerCancel?.(cancel);
+  let inspectBuffer = "";
+  let inspectedModel = false;
+  const inspect = (chunk: Uint8Array) => {
+    if (!onModel || inspectedModel) return;
+    inspectBuffer += new TextDecoder().decode(chunk);
+    if (inspectBuffer.length > 64_000) inspectBuffer = inspectBuffer.slice(-64_000);
+    const lines = inspectBuffer.split(/\r?\n/);
+    inspectBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data:") || line.slice(5).trim() === "[DONE]") continue;
+      try {
+        const value = JSON.parse(line.slice(5).trim()) as { model?: unknown };
+        if (typeof value.model === "string" && value.model.length < 256) {
+          inspectedModel = true;
+          onModel(value.model);
+          return;
+        }
+      } catch { /* incomplete or non-JSON SSE data */ }
+    }
+  };
+  const stream = new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const next = await reader.read();
+        if (next.done) {
+          release();
+          controller.close();
+        } else { inspect(next.value); controller.enqueue(next.value); }
+      } catch (error) {
+        release();
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      release();
+      await cancel(reason);
+    },
+  });
+  return new Response(stream, {
+    status: response.status,
+    headers: { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" },
+  });
+}
+
+export async function startModelRelay(options: ModelRelayOptions): Promise<ModelRelay> {
+  const host = options.host ?? "127.0.0.1";
+  assertLoopback(host);
+  const token = options.token ?? randomUUID();
+  const mlxAlias = options.mlxAlias ?? "mlx/fast";
+  const dgxMaxInputTokens = options.dgxMaxInputTokens ?? 262_144;
+  const defaultBackend = options.defaultBackend ?? (options.mlx ? { kind: "mlx", alias: mlxAlias } : { kind: "dgx", alias: "dgx/coding" });
+  const models = [...new Set([...(options.mlx ? [mlxAlias] : []), ...Object.keys(options.allowedDGXmodels)])];
+  let mlx: MlxHandle | undefined;
+  let mlxStarting: Promise<MlxHandle> | undefined;
+  const states = new Map<string, RelayBackendStatus>();
+  const activeRequests = new Set<ActiveRequest>();
+  const activeByAlias = new Map<string, number>();
+
+  const ensureMlxHandle = async (): Promise<MlxHandle> => (mlx ??= await (mlxStarting ??= ensureMlx(options.mlx).finally(() => { mlxStarting = undefined; })));
+  const state = (backend: ModelBackend): RelayBackendStatus => states.get(aliasOf(backend, mlxAlias)) ?? {
+    alias: aliasOf(backend, mlxAlias), kind: backend.kind, state: "idle", active: 0,
+  };
+  const setState = (backend: ModelBackend, patch: Partial<RelayBackendStatus>) => {
+    const alias = aliasOf(backend, mlxAlias);
+    states.set(alias, { ...state(backend), ...patch, alias, kind: backend.kind });
+  };
+
+  const resolve = async (body: RelayRequest): Promise<ModelBackend> => {
+    const requested = typeof body.model === "string" ? body.model : undefined;
+    if (requested && !models.includes(requested)) throw new Error("model alias is not allowed");
+    if (requested === mlxAlias && options.mlx) return { kind: "mlx", alias: mlxAlias };
+    if (requested && requested in options.allowedDGXmodels) return { kind: "dgx", alias: requested };
+    const selected = options.selectBackend ? await options.selectBackend(body) : defaultBackend;
+    if (selected.kind === "mlx" && !options.mlx) throw new Error("MLX backend is not configured");
+    if (selected.kind === "dgx" && !(selected.alias in options.allowedDGXmodels)) throw new Error("DGX model alias is not allowed");
+    return selected;
+  };
+
+  const upstream = async (request: RelayRequest, backend: ModelBackend, signal: AbortSignal): Promise<{ response: Response; release: () => void; onModel?: (model: string) => void }> => {
+    const alias = aliasOf(backend, mlxAlias);
+    let base: string;
+    let model: string;
+    let release = () => {};
+    let released = false;
+    const count = (delta: number) => activeByAlias.set(alias, Math.max(0, (activeByAlias.get(alias) ?? 0) + delta));
+    if (backend.kind === "mlx") {
+      setState(backend, { state: "starting", requestedModel: request.model });
+      let handle: MlxHandle;
+      try {
+        handle = await ensureMlxHandle();
+      } catch (error) {
+        setState(backend, { state: "error", lastError: error instanceof Error ? error.message.slice(0, 160) : "MLX startup failed" });
+        throw error;
+      }
+      base = handle.url;
+      model = options.mlxModel ?? handle.model;
+      if (signal.aborted) throw new Error("request was cancelled before MLX generation started");
+      release = await handle.acquire(signal);
+    } else {
+      base = (await options.omni.base()) ?? (() => { throw new Error("DGX gateway is unavailable"); })();
+      model = options.allowedDGXmodels[backend.alias]!;
+    }
+    const key = backend.kind === "dgx" ? options.omni.apiKey() : "";
+    if (backend.kind === "dgx" && !key) throw new Error("DGX gateway key is unavailable");
+    count(1);
+    const releaseOnce = () => {
+      if (released) return;
+      released = true;
+      release();
+      count(-1);
+    };
+    const headers: Record<string, string> = { "content-type": "application/json" };
+    if (key) Object.assign(headers, { authorization: `Bearer ${key}` }, options.omni.accessHeaders(base));
+    let response: Response;
+    try {
+      response = await fetch(`${base.replace(/\/$/, "")}/chat/completions`, { method: "POST", headers, body: JSON.stringify(bodyForUpstream(request, model)), signal: AbortSignal.any([signal, AbortSignal.timeout(180_000)]) });
+    } catch (error) {
+      releaseOnce();
+      setState(backend, { state: "error", lastError: error instanceof Error ? error.message.slice(0, 160) : "upstream request failed" });
+      throw error;
+    }
+    if (!response.ok) {
+      releaseOnce();
+      const message = `backend returned HTTP ${response.status}`;
+      setState(backend, { state: "error", lastError: message });
+      throw new Error(message);
+    }
+    const provider = safeHeader(response.headers.get("x-omniroute-provider"));
+    const actualModel = safeHeader(response.headers.get("x-model-router-selected-model"));
+    setState(backend, { state: "ready", requestedModel: request.model, active: activeByAlias.get(alias) ?? 0,
+      provider: provider ?? undefined, actualModel: actualModel ?? (backend.kind === "mlx" ? model : undefined) });
+    const releaseWithStatus = () => {
+      releaseOnce();
+      setState(backend, { active: activeByAlias.get(alias) ?? 0 });
+    };
+    return { response, release: releaseWithStatus, ...(actualModel ? {} : { onModel: (value: string) => setState(backend, { actualModel: value }) }) };
+  };
+
+  const server = Bun.serve({
+    hostname: host,
+    port: options.port ?? 0,
+    idleTimeout: 255,
+    async fetch(request) {
+      if (bearer(request) !== token) return new Response("unauthorized", { status: 401 });
+      if (request.headers.has("origin")) return new Response("origin header is not accepted", { status: 403 });
+      const path = new URL(request.url).pathname;
+      if (request.method === "GET" && path === "/health") return Response.json({ ok: true, status: status() });
+      if (request.method === "GET" && path === "/v1/models") return Response.json({ object: "list", data: models.map((id) => ({ id, object: "model", owned_by: id.startsWith("mlx/") ? "mlx" : "dgx" })) });
+      if (request.method !== "POST" || path !== "/v1/chat/completions") return new Response("not found", { status: 404 });
+      if (Number(request.headers.get("content-length") ?? 0) > 2_000_000) return new Response("request too large", { status: 413 });
+      const controller = new AbortController();
+      const onAbort = () => controller.abort(request.signal.reason);
+      request.signal.addEventListener("abort", onAbort, { once: true });
+      const record: ActiveRequest = { controller, cleanup: () => request.signal.removeEventListener("abort", onAbort) };
+      activeRequests.add(record);
+      let body: RelayRequest;
+      try {
+        const raw = await request.text();
+        if (new TextEncoder().encode(raw).byteLength > 2_000_000) throw new Error("request too large");
+        body = JSON.parse(raw) as RelayRequest;
+        if (!Array.isArray(body.messages) || body.messages.length === 0) throw new Error("messages is required");
+      } catch (error) {
+        record.cleanup();
+        activeRequests.delete(record);
+        return Response.json({ error: error instanceof Error ? error.message : "invalid request" }, { status: 400 });
+      }
+      let backend: ModelBackend;
+      try { backend = await resolve(body); } catch (error) {
+        record.cleanup();
+        activeRequests.delete(record);
+        return Response.json({ error: error instanceof Error ? error.message : "backend unavailable" }, { status: 400 });
+      }
+      const inputBudget = backend.kind === "mlx" ? (options.mlx?.maxInputTokens ?? 16_000) : dgxMaxInputTokens;
+      if (estimateInputTokens(body.messages, body.tools) > inputBudget) {
+        record.cleanup();
+        activeRequests.delete(record);
+        return Response.json({ error: "input exceeds the model context budget" }, { status: 400 });
+      }
+      const fallback = backend.kind === "mlx" && options.fallbackDGXAlias ? { kind: "dgx", alias: options.fallbackDGXAlias } as ModelBackend : undefined;
+      try {
+        const result = await upstream(body, backend, controller.signal);
+        let released = false;
+        const release = () => {
+          if (released) return;
+          released = true;
+          result.release();
+          record.cleanup();
+          activeRequests.delete(record);
+        };
+        record.release = release;
+        return sseResponse(result.response, release, result.onModel, (cancel) => { record.cancel = cancel; });
+      } catch (error) {
+        if (!fallback || controller.signal.aborted) {
+          record.cleanup();
+          activeRequests.delete(record);
+          return Response.json({ error: error instanceof Error ? error.message : "backend unavailable" }, { status: 502 });
+        }
+        try {
+          const result = await upstream({ ...body, model: fallback.alias }, fallback, controller.signal);
+          let released = false;
+          const release = () => {
+            if (released) return;
+            released = true;
+            result.release();
+            record.cleanup();
+            activeRequests.delete(record);
+          };
+          record.release = release;
+          return sseResponse(result.response, release, result.onModel, (cancel) => { record.cancel = cancel; });
+        } catch (fallbackError) {
+          record.cleanup();
+          activeRequests.delete(record);
+          return Response.json({ error: fallbackError instanceof Error ? fallbackError.message : "fallback unavailable" }, { status: 502 });
+        }
+      }
+    },
+  });
+  const url = `http://${host}:${server.port}/v1`;
+  const status = (): ModelRelayStatus => ({ url, models, backends: [...states.values()].map((value) => ({ ...value })) });
+  return { url, token, models, status, close: async () => {
+    const closing = [...activeRequests].map(async (request) => {
+      request.controller.abort(new Error("model relay closed"));
+      await request.cancel?.(new Error("model relay closed"));
+      request.release?.();
+      request.cleanup();
+    });
+    await Promise.allSettled(closing);
+    activeRequests.clear();
+    server.stop(false);
+    await mlx?.close();
+  } };
+}

package/src/pi/extension.ts

@@ -0,0 +1,120 @@
+type ExtensionAPI = any;
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+
+type BridgeEvent = { type: string; text?: string; sessionId?: string; sessionFile?: string; error?: string };
+
+const bridgeUrl = process.env.AGENTHUB_PI_BRIDGE_URL ?? "";
+const bridgeToken = process.env.AGENTHUB_PI_BRIDGE_TOKEN ?? "";
+const ownerToken = process.env.AGENTHUB_PI_OWNER_TOKEN ?? "";
+const relayUrl = process.env.AGENTHUB_PI_RELAY_URL ?? "";
+const relayToken = process.env.AGENTHUB_PI_RELAY_TOKEN ?? "";
+const models = (() => {
+  try { return JSON.parse(process.env.AGENTHUB_PI_MODELS ?? "[]") as unknown[]; } catch { return []; }
+})();
+let pollStarted = false;
+let toolSteps = 0;
+let lastActivity = 0;
+let forcedFailure = "";
+const maxSteps = Number(process.env.AGENTHUB_PI_MAX_STEPS ?? 30);
+let shutdown: (() => void) | undefined;
+let runtimeCtx: any;
+let modelRegistry: any;
+
+async function post(path: string, body: unknown): Promise<any> {
+  if (!bridgeUrl || !bridgeToken) throw new Error("Pi bridge is not configured");
+  const response = await fetch(`${bridgeUrl}${path}`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${bridgeToken}` }, body: JSON.stringify(body) });
+  if (!response.ok) throw new Error(`Pi bridge HTTP ${response.status}`);
+  return response.json();
+}
+function processSignature(): string | undefined { try { const text = execFileSync("ps", ["-p", String(process.pid), "-o", "lstart=,comm="], { encoding: "utf8" }).trim(); return text ? createHash("sha256").update(text).digest("hex") : undefined; } catch { return undefined; } }
+
+async function poll(pi: ExtensionAPI): Promise<void> {
+  while (true) {
+    try {
+      const response = await fetch(`${bridgeUrl}/commands`, { headers: { authorization: `Bearer ${bridgeToken}` } });
+      const payload = await response.json() as { command?: any };
+      const command = payload.command;
+      if (!command) continue;
+      try {
+        if (command.type === "prompt" || command.type === "steer") {
+          pi.sendMessage({ customType: "agent-hub", content: String(command.message ?? ""), display: true }, { triggerTurn: command.type === "prompt", deliverAs: command.type === "steer" ? "steer" : "followUp" });
+        } else if (command.type === "set_model") {
+          const model = modelRegistry?.find(String(command.provider), String(command.modelId));
+          if (!model || !(await (pi as any).setModel?.(model))) throw new Error("Pi model is not available");
+        } else if (command.type === "shutdown") {
+          shutdown?.();
+        }
+        await post("/ack", { id: command.id, ok: true });
+      } catch (error) { await post("/ack", { id: command.id, ok: false, error: (error as Error).message }); }
+    } catch { await new Promise((resolve) => setTimeout(resolve, 250)); }
+  }
+}
+
+export default function(pi: ExtensionAPI): void {
+  if (relayUrl) {
+    pi.registerProvider("agent-hub-local", {
+      baseUrl: relayUrl,
+      api: "openai-completions",
+      apiKey: relayToken || "agent-hub-local",
+      models: models.filter((m): m is any => !!m && typeof m === "object" && typeof (m as any).id === "string").map((m: any) => ({
+        id: m.id, name: m.name ?? m.id, reasoning: !!m.reasoning, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: m.contextWindow ?? 131072, maxTokens: m.maxTokens ?? 8192,
+      })),
+    });
+  }
+  pi.on("session_start", async (_event: any, ctx: any) => {
+    runtimeCtx = ctx;
+    modelRegistry = ctx.modelRegistry;
+    shutdown = ctx.shutdown;
+    const state = ctx.sessionManager.getHeader();
+    try {
+      const claimed = await post("/event", { type: "session_start", ownerToken, pid: process.pid, signature: processSignature(), sessionId: state?.id, sessionFile: ctx.sessionManager.getSessionFile() });
+      if (claimed?.ok === false) { ctx.shutdown?.(); return; }
+    } catch (error) { ctx.shutdown?.(); throw error; }
+    if (!pollStarted) { pollStarted = true; void poll(pi); }
+  });
+  pi.on("agent_end", async (event: any) => {
+    const message = (event as any).messages?.slice().reverse().find((m: any) => m?.role === "assistant");
+    const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
+    const failed = !!forcedFailure || message?.stopReason === "error";
+    const cancelled = !forcedFailure && message?.stopReason === "aborted";
+    await post("/event", { type: "agent_end", text: text ?? "", failed, cancelled, ...(failed ? { error: forcedFailure || message?.errorMessage || message?.stopReason } : {}) });
+  });
+  pi.on("message_update", async () => {
+    const now = Date.now();
+    if (now - lastActivity < 1000) return;
+    lastActivity = now;
+    try { await post("/event", { type: "activity" }); } catch { /* shutdown owns bridge cleanup */ }
+  });
+  pi.on("agent_start", async () => { toolSteps = 0; forcedFailure = ""; await post("/event", { type: "agent_start" }); });
+  pi.on("model_select", async (_event: any, ctx: any) => { if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") ctx.shutdown?.(); });
+  pi.on("before_agent_start", async (event: any, ctx: any) => {
+    if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") { ctx.abort?.(); return { systemPrompt: event.systemPrompt }; }
+    return undefined;
+  });
+  pi.on("before_provider_request", async (_event: any, ctx: any) => { if (ctx.model?.provider && ctx.model.provider !== "agent-hub-local") ctx.abort?.(); return undefined; });
+  pi.on("agent_settled", async (_event: any, ctx: any) => {
+    const entries = ctx.sessionManager?.getEntries?.() ?? [];
+    const message = entries.slice().reverse().find((entry: any) => entry.type === "message" && entry.message?.role === "assistant")?.message;
+    const text = message?.content?.filter((c: any) => c?.type === "text").map((c: any) => c.text).join("")?.trim();
+    await post("/event", { type: "agent_settled", ...(text ? { text } : {}) });
+  });
+  pi.on("user_bash", async (event: any) => {
+    const result = await post("/tool", { name: "bash", args: { command: event.command, cwd: event.cwd }, toolCallId: `pi-shell-${Date.now()}` });
+    return { result: { output: String(result.text ?? result), exitCode: 0, cancelled: false, truncated: false } };
+  });
+  // Managed sessions may only be handed over by PiPeer after it has fenced the
+  // owner and verified the replacement identity. User /fork and /resume would
+  // otherwise silently detach the hub from its recorded session.
+  pi.on("session_before_switch", async () => ({ cancel: true }));
+  pi.on("session_before_fork", async () => ({ cancel: true }));
+  pi.on("session_shutdown", async () => { await post("/event", { type: "session_shutdown" }); });
+  for (const raw of (() => { try { return JSON.parse(process.env.AGENTHUB_PI_TOOLS ?? "[]") as any[]; } catch { return []; } })()) {
+    if (!raw || typeof raw.name !== "string" || !raw.parameters) continue;
+    pi.registerTool({ name: raw.name, label: raw.name, description: raw.description ?? raw.name, parameters: raw.parameters, async execute(toolCallId: string, params: unknown) {
+      if (toolSteps++ >= maxSteps) { const reason = `Pi tool step limit ${maxSteps} reached`; forcedFailure = reason; await post("/event", { type: "agent_end", failed: true, error: reason }); runtimeCtx?.abort?.(); return { content: [{ type: "text", text: `error: ${reason}` }], details: {}, isError: true }; }
+      const result = await post("/tool", { name: raw.name, args: params, toolCallId });
+      return { content: [{ type: "text", text: String(result.text ?? result) }], details: {} };
+    } });
+  }
+}

package/src/pi/tool-receipts.ts

@@ -0,0 +1,52 @@
+import { chmodSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { createHash } from "node:crypto";
+
+/** Private, session-scoped dedupe. An interrupted effect is never automatically repeated. */
+export class PiToolReceipts {
+  private readonly db: Database;
+  private closing = false;
+  private closed = false;
+  private readonly pending = new Map<string, Promise<string>>();
+  constructor(file: string) {
+    this.db = new Database(file, { create: true });
+    chmodSync(file, 0o600);
+    this.db.run("PRAGMA busy_timeout = 5000");
+    this.db.run(`CREATE TABLE IF NOT EXISTS pi_tool_receipts (
+      session TEXT NOT NULL, call_id TEXT NOT NULL, fingerprint TEXT NOT NULL,
+      state TEXT NOT NULL, result TEXT, PRIMARY KEY(session, call_id))`);
+  }
+
+  async execute(session: string, callId: string, name: string, args: unknown, run: () => Promise<string>): Promise<string> {
+    if (this.closing) return "error: Pi tool ledger is shutting down; no new operation was executed";
+    if (!session || !callId || session.length > 512 || callId.length > 512) return "error: invalid Pi session/tool call identity";
+    const fingerprint = createHash("sha256").update(JSON.stringify({ name, args })).digest("hex");
+    const key = JSON.stringify([session, callId]);
+    const row = this.db.query("SELECT fingerprint,state,result FROM pi_tool_receipts WHERE session=? AND call_id=?").get(session, callId) as { fingerprint: string; state: string; result: string | null } | null;
+    if (row) {
+      if (row.fingerprint !== fingerprint) return "error: Pi tool call ID was reused with different arguments";
+      if (row.state === "done") return row.result ?? "";
+      const active = this.pending.get(key);
+      return active ?? "error: previous tool outcome is uncertain; stop and reconcile it, do not repeat the effect";
+    }
+    const claim = this.db.query("INSERT OR IGNORE INTO pi_tool_receipts(session,call_id,fingerprint,state) VALUES(?,?,?,'pending')").run(session, callId, fingerprint);
+    if (!claim.changes) return this.execute(session, callId, name, args, run);
+    const work = Promise.resolve().then(run).then((result) => {
+      const text = result.slice(0, 100_000);
+      this.db.query("UPDATE pi_tool_receipts SET state='done',result=? WHERE session=? AND call_id=?").run(text, session, callId);
+      return text;
+    }).catch(() => "error: tool outcome is uncertain; stop and reconcile it, do not repeat the effect")
+      .finally(() => this.pending.delete(key));
+    this.pending.set(key, work);
+    return work;
+  }
+
+  get inFlight(): number { return this.pending.size; }
+  async drain(): Promise<void> { await Promise.allSettled(this.pending.values()); }
+
+  async close(): Promise<void> {
+    this.closing = true;
+    await this.drain();
+    if (!this.closed) { this.closed = true; this.db.close(); }
+  }
+}

package/src/ui/index.html

@@ -138,6 +138,10 @@ function render(snapshot) {
       head.append(el('span', id, 'label'), el('span', peer.state, 'badge' + (peer.state === 'paused' ? ' warn' : '')));
       row.append(head, el('p', peer.queued + ' queued', 'meta'));
       if (peer.paused) row.append(el('p', peer.paused, 'meta'));
+      if (peer.requestedModel) row.append(el('p', 'Requested: ' + peer.requestedModel, 'meta'));
+      for (const backend of peer.backends || []) {
+        if (backend.requestedModel) row.append(el('p', backend.kind.toUpperCase() + ': ' + (backend.actualModel || 'model not reported') + ' (' + backend.state + ')', 'meta'));
+      }
       const paused = peer.state === 'paused' || peer.paused;
       row.append(button(paused ? 'Resume' : 'Pause', {action:paused ? 'resume' : 'pause', peer:id})); target.append(row);
     }

package/templates/config.json

@@ -2,6 +2,7 @@
   "watchdog_ms": 300000,
   "kimi_cmd": ["kimi", "acp"],
   "codex_bin": "codex",
+  "pi": { "enabled": false, "auto_start": false, "cmd": ["pi"], "backend": "auto", "dgx_coding": "coding", "dgx_fast": "fast", "max_steps": 30 },
   "batch_max": 3,
   "batch_ms": 15000,
   "queue_cap": 200,
@@ -10,7 +11,8 @@
     "claude": ["planner", "reviewer"],
     "codex": ["implementer"],
     "kimi": ["implementer", "verifier"],
-    "local": ["implementer", "verifier"]
+    "local": ["implementer", "verifier"],
+    "pi": ["implementer", "verifier"]
   },
   "budget": { "gate": 0.9, "stale_min": 30, "poll_min": 10, "checkpoint_timeout_s": 90, "kimi_tokens_5h": 0 },
   "inference": { "enabled": true, "digest_min_items": 5, "digest_min_chars": 8000, "triage": true },

package/templates/routing.toml

@@ -52,33 +52,44 @@ pii = "local_only"            # hard: a PII task is owned by `local` or nobody,
 long_context = "skip_local"
 budget_paused = "skip_peer"
 
+[pi]
+dgx_max_context_tokens = 262144
+mlx_max_context_tokens = 16000
+
 [classes.plan]
 peers = ["claude", "codex"]
 local_allowed = false
 
 [classes.implement]
-peers = ["codex", "kimi", "local"]
+peers = ["pi", "local", "codex", "kimi"]
 route = "sy/coding"
-escalate_to = ["kimi", "claude"]
+pi_backend = "dgx"
+escalate_to = ["codex", "kimi", "claude"]
 
 [classes.bulk_edit]
-peers = ["local", "kimi"]
+peers = ["pi", "local", "kimi"]
 route = "sy/fast"
-escalate_to = ["kimi", "codex"]
+pi_backend = "dgx"
+escalate_to = ["codex", "kimi"]
 
 [classes.test]
-peers = ["kimi", "local", "codex"]
+peers = ["pi", "local", "kimi", "codex"]
 route = "sy/fast"
-escalate_to = ["codex"]
+pi_backend = "dgx"
+escalate_to = ["codex", "kimi"]
 
 [classes.review]
 peers = ["claude", "codex"]
 local_allowed = false         # judgment classes never go to local
 
 [classes.summarize]
-peers = ["local", "kimi"]
+peers = ["pi", "local", "kimi"]
 route = "sy/fast"
+pi_backend = "mlx"
+escalate_to = ["codex", "kimi"]
 
 [classes.triage]
-peers = ["local", "kimi"]
+peers = ["pi", "local", "kimi"]
 route = "sy/fast"
+pi_backend = "mlx"
+escalate_to = ["codex", "kimi"]