@datalabrotterdam/nova-ai-cli 1.1.0 → 1.2.0-alpha.2

package/dist/webui-L4GGMXJ3.js

@@ -0,0 +1,9 @@
+// src/webui/index.ts
+async function runWebUi() {
+  console.log("nova-ai --web is a work in progress \u2014 the browser UI isn't built yet.");
+  console.log("Use `nova-ai` for the terminal UI, `nova-ai -p` headless, or `nova-ai --acp` for editors.");
+}
+var webui_default = runWebUi;
+export {
+  webui_default as default
+};

package/package.json

@@ -1,58 +1,58 @@
 {
   "name": "@datalabrotterdam/nova-ai-cli",
-  "version": "1.1.0",
-  "description": "CLI for DataLab Rotterdam's Nova AI, with an Agent Client Protocol mode for editors/IDEs, backed by @datalabrotterdam/nova-sdk",
+  "version": "1.2.0-alpha.2",
+  "description": "Agentic coding with DataLab Rotterdam's Nova AI in your terminal: interactive TUI, headless mode, and an ACP agent for editors",
   "license": "Apache-2.0",
   "author": "DataLab Rotterdam",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "nova-ai-cli": "dist/index.js",
-    "nova-ai": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "src/acp/web/dist",
-    "LICENSE"
-  ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Datalab-Rotterdam/nova-ai-cli.git"
+    "url": "git+https://github.com/Datalab-Rotterdam/nova-ai-cli.git",
+    "directory": "packages/cli"
   },
   "bugs": {
     "url": "https://github.com/Datalab-Rotterdam/nova-ai-cli/issues"
   },
-  "homepage": "https://github.com/Datalab-Rotterdam/nova-ai-cli#readme",
   "publishConfig": {
     "access": "public"
   },
