@mozaik-ai/core 3.8.0 → 3.8.3

package/README.md

@@ -4,7 +4,7 @@
 
 ![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)
 
-In Mozaik, humans, agents, observers, and tools are all `Participant`s of the same `AgenticEnvironment`. Each participant runs **non-blocking** and produces typed events — function calls, function call outputs, reasoning, model messages, and plain-text messages — into the environment. Every other participant sees those events in real time and can react, intercept, or stay silent — without any central scheduler.
+In Mozaik, humans, agents, observers, and tools are all `Participant`s of the same `AgenticEnvironment`. Each participant runs **non-blocking** and produces events into the environment: plain-text **messages** for conversational input/output, and typed `ContextItem`s for model internals (function calls, function call outputs, reasoning, model messages). Every other participant sees those events in real time and can react, intercept, or stay silent — without any central scheduler.
 
 ---
 
@@ -27,13 +27,13 @@ OPENAI_API_KEY=your-openai-key-here
 
 `AgenticEnvironment` is a broadcast bus for typed events. `Participant`s `join()` it, and anything produced by one participant is delivered to every subscriber through a **dedicated typed callback** — one per event kind, with separate handlers for items the participant emitted itself versus items emitted by someone else:
 
-| Producer call                            | Self handler            | External handler                          |
-| ---------------------------------------- | ----------------------- | ----------------------------------------- |
-| `deliverFunctionCall(source, item)`      | `onFunctionCall`        | `onExternalFunctionCall(source, …)`       |
-| `deliverFunctionCallOutput(source, item)`| `onFunctionCallOutput`  | `onExternalFunctionCallOutput(source, …)` |
-| `deliverReasoning(source, item)`         | `onReasoning`           | `onExternalReasoning(source, …)`          |
-| `deliverModelMessage(source, item)`      | `onModelMessage`        | `onExternalModelMessage(source, …)`       |
-| `deliverMessage(source, message)`        | _(not delivered)_       | `onMessage(message)`                      |
+| Producer call                             | Self handler           | External handler                          |
+| ----------------------------------------- | ---------------------- | ----------------------------------------- |
+| `deliverFunctionCall(source, item)`       | `onFunctionCall`       | `onExternalFunctionCall(source, …)`       |
+| `deliverFunctionCallOutput(source, item)` | `onFunctionCallOutput` | `onExternalFunctionCallOutput(source, …)` |
+| `deliverReasoning(source, item)`          | `onReasoning`          | `onExternalReasoning(source, …)`          |
+| `deliverModelMessage(source, item)`       | `onModelMessage`       | `onExternalModelMessage(source, …)`       |
+| `deliverMessage(source, message)`         | _(not delivered)_      | `onMessage(message)`                      |
 
 Messages are plain `string`s exchanged between participants. Every other event flows as a typed `ContextItem` (`FunctionCallItem`, `FunctionCallOutputItem`, `ReasoningItem`, `ModelMessageItem`).
 
@@ -53,37 +53,10 @@ flowchart LR
 
 Mozaik ships two ready-to-use participants:
 
