@mozaik-ai/core 3.4.1 → 3.5.0

package/dist/index.d.mts

@@ -449,45 +449,44 @@ interface ToolExecutor {
     produce(functionCallItem: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
 }
 
-interface InferenceHandler {
-    produce(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem>;
-}
-
 interface MessageSender {
     stream(message: string, signal?: AbortSignal): AsyncIterable<string>;
 }
 
-declare abstract class Participant {
-    abstract onFunctionCallOutput(participant: Participant, item: FunctionCallOutputItem): Promise<void>;
-    abstract onMessage(participant: Participant, message: string): Promise<void>;
-    abstract onFunctionCall(participant: Participant, item: FunctionCallItem): Promise<void>;
-    abstract onReasoning(participant: Participant, item: ReasoningItem): Promise<void>;
-    abstract onOutputMessage(participant: Participant, item: ModelMessageItem): Promise<void>;
+interface InferenceHandler {
+    produce(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem>;
 }
 
 declare abstract class AgenticEnvironment {
-    protected toolExecutor: ToolExecutor;
-    protected messageSender: MessageSender;
-    protected inferenceHandler: InferenceHandler;
-    protected participants: Participant[];
-    constructor(toolExecutor: ToolExecutor, messageSender: MessageSender, inferenceHandler: InferenceHandler);
-    join(user: Participant): void;
-    leave(user: Participant): void;
+    protected subscribers: Participant[];
+    private isActive;
+    start(): Promise<void>;
+    stop(): void;
+    subscribe(subscriber: Participant): void;
+    unsubscribe(user: Participant): void;
     notifyFunctionCallOutput(user: Participant, item: FunctionCallOutputItem): void;
     notifyMessage(user: Participant, message: string): void;
-    abstract executeFunctionCall(user: Participant, functionCallItem: FunctionCallItem): Promise<void>;
-    abstract sendMessage(user: Participant, message: string): Promise<void>;
-    abstract runInference(user: Participant, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
     notifyFunctionCall(user: Participant, item: FunctionCallItem): void;
     notifyReasoning(user: Participant, item: ReasoningItem): void;
     notifyOutputMessage(user: Participant, item: ModelMessageItem): void;
 }
 
-declare class Environment extends AgenticEnvironment {
+declare abstract class Participant {
+    protected toolExecutor: ToolExecutor;
+    protected messageSender: MessageSender;
+    protected inferenceHandler: InferenceHandler;
+    protected environments: AgenticEnvironment[];
     constructor(toolExecutor: ToolExecutor, messageSender: MessageSender, inferenceHandler: InferenceHandler);
-    executeFunctionCall(user: Participant, functionCallItem: FunctionCallItem): Promise<void>;
-    sendMessage(user: Participant, message: string): Promise<void>;
-    runInference(user: Participant, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
+    abstract onFunctionCallOutput(participant: Participant, item: FunctionCallOutputItem): Promise<void>;
+    abstract onMessage(participant: Participant, message: string): Promise<void>;
+    abstract onFunctionCall(participant: Participant, item: FunctionCallItem): Promise<void>;
+    abstract onReasoning(participant: Participant, item: ReasoningItem): Promise<void>;
+    abstract onOutputMessage(participant: Participant, item: ModelMessageItem): Promise<void>;
+    sendMessage(message: string, environment: AgenticEnvironment): Promise<void>;
+    executeFunctionCall(functionCallItem: FunctionCallItem, environment: AgenticEnvironment): Promise<void>;
+    runInference(environment: AgenticEnvironment, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
+    join(environment: AgenticEnvironment): void;
+    leave(environment: AgenticEnvironment): void;
 }
 
-export { type Action, Agent, AgentSociety, type AsyncAction, type AsyncRule, BaseSpecification, ContextItem, DeveloperMessageItem, Environment, FunctionCallItem, FunctionCallOutputItem, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryModelContextRepository, type InferenceHandler, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, type MessageSender, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, type RuntimeContext, type Specification, SystemMessageItem, TokenUsage, type Tool, type ToolExecutor, UserMessageItem };
+export { type Action, Agent, AgentSociety, AgenticEnvironment, type AsyncAction, type AsyncRule, BaseSpecification, ContextItem, DeveloperMessageItem, FunctionCallItem, FunctionCallOutputItem, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryModelContextRepository, type InferenceHandler, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, type MessageSender, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, type RuntimeContext, type Specification, SystemMessageItem, TokenUsage, type Tool, type ToolExecutor, UserMessageItem };

package/dist/index.d.ts

@@ -449,45 +449,44 @@ interface ToolExecutor {
     produce(functionCallItem: FunctionCallItem, signal?: AbortSignal): AsyncIterable<FunctionCallOutputItem>;
 }
 
-interface InferenceHandler {
-    produce(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem>;
-}
-
 interface MessageSender {
     stream(message: string, signal?: AbortSignal): AsyncIterable<string>;
 }
 
-declare abstract class Participant {
-    abstract onFunctionCallOutput(participant: Participant, item: FunctionCallOutputItem): Promise<void>;
-    abstract onMessage(participant: Participant, message: string): Promise<void>;
-    abstract onFunctionCall(participant: Participant, item: FunctionCallItem): Promise<void>;
-    abstract onReasoning(participant: Participant, item: ReasoningItem): Promise<void>;
-    abstract onOutputMessage(participant: Participant, item: ModelMessageItem): Promise<void>;
+interface InferenceHandler {
+    produce(context: ModelContext, model: GenerativeModel, signal?: AbortSignal): AsyncIterable<ReasoningItem | FunctionCallItem | ModelMessageItem>;
 }
 
 declare abstract class AgenticEnvironment {
-    protected toolExecutor: ToolExecutor;
-    protected messageSender: MessageSender;
-    protected inferenceHandler: InferenceHandler;
-    protected participants: Participant[];
-    constructor(toolExecutor: ToolExecutor, messageSender: MessageSender, inferenceHandler: InferenceHandler);
-    join(user: Participant): void;
-    leave(user: Participant): void;
+    protected subscribers: Participant[];
+    private isActive;
+    start(): Promise<void>;
+    stop(): void;
+    subscribe(subscriber: Participant): void;
+    unsubscribe(user: Participant): void;
     notifyFunctionCallOutput(user: Participant, item: FunctionCallOutputItem): void;
     notifyMessage(user: Participant, message: string): void;
-    abstract executeFunctionCall(user: Participant, functionCallItem: FunctionCallItem): Promise<void>;
-    abstract sendMessage(user: Participant, message: string): Promise<void>;
-    abstract runInference(user: Participant, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
     notifyFunctionCall(user: Participant, item: FunctionCallItem): void;
     notifyReasoning(user: Participant, item: ReasoningItem): void;
     notifyOutputMessage(user: Participant, item: ModelMessageItem): void;
 }
 
-declare class Environment extends AgenticEnvironment {
+declare abstract class Participant {
+    protected toolExecutor: ToolExecutor;
+    protected messageSender: MessageSender;
+    protected inferenceHandler: InferenceHandler;
+    protected environments: AgenticEnvironment[];
     constructor(toolExecutor: ToolExecutor, messageSender: MessageSender, inferenceHandler: InferenceHandler);
-    executeFunctionCall(user: Participant, functionCallItem: FunctionCallItem): Promise<void>;
-    sendMessage(user: Participant, message: string): Promise<void>;
-    runInference(user: Participant, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
+    abstract onFunctionCallOutput(participant: Participant, item: FunctionCallOutputItem): Promise<void>;
+    abstract onMessage(participant: Participant, message: string): Promise<void>;
+    abstract onFunctionCall(participant: Participant, item: FunctionCallItem): Promise<void>;
+    abstract onReasoning(participant: Participant, item: ReasoningItem): Promise<void>;
+    abstract onOutputMessage(participant: Participant, item: ModelMessageItem): Promise<void>;
+    sendMessage(message: string, environment: AgenticEnvironment): Promise<void>;
+    executeFunctionCall(functionCallItem: FunctionCallItem, environment: AgenticEnvironment): Promise<void>;
+    runInference(environment: AgenticEnvironment, context: ModelContext, model: GenerativeModel, signal?: AbortSignal): Promise<void>;
+    join(environment: AgenticEnvironment): void;
+    leave(environment: AgenticEnvironment): void;
 }
 
-export { type Action, Agent, AgentSociety, type AsyncAction, type AsyncRule, BaseSpecification, ContextItem, DeveloperMessageItem, Environment, FunctionCallItem, FunctionCallOutputItem, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryModelContextRepository, type InferenceHandler, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, type MessageSender, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, type RuntimeContext, type Specification, SystemMessageItem, TokenUsage, type Tool, type ToolExecutor, UserMessageItem };
+export { type Action, Agent, AgentSociety, AgenticEnvironment, type AsyncAction, type AsyncRule, BaseSpecification, ContextItem, DeveloperMessageItem, FunctionCallItem, FunctionCallOutputItem, type GenerativeModel, Gpt54, Gpt54Mini, Gpt54Nano, If, InMemoryModelContextRepository, type InferenceHandler, InferenceRequest, InferenceResponse, type InferenceVisitor, InputTokenDetails, Loop, type MessageSender, ModelContext, type ModelContextRepository, ModelMessageItem, OpenAIResponses, OutputTokenDetails, Participant, ReasoningItem, type RuntimeContext, type Specification, SystemMessageItem, TokenUsage, type Tool, type ToolExecutor, UserMessageItem };

package/dist/index.js

@@ -32,10 +32,10 @@ var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
   AgentSociety: () => AgentSociety,
+  AgenticEnvironment: () => AgenticEnvironment,
   BaseSpecification: () => BaseSpecification,
   ContextItem: () => ContextItem,
   DeveloperMessageItem: () => DeveloperMessageItem,
-  Environment: () => Environment,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
   Gpt54: () => Gpt54,
@@ -1089,89 +1089,118 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   }
 };
 
-// src/domain/agentic-environment/agentic-environment.ts
-var AgenticEnvironment = class {
+// src/domain/agentic-environment/participant.ts
+var Participant = class {
   constructor(toolExecutor, messageSender, inferenceHandler) {
-    this.participants = [];
+    this.environments = [];
     this.toolExecutor = toolExecutor;
     this.messageSender = messageSender;
     this.inferenceHandler = inferenceHandler;
   }
-  join(user) {
-    this.participants.push(user);
-  }
-  leave(user) {
-    this.participants = this.participants.filter((p) => p !== user);
-  }
-  notifyFunctionCallOutput(user, item) {
-    for (const participant of this.participants) {
-      participant.onFunctionCallOutput(user, item);
+  async sendMessage(message, environment) {
+    if (!this.environments.includes(environment)) {
+      return;
+    }
+    for await (const messagePart of this.messageSender.stream(message)) {
+      environment.notifyMessage(this, messagePart);
     }
   }
-  notifyMessage(user, message) {
-    for (const participant of this.participants) {
-      if (participant === user) {
-        continue;
-      }
-      participant.onMessage(user, message);
+  async executeFunctionCall(functionCallItem, environment) {
+    if (!this.environments.includes(environment)) {
+      return;
+    }
+    for await (const item of this.toolExecutor.produce(functionCallItem)) {
+      environment.notifyFunctionCallOutput(this, item);
     }
   }
-  notifyFunctionCall(user, item) {
-    for (const participant of this.participants) {
-      participant.onFunctionCall(user, item);
+  async runInference(environment, context, model, signal) {
+    if (!this.environments.includes(environment)) {
+      return;
+    }
+    for await (const item of this.inferenceHandler.produce(context, model, signal)) {
+      if (item instanceof FunctionCallItem) {
+        environment.notifyFunctionCall(this, item);
+      } else if (item instanceof ReasoningItem) {
+        environment.notifyReasoning(this, item);
+      } else if (item instanceof ModelMessageItem) {
+        environment.notifyOutputMessage(this, item);
+      }
     }
   }
-  notifyReasoning(user, item) {
-    for (const participant of this.participants) {
-      participant.onReasoning(user, item);
+  join(environment) {
+    if (this.environments.includes(environment)) {
+      return;
     }
+    environment.subscribe(this);
+    this.environments.push(environment);
   }
-  notifyOutputMessage(user, item) {
-    for (const participant of this.participants) {
-      participant.onOutputMessage(user, item);
+  leave(environment) {
+    if (!this.environments.includes(environment)) {
+      return;
     }
+    environment.unsubscribe(this);
+    this.environments = this.environments.filter((e) => e !== environment);
   }
 };
 
-// src/application/environment.ts
-var Environment = class extends AgenticEnvironment {
-  constructor(toolExecutor, messageSender, inferenceHandler) {
-    super(toolExecutor, messageSender, inferenceHandler);
+// src/domain/agentic-environment/agentic-environment.ts
+var AgenticEnvironment = class {
+  constructor() {
+    this.subscribers = [];
+    this.isActive = false;
   }
-  async executeFunctionCall(user, functionCallItem) {
-    for await (const item of this.toolExecutor.produce(functionCallItem)) {
-      this.notifyFunctionCallOutput(user, item);
+  async start() {
+    this.isActive = true;
+    while (this.isActive) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
     }
   }
-  async sendMessage(user, message) {
-    for await (const messagePart of this.messageSender.stream(message)) {
-      this.notifyMessage(user, messagePart);
+  stop() {
+    this.isActive = false;
+  }
+  subscribe(subscriber) {
+    this.subscribers.push(subscriber);
+  }
+  unsubscribe(user) {
+    this.subscribers = this.subscribers.filter((p) => p !== user);
+  }
+  notifyFunctionCallOutput(user, item) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onFunctionCallOutput(subscriber, item);
     }
   }
-  async runInference(user, context, model, signal) {
-    for await (const item of this.inferenceHandler.produce(context, model, signal)) {
-      if (item instanceof FunctionCallItem) {
-        this.notifyFunctionCall(user, item);
-      } else if (item instanceof ReasoningItem) {
-        this.notifyReasoning(user, item);
-      } else if (item instanceof ModelMessageItem) {
-        this.notifyOutputMessage(user, item);
+  notifyMessage(user, message) {
+    for (const subscriber of this.subscribers) {
+      if (subscriber === user) {
+        continue;
       }
+      subscriber.onMessage(subscriber, message);
+    }
+  }
+  notifyFunctionCall(user, item) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onFunctionCall(user, item);
+    }
+  }
+  notifyReasoning(user, item) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onReasoning(user, item);
+    }
+  }
+  notifyOutputMessage(user, item) {
+    for (const subscriber of this.subscribers) {
+      subscriber.onOutputMessage(user, item);
     }
   }
-};
-
-// src/domain/agentic-environment/participant.ts
-var Participant = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
   AgentSociety,
+  AgenticEnvironment,
   BaseSpecification,
   ContextItem,
   DeveloperMessageItem,
-  Environment,
   FunctionCallItem,
   FunctionCallOutputItem,
   Gpt54,