@mozaik-ai/core 3.6.6 → 3.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JigJoy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,10 @@
 # Mozaik
 
-**Mozaik** is an open-source TypeScript framework for building AI agents that share an **agentic environment** instead of being orchestrated through rigid pipelines.
+**Mozaik** is an open-source TypeScript framework for building reactive AI agents that share an **agentic environment** instead of being orchestrated through rigid workflows.
 
-In Mozaik, humans, agents, observers, and tools are all `Participant`s of the same `AgenticEnvironment`. Each participant runs **non-blocking** and streams typed `ContextItem`s into the environment. Every other participant sees those items in real time and can react, intercept, or stay silent — without any central scheduler.
+![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.
 
 ---
 
@@ -23,16 +25,26 @@ OPENAI_API_KEY=your-openai-key-here
 
 ## The agentic environment
 
-`AgenticEnvironment` is a broadcast bus for typed context items. `Participant`s `join()` it, and any item produced by one participant is delivered to every subscriber's `onContextItem(source, item)` callback.
+`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)`                      |
+
+Messages are plain `string`s exchanged between participants. Every other event flows as a typed `ContextItem` (`FunctionCallItem`, `FunctionCallOutputItem`, `ReasoningItem`, `ModelMessageItem`).
 
 ```mermaid
 flowchart LR
     Human[BaseHumanParticipant] -->|streamInput| Env(("AgenticEnvironment"))
     Agent[BaseAgentParticipant] -->|"runInference / executeFunctionCall"| Env
     Observer[Custom Participant] -->|join| Env
-    Env -->|onContextItem| Human
-    Env -->|onContextItem| Agent
-    Env -->|onContextItem| Observer
+    Env -->|"onMessage / onExternal*"| Human
+    Env -->|"onFunctionCall / onReasoning / …"| Agent
+    Env -->|"onExternal*"| Observer
 ```
 
 ---
@@ -41,35 +53,45 @@ flowchart LR
 
 Mozaik ships two ready-to-use participants:
 
-| Participant | Capabilities | Pulls from |
-| --- | --- | --- |
-| `BaseHumanParticipant` | `InputCapable` | `InputItemSource` |
-| `BaseAgentParticipant` | `InputCapable`, `InferenceCapable`, `FunctionCallCapable` | `InputItemSource`, `InferenceRunner`, `FunctionCallRunner` |
-
-Each capability method is **non-blocking**: it returns `Promise<void>`, and as the underlying generator yields items they are streamed into the environment one-by-one through the `deliverStream` helper:
-
-```5:14:src/application/deliver-stream.ts
-export async function deliverStream<T extends ContextItem>(
-    environment: AgenticEnvironment,
-    initiator: Participant,
-    stream: AsyncIterable<T>,
-  ): Promise<void> {
-
-    for await (const item of stream) {
-        await environment.deliverContextItem(initiator, item);
-    }
-}
+| 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**:
 
 ```ts
 import {
-    AgenticEnvironment,
-    BaseAgentParticipant,
-    BaseHumanParticipant,
-    Gpt54Mini,
-    ModelContext,
+	AgenticEnvironment,
+	BaseAgentParticipant,
+	BaseHumanParticipant,
+	Gpt54Mini,
+	ModelContext,
 } from "@mozaik-ai/core"
 
 const environment = new AgenticEnvironment()
@@ -94,84 +116,149 @@ The environment fans every item out to every subscriber synchronously and withou
 
 ---
 
-## Intercepting items from other participants
+## Intercepting events from other participants
+
+Instead of a single catch-all callback, `Participant` exposes **one typed handler per event kind**, with a clear split between events the participant emitted itself and events emitted by someone else. A participant can:
+
+- **Observe** events from other participants via the `onExternal*` family (telemetry, audit, UI streaming) and `onMessage` for plain-text messages.
+- **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>
 
-`onContextItem(source, item)` is the single intercept point. A participant can:
+	abstract onModelMessage(item: ModelMessageItem): Promise<void>
 
-- **Observe** items from other participants (telemetry, audit, UI streaming).
-- **React** to items by triggering its own capabilities (turn a `UserMessageItem` into an inference run, turn a `FunctionCallItem` into a tool execution).
-- **Ignore** items it doesn't care about — it is just a method call.
+	abstract onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void>
 
-Items are discriminated by the `ContextItem` subclass and, for messages, the `role` field. The full taxonomy is in [src/domain/model-context/context-item](src/domain/model-context/context-item):
+	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: `UserMessageItem`, `DeveloperMessageItem`, `SystemMessageItem`, `FunctionCallOutputItem`
+- Client-produced: `FunctionCallOutputItem` (and `UserMessageItem` / `DeveloperMessageItem` / `SystemMessageItem` when building a `ModelContext` directly)
 - Model-produced: `ModelMessageItem`, `FunctionCallItem`, `ReasoningItem`
 
+Plain conversational input flows as a `string` through `onMessage` — participants exchange messages without committing to a specific `ContextItem` shape on the wire.
+
 ### Passive observer
 
+A passive observer subclasses `Participant` and overrides only the handlers it cares about:
+
 ```ts
-import { Participant, ContextItem } from "@mozaik-ai/core"
+import {
+	Participant,
+	FunctionCallItem,
+	FunctionCallOutputItem,
+	ReasoningItem,
+	ModelMessageItem,
+} from "@mozaik-ai/core"
 
 export class TranscriptLogger extends Participant {
-    async onContextItem(source: Participant, item: ContextItem): Promise<void> {
-        console.log(`[${source.constructor.name}]`, item.toJSON())
-    }
+	async onMessage(message: string): Promise<void> {
+		console.log("[message]", message)
+	}
+
+	async onExternalFunctionCall(source: Participant, item: FunctionCallItem): Promise<void> {
+		console.log(`[${source.constructor.name}] function_call`, item.toJSON())
+	}
+
+	async onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): Promise<void> {
+		console.log(`[${source.constructor.name}] function_call_output`, item.toJSON())
+	}
+
+	async onExternalReasoning(source: Participant, item: ReasoningItem): Promise<void> {
+		console.log(`[${source.constructor.name}] reasoning`, item.toJSON())
+	}
+
+	async onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void> {
+		console.log(`[${source.constructor.name}] model_message`, item.toJSON())
+	}
+
+	// Self-emitted handlers (onFunctionCall, onReasoning, …) can be no-ops for a pure observer.
+	async onFunctionCall(): Promise<void> {}
+	async onFunctionCallOutput(): Promise<void> {}
+	async onReasoning(): Promise<void> {}
+	async onModelMessage(): Promise<void> {}
 }
 ```
 
 ### Reactive agent
 
-A reactive agent extends `BaseAgentParticipant` and uses incoming items from *other* participants to decide when to run inference or execute a tool call:
+A reactive agent extends `BaseAgentParticipant` and overrides the handlers it wants to react on. Each handler is already a no-op in the base class, so only the relevant ones need bodies:
 
 ```ts
 import {
-    BaseAgentParticipant,
-    Participant,
-    ContextItem,
-    UserMessageItem,
-    FunctionCallItem,
-    AgenticEnvironment,
-    ModelContext,
-    GenerativeModel,
-    InputItemSource,
-    InferenceRunner,
-    FunctionCallRunner,
+	BaseAgentParticipant,
+	Participant,
+	UserMessageItem,
+	FunctionCallItem,
+	AgenticEnvironment,
+	ModelContext,
+	GenerativeModel,
+	InputStream,
+	InferenceRunner,
+	FunctionCallRunner,
 } from "@mozaik-ai/core"
 
 export class ReactiveAgent extends BaseAgentParticipant {
-    constructor(
-        inputSource: InputItemSource,
-        inferenceRunner: InferenceRunner,
-        functionCallRunner: FunctionCallRunner,
-        private readonly environment: AgenticEnvironment,
-        private readonly context: ModelContext,
-        private readonly model: GenerativeModel,
-    ) {
-        super(inputSource, inferenceRunner, functionCallRunner)
-    }
-
-    async onContextItem(source: Participant, item: ContextItem): Promise<void> {
-        if (source === this) return
-
-        this.context.addContextItem(item)
-
-        if (item instanceof UserMessageItem) {
-            this.runInference(this.environment, this.context, this.model)
-            return
-        }
-
-        if (item instanceof FunctionCallItem) {
-            this.executeFunctionCall(this.environment, item)
-            return
-        }
-    }
+	constructor(
+		inputSource: InputStream,
+		inferenceRunner: InferenceRunner,
+		functionCallRunner: FunctionCallRunner,
+		private readonly environment: AgenticEnvironment,
+		private readonly context: ModelContext,
+		private readonly model: GenerativeModel,
+	) {
+		super(inputSource, inferenceRunner, functionCallRunner)
+	}
+
+	// A message from a human (or any other participant) → record it and think.
+	async onMessage(message: string): Promise<void> {
+		this.context.addContextItem(UserMessageItem.create(message))
+		this.runInference(this.environment, this.context, this.model)
+	}
+
+	// The agent just produced a function call → execute it.
+	async onFunctionCall(item: FunctionCallItem): Promise<void> {
+		this.context.addContextItem(item)
+		this.executeFunctionCall(this.environment, item)
+	}
+
+	// The tool just produced an output → feed it back and run inference again.
+	async onFunctionCallOutput(item: FunctionCallOutputItem): Promise<void> {
+		this.context.addContextItem(item)
+		this.runInference(this.environment, this.context, this.model)
+	}
+
+	// Keep the local context in sync with model-emitted reasoning and replies.
+	async onReasoning(item: ReasoningItem): Promise<void> {
+		this.context.addContextItem(item)
+	}
+
+	async onModelMessage(item: ModelMessageItem): Promise<void> {
+		this.context.addContextItem(item)
+	}
 }
 ```
 
-Two things to note:
+Three things to note:
 
-1. The agent never `await`s its own capability calls inside `onContextItem` — the methods are non-blocking, so the environment keeps delivering items while inference and tool execution run in the background.
-2. Behaviors compose by **reaction**, not orchestration. Add a second agent that listens for `ModelMessageItem`s and you get a critique loop. Add a `TranscriptLogger` and you get a UI stream. Neither change touches the existing participants.
+1. The split between self handlers and `onExternal*` handlers means a participant can encode "act on my own outputs" separately from "observe others", without inspecting `source` by hand.
+2. The agent never `await`s its own capability calls inside the handlers — those methods are non-blocking, so the environment keeps delivering events while inference and tool execution run in the background.
+3. Behaviors compose by **reaction**, not orchestration. Add a second agent that overrides `onExternalModelMessage` and you get a critique loop. Add a `TranscriptLogger` and you get a UI stream. Neither change touches the existing participants.
 
 ---
 
@@ -180,16 +267,11 @@ Two things to note:
 `ModelContext` is the ordered list of `ContextItem`s a `GenerativeModel` is asked to reason over. It is constructed and mutated explicitly — typically inside a participant in response to delivered items.
 
 ```ts
-import {
-    ModelContext,
-    DeveloperMessageItem,
-    UserMessageItem,
-    InMemoryModelContextRepository,
-} from "@mozaik-ai/core"
+import { ModelContext, DeveloperMessageItem, UserMessageItem, InMemoryModelContextRepository } from "@mozaik-ai/core"
 
 const context = ModelContext.create("project-id")
-    .addContextItem(DeveloperMessageItem.create("You are a helpful assistant."))
-    .addContextItem(UserMessageItem.create("What is the capital of France?"))
+	.addContextItem(DeveloperMessageItem.create("You are a helpful assistant."))
+	.addContextItem(UserMessageItem.create("What is the capital of France?"))
 
 const repo = new InMemoryModelContextRepository()
 await repo.save(context)
@@ -197,7 +279,7 @@ await repo.save(context)
 
 Implement `ModelContextRepository` to plug in any storage backend.
 
-The default OpenAI provider is `OpenAIResponses`, implementing the [OpenResponses](https://www.openresponses.org/) spec. It maps `ModelContext` to the OpenAI Responses API and back into typed `ContextItem`s. Bundled models: `Gpt54`, `Gpt54Mini`, `Gpt54Nano`.
+The default OpenAI provider is `OpenAIResponses`, implementing the [OpenResponses](https://www.openresponses.org/) spec. It maps `ModelContext` to the OpenAI Responses API and back into typed `ContextItem`s. Bundled models: `Gpt54`, `Gpt54Mini`, `Gpt54Nano`, `Gpt55`.
 
 ```ts
 import { OpenAIResponses, InferenceRequest, Gpt54 } from "@mozaik-ai/core"
@@ -210,42 +292,37 @@ const response = await runtime.infer(new InferenceRequest(new Gpt54(), context))
 
 ## Advanced: overriding generators
 
-`BaseAgentParticipant` and `BaseHumanParticipant` are deliberately thin shells around three generator interfaces. Swap any of them to change *how* items are produced without touching the environment, the participants, or any consumers.
+`BaseAgentParticipant` and `BaseHumanParticipant` are deliberately thin shells around three generator interfaces. Swap any of them to change _how_ events are produced without touching the environment, the participants, or any consumers.
 
-### Custom `InputItemSource`
+### Custom `InputStream`
 
-```ts
-import {
-    InputItemSource,
-    UserMessageItem,
-    DeveloperMessageItem,
-    SystemMessageItem,
-} from "@mozaik-ai/core"
+An `InputStream` yields plain `string` messages, which are then broadcast to every other participant through `onMessage`:
 
-type InputItem = UserMessageItem | DeveloperMessageItem | SystemMessageItem
-
-export class QueueInputSource implements InputItemSource {
-    private readonly queue: InputItem[] = []
-    private resolveNext?: () => void
-
-    push(item: InputItem) {
-        this.queue.push(item)
-        this.resolveNext?.()
-        this.resolveNext = undefined
-    }
-
-    async *stream(signal?: AbortSignal): AsyncIterable<InputItem> {
-        while (!signal?.aborted) {
-            while (this.queue.length > 0) {
-                yield this.queue.shift()!
-            }
-            await new Promise<void>((resolve) => (this.resolveNext = resolve))
-        }
-    }
+```ts
+import { InputStream } from "@mozaik-ai/core"
+
+export class QueueInputStream implements InputStream {
+	private readonly queue: string[] = []
+	private resolveNext?: () => void
+
+	push(message: string) {
+		this.queue.push(message)
+		this.resolveNext?.()
+		this.resolveNext = undefined
+	}
+
+	async *stream(signal?: AbortSignal): AsyncIterable<string> {
+		while (!signal?.aborted) {
+			while (this.queue.length > 0) {
+				yield this.queue.shift()!
+			}
+			await new Promise<void>((resolve) => (this.resolveNext = resolve))
+		}
+	}
 }
 ```
 
-Use it for stdin, websockets, an HTTP queue, or anything that produces user/developer/system messages over time.
+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`.
 
 ### Custom `InferenceRunner`
 
@@ -253,31 +330,27 @@ Wrap any model runtime — including `OpenAIResponses` — and decide how its ou
 
 ```ts
 import {
-    InferenceRunner,
-    InferenceRequest,
-    ModelContext,
-    GenerativeModel,
-    OpenAIResponses,
-    ReasoningItem,
-    FunctionCallItem,
-    ModelMessageItem,
+	InferenceRunner,
+	InferenceRequest,
+	ModelContext,
+	GenerativeModel,
+	OpenAIResponses,
+	ReasoningItem,
+	FunctionCallItem,
+	ModelMessageItem,
 } from "@mozaik-ai/core"
 
 type InferenceItem = ReasoningItem | FunctionCallItem | ModelMessageItem
 
 export class OpenAIInferenceRunner implements InferenceRunner {
-    private readonly runtime = new OpenAIResponses()
-
-    async *run(
-        context: ModelContext,
-        model: GenerativeModel,
-        signal?: AbortSignal,
-    ): AsyncIterable<InferenceItem> {
-        const response = await this.runtime.infer(new InferenceRequest(model, context))
-        for (const item of response.contextItems) {
-            yield item as InferenceItem
-        }
-    }
+	private readonly runtime = new OpenAIResponses()
+
+	async *run(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<InferenceItem> {
+		const response = await this.runtime.infer(new InferenceRequest(model, context))
+		for (const item of response.contextItems) {
+			yield item as InferenceItem
+		}
+	}
 }
 ```
 
@@ -288,26 +361,18 @@ Replace the body with a streaming runtime and items will flow into the environme
 Resolve a `FunctionCallItem` against a tool registry and yield its output:
 
 ```ts
-import {
-    FunctionCallRunner,
-    FunctionCallItem,
-    FunctionCallOutputItem,
-    Tool,
-} from "@mozaik-ai/core"
+import { FunctionCallRunner, FunctionCallItem, FunctionCallOutputItem, Tool } from "@mozaik-ai/core"
 
 export class ToolRegistryFunctionCallRunner implements FunctionCallRunner {
-    constructor(private readonly tools: Tool[]) {}
-
-    async *run(
-        call: FunctionCallItem,
-        signal?: AbortSignal,
-    ): AsyncIterable<FunctionCallOutputItem> {
-        const tool = this.tools.find((t) => t.name === call.name)
-        if (!tool) throw new Error(`Unknown tool: ${call.name}`)
-
-        const result = await tool.invoke(JSON.parse(call.args))
-        yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result))
-    }
+	constructor(private readonly tools: Tool[]) {}
+
+	async *run(call: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem> {
+		const tool = this.tools.find((t) => t.name === call.name)
+		if (!tool) throw new Error(`Unknown tool: ${call.name}`)
+
+		const result = await tool.invoke(JSON.parse(call.args))
+		yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result))
+	}
 }
 ```
 
@@ -317,9 +382,9 @@ export class ToolRegistryFunctionCallRunner implements FunctionCallRunner {
 import { BaseAgentParticipant, AgenticEnvironment } from "@mozaik-ai/core"
 
 const agent = new BaseAgentParticipant(
-    new QueueInputSource(),
-    new OpenAIInferenceRunner(),
-    new ToolRegistryFunctionCallRunner(tools),
+	new QueueInputStream(),
+	new OpenAIInferenceRunner(),
+	new ToolRegistryFunctionCallRunner(tools),
 )
 
 agent.join(new AgenticEnvironment())

package/dist/index.d.mts

@@ -298,7 +298,11 @@ declare class AgenticEnvironment {
     private isActive;
     subscribe(subscriber: Participant): void;
     unsubscribe(user: Participant): void;
-    deliverContextItem(source: Participant, item: ContextItem): void;
+    deliverFunctionCall(source: Participant, item: FunctionCallItem): void;
+    deliverModelMessage(source: Participant, item: ModelMessageItem): void;
+    deliverReasoning(source: Participant, item: ReasoningItem): void;
+    deliverFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): void;
+    deliverMessage(source: Participant, message: string): void;
     start(): Promise<void>;
     stop(): void;
 }
@@ -309,7 +313,15 @@ declare abstract class Participant {
     leave(environment: AgenticEnvironment): void;
     protected isJoinedTo(environment: AgenticEnvironment): boolean;
     getEnvironments(): AgenticEnvironment[];
-    abstract onContextItem(source: Participant, item: ContextItem): Promise<void>;
+    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>;
 }
 
 interface InputCapable {
@@ -330,16 +342,25 @@ interface FunctionCallRunner {
     run(functionCallItem: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
 }
 
-interface InputItemSource {
-    stream(signal?: AbortSignal): AsyncIterable<UserMessageItem | DeveloperMessageItem | SystemMessageItem>;
+interface InputStream {
+    stream(signal?: AbortSignal): AsyncIterable<string>;
 }
 
 declare class BaseAgentParticipant extends Participant implements InputCapable, InferenceCapable, FunctionCallCapable {
     private inputSource;
     private inferenceRunner;
     private functionCallRunner;
-    constructor(inputSource: InputItemSource, inferenceRunner: InferenceRunner, functionCallRunner: FunctionCallRunner);
-    onContextItem(source: Participant, item: ContextItem): Promise<void>;
+    constructor(inputSource: InputStream, inferenceRunner: InferenceRunner, functionCallRunner: FunctionCallRunner);
+    onInternalContextItem(item: ContextItem): Promise<void>;
+    onFunctionCall(item: FunctionCallItem): Promise<void>;
+    onExternalFunctionCall(source: Participant, item: FunctionCallItem): Promise<void>;
+    onFunctionCallOutput(item: FunctionCallOutputItem): Promise<void>;
+    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): Promise<void>;
+    onReasoning(item: ReasoningItem): Promise<void>;
+    onExternalReasoning(source: Participant, item: ReasoningItem): Promise<void>;
+    onModelMessage(item: ModelMessageItem): Promise<void>;
+    onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void>;
+    onMessage(message: string): Promise<void>;
     executeFunctionCall(environment: AgenticEnvironment, functionCallItem: FunctionCallItem, signal?: AbortSignal): Promise<void>;
     runInference(environment: AgenticEnvironment, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
     streamInput(environment: AgenticEnvironment): Promise<void>;
@@ -347,8 +368,17 @@ declare class BaseAgentParticipant extends Participant implements InputCapable,
 
 declare class BaseHumanParticipant extends Participant implements InputCapable {
     private inputSource;
-    constructor(inputSource: InputItemSource);
+    constructor(inputSource: InputStream);
+    onFunctionCall(item: FunctionCallItem): Promise<void>;
+    onExternalFunctionCall(source: Participant, item: FunctionCallItem): Promise<void>;
     onContextItem(source: Participant, item: ContextItem): Promise<void>;
+    onFunctionCallOutput(item: FunctionCallOutputItem): Promise<void>;
+    onExternalFunctionCallOutput(source: Participant, item: FunctionCallOutputItem): Promise<void>;
+    onReasoning(item: ReasoningItem): Promise<void>;
+    onExternalReasoning(source: Participant, item: ReasoningItem): Promise<void>;
+    onModelMessage(item: ModelMessageItem): Promise<void>;
+    onExternalModelMessage(source: Participant, item: ModelMessageItem): Promise<void>;
+    onMessage(message: string): Promise<void>;
     streamInput(environment: AgenticEnvironment): Promise<void>;
 }
 
@@ -364,4 +394,22 @@ declare class DefaultFunctionCallRunner implements FunctionCallRunner {
     run(call: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
 }
 
-export { AgenticEnvironment, BaseAgentParticipant, BaseHumanParticipant, ContextItem, DefaultFunctionCallRunner, DeveloperMessageItem, FunctionCallItem, FunctionCallOutputItem, type FunctionCallRunner, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, InMemoryModelContextRepository, InferenceRequest, InferenceResponse, type InferenceRunner, type InputItemSource, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIInferenceRunner, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, SystemMessageItem, TokenUsage, type Tool, UserMessageItem };
+declare class Gpt55 implements GenerativeModel, ReasoningEffort<OpenAIReasoningEffortType>, ToolCallingCapability {
+    readonly specification: {
+        name: string;
+        supportReasoningEffort: boolean;
+        defaultReasoningEffort: OpenAIReasoningEffortType;
+        supportStreaming: boolean;
+        contextWindowSize: number;
+        maxOutputTokens: number;
+        supportFunctionCalling: boolean;
+    };
+    private tools;
+    setTools(tools: Tool[]): void;
+    getTools(): Tool[];
+    private readonly effort;
+    setReasoningEffort(effort: OpenAIReasoningEffortType): void;
+    getReasoningEffort(): OpenAIReasoningEffortType;
+}
+
+export { AgenticEnvironment, BaseAgentParticipant, BaseHumanParticipant, ContextItem, DefaultFunctionCallRunner, DeveloperMessageItem, FunctionCallItem, FunctionCallOutputItem, type FunctionCallRunner, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, Gpt55, InMemoryModelContextRepository, InferenceRequest, InferenceResponse, type InferenceRunner, type InputStream, InputTokenDetails, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIInferenceRunner, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, SystemMessageItem, TokenUsage, type Tool, UserMessageItem };