+  "homepage": "https://github.com/Datalab-Rotterdam/nova-ai-cli#readme",
+  "bin": {
+    "nova-ai-cli": "dist/index.js",
+    "nova-ai": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "scripts": {
-    "build": "npm install --prefix src/acp/web && npm run build --prefix src/acp/web && tsc -p tsconfig.json",
-    "dev": "tsc -p tsconfig.json --watch",
-    "test": "tsc -p tsconfig.json --noEmit && npm run test:unit",
-    "test:unit": "node -e \"require('fs').rmSync('dist-test',{recursive:true,force:true})\" && tsc -p tsconfig.test.json && node --test \"dist-test/tests/**/*.test.js\""
+    "build": "tsup",
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run typecheck && npm run test:unit && npm run test:pty",
+    "test:unit": "node -e \"require('fs').rmSync('dist-test',{recursive:true,force:true})\" && tsc -p tsconfig.test.json && node --import ./dist-test/test-support/setup-env.js --test --test-timeout=30000 \"dist-test/packages/cli/tests/**/*.test.js\"",
+    "test:pty": "tsx tests/tui/pty-runtime-runner.ts"
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.29.0",
-    "@datalabrotterdam/nova-ai-cli": "^1.0.1",
+    "@datalabrotterdam/nova-ai-agent": "^1.0.0-alpha.1",
     "@datalabrotterdam/nova-sdk": "^1.3.2",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "@sourceregistry/node-webserver": "^1.8.0"
-  },
-  "devDependencies": {
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^13.0.1",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/npm": "^13.1.5",
-    "@semantic-release/release-notes-generator": "^14.1.0",
-    "@types/node": "^22.20.0",
-    "typescript": "^5.6.0"
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "diff": "^9.0.0",
+    "ink": "^7.1.1",
+    "marked": "^18.0.14",
+    "react": "^19.3.0",
+    "string-width": "^8.3.0"
   },
   "release": {
+    "extends": "semantic-release-monorepo",
+    "tagFormat": "@datalabrotterdam/nova-ai-cli@${version}",
     "branches": [
       "main",
       {

package/dist/acp/agent.d.ts

@@ -1,13 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export declare class NovaAgent {
-    private readonly sessions;
-    private clientCapabilities;
-    initialize(params: acp.InitializeRequest): acp.InitializeResponse;
-    newSession(params: acp.NewSessionRequest): Promise<acp.NewSessionResponse>;
-    loadSession(params: acp.LoadSessionRequest, client: acp.AgentContext): Promise<acp.LoadSessionResponse>;
-    listSessions(params: acp.ListSessionsRequest): acp.ListSessionsResponse;
-    authenticate(params: acp.AuthenticateRequest): Promise<acp.AuthenticateResponse>;
-    prompt(params: acp.PromptRequest, client: acp.AgentContext): Promise<acp.PromptResponse>;
-    cancel(params: acp.CancelNotification): void;
-    closeSession(params: acp.CloseSessionRequest): Promise<acp.CloseSessionResponse>;
-}

package/dist/acp/agent.js

@@ -1,242 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-import { NovaAI, NovaAIError } from "@datalabrotterdam/nova-sdk";
-import { runBrowserAuth } from "./auth-server.js";
-import { readCredentials } from "./credentials.js";
-import { closeMcpConnections, connectMcpServers, listMcpTools } from "./mcp.js";
-import { appendSessionTurn, deriveTitle, listStoredSessions, loadStoredSession } from "./sessions.js";
-import { availableTools, buildToolsSystemPrompt, extractToolCall, hasPendingFence, requestPermissionIfNeeded, sendToolCallPending, sendToolCallUpdate, } from "./tools/index.js";
-const AUTH_METHOD_ID = "nova-api-key";
-const MAX_TOOL_ROUNDS = 10;
-export class NovaAgent {
-    sessions = new Map();
-    clientCapabilities;
-    initialize(params) {
-        this.clientCapabilities = params.clientCapabilities;
-        return {
-            protocolVersion: acp.PROTOCOL_VERSION,
-            agentCapabilities: {
-                loadSession: true,
-                promptCapabilities: {
-                    // Image/audio content isn't forwarded to the model; only text and
-                    // embedded text resources are supported.
-                    embeddedContext: true,
-                },
-                mcpCapabilities: {
-                    http: true,
-                    sse: true,
-                },
-                sessionCapabilities: {
-                    list: {},
-                    close: {},
-                },
-            },
-            authMethods: [
-                {
-                    id: AUTH_METHOD_ID,
-                    name: "Nova API Key",
-                    description: "Opens a local page in your browser to connect your DataLab Rotterdam Nova AI account.",
-                },
-            ],
-        };
-    }
-    async newSession(params) {
-        const sessionId = crypto.randomUUID();
-        const mcpConnections = await connectMcpServers(params.mcpServers);
-        const mcpTools = await listMcpTools(mcpConnections);
-        this.sessions.set(sessionId, {
-            pendingPrompt: null,
-            cwd: params.cwd,
-            history: [],
-            title: null,
-            mcpConnections,
-            mcpTools,
-        });
-        return { sessionId };
-    }
-    async loadSession(params, client) {
-        const stored = loadStoredSession(params.sessionId);
-        if (!stored) {
-            throw acp.RequestError.internalError(undefined, `Session ${params.sessionId} not found`);
-        }
-        const mcpConnections = await connectMcpServers(params.mcpServers);
-        const mcpTools = await listMcpTools(mcpConnections);
-        this.sessions.set(params.sessionId, {
-            pendingPrompt: null,
-            cwd: params.cwd,
-            history: stored.messages,
-            title: stored.title,
-            mcpConnections,
-            mcpTools,
-        });
-        for (const message of stored.messages) {
-            if (typeof message.content !== "string" || !message.content)
-                continue;
-            if (message.role === "user") {
-                await client.notify("session/update", {
-                    sessionId: params.sessionId,
-                    update: { sessionUpdate: "user_message_chunk", content: { type: "text", text: message.content } },
-                });
-            }
-            else if (message.role === "assistant") {
-                await client.notify("session/update", {
-                    sessionId: params.sessionId,
-                    update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: message.content } },
-                });
-            }
-        }
-        return {};
-    }
-    listSessions(params) {
-        const sessions = listStoredSessions(params.cwd ?? undefined).map((s) => ({
-            sessionId: s.sessionId,
-            cwd: s.cwd,
-            title: s.title,
-            updatedAt: s.updatedAt,
-        }));
-        return { sessions };
-    }
-    async authenticate(params) {
-        if (params.methodId !== AUTH_METHOD_ID) {
-            throw new Error(`Unknown auth method: ${params.methodId}`);
-        }
-        await runBrowserAuth();
-        return {};
-    }
-    async prompt(params, client) {
-        const session = this.sessions.get(params.sessionId);
-        if (!session) {
-            throw new Error(`Session ${params.sessionId} not found`);
-        }
-        const credentials = readCredentials();
-        if (!credentials) {
-            throw acp.RequestError.authRequired();
-        }
-        session.pendingPrompt?.abort();
-        const abortController = new AbortController();
-        session.pendingPrompt = abortController;
-        const novaClient = new NovaAI({ apiKey: credentials.apiKey });
-        const model = credentials.defaultModel ?? process.env.NOVA_MODEL;
-        if (!model) {
-            throw new Error("No Nova model configured. Re-run authentication or set NOVA_MODEL.");
-        }
-        const tools = [...availableTools(this.clientCapabilities), ...session.mcpTools];
-        const findSessionTool = (name) => tools.find((tool) => tool.name === name);
-        const systemPrompt = buildToolsSystemPrompt(tools, session.cwd);
-        const userMessage = { role: "user", content: contentBlocksToText(params.prompt) };
-        session.history.push(userMessage);
-        const turnMessages = [userMessage];
-        const messages = [
-            ...(systemPrompt ? [{ role: "system", content: systemPrompt }] : []),
-            ...session.history,
-        ];
-        const pushTurn = (message) => {
-            session.history.push(message);
-            messages.push(message);
-            turnMessages.push(message);
-        };
-        try {
-            for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
-                if (abortController.signal.aborted) {
-                    return { stopReason: "cancelled" };
-                }
-                let buffer = "";
-                let flushed = 0;
-                for await (const event of novaClient.chat.completions.stream({ model, messages }, { signal: abortController.signal })) {
-                    if (event.type !== "chunk")
-                        continue;
-                    const text = event.data.choices?.[0]?.delta?.content;
-                    if (typeof text !== "string" || text.length === 0)
-                        continue;
-                    buffer += text;
-                    if (!hasPendingFence(buffer)) {
-                        const toFlush = buffer.slice(flushed);
-                        if (toFlush) {
-                            await client.notify("session/update", {
-                                sessionId: params.sessionId,
-                                update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: toFlush } },
-                            });
-                            flushed = buffer.length;
-                        }
-                    }
-                }
-                const toolCall = extractToolCall(buffer);
-                if (!toolCall) {
-                    const remaining = buffer.slice(flushed);
-                    if (remaining) {
-                        await client.notify("session/update", {
-                            sessionId: params.sessionId,
-                            update: { sessionUpdate: "agent_message_chunk", content: { type: "text", text: remaining } },
-                        });
-                    }
-                    pushTurn({ role: "assistant", content: buffer });
-                    return { stopReason: "end_turn" };
-                }
-                const tool = findSessionTool(toolCall.name);
-                const toolCallId = crypto.randomUUID();
-                const toolCtx = { client, sessionId: params.sessionId, signal: abortController.signal };
-                pushTurn({ role: "assistant", content: buffer });
-                if (!tool) {
-                    pushTurn({ role: "user", content: `Tool "${toolCall.name}" is not available.` });
-                    continue;
-                }
-                await sendToolCallPending(toolCtx, toolCallId, tool, toolCall.args);
-                const allowed = await requestPermissionIfNeeded(toolCtx, toolCallId, tool, toolCall.args);
-                if (!allowed) {
-                    await sendToolCallUpdate(toolCtx, toolCallId, "failed", "Permission denied by user.");
-                    pushTurn({ role: "user", content: "Tool call rejected by user." });
-                    continue;
-                }
-                const result = await tool.execute(toolCtx, toolCall.args);
-                if ("error" in result) {
-                    await sendToolCallUpdate(toolCtx, toolCallId, "failed", result.error);
-                    pushTurn({ role: "user", content: `Tool error: ${result.error}` });
-                }
-                else {
-                    await sendToolCallUpdate(toolCtx, toolCallId, "completed", result.output);
-                    pushTurn({ role: "user", content: `Tool result: ${result.output}` });
-                }
-            }
-            return { stopReason: "max_turn_requests" };
-        }
-        catch (err) {
-            if (abortController.signal.aborted) {
-                return { stopReason: "cancelled" };
-            }
-            if (err instanceof NovaAIError) {
-                throw new Error(`Nova AI request failed (status ${err.status}, requestId ${err.requestId}): ${err.message}`);
-            }
-            throw err;
-        }
-        finally {
-            session.pendingPrompt = null;
-            session.title ??= deriveTitle(session.history);
-            appendSessionTurn(params.sessionId, { cwd: session.cwd, title: session.title }, turnMessages);
-        }
-    }
-    cancel(params) {
-        this.sessions.get(params.sessionId)?.pendingPrompt?.abort();
-    }
-    async closeSession(params) {
-        const session = this.sessions.get(params.sessionId);
-        if (session) {
-            session.pendingPrompt?.abort();
-            await closeMcpConnections(session.mcpConnections);
-            this.sessions.delete(params.sessionId);
-        }
-        return {};
-    }
-}
-function contentBlocksToText(prompt) {
-    return prompt
-        .map((block) => {
-        if (block.type === "text")
-            return block.text;
-        if (block.type === "resource_link")
-            return block.uri;
-        if (block.type === "resource" && "text" in block.resource)
-            return block.resource.text;
-        return "";
-    })
-        .filter(Boolean)
-        .join("\n");
-}

