pi-fabric 0.1.0

package/dist/providers/pi-tools-provider.js

@@ -0,0 +1,200 @@
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, } from "@earendil-works/pi-coding-agent";
+import { CapturedToolCatalog } from "../capture/catalog.js";
+import { PI_CORE_TOOL_NAMES } from "../core/pi-tools.js";
+import { CapturedToolsProvider } from "./captured-tools-provider.js";
+const readTools = new Set(["read", "grep", "find", "ls"]);
+const writeTools = new Set(["edit", "write"]);
+const riskForTool = (name) => {
+    if (readTools.has(name))
+        return "read";
+    if (writeTools.has(name))
+        return "write";
+    return "execute";
+};
+const textContent = (content) => content
+    .filter((part) => part.type === "text")
+    .map((part) => part.text)
+    .join("\n");
+const normalizeResult = (name, result) => {
+    const text = textContent(result.content);
+    if (result.isError)
+        throw new Error(text || `${name} failed`);
+    if (name === "read" || name === "grep" || name === "find" || name === "ls") {
+        return text;
+    }
+    return {
+        ok: true,
+        output: text,
+        details: result.details ?? null,
+    };
+};
+export class PiToolsProvider {
+    name = "pi";
+    description = "Pi's built-in coding tools";
+    #tools;
+    #catalog;
+    #capturedTools;
+    constructor(cwd, catalog, capturedTools) {
+        this.#tools = {
+            read: createReadToolDefinition(cwd),
+            bash: createBashToolDefinition(cwd),
+            edit: createEditToolDefinition(cwd),
+            write: createWriteToolDefinition(cwd),
+            grep: createGrepToolDefinition(cwd),
+            find: createFindToolDefinition(cwd),
+            ls: createLsToolDefinition(cwd),
+        };
+        this.#catalog = catalog;
+        this.#capturedTools = capturedTools;
+    }
+    async list(request, _context) {
+        const query = request.query?.toLowerCase();
+        const descriptors = await Promise.all(PI_CORE_TOOL_NAMES.map((name) => this.describe(name, _context)));
+        return descriptors
+            .filter((descriptor) => descriptor !== undefined)
+            .filter((descriptor) => query ? `${descriptor.name} ${descriptor.description}`.toLowerCase().includes(query) : true);
+    }
+    async describe(actionName, _context) {
+        if (!(actionName in this.#tools))
+            return undefined;
+        const name = actionName;
+        const override = await this.#capturedTools?.describe(name, _context);
+        if (override)
+            return { ...override, namespace: "extension-override" };
+        const tool = this.#tools[name];
+        return this.#descriptor(name, tool);
+    }
+    prepareArguments(actionName, args) {
+        if (this.#catalog?.get(actionName)) {
+            return this.#capturedTools.prepareArguments(actionName, args);
+        }
+        if (!(actionName in this.#tools))
+            return args;
+        const prepare = this.#tools[actionName].prepareArguments;
+        if (!prepare)
+            return args;
+        const prepared = prepare(args);
+        if (typeof prepared !== "object" || prepared === null || Array.isArray(prepared)) {
+            throw new Error(`Pi tool ${actionName} prepared non-object arguments`);
+        }
+        return prepared;
+    }
+    async invoke(actionName, args, context) {
+        if (!(actionName in this.#tools))
+            throw new Error(`Unknown Pi tool: ${actionName}`);
+        const name = actionName;
+        // A captured extension override (e.g. an extension that registered a "read"
+        // tool) already replays the full event lifecycle itself via
+        // CapturedToolsProvider, so delegate to it unchanged.
+        if (this.#catalog?.get(name)) {
+            const result = await this.#capturedTools.invoke(name, args, context);
+            return normalizeResult(name, result);
+        }
+        const tool = this.#tools[name];
+        const runner = this.#catalog?.runner;
+        // Without a runner (e.g. before the first tool refresh populated the
+        // catalog) fall back to a direct execute — no extension hooks fire, but
+        // the call still works. Once tools are refreshed the runner is available.
+        if (!runner) {
+            const result = await tool.execute(context.nestedToolCallId, args, context.signal, undefined, context.extensionContext);
+            return normalizeResult(name, result);
+        }
+        return this.#invokeWithEvents(name, tool, args, context, runner);
+    }
+    // Replay the agent-core tool-execution lifecycle for a nested pi.* call, so
+    // extensions that hook tool_call / tool_result / tool_execution_* see pi
+    // core tools invoked through fabric_exec in full-code mode — exactly as
+    // they would for a top-level call in the normal (non-codemode) flow, and
+    // exactly as CapturedToolsProvider already does for captured extension
+    // tools. tool_result patches (content/details/isError) are applied, so
+    // extensions like pi-vision-handoff can replace image blocks with text
+    // descriptions before the result returns to the sandbox.
+    async #invokeWithEvents(name, tool, args, context, runner) {
+        const toolCallId = context.nestedToolCallId;
+        await runner.emit({
+            type: "tool_execution_start",
+            toolCallId,
+            toolName: name,
+            args,
+        });
+        let result;
+        let isError = false;
+        let thrown;
+        let updateTail = Promise.resolve();
+        try {
+            const preflight = await runner.emitToolCall({
+                type: "tool_call",
+                toolName: name,
+                toolCallId,
+                input: args,
+            });
+            if (preflight?.block) {
+                throw new Error(preflight.reason || `Pi tool ${name} was blocked`);
+            }
+            result = (await tool.execute(toolCallId, args, context.signal, (partialResult) => {
+                const progress = textContent(partialResult.content).trim();
+                if (progress)
+                    context.update(`${name}: ${progress.slice(0, 500)}`);
+                updateTail = updateTail
+                    .then(() => runner.emit({
+                    type: "tool_execution_update",
+                    toolCallId,
+                    toolName: name,
+                    args,
+                    partialResult,
+                }))
+                    .catch(() => undefined);
+            }, context.extensionContext));
+        }
+        catch (error) {
+            thrown = error;
+            isError = true;
+            result = {
+                content: [
+                    { type: "text", text: error instanceof Error ? error.message : String(error) },
+                ],
+                details: undefined,
+            };
+        }
+        await updateTail;
+        const patch = await runner.emitToolResult({
+            type: "tool_result",
+            toolName: name,
+            toolCallId,
+            input: args,
+            content: result.content,
+            details: result.details,
+            isError,
+        });
+        if (patch) {
+            result = {
+                ...result,
+                content: patch.content ?? result.content,
+                ...(patch.details !== undefined ? { details: patch.details } : {}),
+            };
+            isError = patch.isError ?? isError;
+        }
+        await runner.emit({
+            type: "tool_execution_end",
+            toolCallId,
+            toolName: name,
+            result,
+            isError,
+        });
+        if (isError) {
+            const text = textContent(result.content).trim();
+            throw new Error(text || (thrown instanceof Error ? thrown.message : `Pi tool ${name} failed`));
+        }
+        return normalizeResult(name, result);
+    }
+    #descriptor(name, tool) {
+        return {
+            name,
+            description: tool.description,
+            inputSchema: tool.parameters,
+            risk: riskForTool(name),
+            namespace: "builtin",
+        };
+    }
+}
+//# sourceMappingURL=pi-tools-provider.js.map

package/dist/providers/pi-tools-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi-tools-provider.js","sourceRoot":"","sources":["../../src/providers/pi-tools-provider.ts"],"names":[],"mappings":"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"}

package/dist/runtime/guest-types.d.ts

@@ -0,0 +1,3 @@
+export declare const GUEST_TYPE_DECLARATIONS = "\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };\ntype FabricTransport = \"auto\" | \"process\" | \"tmux\" | \"screen\" | \"localterm\";\ntype FabricThinking = \"off\" | \"minimal\" | \"low\" | \"medium\" | \"high\" | \"xhigh\" | \"max\";\ninterface FabricAction {\n  ref: string;\n  provider: string;\n  name: string;\n  description: string;\n  inputSchema: Record<string, unknown>;\n  outputSchema?: Record<string, unknown>;\n  risk: \"read\" | \"write\" | \"execute\" | \"network\" | \"agent\";\n  namespace?: string;\n}\ninterface FabricAgentRequest {\n  task: string;\n  name?: string;\n  transport?: FabricTransport;\n  model?: string;\n  thinking?: FabricThinking;\n  tools?: string[];\n  timeoutMs?: number;\n  extensions?: boolean;\n  recursive?: boolean;\n  worktree?: boolean;\n  schema?: Record<string, unknown>;\n}\ninterface FabricAgentHandle {\n  id: string;\n  name: string;\n  status: string;\n  transport: FabricTransport;\n  cwd: string;\n  model?: string;\n  thinking?: FabricThinking;\n  actorId?: string;\n  actorName?: string;\n  sessionId?: string;\n  attachCommand?: string;\n  branch?: string;\n  worktree?: string;\n  text?: string;\n  value?: unknown;\n  error?: string;\n  logFile?: string;\n}\ninterface FabricAgentResult extends FabricAgentHandle {\n  task: string;\n  startedAt: number;\n  finishedAt?: number;\n  turns: number;\n  toolCalls: number;\n  text: string;\n  value?: unknown;\n  error?: string;\n  usage: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number };\n}\ninterface FabricToolsApi {\n  providers(): Promise<Array<{ name: string; description: string }>>;\n  list(args?: { provider?: string; namespace?: string; query?: string; limit?: number }): Promise<FabricAction[]>;\n  search(args: { query: string; limit?: number }): Promise<FabricAction[]>;\n  describe(args: { ref: string }): Promise<FabricAction>;\n  call(args: { ref: string; args?: Record<string, unknown> }): Promise<unknown>;\n  progress(args: { message: string }): Promise<void>;\n}\ninterface FabricCapturedToolResult {\n  content: Array<{ type: string; text?: string; [key: string]: unknown }>;\n  text: string;\n  details?: unknown;\n  isError: boolean;\n  terminate?: boolean;\n  source: { path: string; source: string; scope: string; origin: string; baseDir?: string };\n}\ninterface FabricCapturedTool {\n  (args?: Record<string, unknown>): Promise<FabricCapturedToolResult>;\n}\ntype FabricExtensionsApi = Record<string, FabricCapturedTool>;\n// String-primary tools (read/bash/grep/find/ls) accept a bare string; the\n// runtime proxy coerces it to { <primaryField>: string }. Lets the model write\n// the natural form (pi.bash(\"ls\")) instead of pi.bash({ command: \"ls\" }).\n// Return shapes differ by tool: read/grep/find/ls return their text as a bare\n// string (e.g. const src: string = await pi.read({ path })); bash/edit/write\n// return { ok, output, details } (e.g. const { output } = await pi.bash(...)).\n// Common alias keys (cmd\u2192command, query\u2192pattern, file\u2192path, dir\u2192path) and a\n// flat edit shape ({ path, oldText, newText }) are also accepted; the runtime\n// proxy normalizes them to the canonical form before the host validates args.\ninterface PiToolsApi {\n  read(args: string | { path: string; offset?: number; limit?: number } | { file: string; offset?: number; limit?: number }): Promise<string>;\n  bash(args: string | { command: string; timeout?: number } | { cmd: string; timeout?: number }): Promise<{ ok: true; output: string; details: unknown }>;\n  edit(args: { path: string; edits: Array<{ oldText: string; newText: string }> } | { file: string; edits: Array<{ oldText: string; newText: string }> } | { path: string; oldText: string; newText: string } | { file: string; oldText: string; newText: string }): Promise<{ ok: true; output: string; details: unknown }>;\n  write(args: { path: string; content: string } | { file: string; content: string }): Promise<{ ok: true; output: string; details: unknown }>;\n  grep(args: string | { pattern: string; path?: string; glob?: string; ignoreCase?: boolean; literal?: boolean; context?: number; limit?: number } | { query: string; path?: string; glob?: string; ignoreCase?: boolean; literal?: boolean; context?: number; limit?: number }): Promise<string>;\n  find(args: string | { pattern: string; path?: string; limit?: number } | { query: string; path?: string; limit?: number }): Promise<string>;\n  ls(args?: string | { path?: string; limit?: number } | { dir?: string; limit?: number } | { file?: string; limit?: number }): Promise<string>;\n}\ntype FabricActorHostEvent = \"input\" | \"turn_end\" | \"agent_settled\" | \"tool_error\" | \"session_compact\";\ntype FabricActorDelivery = \"mailbox\" | \"steer\" | \"followUp\" | \"nextTurn\";\ninterface FabricActorRequest {\n  name: string;\n  instructions: string;\n  events?: FabricActorHostEvent[];\n  topics?: string[];\n  delivery?: FabricActorDelivery;\n  responseMode?: \"text\" | \"directive\";\n  triggerTurn?: boolean;\n  coalesce?: boolean;\n  model?: string;\n  thinking?: FabricThinking;\n  tools?: string[];\n  transport?: FabricTransport;\n  timeoutMs?: number;\n}\ninterface FabricActorInfo {\n  id: string;\n  name: string;\n  status: \"idle\" | \"queued\" | \"running\" | \"stopped\";\n  events: FabricActorHostEvent[];\n  topics: string[];\n  delivery: FabricActorDelivery;\n  responseMode: \"text\" | \"directive\";\n  triggerTurn: boolean;\n  coalesce: boolean;\n  model?: string;\n  thinking?: FabricThinking;\n  tools?: string[];\n  queued: number;\n  messages: number;\n  createdAt: number;\n  updatedAt: number;\n  lastRunId?: string;\n  lastError?: string;\n}\ninterface FabricActorMessage {\n  id: string;\n  actorId: string;\n  actorName: string;\n  direction: \"in\" | \"out\";\n  source: string;\n  createdAt: number;\n  text?: string;\n  data?: unknown;\n  action?: \"silent\" | \"message\" | \"stop\";\n  runId?: string;\n  error?: string;\n}\ninterface FabricAgentsApi {\n  run(args: FabricAgentRequest): Promise<FabricAgentResult>;\n  spawn(args: FabricAgentRequest): Promise<FabricAgentHandle>;\n  wait(args: { id: string }): Promise<FabricAgentResult>;\n  status(args: { id: string }): Promise<FabricAgentResult | FabricAgentHandle>;\n  list(): Promise<Array<FabricAgentResult | FabricAgentHandle>>;\n  stop(args: { id: string }): Promise<FabricAgentResult>;\n  cleanup(args: { id: string; deleteBranch?: boolean }): Promise<{ cleaned: boolean }>;\n  create(args: FabricActorRequest): Promise<FabricActorInfo>;\n  ask(args: { id: string; message: string; data?: unknown }): Promise<FabricActorMessage>;\n  tell(args: { id: string; message: string; data?: unknown }): Promise<{ queued: true; messageId: string }>;\n  actorStatus(args: { id: string }): Promise<FabricActorInfo>;\n  actors(): Promise<FabricActorInfo[]>;\n  messages(args: { id: string; limit?: number }): Promise<FabricActorMessage[]>;\n  remove(args: { id: string }): Promise<{ removed: boolean }>;\n}\ninterface FabricMcpResult {\n  text: string;\n  content: unknown[];\n  structuredContent: unknown;\n}\ninterface FabricMcpTool {\n  (args?: Record<string, unknown>): Promise<FabricMcpResult | unknown>;\n}\ninterface FabricMcpServer {\n  [tool: string]: FabricMcpTool;\n}\ntype FabricMcpApi = Record<string, FabricMcpServer> & {\n  servers(): Promise<Array<{ name: string; description: string | null; transport: \"http\" | \"stdio\" }>>;\n  reload(): Promise<{ servers: string[] }>;\n  register(args: {\n    name: string;\n    description?: string;\n    command?: string;\n    args?: string[];\n    cwd?: string;\n    baseUrl?: string;\n    headers?: Record<string, string>;\n    env?: Record<string, string>;\n    overwrite?: boolean;\n  }): Promise<{ registered: string }>;\n  call(args: { server: string; tool: string; args?: Record<string, unknown> }): Promise<unknown>;\n};\ninterface FabricCouncilRunOptions {\n  task: string;\n  roles: string[];\n  transport?: FabricTransport;\n  model?: string;\n  thinking?: FabricThinking;\n  tools?: string[];\n  timeoutMs?: number;\n  worktree?: boolean;\n}\ninterface FabricCouncilApi {\n  run(args: FabricCouncilRunOptions & { synthesize?: true }): Promise<FabricAgentResult>;\n  run(args: FabricCouncilRunOptions & { synthesize: false }): Promise<FabricAgentResult[]>;\n}\ninterface FabricMeshIdentity {\n  id: string;\n  name: string;\n  kind: \"main\" | \"actor\" | \"agent\";\n  sessionId?: string;\n}\ninterface FabricMeshEvent {\n  id: string;\n  sequence: number;\n  topic: string;\n  kind: string;\n  from: FabricMeshIdentity;\n  to?: string;\n  text?: string;\n  data?: unknown;\n  createdAt: number;\n}\ninterface FabricMeshStateEntry<T = unknown> {\n  key: string;\n  value: T;\n  version: number;\n  updatedAt: number;\n  updatedBy: FabricMeshIdentity;\n}\ninterface FabricMeshApi {\n  self(): Promise<FabricMeshIdentity>;\n  publish(args: { topic: string; kind?: string; to?: string; text?: string; data?: unknown }): Promise<FabricMeshEvent>;\n  read(args?: { after?: number; topic?: string; to?: string; limit?: number }): Promise<FabricMeshEvent[]>;\n  members(args?: { limit?: number }): Promise<Array<FabricMeshStateEntry<FabricActorInfo>>>;\n  get<T = unknown>(args: { key: string }): Promise<FabricMeshStateEntry<T> | null>;\n  list<T = unknown>(args?: { prefix?: string; limit?: number }): Promise<Array<FabricMeshStateEntry<T>>>;\n  put<T = unknown>(args: { key: string; value: T; ifVersion?: number }): Promise<FabricMeshStateEntry<T>>;\n  delete(args: { key: string; ifVersion?: number }): Promise<{ deleted: boolean; version?: number }>;\n}\ninterface FabricWorkflowAgentOptions extends Omit<FabricAgentRequest, \"task\"> {\n  label?: string;\n}\ntype FabricActivityStatus = \"pending\" | \"running\" | \"completed\" | \"failed\" | \"blocked\" | \"stopped\";\ntype FabricActivityKind = \"agent\" | \"actor\" | \"tool\" | \"extension\" | \"mcp\" | \"mesh\" | \"task\" | \"custom\";\ninterface FabricWorkflowDisplay {\n  name?: string;\n  description?: string;\n}\ninterface FabricWorkflowPhaseOptions {\n  id?: string;\n  description?: string;\n  total?: number;\n}\ninterface FabricWorkflowItem {\n  id: string;\n  label: string;\n  status?: FabricActivityStatus;\n  phase?: string;\n  detail?: string;\n  kind?: FabricActivityKind;\n  current?: string;\n  total?: number;\n  completed?: number;\n  data?: unknown;\n}\ninterface FabricWorkflowApi {\n  agent<T = string>(prompt: string, options?: FabricWorkflowAgentOptions): Promise<T>;\n  parallel<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R> | R, concurrency?: number | { concurrency?: number }): Promise<R[]>;\n  parallel<T>(thunks: Array<() => Promise<T> | T>, concurrency?: number | { concurrency?: number }): Promise<T[]>;\n  pipeline<T>(items: T[], ...stages: Array<(value: unknown, original: T, index: number) => Promise<unknown> | unknown>): Promise<unknown[]>;\n  configure(display: FabricWorkflowDisplay): Promise<FabricWorkflowDisplay>;\n  phase(name: string, options?: FabricWorkflowPhaseOptions): Promise<{ name: string; index: number; id?: string }>;\n  item(item: FabricWorkflowItem): Promise<FabricWorkflowItem>;\n  event(event: { message: string; level?: \"info\" | \"success\" | \"warning\" | \"error\"; data?: unknown }): Promise<void>;\n  log(...values: unknown[]): void;\n  budget: { total: number; spent(): number; remaining(): number };\n}\ndeclare const tools: FabricToolsApi;\ndeclare const pi: PiToolsApi;\ndeclare const extensions: FabricExtensionsApi;\ndeclare const agents: FabricAgentsApi;\ndeclare const mesh: FabricMeshApi;\ndeclare const mcp: FabricMcpApi;\ndeclare const council: FabricCouncilApi;\ndeclare const workflow: FabricWorkflowApi;\ndeclare function agent<T = string>(prompt: string, options?: FabricWorkflowAgentOptions): Promise<T>;\ndeclare function parallel<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R> | R, concurrency?: number | { concurrency?: number }): Promise<R[]>;\ndeclare function parallel<T>(thunks: Array<() => Promise<T> | T>, concurrency?: number | { concurrency?: number }): Promise<T[]>;\ndeclare function pipeline<T>(items: T[], ...stages: Array<(value: unknown, original: T, index: number) => Promise<unknown> | unknown>): Promise<unknown[]>;\ndeclare function phase(name: string, options?: FabricWorkflowPhaseOptions): Promise<{ name: string; index: number; id?: string }>;\ndeclare function log(...values: unknown[]): void;\ndeclare const budget: FabricWorkflowApi[\"budget\"];\ndeclare const rlm: { query(args: FabricAgentRequest): Promise<FabricAgentResult> };\ninterface FabricConsole {\n  log(...args: unknown[]): void;\n  info(...args: unknown[]): void;\n  warn(...args: unknown[]): void;\n  error(...args: unknown[]): void;\n}\ndeclare const console: FabricConsole;\ndeclare const \u03C0: Readonly<Record<string, string>>;\ndeclare function print(...args: unknown[]): void;\ndeclare function setTimeout(handler: (...args: any[]) => void, timeout?: number): number;\ndeclare function clearTimeout(handle: number): void;\ndeclare function setInterval(handler: (...args: any[]) => void, timeout?: number): number;\ndeclare function clearInterval(handle: number): void;\n";
+export declare const guestTypeDeclarations: (fullCodeMode: boolean) => string;
+//# sourceMappingURL=guest-types.d.ts.map

package/dist/runtime/guest-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guest-types.d.ts","sourceRoot":"","sources":["../../src/runtime/guest-types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,2/ZAgTnC,CAAC;AAOF,eAAO,MAAM,qBAAqB,GAAI,cAAc,OAAO,KAAG,MAMvD,CAAC"}

package/dist/runtime/guest-types.js

@@ -0,0 +1,313 @@
+export const GUEST_TYPE_DECLARATIONS = `
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+type FabricTransport = "auto" | "process" | "tmux" | "screen" | "localterm";
+type FabricThinking = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+interface FabricAction {
+  ref: string;
+  provider: string;
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+  risk: "read" | "write" | "execute" | "network" | "agent";
+  namespace?: string;
+}
+interface FabricAgentRequest {
+  task: string;
+  name?: string;
+  transport?: FabricTransport;
+  model?: string;
+  thinking?: FabricThinking;
+  tools?: string[];
+  timeoutMs?: number;
+  extensions?: boolean;
+  recursive?: boolean;
+  worktree?: boolean;
+  schema?: Record<string, unknown>;
+}
+interface FabricAgentHandle {
+  id: string;
+  name: string;
+  status: string;
+  transport: FabricTransport;
+  cwd: string;
+  model?: string;
+  thinking?: FabricThinking;
+  actorId?: string;
+  actorName?: string;
+  sessionId?: string;
+  attachCommand?: string;
+  branch?: string;
+  worktree?: string;
+  text?: string;
+  value?: unknown;
+  error?: string;
+  logFile?: string;
+}
+interface FabricAgentResult extends FabricAgentHandle {
+  task: string;
+  startedAt: number;
+  finishedAt?: number;
+  turns: number;
+  toolCalls: number;
+  text: string;
+  value?: unknown;
+  error?: string;
+  usage: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: number };
+}
+interface FabricToolsApi {
+  providers(): Promise<Array<{ name: string; description: string }>>;
+  list(args?: { provider?: string; namespace?: string; query?: string; limit?: number }): Promise<FabricAction[]>;
+  search(args: { query: string; limit?: number }): Promise<FabricAction[]>;
+  describe(args: { ref: string }): Promise<FabricAction>;
+  call(args: { ref: string; args?: Record<string, unknown> }): Promise<unknown>;
+  progress(args: { message: string }): Promise<void>;
+}
+interface FabricCapturedToolResult {
+  content: Array<{ type: string; text?: string; [key: string]: unknown }>;
+  text: string;
+  details?: unknown;
+  isError: boolean;
+  terminate?: boolean;
+  source: { path: string; source: string; scope: string; origin: string; baseDir?: string };
+}
+interface FabricCapturedTool {
+  (args?: Record<string, unknown>): Promise<FabricCapturedToolResult>;
+}
+type FabricExtensionsApi = Record<string, FabricCapturedTool>;
+// String-primary tools (read/bash/grep/find/ls) accept a bare string; the
+// runtime proxy coerces it to { <primaryField>: string }. Lets the model write
+// the natural form (pi.bash("ls")) instead of pi.bash({ command: "ls" }).
+// Return shapes differ by tool: read/grep/find/ls return their text as a bare
+// string (e.g. const src: string = await pi.read({ path })); bash/edit/write
+// return { ok, output, details } (e.g. const { output } = await pi.bash(...)).
+// Common alias keys (cmd→command, query→pattern, file→path, dir→path) and a
+// flat edit shape ({ path, oldText, newText }) are also accepted; the runtime
+// proxy normalizes them to the canonical form before the host validates args.
+interface PiToolsApi {
+  read(args: string | { path: string; offset?: number; limit?: number } | { file: string; offset?: number; limit?: number }): Promise<string>;
+  bash(args: string | { command: string; timeout?: number } | { cmd: string; timeout?: number }): Promise<{ ok: true; output: string; details: unknown }>;
+  edit(args: { path: string; edits: Array<{ oldText: string; newText: string }> } | { file: string; edits: Array<{ oldText: string; newText: string }> } | { path: string; oldText: string; newText: string } | { file: string; oldText: string; newText: string }): Promise<{ ok: true; output: string; details: unknown }>;
+  write(args: { path: string; content: string } | { file: string; content: string }): Promise<{ ok: true; output: string; details: unknown }>;
+  grep(args: string | { pattern: string; path?: string; glob?: string; ignoreCase?: boolean; literal?: boolean; context?: number; limit?: number } | { query: string; path?: string; glob?: string; ignoreCase?: boolean; literal?: boolean; context?: number; limit?: number }): Promise<string>;
+  find(args: string | { pattern: string; path?: string; limit?: number } | { query: string; path?: string; limit?: number }): Promise<string>;
+  ls(args?: string | { path?: string; limit?: number } | { dir?: string; limit?: number } | { file?: string; limit?: number }): Promise<string>;
+}
+type FabricActorHostEvent = "input" | "turn_end" | "agent_settled" | "tool_error" | "session_compact";
+type FabricActorDelivery = "mailbox" | "steer" | "followUp" | "nextTurn";
+interface FabricActorRequest {
+  name: string;
+  instructions: string;
+  events?: FabricActorHostEvent[];
+  topics?: string[];
+  delivery?: FabricActorDelivery;
+  responseMode?: "text" | "directive";
+  triggerTurn?: boolean;
+  coalesce?: boolean;
+  model?: string;
+  thinking?: FabricThinking;
+  tools?: string[];
+  transport?: FabricTransport;
+  timeoutMs?: number;
+}
+interface FabricActorInfo {
+  id: string;
+  name: string;
+  status: "idle" | "queued" | "running" | "stopped";
+  events: FabricActorHostEvent[];
+  topics: string[];
+  delivery: FabricActorDelivery;
+  responseMode: "text" | "directive";
+  triggerTurn: boolean;
+  coalesce: boolean;
+  model?: string;
+  thinking?: FabricThinking;
+  tools?: string[];
+  queued: number;
+  messages: number;
+  createdAt: number;
+  updatedAt: number;
+  lastRunId?: string;
+  lastError?: string;
+}
+interface FabricActorMessage {
+  id: string;
+  actorId: string;
+  actorName: string;
+  direction: "in" | "out";
+  source: string;
+  createdAt: number;
+  text?: string;
+  data?: unknown;
+  action?: "silent" | "message" | "stop";
+  runId?: string;
+  error?: string;
+}
+interface FabricAgentsApi {
+  run(args: FabricAgentRequest): Promise<FabricAgentResult>;
+  spawn(args: FabricAgentRequest): Promise<FabricAgentHandle>;
+  wait(args: { id: string }): Promise<FabricAgentResult>;
+  status(args: { id: string }): Promise<FabricAgentResult | FabricAgentHandle>;
+  list(): Promise<Array<FabricAgentResult | FabricAgentHandle>>;
+  stop(args: { id: string }): Promise<FabricAgentResult>;
+  cleanup(args: { id: string; deleteBranch?: boolean }): Promise<{ cleaned: boolean }>;
+  create(args: FabricActorRequest): Promise<FabricActorInfo>;
+  ask(args: { id: string; message: string; data?: unknown }): Promise<FabricActorMessage>;
+  tell(args: { id: string; message: string; data?: unknown }): Promise<{ queued: true; messageId: string }>;
+  actorStatus(args: { id: string }): Promise<FabricActorInfo>;
+  actors(): Promise<FabricActorInfo[]>;
+  messages(args: { id: string; limit?: number }): Promise<FabricActorMessage[]>;
+  remove(args: { id: string }): Promise<{ removed: boolean }>;
+}
+interface FabricMcpResult {
+  text: string;
+  content: unknown[];
+  structuredContent: unknown;
+}
+interface FabricMcpTool {
+  (args?: Record<string, unknown>): Promise<FabricMcpResult | unknown>;
+}
+interface FabricMcpServer {
+  [tool: string]: FabricMcpTool;
+}
+type FabricMcpApi = Record<string, FabricMcpServer> & {
+  servers(): Promise<Array<{ name: string; description: string | null; transport: "http" | "stdio" }>>;
+  reload(): Promise<{ servers: string[] }>;
+  register(args: {
+    name: string;
+    description?: string;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+    overwrite?: boolean;
+  }): Promise<{ registered: string }>;
+  call(args: { server: string; tool: string; args?: Record<string, unknown> }): Promise<unknown>;
+};
+interface FabricCouncilRunOptions {
+  task: string;
+  roles: string[];
+  transport?: FabricTransport;
+  model?: string;
+  thinking?: FabricThinking;
+  tools?: string[];
+  timeoutMs?: number;
+  worktree?: boolean;
+}
+interface FabricCouncilApi {
+  run(args: FabricCouncilRunOptions & { synthesize?: true }): Promise<FabricAgentResult>;
+  run(args: FabricCouncilRunOptions & { synthesize: false }): Promise<FabricAgentResult[]>;
+}
+interface FabricMeshIdentity {
+  id: string;
+  name: string;
+  kind: "main" | "actor" | "agent";
+  sessionId?: string;
+}
+interface FabricMeshEvent {
+  id: string;
+  sequence: number;
+  topic: string;
+  kind: string;
+  from: FabricMeshIdentity;
+  to?: string;
+  text?: string;
+  data?: unknown;
+  createdAt: number;
+}
+interface FabricMeshStateEntry<T = unknown> {
+  key: string;
+  value: T;
+  version: number;
+  updatedAt: number;
+  updatedBy: FabricMeshIdentity;
+}
+interface FabricMeshApi {
+  self(): Promise<FabricMeshIdentity>;
+  publish(args: { topic: string; kind?: string; to?: string; text?: string; data?: unknown }): Promise<FabricMeshEvent>;
+  read(args?: { after?: number; topic?: string; to?: string; limit?: number }): Promise<FabricMeshEvent[]>;
+  members(args?: { limit?: number }): Promise<Array<FabricMeshStateEntry<FabricActorInfo>>>;
+  get<T = unknown>(args: { key: string }): Promise<FabricMeshStateEntry<T> | null>;
+  list<T = unknown>(args?: { prefix?: string; limit?: number }): Promise<Array<FabricMeshStateEntry<T>>>;
+  put<T = unknown>(args: { key: string; value: T; ifVersion?: number }): Promise<FabricMeshStateEntry<T>>;
+  delete(args: { key: string; ifVersion?: number }): Promise<{ deleted: boolean; version?: number }>;
+}
+interface FabricWorkflowAgentOptions extends Omit<FabricAgentRequest, "task"> {
+  label?: string;
+}
+type FabricActivityStatus = "pending" | "running" | "completed" | "failed" | "blocked" | "stopped";
+type FabricActivityKind = "agent" | "actor" | "tool" | "extension" | "mcp" | "mesh" | "task" | "custom";
+interface FabricWorkflowDisplay {
+  name?: string;
+  description?: string;
+}
+interface FabricWorkflowPhaseOptions {
+  id?: string;
+  description?: string;
+  total?: number;
+}
+interface FabricWorkflowItem {
+  id: string;
+  label: string;
+  status?: FabricActivityStatus;
+  phase?: string;
+  detail?: string;
+  kind?: FabricActivityKind;
+  current?: string;
+  total?: number;
+  completed?: number;
+  data?: unknown;
+}
+interface FabricWorkflowApi {
+  agent<T = string>(prompt: string, options?: FabricWorkflowAgentOptions): Promise<T>;
+  parallel<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R> | R, concurrency?: number | { concurrency?: number }): Promise<R[]>;
+  parallel<T>(thunks: Array<() => Promise<T> | T>, concurrency?: number | { concurrency?: number }): Promise<T[]>;
+  pipeline<T>(items: T[], ...stages: Array<(value: unknown, original: T, index: number) => Promise<unknown> | unknown>): Promise<unknown[]>;
+  configure(display: FabricWorkflowDisplay): Promise<FabricWorkflowDisplay>;
+  phase(name: string, options?: FabricWorkflowPhaseOptions): Promise<{ name: string; index: number; id?: string }>;
+  item(item: FabricWorkflowItem): Promise<FabricWorkflowItem>;
+  event(event: { message: string; level?: "info" | "success" | "warning" | "error"; data?: unknown }): Promise<void>;
+  log(...values: unknown[]): void;
+  budget: { total: number; spent(): number; remaining(): number };
+}
+declare const tools: FabricToolsApi;
+declare const pi: PiToolsApi;
+declare const extensions: FabricExtensionsApi;
+declare const agents: FabricAgentsApi;
+declare const mesh: FabricMeshApi;
+declare const mcp: FabricMcpApi;
+declare const council: FabricCouncilApi;
+declare const workflow: FabricWorkflowApi;
+declare function agent<T = string>(prompt: string, options?: FabricWorkflowAgentOptions): Promise<T>;
+declare function parallel<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R> | R, concurrency?: number | { concurrency?: number }): Promise<R[]>;
+declare function parallel<T>(thunks: Array<() => Promise<T> | T>, concurrency?: number | { concurrency?: number }): Promise<T[]>;
+declare function pipeline<T>(items: T[], ...stages: Array<(value: unknown, original: T, index: number) => Promise<unknown> | unknown>): Promise<unknown[]>;
+declare function phase(name: string, options?: FabricWorkflowPhaseOptions): Promise<{ name: string; index: number; id?: string }>;
+declare function log(...values: unknown[]): void;
+declare const budget: FabricWorkflowApi["budget"];
+declare const rlm: { query(args: FabricAgentRequest): Promise<FabricAgentResult> };
+interface FabricConsole {
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}
+declare const console: FabricConsole;
+declare const π: Readonly<Record<string, string>>;
+declare function print(...args: unknown[]): void;
+declare function setTimeout(handler: (...args: any[]) => void, timeout?: number): number;
+declare function clearTimeout(handle: number): void;
+declare function setInterval(handler: (...args: any[]) => void, timeout?: number): number;
+declare function clearInterval(handle: number): void;
+`;
+const FULL_CODE_GLOBAL_DECLARATIONS = [
+    "declare const pi: PiToolsApi;\n",
+    "declare const extensions: FabricExtensionsApi;\n",
+];
+export const guestTypeDeclarations = (fullCodeMode) => fullCodeMode
+    ? GUEST_TYPE_DECLARATIONS
+    : FULL_CODE_GLOBAL_DECLARATIONS.reduce((declarations, declaration) => declarations.replace(declaration, ""), GUEST_TYPE_DECLARATIONS);
+//# sourceMappingURL=guest-types.js.map

package/dist/runtime/guest-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guest-types.js","sourceRoot":"","sources":["../../src/runtime/guest-types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgTtC,CAAC;AAEF,MAAM,6BAA6B,GAAG;IACpC,iCAAiC;IACjC,kDAAkD;CACnD,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,YAAqB,EAAU,EAAE,CACrE,YAAY;IACV,CAAC,CAAC,uBAAuB;IACzB,CAAC,CAAC,6BAA6B,CAAC,MAAM,CAClC,CAAC,YAAY,EAAE,WAAW,EAAE,EAAE,CAAC,YAAY,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,EACpE,uBAAuB,CACxB,CAAC"}

package/dist/runtime/quickjs-runtime.d.ts

@@ -0,0 +1,18 @@
+export interface FabricSandboxResult {
+    value: unknown;
+    logs: string[];
+    error?: string;
+}
+export interface FabricSandboxOptions {
+    timeoutMs: number;
+    memoryLimitBytes: number;
+    maxLogChars?: number;
+    strings?: Record<string, string>;
+    tokenBudget?: number;
+    signal?: AbortSignal;
+}
+export type FabricHostCall = (ref: string, args: Record<string, unknown>, signal: AbortSignal) => Promise<unknown>;
+export declare class QuickJsRuntime {
+    execute(code: string, hostCall: FabricHostCall, options: FabricSandboxOptions): Promise<FabricSandboxResult>;
+}
+//# sourceMappingURL=quickjs-runtime.d.ts.map

package/dist/runtime/quickjs-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quickjs-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/quickjs-runtime.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,WAAW,KAChB,OAAO,CAAC,OAAO,CAAC,CAAC;AAiUtB,qBAAa,cAAc;IACnB,OAAO,CACX,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC;CAgOhC"}