@mozaik-ai/core 3.4.2 → 3.5.1

package/dist/index.d.mts

@@ -449,48 +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;
+declare class AgenticEnvironment {
+    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 {
-    private isActive;
+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>;
-    start(): Promise<void>;
-    stop(): 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,48 +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;
+declare class AgenticEnvironment {
+    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 {
-    private isActive;
+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>;
-    start(): Promise<void>;
-    stop(): 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,77 +1089,66 @@ 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);
-    }
-  }
-  notifyMessage(user, message) {
-    for (const participant of this.participants) {
-      if (participant === user) {
-        continue;
-      }
-      participant.onMessage(user, message);
-    }
-  }
-  notifyFunctionCall(user, item) {
-    for (const participant of this.participants) {
-      participant.onFunctionCall(user, item);
+  async sendMessage(message, environment) {
+    if (!this.environments.includes(environment)) {
+      return;
     }
-  }
-  notifyReasoning(user, item) {
-    for (const participant of this.participants) {
-      participant.onReasoning(user, item);
+    for await (const messagePart of this.messageSender.stream(message)) {
+      environment.notifyMessage(this, messagePart);
     }
   }
-  notifyOutputMessage(user, item) {
-    for (const participant of this.participants) {
-      participant.onOutputMessage(user, item);
+  async executeFunctionCall(functionCallItem, environment) {
+    if (!this.environments.includes(environment)) {
+      return;
     }
-  }
-};
-
-// src/application/environment.ts
-var Environment = class extends AgenticEnvironment {
-  constructor(toolExecutor, messageSender, inferenceHandler) {
-    super(toolExecutor, messageSender, inferenceHandler);
-    this.isActive = false;
-  }
-  async executeFunctionCall(user, functionCallItem) {
     for await (const item of this.toolExecutor.produce(functionCallItem)) {
-      this.notifyFunctionCallOutput(user, item);
+      environment.notifyFunctionCallOutput(this, item);
     }
   }
-  async sendMessage(user, message) {
-    for await (const messagePart of this.messageSender.stream(message)) {
-      this.notifyMessage(user, messagePart);
+  async runInference(environment, context, model, signal) {
+    if (!this.environments.includes(environment)) {
+      return;
     }
-  }
-  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);
+        environment.notifyFunctionCall(this, item);
       } else if (item instanceof ReasoningItem) {
-        this.notifyReasoning(user, item);
+        environment.notifyReasoning(this, item);
       } else if (item instanceof ModelMessageItem) {
-        this.notifyOutputMessage(user, item);
+        environment.notifyOutputMessage(this, item);
       }
     }
   }
+  join(environment) {
+    if (this.environments.includes(environment)) {
+      return;
+    }
+    environment.subscribe(this);
+    this.environments.push(environment);
+  }
+  leave(environment) {
+    if (!this.environments.includes(environment)) {
+      return;
+    }
+    environment.unsubscribe(this);
+    this.environments = this.environments.filter((e) => e !== environment);
+  }
+};
+
+// src/domain/agentic-environment/agentic-environment.ts
+var AgenticEnvironment = class {
+  constructor() {
+    this.subscribers = [];
+    this.isActive = false;
+  }
   async start() {
     this.isActive = true;
     while (this.isActive) {
@@ -1169,19 +1158,49 @@ var Environment = class extends AgenticEnvironment {
   stop() {
     this.isActive = false;
   }
-};
-
-// src/domain/agentic-environment/participant.ts
-var Participant = class {
+  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);
+    }
+  }
+  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);
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
   AgentSociety,
+  AgenticEnvironment,
   BaseSpecification,
   ContextItem,
   DeveloperMessageItem,
-  Environment,
   FunctionCallItem,
   FunctionCallOutputItem,
   Gpt54,