package/dist/acp/auth-server.d.ts

@@ -1,10 +0,0 @@
-import { credentialsPath } from "./credentials.js";
-/**
- * Agent Auth flow (AUTHENTICATION.md, type "agent"): the agent itself runs a
- * local HTTP server and opens the browser. Today the page just collects a
- * Nova API key; swapping to real OAuth later means changing what this page
- * does (redirect to the provider's authorize URL, exchange the callback code)
- * without touching the server lifecycle or the rest of the agent.
- */
-export declare function runBrowserAuth(): Promise<void>;
-export { credentialsPath };

package/dist/acp/auth-server.js

@@ -1,67 +0,0 @@
-import { exec } from "node:child_process";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { NovaAI, NovaAIError } from "@datalabrotterdam/nova-sdk";
-import { dir, json, WebServer } from "@sourceregistry/node-webserver";
-import { credentialsPath, writeCredentials } from "./credentials.js";
-const AUTH_TIMEOUT_MS = 5 * 60 * 1000;
-const UI_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "src", "acp", "web", "dist");
-function openBrowser(url) {
-    const cmd = process.platform === "darwin"
-        ? `open "${url}"`
-        : process.platform === "win32"
-            ? `start "" "${url}"`
-            : `xdg-open "${url}"`;
-    exec(cmd, () => {
-        // best-effort; the URL is always printed as a fallback
-    });
-}
-/**
- * Agent Auth flow (AUTHENTICATION.md, type "agent"): the agent itself runs a
- * local HTTP server and opens the browser. Today the page just collects a
- * Nova API key; swapping to real OAuth later means changing what this page
- * does (redirect to the provider's authorize URL, exchange the callback code)
- * without touching the server lifecycle or the rest of the agent.
- */
-export function runBrowserAuth() {
-    return new Promise((resolve, reject) => {
-        const app = new WebServer();
-        app.POST("/api/authenticate", async (event) => {
-            const body = await event.request.json().catch(() => null);
-            const apiKey = typeof body?.apiKey === "string" ? body.apiKey.trim() : "";
-            if (!apiKey) {
-                return json({ message: "API key is required." }, { status: 400 });
-            }
-            try {
-                const client = new NovaAI({ apiKey });
-                const { data: models } = await client.models.list();
-                const defaultModel = (models.find((m) => m.enabled !== false) ?? models[0])?.id;
-                writeCredentials({ apiKey, defaultModel });
-                clearTimeout(timeout);
-                const response = json({ ok: true });
-                void app.shutdown().then(resolve);
-                return response;
-            }
-            catch (err) {
-                const message = err instanceof NovaAIError
-                    ? `Nova AI rejected this key (status ${err.status}): ${err.message}`
-                    : "Unexpected error validating the key.";
-                return json({ message }, { status: 401 });
-            }
-        });
-        app.GET("/", dir(UI_DIR, { spa: true }));
-        app.GET("/[...path]", dir(UI_DIR, { spa: true }));
-        const timeout = setTimeout(() => {
-            void app.shutdown();
-            reject(new Error("Nova AI authentication timed out after 5 minutes."));
-        }, AUTH_TIMEOUT_MS);
-        app.listen(0, "127.0.0.1", () => {
-            const address = app.address();
-            const port = typeof address === "object" && address ? address.port : 0;
-            const url = `http://127.0.0.1:${port}`;
-            console.error(`Opening browser to authenticate with Nova AI: ${url}`);
-            openBrowser(url);
-        });
-    });
-}
-export { credentialsPath };