-| Participant            | Capabilities                                              | Pulls from                                            |
-| ---------------------- | --------------------------------------------------------- | ----------------------------------------------------- |
-| `BaseHumanParticipant` | `InputCapable`                                            | `InputStream`                                         |
-| `BaseAgentParticipant` | `InputCapable`, `InferenceCapable`, `FunctionCallCapable` | `InputStream`, `InferenceRunner`, `FunctionCallRunner`|
-
-Each capability method is **non-blocking**: it returns `Promise<void>`, and as the underlying generator yields, items are streamed into the environment one-by-one through the matching typed `deliverX` method. For example, `runInference` dispatches each yielded item to `deliverReasoning`, `deliverFunctionCall`, or `deliverModelMessage`:
-
-```81:100:src/application/agent.ts
-	async runInference(
-		environment: AgenticEnvironment,
-		context: ModelContext,
-		model: GenerativeModel,
-		signal?: AbortSignal,
-	): Promise<void> {
-		if (!this.isJoinedTo(environment)) return
-
-		const stream = this.inferenceRunner.run(context, model, signal)
-
-		for await (const item of stream) {
-			if (item.type === "reasoning") {
-				await environment.deliverReasoning(this, item)
-			} else if (item.type === "function_call") {
-				await environment.deliverFunctionCall(this, item)
-			} else if (item.type === "message" && item.role === "assistant") {
-				await environment.deliverModelMessage(this, item)
-			}
-		}
-	}
-```
-
-Because each call is a fresh promise that wraps an async iterable, multiple participants can act on the same environment **concurrently**:
+| Participant            | Capabilities                                              | Pulls from                                             |
+| ---------------------- | --------------------------------------------------------- | ------------------------------------------------------ |
+| `BaseHumanParticipant` | `InputCapable`                                            | `InputStream`                                          |
+| `BaseAgentParticipant` | `InputCapable`, `InferenceCapable`, `FunctionCallCapable` | `InputStream`, `InferenceRunner`, `FunctionCallRunner` |
 
 ```ts
 import {
@@ -124,28 +97,6 @@ Instead of a single catch-all callback, `Participant` exposes **one typed handle
 - **React** to its own outputs via the self handlers (e.g. execute a `FunctionCallItem` it just produced), or to others' outputs via the external handlers.
 - **Ignore** events it doesn't care about — every handler defaults to a no-op in the bundled participants.
 
-The intercept surface, taken from `Participant`:
-
-```38:54:src/domain/agentic-environment/participant.ts
-	abstract onFunctionCall(item: FunctionCallItem): Promise<void>
-
-	abstract onExternalFunctionCall(source: Participant, item: FunctionCallItem): Promise<void>
-
-	abstract onFunctionCallOutput(item: FunctionCallOutputItem): Promise<void>
-
-	abstract onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): Promise<void>
-
-	abstract onReasoning(item: ReasoningItem): Promise<void>
-
-	abstract onExternalReasoning(source: Participant, item: ReasoningItem): Promise<void>
-
-	abstract onModelMessage(item: ModelMessageItem): Promise<void>
-
-	abstract onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void>
-
-	abstract onMessage(message: string): Promise<void>
-```
-
 The typed `ContextItem`s involved are defined in [src/domain/model-context/context-item](src/domain/model-context/context-item):
 
 - Client-produced: `FunctionCallOutputItem` (and `UserMessageItem` / `DeveloperMessageItem` / `SystemMessageItem` when building a `ModelContext` directly)
@@ -158,13 +109,7 @@ Plain conversational input flows as a `string` through `onMessage` — participa
 A passive observer subclasses `Participant` and overrides only the handlers it cares about:
 
 ```ts
-import {
-	Participant,
-	FunctionCallItem,
-	FunctionCallOutputItem,
-	ReasoningItem,
-	ModelMessageItem,
-} from "@mozaik-ai/core"
+import { Participant, FunctionCallItem, FunctionCallOutputItem, ReasoningItem, ModelMessageItem } from "@mozaik-ai/core"
 
 export class TranscriptLogger extends Participant {
 	async onMessage(message: string): Promise<void> {
@@ -296,7 +241,15 @@ const response = await runtime.infer(new InferenceRequest(new Gpt54(), context))
 
 ### Custom `InputStream`
 
-An `InputStream` yields plain `string` messages, which are then broadcast to every other participant through `onMessage`:
+An `InputStream` is the minimal text-source contract a participant uses to feed messages into the environment:
+
+```ts
+export interface InputStream {
+	stream(signal?: AbortSignal): AsyncIterable<string>
+}
+```
+
+Each yielded string is delivered to every other participant through `onMessage(message: string)`. This keeps the wire format dead simple: participants exchange text, and each one decides how to turn that text into a `ContextItem` for its own `ModelContext`.
 
 ```ts
 import { InputStream } from "@mozaik-ai/core"
@@ -322,7 +275,7 @@ export class QueueInputStream implements InputStream {
 }
 ```
 
-Use it for stdin, websockets, an HTTP queue, or anything that produces messages over time. Participants decide for themselves what to do with the string — e.g. wrap it in a `UserMessageItem` before adding it to a `ModelContext`.
+Use it for stdin, websockets, an HTTP queue, or anything that produces text over time. A reactive agent typically wraps the incoming string in a `UserMessageItem` inside `onMessage` before adding it to its `ModelContext` — see the [Reactive agent](#reactive-agent) example above.
 
 ### Custom `InferenceRunner`
 
@@ -394,6 +347,12 @@ You now own input, inference, and tool execution end-to-end while keeping the sa
 
 ---
 
+## Made with Mozaik
+
+- **[baro](https://github.com/Lotus015/baro)** — a Claude agent orchestrator where ten specialized participants (planner, executors, reviewer, fixer, librarian, auditor, and more) work fully concurrently on the same goal, like a team collaborating in real time instead of a single agent doing everything alone.
+
+---
+
 ## Author & License
 
 Created by the [JigJoy](https://jigjoy.io) team.  

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mozaik-ai/core",
-	"version": "3.8.0",
+	"version": "3.8.3",
 	"description": "A TypeScript framework for building reactive agents",
 	"main": "dist/index.js",
 	"module": "dist/index.mjs",