@mozaik-ai/core 3.13.1 → 3.14.0

package/README.md

@@ -1,10 +1,10 @@
 # Mozaik
 
-**Mozaik** is TypeScript framework for building reactive agents. It provides the easiest way to build collaborative, **event-driven agents** that can work together in parallel.
+**Mozaik** is a TypeScript framework for building agentic teams. It enables AI agents to work in parallel, stay aware of each other, and collaborate through event-driven communication.
 
 ![npm downloads](https://img.shields.io/npm/dt/@mozaik-ai/core) ![npm downloads weekly](https://img.shields.io/npm/dw/@mozaik-ai/core) ![npm version](https://img.shields.io/npm/v/@mozaik-ai/core)
 
-Mozaik is built for **truly parallel, non-blocking agents**. It enables agents to communicate through semantic events, react to each other’s outputs, run asynchronously, and collaborate without being locked into a single sequential workflow.
+Instead of forcing agents into sequential workflows, Mozaik makes collaboration a first-class concept — creating the foundation for moving from autonomous agents to autonomous teams of AI agents.
 
 ---
 

package/dist/index.d.mts

@@ -269,6 +269,71 @@ interface ModelContextRepository {
     getByProjectId(projectId: string): Promise<ModelContext[]>;
 }
 
+interface McpServerConfig {
+    /** The MCP server URL, e.g. https://api.githubcopilot.com/mcp/ */
+    url: string;
+    /** Bearer token sent as `Authorization: Bearer <token>` (e.g. a GitHub token). */
+    authToken?: string;
+    /** Extra headers merged into every request (overridden by `authToken` for Authorization). */
+    headers?: Record<string, string>;
+    /** Client name reported to the server (defaults to "mozaik"). */
+    name?: string;
+}
+interface McpToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments (maps 1:1 to FunctionTool.parameters). */
+    inputSchema: Record<string, any>;
+}
+/**
+ * A thin wrapper over the MCP TypeScript SDK using the Streamable HTTP transport — what
+ * remote MCP servers (e.g. GitHub's `api.githubcopilot.com/mcp/`) speak. One client per
+ * server; lazily connects on first use. Infrastructure-only: the domain never sees this.
+ */
+declare class McpClient {
+    private readonly config;
+    private readonly client;
+    private readonly transport;
+    private connected;
+    constructor(config: McpServerConfig);
+    connect(): Promise<void>;
+    /** The tools this server exposes. */
+    listTools(): Promise<McpToolSpec[]>;
+    /** Call a tool by name; returns its text output. Throws if the server flags an error. */
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
+}
+
+/** The slice of an MCP client the registry needs — lets tests inject a fake. */
+interface McpClientLike {
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>>;
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
+}
+/**
+ * Connects to one or more MCP servers and exposes their tools as mozaik `FunctionTool`s.
+ * Each tool's `invoke()` proxies the call back to its MCP server. Because they are plain
+ * FunctionTools, every provider mapper and the existing function-call loop handle them
+ * with no changes — MCP support adds no new tool type and touches no provider code.
+ *
+ * `strict` is false: MCP servers publish arbitrary JSON Schemas that won't always satisfy
+ * a provider's strict function-calling mode.
+ */
+declare class McpToolRegistry {
+    private readonly servers;
+    private readonly createClient;
+    private readonly clients;
+    constructor(servers: McpServerConfig[], createClient?: (config: McpServerConfig) => McpClientLike);
+    /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
+    discoverTools(): Promise<FunctionTool[]>;
+    /** Close all underlying MCP connections. */
+    close(): Promise<void>;
+}
+
 declare class InMemoryModelContextRepository implements ModelContextRepository {
     private readonly store;
     private readonly projectIndex;
@@ -290,27 +355,27 @@ declare class SystemMessageItem extends ContextItem {
 }
 
 declare class BaseParticipant extends Participant {
-    onFunctionCall(item: FunctionCallItem): void;
-    onExternalFunctionCall(source: Participant, item: FunctionCallItem): void;
-    onFunctionCallOutput(item: FunctionCallOutputItem): void;
-    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
-    onReasoning(item: ReasoningItem): void;
-    onExternalReasoning(source: Participant, item: ReasoningItem): void;
-    onModelMessage(item: ModelMessageItem): void;
-    onExternalModelMessage(source: Participant, item: ModelMessageItem): void;
-    onMessage(message: string): void;
+    onFunctionCall(_item: FunctionCallItem): void;
+    onExternalFunctionCall(_source: Participant, _item: FunctionCallItem): void;
+    onFunctionCallOutput(_item: FunctionCallOutputItem): void;
+    onExternalFunctionCallOutput(_source: Participant, _item: FunctionCallOutputItem): void;
+    onReasoning(_item: ReasoningItem): void;
+    onExternalReasoning(_source: Participant, _item: ReasoningItem): void;
+    onModelMessage(_item: ModelMessageItem): void;
+    onExternalModelMessage(_source: Participant, _item: ModelMessageItem): void;
+    onMessage(_message: string): void;
     onJoined(): void;
     onLeft(): void;
-    onParticipantJoined(participant: Participant): void;
-    onParticipantLeft(participant: Participant): void;
-    onInternalEvent(item: SemanticEvent<unknown>): void;
-    onExternalEvent(source: Participant, item: SemanticEvent<unknown>): void;
-    onError(error: AgenticError): void;
-    onParticipantError(source: Participant, error: AgenticError): void;
+    onParticipantJoined(_participant: Participant): void;
+    onParticipantLeft(_participant: Participant): void;
+    onInternalEvent(_item: SemanticEvent<unknown>): void;
+    onExternalEvent(_source: Participant, _item: SemanticEvent<unknown>): void;
+    onError(_error: AgenticError): void;
+    onParticipantError(_source: Participant, _error: AgenticError): void;
 }
 
 declare const runInference: (inferenceParams: InferenceParams<ModelName>) => void;
 declare const executeFunctionCall: (environment: AgenticEnvironment, functionCallItem: FunctionCallItem, tool: Tool, caller: Participant) => void;
 declare const sendMessage: (environment: AgenticEnvironment, message: string, caller: Participant) => void;
 
-export { AgenticEnvironment, AgenticError, BaseParticipant, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, InMemoryModelContextRepository, type InferenceParams, InferenceResponse, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };
+export { AgenticEnvironment, AgenticError, BaseParticipant, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, InMemoryModelContextRepository, type InferenceParams, InferenceResponse, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };

package/dist/index.d.ts

@@ -269,6 +269,71 @@ interface ModelContextRepository {
     getByProjectId(projectId: string): Promise<ModelContext[]>;
 }
 
+interface McpServerConfig {
+    /** The MCP server URL, e.g. https://api.githubcopilot.com/mcp/ */
+    url: string;
+    /** Bearer token sent as `Authorization: Bearer <token>` (e.g. a GitHub token). */
+    authToken?: string;
+    /** Extra headers merged into every request (overridden by `authToken` for Authorization). */
+    headers?: Record<string, string>;
+    /** Client name reported to the server (defaults to "mozaik"). */
+    name?: string;
+}
+interface McpToolSpec {
+    name: string;
+    description: string;
+    /** JSON Schema for the tool's arguments (maps 1:1 to FunctionTool.parameters). */
+    inputSchema: Record<string, any>;
+}
+/**
+ * A thin wrapper over the MCP TypeScript SDK using the Streamable HTTP transport — what
+ * remote MCP servers (e.g. GitHub's `api.githubcopilot.com/mcp/`) speak. One client per
+ * server; lazily connects on first use. Infrastructure-only: the domain never sees this.
+ */
+declare class McpClient {
+    private readonly config;
+    private readonly client;
+    private readonly transport;
+    private connected;
+    constructor(config: McpServerConfig);
+    connect(): Promise<void>;
+    /** The tools this server exposes. */
+    listTools(): Promise<McpToolSpec[]>;
+    /** Call a tool by name; returns its text output. Throws if the server flags an error. */
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
+}
+
+/** The slice of an MCP client the registry needs — lets tests inject a fake. */
+interface McpClientLike {
+    listTools(): Promise<Array<{
+        name: string;
+        description: string;
+        inputSchema: Record<string, any>;
+    }>>;
+    callTool(name: string, args: Record<string, any>): Promise<string>;
+    close(): Promise<void>;
+}
+/**
+ * Connects to one or more MCP servers and exposes their tools as mozaik `FunctionTool`s.
+ * Each tool's `invoke()` proxies the call back to its MCP server. Because they are plain
+ * FunctionTools, every provider mapper and the existing function-call loop handle them
+ * with no changes — MCP support adds no new tool type and touches no provider code.
+ *
+ * `strict` is false: MCP servers publish arbitrary JSON Schemas that won't always satisfy
+ * a provider's strict function-calling mode.
+ */
+declare class McpToolRegistry {
+    private readonly servers;
+    private readonly createClient;
+    private readonly clients;
+    constructor(servers: McpServerConfig[], createClient?: (config: McpServerConfig) => McpClientLike);
+    /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
+    discoverTools(): Promise<FunctionTool[]>;
+    /** Close all underlying MCP connections. */
+    close(): Promise<void>;
+}
+
 declare class InMemoryModelContextRepository implements ModelContextRepository {
     private readonly store;
     private readonly projectIndex;
@@ -290,27 +355,27 @@ declare class SystemMessageItem extends ContextItem {
 }
 
 declare class BaseParticipant extends Participant {
-    onFunctionCall(item: FunctionCallItem): void;
-    onExternalFunctionCall(source: Participant, item: FunctionCallItem): void;
-    onFunctionCallOutput(item: FunctionCallOutputItem): void;
-    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
-    onReasoning(item: ReasoningItem): void;
-    onExternalReasoning(source: Participant, item: ReasoningItem): void;
-    onModelMessage(item: ModelMessageItem): void;
-    onExternalModelMessage(source: Participant, item: ModelMessageItem): void;
-    onMessage(message: string): void;
+    onFunctionCall(_item: FunctionCallItem): void;
+    onExternalFunctionCall(_source: Participant, _item: FunctionCallItem): void;
+    onFunctionCallOutput(_item: FunctionCallOutputItem): void;
+    onExternalFunctionCallOutput(_source: Participant, _item: FunctionCallOutputItem): void;
+    onReasoning(_item: ReasoningItem): void;
+    onExternalReasoning(_source: Participant, _item: ReasoningItem): void;
+    onModelMessage(_item: ModelMessageItem): void;
+    onExternalModelMessage(_source: Participant, _item: ModelMessageItem): void;
+    onMessage(_message: string): void;
     onJoined(): void;
     onLeft(): void;
-    onParticipantJoined(participant: Participant): void;
-    onParticipantLeft(participant: Participant): void;
-    onInternalEvent(item: SemanticEvent<unknown>): void;
-    onExternalEvent(source: Participant, item: SemanticEvent<unknown>): void;
-    onError(error: AgenticError): void;
-    onParticipantError(source: Participant, error: AgenticError): void;
+    onParticipantJoined(_participant: Participant): void;
+    onParticipantLeft(_participant: Participant): void;
+    onInternalEvent(_item: SemanticEvent<unknown>): void;
+    onExternalEvent(_source: Participant, _item: SemanticEvent<unknown>): void;
+    onError(_error: AgenticError): void;
+    onParticipantError(_source: Participant, _error: AgenticError): void;
 }
 
 declare const runInference: (inferenceParams: InferenceParams<ModelName>) => void;
 declare const executeFunctionCall: (environment: AgenticEnvironment, functionCallItem: FunctionCallItem, tool: Tool, caller: Participant) => void;
 declare const sendMessage: (environment: AgenticEnvironment, message: string, caller: Participant) => void;
 
-export { AgenticEnvironment, AgenticError, BaseParticipant, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, InMemoryModelContextRepository, type InferenceParams, InferenceResponse, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };
+export { AgenticEnvironment, AgenticError, BaseParticipant, ContextItem, DeveloperMessageItem, type Endpoint, FunctionCallItem, FunctionCallOutputItem, InMemoryModelContextRepository, type InferenceParams, InferenceResponse, InputTokenDetails, McpClient, type McpServerConfig, McpToolRegistry, type McpToolSpec, ModelContext, type ModelContextRepository, ModelMessageItem, type ModelName, OutputTokenDetails, Participant, ReasoningItem, SemanticEvent, type StructuredOutputFormat, SystemMessageItem, TokenUsage, type Tool, UserMessageItem, executeFunctionCall, runInference, sendMessage };

package/dist/index.js

@@ -40,6 +40,8 @@ __export(index_exports, {
   InMemoryModelContextRepository: () => InMemoryModelContextRepository,
   InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
+  McpClient: () => McpClient,
+  McpToolRegistry: () => McpToolRegistry,
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
   OutputTokenDetails: () => OutputTokenDetails,
@@ -261,6 +263,98 @@ var TokenUsage = class {
   }
 };
 
+// src/infrastructure/mcp/mcp-client.ts
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var McpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.connected = false;
+    var _a, _b;
+    const headers = { ...(_a = config.headers) != null ? _a : {} };
+    if (config.authToken) headers.Authorization = `Bearer ${config.authToken}`;
+    this.transport = new import_streamableHttp.StreamableHTTPClientTransport(
+      new URL(config.url),
+      Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0
+    );
+    this.client = new import_client.Client({ name: (_b = config.name) != null ? _b : "mozaik", version: "1.0.0" }, { capabilities: {} });
+  }
+  async connect() {
+    if (this.connected) return;
+    await this.client.connect(this.transport);
+    this.connected = true;
+  }
+  /** The tools this server exposes. */
+  async listTools() {
+    var _a;
+    await this.connect();
+    const res = await this.client.listTools();
+    return ((_a = res.tools) != null ? _a : []).map((t) => {
+      var _a2, _b;
+      return {
+        name: t.name,
+        description: (_a2 = t.description) != null ? _a2 : "",
+        inputSchema: (_b = t.inputSchema) != null ? _b : { type: "object", properties: {} }
+      };
+    });
+  }
+  /** Call a tool by name; returns its text output. Throws if the server flags an error. */
+  async callTool(name, args) {
+    await this.connect();
+    const res = await this.client.callTool({ name, arguments: args != null ? args : {} });
+    const text = extractText(res);
+    if (res.isError) {
+      throw new Error(`MCP tool "${name}" failed: ${text || "unknown error"}`);
+    }
+    return text;
+  }
+  async close() {
+    if (!this.connected) return;
+    try {
+      await this.client.close();
+    } catch (e) {
+    }
+    this.connected = false;
+  }
+};
+function extractText(res) {
+  const content = res.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((c) => (c == null ? void 0 : c.type) === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+}
+
+// src/infrastructure/mcp/mcp-tool-registry.ts
+var McpToolRegistry = class {
+  constructor(servers, createClient = (config) => new McpClient(config)) {
+    this.servers = servers;
+    this.createClient = createClient;
+    this.clients = [];
+  }
+  /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
+  async discoverTools() {
+    const tools = [];
+    for (const server of this.servers) {
+      const client = this.createClient(server);
+      this.clients.push(client);
+      for (const spec of await client.listTools()) {
+        tools.push({
+          type: "function",
+          name: spec.name,
+          description: spec.description,
+          parameters: spec.inputSchema,
+          strict: false,
+          invoke: (args) => client.callTool(spec.name, args != null ? args : {})
+        });
+      }
+    }
+    return tools;
+  }
+  /** Close all underlying MCP connections. */
+  async close() {
+    await Promise.all(this.clients.map((c) => c.close()));
+  }
+};
+
 // src/infrastructure/repository/in-memory-model-context-repository.ts
 var InMemoryModelContextRepository = class {
   constructor() {
@@ -623,39 +717,39 @@ var FunctionCallRunner = class {
 
 // src/application/participants/participant.ts
 var BaseParticipant = class extends Participant {
-  onFunctionCall(item) {
+  onFunctionCall(_item) {
   }
-  onExternalFunctionCall(source, item) {
+  onExternalFunctionCall(_source, _item) {
   }
-  onFunctionCallOutput(item) {
+  onFunctionCallOutput(_item) {
   }
-  onExternalFunctionCallOutput(source, item) {
+  onExternalFunctionCallOutput(_source, _item) {
   }
-  onReasoning(item) {
+  onReasoning(_item) {
   }
-  onExternalReasoning(source, item) {
+  onExternalReasoning(_source, _item) {
   }
-  onModelMessage(item) {
+  onModelMessage(_item) {
   }
-  onExternalModelMessage(source, item) {
+  onExternalModelMessage(_source, _item) {
   }
-  onMessage(message) {
+  onMessage(_message) {
   }
   onJoined() {
   }
   onLeft() {
   }
-  onParticipantJoined(participant) {
+  onParticipantJoined(_participant) {
   }
-  onParticipantLeft(participant) {
+  onParticipantLeft(_participant) {
   }
-  onInternalEvent(item) {
+  onInternalEvent(_item) {
   }
-  onExternalEvent(source, item) {
+  onExternalEvent(_source, _item) {
   }
-  onError(error) {
+  onError(_error) {
   }
-  onParticipantError(source, error) {
+  onParticipantError(_source, _error) {
   }
 };
 
@@ -1816,6 +1910,8 @@ var sendMessage = (environment, message, caller) => {
   InMemoryModelContextRepository,
   InferenceResponse,
   InputTokenDetails,
+  McpClient,
+  McpToolRegistry,
   ModelContext,
   ModelMessageItem,
   OutputTokenDetails,