@mozaik-ai/core 3.11.0 → 3.13.0

package/dist/index.js

@@ -30,33 +30,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Agent: () => Agent,
   AgenticEnvironment: () => AgenticEnvironment,
+  AgenticError: () => AgenticError,
   AnthropicMessages: () => AnthropicMessages,
-  BaseAgent: () => BaseAgent,
-  BaseHuman: () => BaseHuman,
-  BaseObserver: () => BaseObserver,
+  BaseParticipant: () => BaseParticipant,
   ClaudeHaiku45: () => ClaudeHaiku45,
   ClaudeOpus47: () => ClaudeOpus47,
+  ClaudeOpus48: () => ClaudeOpus48,
   ClaudeSonnet46: () => ClaudeSonnet46,
   ContextItem: () => ContextItem,
-  DefaultFunctionCallRunner: () => DefaultFunctionCallRunner,
+  DeepSeekV4Flash: () => DeepSeekV4Flash,
+  DeepSeekV4Pro: () => DeepSeekV4Pro,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
+  Gemini31Pro: () => Gemini31Pro,
+  Gemini35Flash: () => Gemini35Flash,
+  GeminiGenerateContent: () => GeminiGenerateContent,
   Gpt54: () => Gpt54,
   Gpt54Mini: () => Gpt54Mini,
   Gpt54Nano: () => Gpt54Nano,
   Gpt55: () => Gpt55,
-  Human: () => Human,
   InMemoryModelContextRepository: () => InMemoryModelContextRepository,
   InferenceRequest: () => InferenceRequest,
   InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
-  Observer: () => Observer,
-  OpenAIInferenceRunner: () => OpenAIInferenceRunner,
+  OpenAIChatCompletions: () => OpenAIChatCompletions,
   OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