package/dist/acp/credentials.d.ts

@@ -1,11 +0,0 @@
-export type StoredCredentials = {
-    apiKey: string;
-    defaultModel?: string;
-};
-/**
- * Single place that owns "how we get the Nova API key", so swapping this for
- * an OAuth-based Agent Auth flow later only touches this file.
- */
-export declare function readCredentials(): StoredCredentials | null;
-export declare function writeCredentials(credentials: StoredCredentials): void;
-export declare function credentialsPath(): string;

package/dist/acp/credentials.js

@@ -1,30 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-const CREDENTIALS_PATH = join(homedir(), ".nova-ai", "credentials.json");
-/**
- * Single place that owns "how we get the Nova API key", so swapping this for
- * an OAuth-based Agent Auth flow later only touches this file.
- */
-export function readCredentials() {
-    const envApiKey = process.env.NOVA_API_KEY;
-    if (envApiKey) {
-        return { apiKey: envApiKey, defaultModel: process.env.NOVA_MODEL };
-    }
-    try {
-        const raw = readFileSync(CREDENTIALS_PATH, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function writeCredentials(credentials) {
-    mkdirSync(dirname(CREDENTIALS_PATH), { recursive: true });
-    writeFileSync(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), {
-        mode: 0o600,
-    });
-}
-export function credentialsPath() {
-    return CREDENTIALS_PATH;
-}

package/dist/acp/index.d.ts

@@ -1,2 +0,0 @@
-declare function runAcp(...args: string[]): Promise<void>;
-export default runAcp;

package/dist/acp/index.js

@@ -1,21 +0,0 @@
-import { Readable, Writable } from "node:stream";
-import * as acp from "@agentclientprotocol/sdk";
-import { NovaAgent } from "./agent.js";
-async function runAcp(...args) {
-    const agentImpl = new NovaAgent();
-    const output = Writable.toWeb(process.stdout);
-    const input = Readable.toWeb(process.stdin);
-    const stream = acp.ndJsonStream(output, input);
-    acp
-        .agent({ name: "nova-ai-cli" })
-        .onRequest("initialize", (ctx) => agentImpl.initialize(ctx.params))
-        .onRequest("session/new", (ctx) => agentImpl.newSession(ctx.params))
-        .onRequest("session/load", (ctx) => agentImpl.loadSession(ctx.params, ctx.client))
-        .onRequest("session/list", (ctx) => agentImpl.listSessions(ctx.params))
-        .onRequest("session/close", (ctx) => agentImpl.closeSession(ctx.params))
-        .onRequest("authenticate", (ctx) => agentImpl.authenticate(ctx.params))
-        .onRequest("session/prompt", (ctx) => agentImpl.prompt(ctx.params, ctx.client))
-        .onNotification("session/cancel", (ctx) => agentImpl.cancel(ctx.params))
-        .connect(stream);
-}
-export default runAcp;

package/dist/acp/mcp.d.ts

@@ -1,11 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ToolDefinition } from "./tools/types.js";
-export type McpConnection = {
-    serverName: string;
-    client: Client;
-    close(): Promise<void>;
-};
-export declare function connectMcpServers(servers: acp.McpServer[]): Promise<McpConnection[]>;
-export declare function closeMcpConnections(connections: McpConnection[]): Promise<void>;
-export declare function listMcpTools(connections: McpConnection[]): Promise<ToolDefinition[]>;

package/dist/acp/mcp.js

@@ -1,90 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-const TOOL_NAME_PREFIX = "mcp__";
-function sanitize(name) {
-    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function headersToRecord(headers) {
-    return Object.fromEntries(headers.map((h) => [h.name, h.value]));
-}
-function buildTransport(server) {
-    if ("type" in server && server.type === "http") {
-        return new StreamableHTTPClientTransport(new URL(server.url), {
-            requestInit: { headers: headersToRecord(server.headers) },
-        });
-    }
-    if ("type" in server && server.type === "sse") {
-        return new SSEClientTransport(new URL(server.url), {
-            requestInit: { headers: headersToRecord(server.headers) },
-        });
-    }
-    const stdio = server;
-    return new StdioClientTransport({
-        command: stdio.command,
-        args: stdio.args,
-        env: Object.fromEntries(stdio.env.map((e) => [e.name, e.value])),
-    });
-}
-export async function connectMcpServers(servers) {
-    const connections = [];
-    for (const server of servers) {
-        if ("type" in server && server.type === "acp")
-            continue; // experimental ACP-transport MCP, not yet supported
-        const client = new Client({ name: "nova-ai-cli", version: "1.0.0" });
-        const transport = buildTransport(server);
-        try {
-            await client.connect(transport);
-            connections.push({ serverName: server.name, client, close: () => client.close() });
-        }
-        catch (err) {
-            console.error(`Failed to connect MCP server "${server.name}": ${err.message}`);
-        }
-    }
-    return connections;
-}
-export async function closeMcpConnections(connections) {
-    await Promise.all(connections.map((c) => c.close().catch(() => { })));
-}
-function toToolResult(result) {
-    const text = Array.isArray(result.content)
-        ? result.content
-            .map((block) => {
-            if (typeof block === "object" && block !== null && "type" in block && block.type === "text") {
-                return block.text;
-            }
-            return "";
-        })
-            .filter(Boolean)
-            .join("\n")
-        : "";
-    if (result.isError)
-        return { error: text || "MCP tool call failed." };
-    return { output: text };
-}
-export async function listMcpTools(connections) {
-    const tools = [];
-    for (const connection of connections) {
-        const { tools: serverTools } = await connection.client.listTools();
-        for (const tool of serverTools) {
-            const qualifiedName = `${TOOL_NAME_PREFIX}${sanitize(connection.serverName)}__${sanitize(tool.name)}`;
-            tools.push({
-                name: qualifiedName,
-                description: `${qualifiedName}: ${tool.description ?? tool.name} (from MCP server "${connection.serverName}")`,
-                requiredCapability: () => true,
-                mutating: true,
-                async execute(_ctx, args) {
-                    try {
-                        const result = await connection.client.callTool({ name: tool.name, arguments: args });
-                        return toToolResult(result);
-                    }
-                    catch (err) {
-                        return { error: err.message };
-                    }
-                },
-            });
-        }
-    }
-    return tools;
-}

package/dist/acp/sessions.d.ts

@@ -1,20 +0,0 @@
-import type { ChatMessage } from "@datalabrotterdam/nova-sdk";
-export type StoredSession = {
-    sessionId: string;
-    cwd: string;
-    title: string | null;
-    updatedAt: string;
-    messages: ChatMessage[];
-};
-export declare function loadStoredSession(sessionId: string): StoredSession | null;
-/**
- * Each turn is appended as its own line rather than rewriting the whole
- * session file, so persisting after every prompt stays O(1) instead of
- * O(history length).
- */
-export declare function appendSessionTurn(sessionId: string, header: {
-    cwd: string;
-    title: string | null;
-}, newMessages: ChatMessage[]): void;
-export declare function listStoredSessions(cwd?: string): StoredSession[];
-export declare function deriveTitle(messages: ChatMessage[]): string | null;