hoomanjs 1.0.0 → 1.1.0

package/README.md

@@ -174,7 +174,7 @@ hooman acp --toolkit max
 ACP notes:
 
 - ACP sessions are stored under `~/.hooman/acp-sessions`
-- ACP uses Hooman's local `mcp.json`; client-provided MCP servers and client workspace tools are not exposed
+- ACP loads MCP servers passed on `session/new` and `session/load`, in addition to Hooman's local `mcp.json`
 - ACP `session/new` and `session/load` support `_meta.userId` and `_meta.systemPrompt`
 - when `_meta.systemPrompt` is provided, it is appended to the agent system prompt with a section break
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoomanjs",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Bun-powered local AI agent CLI with chat, exec, ACP, MCP, and skills support.",
   "author": {
     "name": "Vaibhav Pandey",

package/src/acp/acp-agent.ts

@@ -42,6 +42,7 @@ import { extractAcpClientUserId } from "./meta/user-id.ts";
 import { deriveSessionTitleFromEcho } from "./sessions/title.ts";
 import { acpPromptEchoText, acpPromptToInvokeArgs } from "./prompt-invoke.ts";
 import type { Config } from "../core/config.ts";
+import { normalizeAcpSessionMcpServers } from "./mcp-servers.ts";
 import {
   listStoredSessionIds,
   loadSessionMessages,
@@ -206,6 +207,10 @@ export class AcpAgent implements AgentContract {
       authMethods: [],
       agentCapabilities: {
         loadSession: true,
+        mcpCapabilities: {
+          http: true,
+          sse: true,
+        },
         promptCapabilities: {
           embeddedContext: true,
           image: true,
@@ -315,6 +320,7 @@ export class AcpAgent implements AgentContract {
     const clientSystemPrompt =
       extractAcpClientSystemPrompt(params._meta) ?? null;
     const bootstrapUserId = clientUserId ?? sessionId;
+    const mcpServers = normalizeAcpSessionMcpServers(params.mcpServers);
 
     const now = new Date().toISOString();
     const meta: SessionMetaFile = {
@@ -324,6 +330,7 @@ export class AcpAgent implements AgentContract {
       title: null,
       userId: clientUserId,
       systemPrompt: clientSystemPrompt,
+      mcpServers,
     };
     await writeSessionMeta(this.#acpRoot, sessionId, meta);
 
@@ -336,6 +343,7 @@ export class AcpAgent implements AgentContract {
         userId: bootstrapUserId,
         sessionId,
         toolkit: this.#toolkit,
+        mcpServers,
         ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
       },
       false,
@@ -419,6 +427,10 @@ export class AcpAgent implements AgentContract {
         ? requestedSystemPrompt
         : storedSystemPrompt;
     const bootstrapUserId = clientUserId ?? params.sessionId;
+    const mcpServers =
+      params.mcpServers.length > 0
+        ? normalizeAcpSessionMcpServers(params.mcpServers)
+        : (existing.mcpServers ?? []);
 
     const {
       config,
@@ -429,6 +441,7 @@ export class AcpAgent implements AgentContract {
         userId: bootstrapUserId,
         sessionId: params.sessionId,
         toolkit: this.#toolkit,
+        mcpServers,
         ...(clientSystemPrompt ? { systemPrompt: clientSystemPrompt } : {}),
       },
       false,
@@ -487,6 +500,7 @@ export class AcpAgent implements AgentContract {
       ...(requestedSystemPrompt !== undefined
         ? { systemPrompt: requestedSystemPrompt || null }
         : {}),
+      mcpServers,
     });
 
     return {

package/src/acp/mcp-servers.ts

@@ -0,0 +1,64 @@
+import { RequestError, type McpServer } from "@agentclientprotocol/sdk";
+import type { NamedMcpTransport } from "../core/mcp/index.ts";
+
+function pairsToRecord(
+  pairs: ReadonlyArray<{ name: string; value: string }>,
+): Record<string, string> | undefined {
+  if (pairs.length === 0) {
+    return undefined;
+  }
+  return Object.fromEntries(pairs.map((pair) => [pair.name, pair.value]));
+}
+
+function toNamedTransport(server: McpServer): NamedMcpTransport {
+  if ("command" in server) {
+    return {
+      name: server.name,
+      transport: {
+        type: "stdio",
+        command: server.command,
+        args: server.args,
+        env: pairsToRecord(server.env),
+      },
+    };
+  }
+  if (server.type === "http") {
+    return {
+      name: server.name,
+      transport: {
+        type: "streamable-http",
+        url: server.url,
+        headers: pairsToRecord(server.headers),
+      },
+    };
+  }
+  return {
+    name: server.name,
+    transport: {
+      type: "sse",
+      url: server.url,
+      headers: pairsToRecord(server.headers),
+    },
+  };
+}
+
+/**
+ * Convert ACP session MCP server definitions into the transport shape used by
+ * Hooman's MCP manager.
+ */
+export function normalizeAcpSessionMcpServers(
+  servers: readonly McpServer[] | null | undefined,
+): NamedMcpTransport[] {
+  const normalized = (servers ?? []).map(toNamedTransport);
+  const seen = new Set<string>();
+  for (const { name } of normalized) {
+    if (seen.has(name)) {
+      throw RequestError.invalidParams({
+        mcpServers: servers,
+        message: `Duplicate ACP MCP server name "${name}" in session request`,
+      });
+    }
+    seen.add(name);
+  }
+  return normalized;
+}

package/src/acp/sessions/store.ts

@@ -2,6 +2,7 @@ import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { SessionInfo } from "@agentclientprotocol/sdk";
 import type { MessageData } from "@strands-agents/sdk";
+import type { NamedMcpTransport } from "../../core/mcp/config.ts";
 
 export type SessionMetaFile = {
   cwd: string;
@@ -12,6 +13,8 @@ export type SessionMetaFile = {
   userId?: string | null;
   /** Session-level system prompt from ACP client `_meta`. */
   systemPrompt?: string | null;
+  /** Session-scoped MCP servers requested by the ACP client. */
+  mcpServers?: NamedMcpTransport[];
 };
 
 const META = "meta.json";

package/src/core/index.ts

@@ -6,6 +6,7 @@ import {
   createMcpManager,
   type Config as McpServersConfig,
   type Manager as McpConnectionManager,
+  type NamedMcpTransport,
 } from "./mcp/index.ts";
 import { createSkillsRegistry } from "./skills/index.ts";
 import type { Registry } from "./skills/index.ts";
@@ -23,6 +24,7 @@ export async function bootstrap(
     userId?: string;
     sessionId: string;
     systemPrompt?: string;
+    mcpServers?: NamedMcpTransport[];
     toolkit?: Toolkit;
   },
   print: boolean = false,
@@ -34,7 +36,7 @@ export async function bootstrap(
 }> {
   const config = new Config(configJsonPath());
   const mcpConfig = createMcpConfig(mcpJsonPath());
-  const mcpManager = createMcpManager(mcpConfig);
+  const mcpManager = createMcpManager(mcpConfig, meta.mcpServers ?? []);
   const mcp = { config: mcpConfig, manager: mcpManager };
   const registry = createSkillsRegistry(basePath());
   const toolkit = meta.toolkit ?? "max";

package/src/core/mcp/index.ts

@@ -1,13 +1,17 @@
-import { Config } from "./config.ts";
+import { Config, type NamedMcpTransport } from "./config.ts";
 import { Manager } from "./manager.ts";
 
 export { Config, Manager };
+export type { NamedMcpTransport };
 export { createMcpTools } from "./tools.ts";
 
 export function createMcpConfig(path: string): Config {
   return new Config(path);
 }
 
-export function createMcpManager(config: Config): Manager {
-  return new Manager(config);
+export function createMcpManager(
+  config: Config,
+  mcpServers: readonly NamedMcpTransport[] = [],
+): Manager {
+  return new Manager(config, mcpServers);
 }

package/src/core/mcp/manager.ts

@@ -4,7 +4,7 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { Config } from "./config.ts";
+import { Config, type NamedMcpTransport } from "./config.ts";
 import type { McpTransport } from "./types.ts";
 
 function transportFor(spec: McpTransport): Transport {
@@ -43,7 +43,10 @@ function transportFor(spec: McpTransport): Transport {
 export class Manager {
   private instances: Map<string, McpClient> | null = null;
 
-  public constructor(private readonly config: Config) {}
+  public constructor(
+    private readonly config: Config,
+    private readonly mcpServers: readonly NamedMcpTransport[] = [],
+  ) {}
 
   /** Lazily builds clients from the current in-memory config (reloads file first). */
   get clients(): ReadonlyMap<string, McpClient> {
@@ -61,7 +64,12 @@ export class Manager {
     this.config.reload();
     const previous = this.instances;
     const next = new Map<string, McpClient>();
-    for (const { name, transport } of this.config.list()) {
+    const transports = [
+      ...this.config.list(),
+      // Session-scoped ACP servers intentionally override local config names.
+      ...this.mcpServers,
+    ];
+    for (const { name, transport } of transports) {
       next.set(
         name,
         new McpClient({