@@ -64,7 +65,10 @@ __export(index_exports, {
   SemanticEvent: () => SemanticEvent,
   SystemMessageItem: () => SystemMessageItem,
   TokenUsage: () => TokenUsage,
-  UserMessageItem: () => UserMessageItem
+  UserMessageItem: () => UserMessageItem,
+  executeFunctionCall: () => executeFunctionCall,
+  runInference: () => runInference,
+  sendMessage: () => sendMessage
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -325,18 +329,21 @@ var Gpt54Nano = class {
   constructor() {
     this.specification = {
       name: "gpt-5.4-nano",
+      provider: "openai",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 4e5,
       maxOutputTokens: 128e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
-    this.streaming = false;
   }
   setStreaming(streaming) {
     this.streaming = streaming;
@@ -356,6 +363,15 @@ var Gpt54Nano = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
 };
 
 // src/infrastructure/providers/openai/models/gpt-5-4.ts
@@ -363,15 +379,18 @@ var Gpt54 = class {
   constructor() {
     this.specification = {
       name: "gpt-5.4",
+      provider: "openai",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 105e4,
       maxOutputTokens: 128e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
     this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
@@ -394,6 +413,15 @@ var Gpt54 = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
 };
 
 // src/infrastructure/providers/openai/models/gpt-5-4-mini.ts
@@ -401,18 +429,21 @@ var Gpt54Mini = class {
   constructor() {
     this.specification = {
       name: "gpt-5.4-mini",
+      provider: "openai",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 4e5,
       maxOutputTokens: 128e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
-    this.streaming = false;
   }
   setStreaming(streaming) {
     this.streaming = streaming;
@@ -432,6 +463,15 @@ var Gpt54Mini = class {
   getTools() {
     return this.tools;
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
 };
 
 // src/domain/generative-model/token-usage.ts
@@ -522,10 +562,12 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   }
 };
 
-// src/domain/agentic-environment/participants/participant.ts
+// src/domain/agentic-environment/participant.ts
 var Participant = class {
   constructor() {
     this.environments = [];
+    this.listens = [];
+    this.active = /* @__PURE__ */ new Map();
   }
   join(environment) {
     if (this.isJoinedTo(environment)) {
@@ -533,6 +575,7 @@ var Participant = class {
     }
     environment.subscribe(this);
     this.environments.push(environment);
+    this.active.set(environment, true);
   }
   leave(environment) {
     if (!this.isJoinedTo(environment)) {
@@ -540,6 +583,7 @@ var Participant = class {
     }
     environment.unsubscribe(this);
     this.environments = this.environments.filter((e) => e !== environment);
+    this.active.delete(environment);
   }
   isJoinedTo(environment) {
     return this.environments.includes(environment);
@@ -547,13 +591,49 @@ var Participant = class {
   getEnvironments() {
     return this.environments;
   }
+  getListeners() {
+    return this.listens;
+  }
+  getEnvironmentState(environment) {
+    return this.active.get(environment);
+  }
+  markInactive(environment) {
+    if (this.active.has(environment)) {
+      this.active.set(environment, false);
+    }
+  }
+  markActive(environment) {
+    if (this.active.has(environment)) {
+      this.active.set(environment, true);
+    }
+  }
+};
+
+// src/domain/agentic-environment/errors/base-error.ts
+var AgenticError = class extends Error {
+  constructor({ message, stack, source, enviornment }) {
+    super();
+    this.message = message;
+    this.stack = stack;
+    this.source = source;
+    this.environment = enviornment;
+  }
+  getSource() {
+    return this.source;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
 };
 
 // src/domain/agentic-environment/agentic-environment.ts
 var AgenticEnvironment = class {
-  constructor() {
+  constructor(name, opts) {
     this.subscribers = [];
-    this.isActive = false;
+    var _a;
+    this.name = name;
+    this.options = opts;
+    this.showLogs = ((_a = this.options) == null ? void 0 : _a.silent) !== false;
   }
   subscribe(participant) {
     this.subscribers.push(participant);
@@ -577,227 +657,100 @@ var AgenticEnvironment = class {
     }
   }
   deliverFunctionCall(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onFunctionCall(item);
-      } else {
-        subscriber.onExternalFunctionCall(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onFunctionCall(item),
+      external: (sub) => sub.onExternalFunctionCall(source, item)
+    });
   }
   deliverModelMessage(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onModelMessage(item);
-      } else {
-        subscriber.onExternalModelMessage(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onModelMessage(item),
+      external: (sub) => sub.onExternalModelMessage(source, item)
+    });
   }
   deliverReasoning(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onReasoning(item);
-      } else {
-        subscriber.onExternalReasoning(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onReasoning(item),
+      external: (sub) => sub.onExternalReasoning(source, item)
+    });
   }
   deliverFunctionCallOutput(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onFunctionCallOutput(item);
-      } else {
-        subscriber.onExternalFunctionCallOutput(source, item);
-      }
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onFunctionCallOutput(item),
+      external: (sub) => sub.onExternalFunctionCallOutput(source, item)
+    });
   }
   deliverMessage(source, message) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) continue;
-      subscriber.onMessage(message);
-    }
+    this.deliverToSubscribers(source, {
+      external: (sub) => sub.onMessage(message)
+    });
   }
   deliverSemanticEvent(source, item) {
-    for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        subscriber.onInternalEvent(item);
-      } else {
-        subscriber.onExternalEvent(source, item);
-      }
-    }
-  }
-  async start() {
-    this.isActive = true;
-    while (this.isActive) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-  }
-  stop() {
-    this.isActive = false;
-  }
-};
-
-// src/domain/agentic-environment/participants/agent.ts
-var Agent = class extends Participant {
-};
-
-// src/domain/model-context/semantic-event/semantic-event.ts
-var SemanticEvent = class {
-  constructor(type, data) {
-    this.type = type;
-    this.data = data;
-  }
-  getType() {
-    return this.type;
-  }
-};
-
-// src/application/participants/agent.ts
-var BaseAgent = class extends Agent {
-  constructor(inferenceRunner, functionCallRunner) {
-    super();
-    this.inferenceRunner = inferenceRunner;
-    this.functionCallRunner = functionCallRunner;
-  }
-  onJoined() {
-  }
-  onLeft() {
-  }
-  onParticipantJoined(participant) {
-  }
-  onParticipantLeft(participant) {
-  }
-  onFunctionCall(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onReasoning(item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalModelMessage(source, item) {
-  }
-  onMessage(message) {
-  }
-  onInternalEvent(item) {
-  }
-  onExternalEvent(source, item) {
-  }
-  async executeFunctionCall(environment, functionCallItem, signal) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.functionCallRunner.run(functionCallItem, signal);
-    for await (const item of stream) {
-      environment.deliverFunctionCallOutput(this, item);
-    }
+    this.deliverToSubscribers(source, {
+      internal: (src) => src.onInternalEvent(item),
+      external: (sub) => sub.onExternalEvent(source, item)
+    });
   }
-  async runInference(environment, context, model, signal) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.inferenceRunner.run(context, model, signal);
-    for await (const item of stream) {
-      if (item instanceof ReasoningItem) {
-        environment.deliverReasoning(this, item);
-      } else if (item instanceof FunctionCallItem) {
-        environment.deliverFunctionCall(this, item);
-      } else if (item instanceof ModelMessageItem) {
-        environment.deliverModelMessage(this, item);
-      } else if (item instanceof SemanticEvent) {
-        environment.deliverSemanticEvent(this, item);
+  deliverError(source, error) {
+    this.deliverToSubscribers(source, {
+      internal: (src) => {
+        try {
+          src.onError(error);
+        } catch (error2) {
+          if (this.showLogs) {
+            console.warn(`[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`);
+          }
+        } finally {
+          src.markInactive(this);
+        }
+      },
+      external: (sub) => {
+        try {
+          sub.onParticipantError(source, error);
+        } catch (error2) {
+          if (this.showLogs) {
+            console.warn(`[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`);
+          }
+        }
       }
-    }
-  }
-};
-
-// src/domain/agentic-environment/participants/human.ts
-var Human = class extends Participant {
-  sendMessage(environment, message) {
-    if (!this.isJoinedTo(environment)) throw new Error("Not joined to environment");
-    environment.deliverMessage(this, message);
-  }
-};
-
-// src/application/participants/human.ts
-var BaseHuman = class extends Human {
-  onJoined() {
-  }
-  onLeft() {
-  }
-  onParticipantJoined(participant) {
-  }
-  onParticipantLeft(participant) {
-  }
-  onMessage(message) {
-  }
-  onFunctionCall(item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onReasoning(item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onExternalModelMessage(source, item) {
-  }
-  onInternalEvent(item) {
-  }
-  onExternalEvent(source, item) {
-  }
-};
-
-// src/domain/generative-model/inference-request.ts
-var InferenceRequest = class {
-  constructor(model, context) {
-    this.model = model;
-    this.context = context;
+    });
   }
-};
-
-// src/application/runners/openai-inference-runner.ts
-var OpenAIInferenceRunner = class {
-  constructor(runtime) {
-    this.runtime = runtime;
+  getListeningParticipants(source) {
+    return this.subscribers.filter(
+      (sub) => sub !== source && (sub.getListeners().length === 0 || sub.getListeners().some((listener) => source instanceof listener))
+    );
   }
-  async *run(context, model, signal) {
-    const request = new InferenceRequest(model, context);
-    if (model.getStreaming() && this.isStreamingRuntime(this.runtime)) {
-      yield* this.runtime.stream(request, signal);
-      return;
-    }
-    const response = await this.runtime.infer(request);
-    for (const item of response.contextItems) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
+  deliverToSubscribers(source, handlers) {
+    var _a, _b;
+    const authorizedListeners = this.getListeningParticipants(source);
+    for (const subscriber of this.subscribers) {
+      const isActive = subscriber.getEnvironmentState(this);
+      if (isActive) {
+        try {
+          if (subscriber === source) {
+            (_a = handlers == null ? void 0 : handlers.internal) == null ? void 0 : _a.call(handlers, subscriber);
+          } else if (authorizedListeners.includes(subscriber)) {
+            (_b = handlers == null ? void 0 : handlers.external) == null ? void 0 : _b.call(handlers, subscriber);
+          }
+        } catch (error) {
+          this.handleError(subscriber, error);
+        }
       }
-      yield item;
     }
   }
-  isStreamingRuntime(runtime) {
-    return typeof runtime.stream === "function";
-  }
-};
-
-// src/application/runners/function-call-runner.ts
-var DefaultFunctionCallRunner = class {
-  constructor(tools) {
-    this.tools = tools;
-  }
-  async *run(call, signal) {
-    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));
+  handleError(subscriber, error) {
+    if (error instanceof AgenticError) {
+      return this.deliverError(subscriber, error);
+    }
+    const agenticError = new AgenticError({
+      message: error.message,
+      stack: error.stack,
+      enviornment: this,
+      source: subscriber
+    });
+    return this.deliverError(subscriber, agenticError);
   }
 };
 
@@ -806,15 +759,18 @@ var Gpt55 = class {
   constructor() {
     this.specification = {
       name: "gpt-5.5",
+      provider: "openai",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 105e4,
       maxOutputTokens: 128e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
     this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new OpenAIReasoningEffort(
       this.specification.defaultReasoningEffort
     );
@@ -837,47 +793,37 @@ var Gpt55 = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
-};
-
-// src/domain/agentic-environment/participants/observer.ts
-var Observer = class extends Participant {
-};
-
-// src/application/participants/observer.ts
-var BaseObserver = class extends Observer {
-  onFunctionCall(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onReasoning(item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalModelMessage(source, item) {
-  }
-  onMessage(message) {
-  }
-  onJoined() {
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
   }
-  onLeft() {
+  getStructuredOutput() {
+    return this.structuredOutput;
   }
-  onParticipantJoined(participant) {
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
   }
-  onParticipantLeft(participant) {
+};
+
+// src/domain/model-context/semantic-event/semantic-event.ts
+var SemanticEvent = class {
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
   }
-  onInternalEvent(item) {
+  getType() {
+    return this.type;
   }
-  onExternalEvent(source, item) {
+};
+
+// src/domain/agentic-environment/inference/request.ts
+var InferenceRequest = class {
+  constructor(model, context) {
+    this.model = model;
+    this.context = context;
   }
 };
 
-// src/domain/generative-model/inference-response.ts
+// src/domain/agentic-environment/inference/response.ts
 var InferenceResponse = class {
   constructor(contextItems, tokenUsage) {
     this.contextItems = contextItems;
@@ -913,6 +859,7 @@ var OpenAIResponses = class {
     }
   }
   buildRequest(inferenceRequest) {
+    var _a, _b;
     const specification = inferenceRequest.model.specification;
     const input = this.mapContextToRequest(inferenceRequest.context);
     const request = {
@@ -934,6 +881,20 @@ var OpenAIResponses = class {
         effort: inferenceRequest.model.getReasoningEffort()
       };
     }
+    if (inferenceRequest.model.hasStructuredOutput()) {
+      if (!specification.supportStructuredOutput) {
+        throw new Error(`Structured output is not supported for model: ${specification.name}`);
+      }
+      const format = inferenceRequest.model.getStructuredOutput();
+      request.text = {
+        format: {
+          type: "json_schema",
+          name: (_a = format.name) != null ? _a : "response",
+          schema: format.schema,
+          strict: (_b = format.strict) != null ? _b : true
+        }
+      };
+    }
     return request;
   }
   extractTokenUsage(response) {
@@ -977,6 +938,24 @@ var AnthropicMessages = class {
     this.client = new import_sdk.default();
   }
   async infer(inferenceRequest) {
+    const response = await this.client.messages.create(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    const stream = await this.client.messages.create({
+      ...this.buildRequest(inferenceRequest),
+      stream: true
+    });
+    for await (const event of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent(event.type, event);
+    }
+  }
+  buildRequest(inferenceRequest) {
     const { messages, system } = this.mapContextToRequest(inferenceRequest.context);
     const specification = inferenceRequest.model.specification;
     const request = {
@@ -1007,14 +986,23 @@ var AnthropicMessages = class {
         };
       }
     }
-    const response = await this.client.messages.create(request);
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
-  extractTokenUsage(response) {
-    var _a, _b;
-    if (!response.usage) {
+    if (inferenceRequest.model.hasStructuredOutput()) {
+      if (!specification.supportStructuredOutput) {
+        throw new Error(`Structured output is not supported for model: ${specification.name}`);
+      }
+      const format = inferenceRequest.model.getStructuredOutput();
+      request.output_config = {
+        format: {
+          type: "json_schema",
+          json_schema: format.schema
+        }
+      };
+    }
+    return request;
+  }
+  extractTokenUsage(response) {
+    var _a, _b;
+    if (!response.usage) {
       return void 0;
     }
     return new TokenUsage(
@@ -1130,20 +1118,73 @@ var AnthropicReasoningEffort = class {
   }
 };
 
+// src/infrastructure/providers/anthropic/models/claude-4-8-opus.ts
+var ClaudeOpus48 = class {
+  constructor() {
+    this.specification = {
+      name: "claude-opus-4-8",
+      provider: "anthropic",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "none",
+      supportStreaming: true,
+      contextWindowSize: 2e5,
+      maxOutputTokens: 32e3,
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
+    this.effort = new AnthropicReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
 // src/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
 var ClaudeOpus47 = class {
   constructor() {
     this.specification = {
       name: "claude-opus-4-7",
+      provider: "anthropic",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 2e5,
       maxOutputTokens: 32e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
     this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new AnthropicReasoningEffort(
       this.specification.defaultReasoningEffort
     );
@@ -1166,6 +1207,15 @@ var ClaudeOpus47 = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
 };
 
 // src/infrastructure/providers/anthropic/models/claude-4-6-sonnet.ts
@@ -1173,15 +1223,18 @@ var ClaudeSonnet46 = class {
   constructor() {
     this.specification = {
       name: "claude-sonnet-4-6",
+      provider: "anthropic",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 2e5,
       maxOutputTokens: 64e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
     this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new AnthropicReasoningEffort(
       this.specification.defaultReasoningEffort
     );
@@ -1204,6 +1257,15 @@ var ClaudeSonnet46 = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
 };
 
 // src/infrastructure/providers/anthropic/models/claude-4-5-haiku.ts
@@ -1211,15 +1273,18 @@ var ClaudeHaiku45 = class {
   constructor() {
     this.specification = {
       name: "claude-haiku-4-5",
+      provider: "anthropic",
       supportReasoningEffort: true,
       defaultReasoningEffort: "none",
       supportStreaming: true,
       contextWindowSize: 2e5,
       maxOutputTokens: 64e3,
-      supportFunctionCalling: true
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
     };
     this.tools = [];
     this.streaming = false;
+    this.structuredOutput = void 0;
     this.effort = new AnthropicReasoningEffort(
       this.specification.defaultReasoningEffort
     );
@@ -1242,36 +1307,762 @@ var ClaudeHaiku45 = class {
   getReasoningEffort() {
     return this.effort.getReasoningEffort();
   }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
+// src/infrastructure/providers/deepseek/reasoning-effort.ts
+var DeepSeekReasoningEffort = class {
+  constructor(reasoningEffort) {
+    this.reasoningEffort = reasoningEffort;
+  }
+  setReasoningEffort(effort) {
+    this.reasoningEffort = effort;
+  }
+  getReasoningEffort() {
+    if (!this.reasoningEffort) {
+      throw new Error("Reasoning effort not supported");
+    }
+    return this.reasoningEffort;
+  }
+};
+
+// src/infrastructure/providers/deepseek/models/deepseek-v4-flash.ts
+var DeepSeekV4Flash = class {
+  constructor() {
+    this.specification = {
+      name: "deepseek-v4-flash",
+      provider: "deepseek",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1e6,
+      maxOutputTokens: 384e3,
+      supportFunctionCalling: true,
+      supportStructuredOutput: false
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
+    this.effort = new DeepSeekReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
+// src/infrastructure/providers/deepseek/models/deepseek-v4-pro.ts
+var DeepSeekV4Pro = class {
+  constructor() {
+    this.specification = {
+      name: "deepseek-v4-pro",
+      provider: "deepseek",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1e6,
+      maxOutputTokens: 384e3,
+      supportFunctionCalling: true,
+      supportStructuredOutput: false
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
+    this.effort = new DeepSeekReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
+// src/infrastructure/providers/gemini/runtime/gemini-generate-content.ts
+var import_genai = require("@google/genai");
+var GeminiGenerateContent = class {
+  constructor() {
+    this.client = new import_genai.GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+  }
+  async infer(inferenceRequest) {
+    const response = await this.client.models.generateContent(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    const stream = await this.client.models.generateContentStream(this.buildRequest(inferenceRequest));
+    for await (const chunk of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent("generate_content_chunk", chunk);
+    }
+  }
+  buildRequest(inferenceRequest) {
+    const specification = inferenceRequest.model.specification;
+    const { contents, systemInstruction } = this.mapContextToRequest(inferenceRequest.context);
+    const config = {};
+    if (systemInstruction) {
+      config.systemInstruction = systemInstruction;
+    }
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      config.tools = [
+        {
+          functionDeclarations: inferenceRequest.model.getTools().map((tool) => {
+            return {
+              name: tool.name,
+              description: tool.description,
+              parametersJsonSchema: tool.parameters
+            };
+          })
+        }
+      ];
+    }
+    if (specification.supportReasoningEffort) {
+      const effort = inferenceRequest.model.getReasoningEffort();
+      const thinkingLevel = effort === "none" ? "minimal" : effort;
+      config.thinkingConfig = { thinkingLevel, includeThoughts: true };
+    }
+    if (inferenceRequest.model.hasStructuredOutput()) {
+      if (!specification.supportStructuredOutput) {
+        throw new Error(`Structured output is not supported for model: ${specification.name}`);
+      }
+      const format = inferenceRequest.model.getStructuredOutput();
+      config.responseMimeType = "application/json";
+      config.responseSchema = format.schema;
+    }
+    return { model: specification.name, contents, config };
+  }
+  extractTokenUsage(response) {
+    var _a, _b, _c, _d, _e;
+    const usage = response.usageMetadata;
+    if (!usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      (_a = usage.promptTokenCount) != null ? _a : 0,
+      (_b = usage.candidatesTokenCount) != null ? _b : 0,
+      (_c = usage.totalTokenCount) != null ? _c : 0,
+      new InputTokenDetails((_d = usage.cachedContentTokenCount) != null ? _d : 0),
+      new OutputTokenDetails((_e = usage.thoughtsTokenCount) != null ? _e : 0)
+    );
+  }
+  mapContextToRequest(context) {
+    var _a;
+    const contents = [];
+    const system = [];
+    const callNames = /* @__PURE__ */ new Map();
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        system.push(item.content.text);
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        this.addPart(contents, "user", { text: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        this.addPart(contents, "model", { text: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        callNames.set(item.callId, item.name);
+        let args;
+        try {
+          args = JSON.parse(item.args);
+        } catch (e) {
+          args = {};
+        }
+        this.addPart(contents, "model", { functionCall: { id: item.callId, name: item.name, args } });
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        this.addPart(contents, "user", {
+          functionResponse: {
+            id: item.callId,
+            name: (_a = callNames.get(item.callId)) != null ? _a : "",
+            response: this.parseResponse(item.output.text)
+          }
+        });
+      }
+    }
+    return {
+      contents,
+      systemInstruction: system.length > 0 ? system.join("\n\n") : void 0
+    };
+  }
+  extractContextItems(response) {
+    var _a, _b, _c, _d, _e, _f;
+    const items = [];
+    const parts = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) != null ? _d : [];
+    for (const part of parts) {
+      if (part.thought && part.text) {
+        items.push(
+          ReasoningItem.rehydrate({
+            content: InputText.rehydrate({ text: part.text }),
+            encryptedContent: void 0,
+            summary: []
+          })
+        );
+        continue;
+      }
+      if (part.text) {
+        items.push(ModelMessageItem.rehydrate({ text: part.text }));
+        continue;
+      }
+      if (part.functionCall) {
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: (_e = part.functionCall.id) != null ? _e : "",
+            name: part.functionCall.name,
+            args: JSON.stringify((_f = part.functionCall.args) != null ? _f : {})
+          })
+        );
+      }
+    }
+    return items;
+  }
+  parseResponse(output) {
+    try {
+      const parsed = JSON.parse(output);
+      return parsed && typeof parsed === "object" ? parsed : { output };
+    } catch (e) {
+      return { output };
+    }
+  }
+  addPart(contents, role, part) {
+    const last = contents[contents.length - 1];
+    if ((last == null ? void 0 : last.role) === role) {
+      last.parts.push(part);
+      return;
+    }
+    contents.push({ role, parts: [part] });
+  }
+};
+
+// src/infrastructure/providers/gemini/reasoning-effort.ts
+var GeminiReasoningEffort = class {
+  constructor(reasoningEffort) {
+    this.reasoningEffort = reasoningEffort;
+  }
+  setReasoningEffort(effort) {
+    this.reasoningEffort = effort;
+  }
+  getReasoningEffort() {
+    if (!this.reasoningEffort) {
+      throw new Error("Reasoning effort not supported");
+    }
+    return this.reasoningEffort;
+  }
+};
+
+// src/infrastructure/providers/gemini/models/gemini-3-5-flash.ts
+var Gemini35Flash = class {
+  constructor() {
+    this.specification = {
+      name: "gemini-3.5-flash",
+      provider: "google",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "medium",
+      supportStreaming: true,
+      contextWindowSize: 1048576,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
+    this.effort = new GeminiReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
+// src/infrastructure/providers/gemini/models/gemini-3-1-pro.ts
+var Gemini31Pro = class {
+  constructor() {
+    this.specification = {
+      name: "gemini-3.1-pro-preview",
+      provider: "google",
+      supportReasoningEffort: true,
+      defaultReasoningEffort: "high",
+      supportStreaming: true,
+      contextWindowSize: 1048576,
+      maxOutputTokens: 64e3,
+      supportFunctionCalling: true,
+      supportStructuredOutput: true
+    };
+    this.tools = [];
+    this.streaming = false;
+    this.structuredOutput = void 0;
+    this.effort = new GeminiReasoningEffort(
+      this.specification.defaultReasoningEffort
+    );
+  }
+  setStreaming(streaming) {
+    this.streaming = streaming;
+  }
+  getStreaming() {
+    return this.streaming;
+  }
+  setTools(tools) {
+    this.tools = tools;
+  }
+  getTools() {
+    return this.tools;
+  }
+  setReasoningEffort(effort) {
+    this.effort.setReasoningEffort(effort);
+  }
+  getReasoningEffort() {
+    return this.effort.getReasoningEffort();
+  }
+  setStructuredOutput(format) {
+    this.structuredOutput = format;
+  }
+  getStructuredOutput() {
+    return this.structuredOutput;
+  }
+  hasStructuredOutput() {
+    return this.structuredOutput !== void 0;
+  }
+};
+
+// src/infrastructure/providers/openai/runtime/openai-chat-completions.ts
+var import_openai2 = __toESM(require("openai"));
+var OpenAIChatCompletions = class {
+  constructor(config = {}) {
+    var _a;
+    this.client = new import_openai2.default({
+      baseURL: config.baseURL,
+      apiKey: config.apiKey
+    });
+    this.extraBody = (_a = config.extraBody) != null ? _a : {};
+  }
+  async infer(inferenceRequest) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceRequest));
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  async *stream(inferenceRequest, signal) {
+    var _a;
+    const stream = await this.client.chat.completions.create({
+      ...this.buildRequest(inferenceRequest),
+      stream: true
+    });
+    for await (const event of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
+    }
+  }
+  buildRequest(inferenceRequest) {
+    const specification = inferenceRequest.model.specification;
+    const request = {
+      ...this.extraBody,
+      model: specification.name,
+      messages: this.mapContextToRequest(inferenceRequest.context)
+    };
+    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+      request.tools = inferenceRequest.model.getTools().map((tool) => {
+        return {
+          type: "function",
+          function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+          }
+        };
+      });
+    }
+    if (specification.supportReasoningEffort) {
+      request.reasoning_effort = inferenceRequest.model.getReasoningEffort();
+    }
+    return request;
+  }
+  extractTokenUsage(response) {
+    var _a, _b, _c, _d;
+    if (!response.usage) {
+      return void 0;
+    }
+    return new TokenUsage(
+      response.usage.prompt_tokens,
+      response.usage.completion_tokens,
+      response.usage.total_tokens,
+      new InputTokenDetails((_b = (_a = response.usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0),
+      new OutputTokenDetails((_d = (_c = response.usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
+    );
+  }
+  mapContextToRequest(context) {
+    var _a;
+    const messages = [];
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        messages.push({ role: "system", content: item.content.text });
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        messages.push({ role: "user", content: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        messages.push({ role: "assistant", content: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        const toolCall = {
+          id: item.callId,
+          type: "function",
+          function: { name: item.name, arguments: item.args }
+        };
+        const last = messages[messages.length - 1];
+        if ((last == null ? void 0 : last.role) === "assistant") {
+          last.tool_calls = (_a = last.tool_calls) != null ? _a : [];
+          last.tool_calls.push(toolCall);
+        } else {
+          messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
+        }
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
+      }
+    }
+    return messages;
+  }
+  extractContextItems(response) {
+    var _a, _b, _c;
+    const items = [];
+    const message = (_b = (_a = response.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
+    if (!message) {
+      return items;
+    }
+    if (message.reasoning_content) {
+      items.push(
+        ReasoningItem.rehydrate({
+          content: InputText.rehydrate({ text: message.reasoning_content }),
+          encryptedContent: void 0,
+          summary: []
+        })
+      );
+    }
+    if (message.content) {
+      items.push(ModelMessageItem.rehydrate({ text: message.content }));
+    }
+    for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
+      items.push(
+        FunctionCallItem.rehydrate({
+          callId: toolCall.id,
+          name: toolCall.function.name,
+          args: toolCall.function.arguments
+        })
+      );
+    }
+    return items;
+  }
+};
+
+// src/application/services/inference-runner.ts
+var InferenceRunner = class {
+  async *run(context, modelInfo, signal) {
+    const { model, endpoint } = modelInfo;
+    const request = new InferenceRequest(model, context);
+    if (model.getStreaming()) {
+      yield* endpoint.stream(request);
+      return;
+    }
+    const response = await endpoint.infer(request);
+    for (const item of response.contextItems) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield item;
+    }
+  }
+};
+
+// src/application/use-cases/run-inference.ts
+var RunInference = class {
+  constructor(modelRepository, inferenceRunner) {
+    this.modelRepository = modelRepository;
+    this.inferenceRunner = inferenceRunner;
+  }
+  setModelCapabilities(model, inferenceParams) {
+    const { streaming, tools, reasoningEffort, structuredOutput } = inferenceParams;
+    if (streaming) {
+      model.setStreaming(true);
+    }
+    if (tools) {
+      model.setTools(tools);
+    }
+    if (reasoningEffort) {
+      model.setReasoningEffort(reasoningEffort);
+    }
+    if (structuredOutput) {
+      model.setStructuredOutput(structuredOutput);
+    }
+    return model;
+  }
+  async execute(inferenceParams) {
+    const { model, context, caller, environment, signal } = inferenceParams;
+    const modelInfo = this.modelRepository.getModelInfo(model);
+    const generativeModel = this.setModelCapabilities(modelInfo.model, inferenceParams);
+    modelInfo.model = generativeModel;
+    const result = this.inferenceRunner.run(context, modelInfo, signal);
+    for await (const item of result) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      if (item instanceof ReasoningItem) {
+        environment.deliverReasoning(caller, item);
+      } else if (item instanceof FunctionCallItem) {
+        environment.deliverFunctionCall(caller, item);
+      } else if (item instanceof ModelMessageItem) {
+        environment.deliverModelMessage(caller, item);
+      } else if (item instanceof SemanticEvent) {
+        environment.deliverSemanticEvent(caller, item);
+      }
+    }
+  }
+};
+
+// src/application/use-cases/execute-function-call.ts
+var ExecuteFunctionCall = class {
+  constructor(functionCallRunner) {
+    this.functionCallRunner = functionCallRunner;
+  }
+  async execute(environment, functionCallItem, tool, caller, signal) {
+    const stream = this.functionCallRunner.run(functionCallItem, tool, signal);
+    for await (const item of stream) {
+      environment.deliverFunctionCallOutput(caller, item);
+    }
+  }
+};
+
+// src/application/services/model-repository.ts
+var ModelRepository = class {
+  getModelInfo(model) {
+    switch (model) {
+      case "gpt-5-4":
+        return { endpoint: new OpenAIResponses(), model: new Gpt54() };
+      case "gpt-5-4-mini":
+        return { endpoint: new OpenAIResponses(), model: new Gpt54Mini() };
+      case "gpt-5-4-nano":
+        return { endpoint: new OpenAIResponses(), model: new Gpt54Nano() };
+      case "gpt-5-5":
+        return { endpoint: new OpenAIResponses(), model: new Gpt55() };
+      case "claude-4-5-haiku":
+        return { endpoint: new AnthropicMessages(), model: new ClaudeHaiku45() };
+      case "claude-4-6-sonnet":
+        return { endpoint: new AnthropicMessages(), model: new ClaudeSonnet46() };
+      case "claude-4-7-opus":
+        return { endpoint: new AnthropicMessages(), model: new ClaudeOpus47() };
+      case "claude-4-8-opus":
+        return { endpoint: new AnthropicMessages(), model: new ClaudeOpus48() };
+      case "gemini-3-5-flash":
+        return { endpoint: new GeminiGenerateContent(), model: new Gemini35Flash() };
+      case "gemini-3-1-pro":
+        return { endpoint: new GeminiGenerateContent(), model: new Gemini31Pro() };
+      case "deepseek-v4-flash":
+        return { endpoint: new OpenAIChatCompletions(), model: new DeepSeekV4Flash() };
+      case "deepseek-v4-pro":
+        return { endpoint: new OpenAIChatCompletions(), model: new DeepSeekV4Pro() };
+      default:
+        throw new Error(`Unsupported model: ${model}`);
+    }
+  }
+};
+
+// src/application/services/function-call-runner.ts
+var FunctionCallRunner = class {
+  async *run(call, tool, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      return;
+    }
+    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));
+  }
+};
+
+// src/application/participants/participant.ts
+var BaseParticipant = class extends Participant {
+  onFunctionCall(item) {
+  }
+  onExternalFunctionCall(source, item) {
+  }
+  onFunctionCallOutput(item) {
+  }
+  onExternalFunctionCallOutput(source, item) {
+  }
+  onReasoning(item) {
+  }
+  onExternalReasoning(source, item) {
+  }
+  onModelMessage(item) {
+  }
+  onExternalModelMessage(source, item) {
+  }
+  onMessage(message) {
+  }
+  onJoined() {
+  }
+  onLeft() {
+  }
+  onParticipantJoined(participant) {
+  }
+  onParticipantLeft(participant) {
+  }
+  onInternalEvent(item) {
+  }
+  onExternalEvent(source, item) {
+  }
+  onError(error) {
+  }
+  onParticipantError(source, error) {
+  }
+};
+
+// src/application/use-cases/send-message.ts
+var SendMessage = class {
+  async execute(environment, message, caller) {
+    if (!caller.isJoinedTo(environment)) {
+      throw new Error("Not joined to environment");
+    }
+    environment.deliverMessage(caller, message);
+  }
+};
+
+// src/index.ts
+var runInferenceUseCase = new RunInference(new ModelRepository(), new InferenceRunner());
+var executeFunctionCallUseCase = new ExecuteFunctionCall(new FunctionCallRunner());
+var sendMessageUseCase = new SendMessage();
+var runInference = (inferenceParams) => {
+  runInferenceUseCase.execute(inferenceParams);
+};
+var executeFunctionCall = (environment, functionCallItem, tool, caller) => {
+  executeFunctionCallUseCase.execute(environment, functionCallItem, tool, caller);
+};
+var sendMessage = (environment, message, caller) => {
+  sendMessageUseCase.execute(environment, message, caller);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Agent,
   AgenticEnvironment,
+  AgenticError,
   AnthropicMessages,
-  BaseAgent,
-  BaseHuman,
-  BaseObserver,
+  BaseParticipant,
   ClaudeHaiku45,
   ClaudeOpus47,
+  ClaudeOpus48,
   ClaudeSonnet46,
   ContextItem,
-  DefaultFunctionCallRunner,
+  DeepSeekV4Flash,
+  DeepSeekV4Pro,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
+  Gemini31Pro,
+  Gemini35Flash,
+  GeminiGenerateContent,
   Gpt54,
   Gpt54Mini,
   Gpt54Nano,
   Gpt55,
-  Human,
   InMemoryModelContextRepository,
   InferenceRequest,
   InferenceResponse,
   InputTokenDetails,
   ModelContext,
   ModelMessageItem,
-  Observer,
-  OpenAIInferenceRunner,
+  OpenAIChatCompletions,
   OpenAIResponses,
   OutputTokenDetails,
   Participant,
@@ -1279,6 +2070,9 @@ var ClaudeHaiku45 = class {
   SemanticEvent,
   SystemMessageItem,
   TokenUsage,
-  UserMessageItem
+  UserMessageItem,
+  executeFunctionCall,
+  runInference,
+  sendMessage
 });
 //# sourceMappingURL=index.js.map