@anhlp/alp-runtime 0.0.0-beta.1

package/dist/antigravity-transport.js

@@ -0,0 +1,609 @@
+// packages/runtime/src/antigravity-transport.ts
+import { spawn, execFile } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { mkdir, open, readFile, rename, writeFile, unlink } from "node:fs/promises";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { openMcpTools } from "./mcp-tools.js";
+var BRIDGE = `// ALP Antigravity bridge v1
+
+const net = require('node:net');
+const readline = require('node:readline');
+const socket = process.env.ALP_BRIDGE_SOCKET ? net.connect(process.env.ALP_BRIDGE_SOCKET) : null;
+const waiting = new Map();
+let sequence = 0;
+let buffer = '';
+socket?.setEncoding('utf8');
+socket?.write(JSON.stringify({ token: process.env.ALP_BRIDGE_TOKEN }) + '\\n');
+socket?.on('data', data => {
+  buffer += data;
+  for (let index; (index = buffer.indexOf('\\n')) >= 0;) {
+    const line = buffer.slice(0, index); buffer = buffer.slice(index + 1);
+    try { const message = JSON.parse(line); const waiter = waiting.get(message.id); if (waiter) { waiting.delete(message.id); waiter(message); } } catch {}
+  }
+});
+socket?.on('close', () => process.exit(0));
+socket?.on('error', () => process.exit(1));
+const ask = message => !socket ? Promise.resolve({ tools: [], result: { content: [{ type: 'text', text: 'No ALP session' }], isError: true } }) : new Promise(resolve => { const id = ++sequence; waiting.set(id, resolve); socket.write(JSON.stringify({ ...message, id }) + '\\n'); });
+const send = value => process.stdout.write(JSON.stringify({ jsonrpc: '2.0', ...value }) + '\\n');
+readline.createInterface({ input: process.stdin }).on('line', async line => {
+  let message; try { message = JSON.parse(line); } catch { return; }
+  if (message.id === undefined || message.id === null) return;
+  try {
+    if (message.method === 'initialize') return send({ id: message.id, result: { protocolVersion: (message.params && message.params.protocolVersion) || '2025-06-18', capabilities: { tools: {} }, serverInfo: { name: 'alp', version: '1' } } });
+    if (message.method === 'ping') return send({ id: message.id, result: {} });
+    if (message.method === 'tools/list') { const reply = await ask({ op: 'list' }); return send({ id: message.id, result: { tools: reply.tools } }); }
+    if (message.method === 'tools/call') { const reply = await ask({ op: 'call', name: message.params.name, arguments: message.params.arguments || {} }); return send({ id: message.id, result: reply.result }); }
+    send({ id: message.id, error: { code: -32601, message: 'Method not found' } });
+  } catch (error) { send({ id: message.id, error: { code: -32603, message: String((error && error.message) || error) } }); }
+});
+process.stdin.on('end', () => process.exit(0));
+`;
+function encodePrompt(text) {
+  return `${JSON.stringify({ event: "user", message: { content: text } })}
+`;
+}
+var AntigravityTransport = class {
+  constructor(command = "agy", cwd = process.cwd(), env = process.env, provider) {
+    this.command = command;
+    this.cwd = cwd;
+    this.env = env;
+    this.provider = provider;
+  }
+  child;
+  lines;
+  exit = Promise.resolve();
+  listeners = /* @__PURE__ */ new Set();
+  failures = /* @__PURE__ */ new Set();
+  requestHandler;
+  closed = false;
+  conversationId = "";
+  config;
+  activeTurn;
+  messageText = /* @__PURE__ */ new Map();
+  messages = 0;
+  instructionsSent = false;
+  tools = [];
+  bridge;
+  readyPromise;
+  resolveReady;
+  rejectReady;
+  external;
+  externalStarting;
+  startupAbort = new AbortController();
+  async initialize() {
+    if (/\.(cmd|bat|ps1)$/i.test(this.command)) {
+      throw new Error("Antigravity command must be a native executable, not a shell launcher");
+    }
+  }
+  onNotification(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onFailure(listener) {
+    this.failures.add(listener);
+    return () => this.failures.delete(listener);
+  }
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
+  async request(method, params) {
+    if (this.closed) throw new Error("Runtime is closed");
+    if (method === "thread/start" || method === "thread/resume") {
+      if (params.sandbox !== "full-access" && params.sandbox !== "danger-full-access") throw new Error("Antigravity currently supports only full-access");
+      this.config = params;
+      this.tools = params.dynamicTools ?? [];
+      try {
+        if (Object.keys(params.mcpServers ?? {}).length) {
+          this.externalStarting = openMcpTools(params.mcpServers, params.cwd || this.cwd, { ...this.env, ...this.provider?.env, ...params.env }, this.startupAbort.signal);
+          const external = await this.externalStarting;
+          if (this.closed) {
+            await external.close();
+            throw new Error("Runtime is closed");
+          }
+          this.external = external;
+        }
+        if (this.tools.length > 0 || this.external?.tools.length) await this.openBridge();
+        if (this.closed) throw new Error("Runtime is closed");
+        await this.startProcess(params);
+      } catch (error) {
+        await this.close();
+        throw error;
+      }
+      return {
+        thread: { id: this.conversationId, turns: [] },
+        cwd: params.cwd,
+        model: params.model,
+        reasoningEffort: params.thinking
+      };
+    }
+    if (method === "turn/start") {
+      if (!this.conversationId) throw new Error("Antigravity session is not open");
+      if (!this.child) await this.startProcess({ ...this.config, threadId: this.conversationId });
+      if (this.activeTurn) throw new Error("Antigravity already has an active turn");
+      const turnId = randomUUID();
+      this.activeTurn = turnId;
+      this.messageText.clear();
+      const parts = (params.input ?? []).filter((part) => typeof part?.text === "string").map((part) => part.text);
+      let promptText = parts.join("\n\n");
+      if (!this.instructionsSent && this.config?.developerInstructions) {
+        promptText = `Instructions from ALP, which runs you. Follow them for this whole session.
+
+${this.config.developerInstructions}
+
+${promptText}`;
+        this.instructionsSent = true;
+      }
+      setImmediate(() => {
+        try {
+          this.child?.stdin.write(encodePrompt(promptText));
+        } catch (error) {
+          this.endTurn(turnId, "failed", error instanceof Error ? error.message : String(error));
+        }
+      });
+      return { turn: { id: turnId } };
+    }
+    if (method === "turn/steer") {
+      throw new Error("Antigravity takes no messages during a turn; ALP delivers them when it ends");
+    }
+    if (method === "turn/interrupt") {
+      if (this.child && this.activeTurn) {
+        const turnId = this.activeTurn;
+        const child = this.child;
+        this.child = void 0;
+        this.lines?.close();
+        const kill = (signal) => {
+          if (process.platform !== "win32" && child.pid) {
+            try {
+              process.kill(-child.pid, signal);
+            } catch {
+              child.kill(signal);
+            }
+          } else child.kill(signal);
+        };
+        kill("SIGINT");
+        const timer = setTimeout(() => kill("SIGKILL"), 1500);
+        try {
+          await this.exit;
+        } finally {
+          clearTimeout(timer);
+        }
+        this.endTurn(turnId, "interrupted");
+      }
+      return {};
+    }
+    if (method === "session/configure" || method === "thread/delete") {
+      if (method === "session/configure" && params.sandbox && params.sandbox !== "full-access") throw new Error("Antigravity currently supports only full-access");
+      return {};
+    }
+    throw new Error(`Antigravity does not support '${method}'`);
+  }
+  startProcess(params) {
+    if (this.closed) return Promise.reject(new Error("Runtime is closed"));
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    const args = [
+      ...this.provider?.args ?? [],
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--add-dir",
+      params.cwd || this.cwd,
+      "--disable-slash-commands",
+      "--dangerously-skip-permissions"
+    ];
+    if (params.model) {
+      args.push("--model", params.model);
+    }
+    if (params.threadId) {
+      args.push("--conversation", params.threadId);
+    }
+    const env = {
+      ...this.env,
+      ...this.provider?.env ?? {},
+      ...params.env ?? {},
+      // Session credentials are inherited by this agy's MCP child only, never persisted.
+      ALP_BRIDGE_SOCKET: this.bridge?.socket ?? "",
+      ALP_BRIDGE_TOKEN: this.bridge?.token ?? ""
+    };
+    const child = spawn(this.command, args, {
+      cwd: params.cwd || this.cwd,
+      env,
+      windowsHide: true,
+      detached: process.platform !== "win32",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.exit = new Promise((resolve) => {
+      child.once("close", () => resolve());
+      child.once("error", () => resolve());
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr = (stderr + chunk.toString()).slice(-8192);
+    });
+    child.stdin.on("error", (error) => this.fail(error));
+    child.on("error", (error) => {
+      const err = new Error(`Antigravity did not start: ${error.message}`);
+      if (this.rejectReady) this.rejectReady(err);
+      this.fail(err);
+    });
+    child.on("close", (code) => {
+      const msg = stderr.trim() || `Antigravity exited (${code})`;
+      if (!this.closed && this.child === child) {
+        const error = new Error(msg);
+        if (this.rejectReady) this.rejectReady(error);
+        if (this.activeTurn) {
+          this.endTurn(this.activeTurn, "failed", msg);
+        }
+        this.fail(error);
+      }
+    });
+    const lines = createInterface({ input: child.stdout, terminal: false });
+    this.lines = lines;
+    lines.on("line", (line) => this.receiveLine(line));
+    const startupTimeout = setTimeout(() => {
+      if (this.rejectReady) {
+        const error = new Error("Antigravity did not initialize within 30 seconds");
+        this.rejectReady(error);
+        this.fail(error);
+      }
+    }, 3e4);
+    return this.readyPromise.finally(() => clearTimeout(startupTimeout));
+  }
+  receiveLine(line) {
+    if (!line.trim() || this.closed) return;
+    if (line.length > 10 * 1024 * 1024) {
+      this.fail(new Error("Antigravity frame exceeds 10MB limit"));
+      return;
+    }
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (frame.event === "init") {
+      this.conversationId = frame.conversation_id || frame.init?.conversation_id || randomUUID();
+      if (this.resolveReady) {
+        this.resolveReady();
+        this.resolveReady = void 0;
+        this.rejectReady = void 0;
+      }
+      return;
+    }
+    if (frame.event === "step_update") {
+      this.handleStepUpdate(frame.step_update);
+      return;
+    }
+    if (frame.event === "result") {
+      this.handleResult(frame.result);
+      return;
+    }
+  }
+  handleStepUpdate(step) {
+    if (!step || !this.activeTurn) return;
+    if (step.step_type === "agent_response") {
+      const itemId = `agy-msg-${this.activeTurn}-${step.step_index ?? this.messages}`;
+      const delta = typeof step.text_delta === "string" ? step.text_delta : "";
+      if (delta) {
+        this.messageText.set(itemId, (this.messageText.get(itemId) ?? "") + delta);
+        this.emit("item/agentMessage/delta", {
+          threadId: this.conversationId,
+          itemId,
+          delta
+        });
+      }
+      if (step.state === "DONE" && this.messageText.has(itemId)) {
+        this.emit("item/completed", {
+          threadId: this.conversationId,
+          item: { type: "agentMessage", id: itemId, text: this.messageText.get(itemId) }
+        });
+      }
+      if (step.state === "DONE") {
+        this.messageText.delete(itemId);
+        this.messages++;
+      }
+      if (step.usage && typeof step.usage === "object") {
+        const inTokens = step.usage.input_tokens || 0;
+        const outTokens = step.usage.output_tokens || 0;
+        const cachedTokens = step.usage.cache_read_tokens || 0;
+        const total = inTokens + outTokens;
+        const last = { totalTokens: total, inputTokens: inTokens, outputTokens: outTokens };
+        this.emit("thread/tokenUsage/updated", {
+          threadId: this.conversationId,
+          turnId: this.activeTurn,
+          tokenUsage: {
+            last,
+            total: last,
+            ...cachedTokens ? { cachedInputTokens: cachedTokens } : {}
+          }
+        });
+      }
+      return;
+    }
+    if (step.step_type === "tool") {
+      const toolName = step.tool_name || "tool";
+      const callId = `agy-tool-${this.activeTurn}-${step.step_index ?? ++this.messages}`;
+      if (step.state === "ACTIVE") {
+        this.emit("item/started", {
+          threadId: this.conversationId,
+          item: {
+            type: "commandExecution",
+            id: callId,
+            command: toolName,
+            cwd: this.cwd,
+            status: "inProgress",
+            aggregatedOutput: ""
+          }
+        });
+      } else if (step.state === "DONE" || step.state === "ERROR") {
+        const output = typeof step.tool_info?.output === "string" ? step.tool_info.output : step.tool_info?.error?.message || "";
+        this.emit("item/completed", {
+          threadId: this.conversationId,
+          item: {
+            type: "commandExecution",
+            id: callId,
+            command: toolName,
+            cwd: this.cwd,
+            status: step.state === "DONE" ? "completed" : "failed",
+            exitCode: step.state === "DONE" ? 0 : 1,
+            aggregatedOutput: output
+          }
+        });
+      }
+    }
+  }
+  handleResult(result) {
+    if (!this.activeTurn) return;
+    const turnId = this.activeTurn;
+    if (!result || typeof result !== "object") {
+      this.endTurn(turnId, "failed", "Invalid Antigravity result");
+      return;
+    }
+    if (result.status === "ERROR") {
+      const isInterrupted = result.error === "interrupted";
+      this.endTurn(turnId, isInterrupted ? "interrupted" : "failed", result.error);
+    } else {
+      this.endTurn(turnId, "completed");
+    }
+  }
+  endTurn(turnId, status, error) {
+    if (this.activeTurn !== turnId) return;
+    this.activeTurn = void 0;
+    setImmediate(() => {
+      this.emit("turn/completed", {
+        threadId: this.conversationId,
+        turn: {
+          id: turnId,
+          status,
+          ...status === "failed" ? { error: { message: error || "Antigravity turn failed" } } : {}
+        }
+      });
+    });
+  }
+  async openBridge() {
+    if (this.bridge) return;
+    const token = randomBytes(16).toString("hex");
+    const name = `alp-agy-${randomBytes(6).toString("hex")}`;
+    const socket = process.platform === "win32" ? `\\\\.\\pipe\\${name}` : path.join(os.tmpdir(), `${name}.sock`);
+    const connections = /* @__PURE__ */ new Set();
+    const server = net.createServer((connection) => {
+      connections.add(connection);
+      connection.once("close", () => connections.delete(connection));
+      this.serveBridge(connection, token);
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(socket, () => resolve());
+    });
+    this.bridge = { server, socket, token, connections };
+    await this.registerMcpServer();
+  }
+  /** One stable launcher; each child inherits its own socket/token from agy.
+   * No session endpoint or credential is written to the global configuration.
+   * Leave the launcher installed: removing it would break concurrent sessions.
+   */
+  async registerMcpServer() {
+    const configFile = this.env.ALP_AGY_MCP_CONFIG ?? path.join(os.homedir(), ".gemini", "config", "mcp_config.json");
+    await mkdir(path.dirname(configFile), { recursive: true });
+    const lockFile = `${configFile}.alp-lock`;
+    let lock;
+    for (let attempt = 0; attempt < 100; attempt++) {
+      try {
+        lock = await open(lockFile, "wx", 384);
+        break;
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    if (!lock) throw new Error(`Antigravity MCP configuration is locked: ${lockFile}`);
+    const temporary = `${configFile}.${randomUUID()}.tmp`;
+    try {
+      let text = "{}";
+      try {
+        text = await readFile(configFile, "utf8");
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      const config = JSON.parse(text);
+      if (!config || typeof config !== "object" || Array.isArray(config) || config.mcpServers !== void 0 && (!config.mcpServers || typeof config.mcpServers !== "object" || Array.isArray(config.mcpServers))) {
+        throw new Error("Invalid Antigravity MCP configuration; existing file was preserved");
+      }
+      config.mcpServers ??= {};
+      const existing = config.mcpServers.alp;
+      if (existing && !existing.args?.some((arg) => typeof arg === "string" && arg.startsWith("// ALP Antigravity bridge v1"))) {
+        throw new Error("Antigravity already has an MCP server named alp; rename it before using ALP");
+      }
+      const launcher = { command: process.execPath, args: ["-e", BRIDGE], ...process.versions.electron ? { env: { ELECTRON_RUN_AS_NODE: "1" } } : {} };
+      if (JSON.stringify(existing) === JSON.stringify(launcher)) return;
+      config.mcpServers.alp = launcher;
+      await writeFile(temporary, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+      await rename(temporary, configFile);
+    } finally {
+      await unlink(temporary).catch(() => {
+      });
+      await lock.close();
+      await unlink(lockFile);
+    }
+  }
+  serveBridge(connection, token) {
+    let trusted = false;
+    connection.setEncoding("utf8");
+    connection.on("error", () => {
+    });
+    const reply = (value) => {
+      if (!connection.destroyed) connection.write(`${JSON.stringify(value)}
+`);
+    };
+    createInterface({ input: connection }).on("line", async (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        connection.destroy();
+        return;
+      }
+      if (!trusted) {
+        if (message.token !== token) {
+          connection.destroy();
+          return;
+        }
+        trusted = true;
+        return;
+      }
+      if (message.op === "list") {
+        reply({
+          id: message.id,
+          tools: [...this.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema ?? { type: "object" }
+          })), ...this.external?.tools ?? []]
+        });
+        return;
+      }
+      if (message.op === "call") {
+        reply({
+          id: message.id,
+          result: await this.toolCall(String(message.name), message.arguments ?? {})
+        });
+      }
+    });
+  }
+  async toolCall(tool, args) {
+    if (this.activeTurn && this.external?.has(tool)) {
+      const callId2 = `agy-mcp-tool-${randomUUID()}`;
+      const item2 = { type: "dynamicToolCall", id: callId2, callId: callId2, tool, arguments: args };
+      this.emit("item/started", { threadId: this.conversationId, item: { ...item2, status: "inProgress" } });
+      const result2 = await this.external.call(tool, args).catch(() => ({ content: [{ type: "text", text: `External MCP tool '${tool}' failed` }], isError: true }));
+      const ok2 = result2.isError !== true;
+      this.emit("item/completed", {
+        threadId: this.conversationId,
+        item: { ...item2, status: ok2 ? "completed" : "failed", success: ok2, contentItems: (Array.isArray(result2.content) ? result2.content : []).map((part) => ({ type: "inputText", text: part.type === "text" ? part.text : JSON.stringify(part) })) }
+      });
+      return result2;
+    }
+    if (!this.requestHandler || !this.activeTurn || !this.tools.some((t) => t.name === tool)) {
+      return {
+        content: [{ type: "text", text: this.activeTurn ? `Unknown ALP tool '${tool}'` : "ALP tools are unavailable between turns" }],
+        isError: true
+      };
+    }
+    const callId = `agy-alp-tool-${randomUUID()}`;
+    const item = { type: "dynamicToolCall", id: callId, callId, tool, arguments: args };
+    this.emit("item/started", { threadId: this.conversationId, item: { ...item, status: "inProgress" } });
+    const result = await this.requestHandler("item/tool/call", {
+      threadId: this.conversationId,
+      turnId: this.activeTurn,
+      callId,
+      namespace: null,
+      tool,
+      arguments: args
+    }).catch((error) => ({
+      success: false,
+      contentItems: [{ type: "inputText", text: error instanceof Error ? error.message : String(error) }]
+    }));
+    const ok = result?.success !== false;
+    this.emit("item/completed", {
+      threadId: this.conversationId,
+      item: { ...item, status: ok ? "completed" : "failed", success: ok, contentItems: result?.contentItems ?? [] }
+    });
+    return {
+      content: (result?.contentItems ?? []).map((part) => ({ type: "text", text: part.text ?? JSON.stringify(part) })),
+      isError: !ok
+    };
+  }
+  emit(method, params) {
+    for (const listener of this.listeners) listener(method, params);
+  }
+  fail(error) {
+    if (this.closed) return;
+    for (const listener of this.failures) listener(error);
+    void this.close();
+  }
+  async close() {
+    if (this.closed) return this.exit;
+    this.closed = true;
+    this.listeners.clear();
+    this.failures.clear();
+    this.startupAbort.abort();
+    await this.externalStarting?.then((external) => external.close(), () => {
+    });
+    await this.external?.close();
+    if (this.bridge) {
+      this.bridge.server.close();
+      for (const connection of this.bridge.connections) connection.destroy();
+      if (process.platform !== "win32") {
+        try {
+          rmSync(this.bridge.socket, { force: true });
+        } catch {
+        }
+      }
+    }
+    if (this.lines) {
+      this.lines.close();
+    }
+    const child = this.child;
+    if (!child) return;
+    try {
+      child.stdin.end();
+    } catch {
+    }
+    const timer = setTimeout(() => {
+      if (process.platform === "win32" && child.pid) {
+        execFile("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { windowsHide: true }, () => {
+        });
+      } else if (child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          child.kill("SIGKILL");
+        }
+      }
+    }, 1500);
+    let deadline;
+    try {
+      await Promise.race([
+        this.exit,
+        new Promise((resolve) => {
+          deadline = setTimeout(resolve, 4e3);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+      clearTimeout(deadline);
+    }
+  }
+};
+export {
+  AntigravityTransport,
+  encodePrompt
+};

package/dist/board-domain.d.ts

@@ -0,0 +1,56 @@
+import { type Pin } from './board.js';
+import type { RuntimeOptions } from './contracts.js';
+import type { Session } from './session-state.js';
+import type { AlpEvent } from './events.js';
+import type { MailEvent } from './mailbox.js';
+type BoardContext = {
+    options: RuntimeOptions;
+    sessions: Map<string, Session>;
+    boards: Map<string, Promise<Pin[]>>;
+    loadedBoards: Map<string, Pin[]>;
+    rootOf(sessionId: string): string;
+    lineage(sessionId: string): string[];
+    runLog(rootId: string, entry: Record<string, unknown>): void;
+    emit(sessionId: string, event: AlpEvent): void;
+    post(sessionId: string, event: Omit<MailEvent, 'id'>): MailEvent;
+    steerMail(sessionId: string, session: Session): Promise<void>;
+};
+/** Shared project boards retain their original write ordering and session ownership. */
+export declare function createBoardDomain({ options, sessions, boards, loadedBoards, rootOf, lineage, runLog, emit, post, steerMail }: BoardContext): {
+    boardOf: (project: string) => Promise<Pin[]>;
+    claimConflicts: (sessionId: string, pins: Pin[], paths: string[]) => {
+        task?: string | undefined;
+        pinId: string;
+        agent: string;
+        sessionId: string;
+        paths: string[];
+        body: string;
+        at: string;
+    }[];
+    taskOf: (sessionId: string) => string | undefined;
+    addPin: (sessionId: string, session: Session, pins: Pin[], fields: Pick<Pin, "kind" | "body" | "paths" | "task">) => Pin;
+    pinTool: (sessionId: string, session: Session, args: unknown) => Promise<{
+        success: boolean;
+        contentItems: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    boardTool: (session: Session, args: unknown) => Promise<{
+        success: boolean;
+        contentItems: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    unpinTool: (sessionId: string, session: Session, args: unknown) => Promise<{
+        success: boolean;
+        contentItems: {
+            type: string;
+            text: string;
+        }[];
+    }>;
+    releaseClaims: (sessionId: string, project: string) => void;
+    flush: () => Promise<void>;
+};
+export {};