@mozaik-ai/core 3.13.1 → 4.0.0-beta.1

package/dist/index.mjs

@@ -1,39 +1,26 @@
 // src/domain/model-context/model-context.ts
 var ModelContext = class _ModelContext {
-  constructor(id, projectId, items) {
-    this.projectId = projectId;
+  constructor(id, items) {
     this.id = id;
     this.items = items;
   }
-  addContextItem(item) {
-    this.items.push(item);
-    return this;
-  }
-  applyModelOutput(items) {
-    for (const item of items) {
-      const itemType = item.getType();
-      if (itemType !== "function_call" && itemType !== "message" && itemType !== "reasoning") {
-        throw new Error(`Invalid item type: ${itemType}`);
-      }
-    }
-    this.items.push(...items);
-    return this;
-  }
   getItems() {
     return this.items;
   }
-  getLastItem() {
-    if (this.items.length === 0) {
-      throw new Error("No items in context");
-    }
-    return this.items[this.items.length - 1];
+  addContextItems(contextItems) {
+    this.items.push(...contextItems);
+    return this;
+  }
+  addItem(item) {
+    this.items.push(item);
+    return this;
   }
-  static create(projectId) {
+  static create() {
     const id = crypto.randomUUID();
-    return new _ModelContext(id, projectId, []);
+    return new _ModelContext(id, []);
   }
   static rehydrate(data) {
-    return new _ModelContext(data.id, data.projectId, data.items);
+    return new _ModelContext(data.id, data.items);
   }
 };
 
@@ -158,8 +145,8 @@ var StructuredOutputValidation = class {
   constructor() {
     this.name = "structured-output";
   }
-  isValid(inferenceParams, model) {
-    if (inferenceParams.structuredOutput === void 0) {
+  isValid(inferenceInput, model) {
+    if (inferenceInput.structuredOutput === void 0) {
       return true;
     }
     return model.supportsStructuredOutput;
@@ -204,46 +191,96 @@ var TokenUsage = class {
   }
 };
 
-// src/infrastructure/repository/in-memory-model-context-repository.ts
-var InMemoryModelContextRepository = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-    this.projectIndex = /* @__PURE__ */ new Map();
-  }
-  async save(context) {
-    const existing = this.store.get(context.id);
-    if (existing && existing.projectId !== context.projectId) {
-      const prevSet = this.projectIndex.get(existing.projectId);
-      prevSet == null ? void 0 : prevSet.delete(existing.id);
-      if (prevSet && prevSet.size === 0) this.projectIndex.delete(existing.projectId);
-    }
-    this.store.set(context.id, this.clone(context));
-    let set = this.projectIndex.get(context.projectId);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.projectIndex.set(context.projectId, set);
-    }
-    set.add(context.id);
-  }
-  async get(id) {
-    const context = this.store.get(id);
-    if (!context) {
-      throw new Error(`Context not found: ${id}`);
-    }
-    return this.clone(context);
-  }
-  async getByProjectId(projectId) {
-    const ids = this.projectIndex.get(projectId);
-    if (!ids || ids.size === 0) return [];
-    return [...ids].map((id) => this.store.get(id)).filter((c) => Boolean(c)).map((c) => this.clone(c));
-  }
-  clone(context) {
-    return ModelContext.rehydrate({
-      id: context.id,
-      projectId: context.projectId,
-      items: [...context.getItems()]
+// src/infrastructure/mcp/mcp-client.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var McpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.connected = false;
+    var _a, _b;
+    const headers = { ...(_a = config.headers) != null ? _a : {} };
+    if (config.authToken) headers.Authorization = `Bearer ${config.authToken}`;
+    this.transport = new StreamableHTTPClientTransport(
+      new URL(config.url),
+      Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0
+    );
+    this.client = new Client({ name: (_b = config.name) != null ? _b : "mozaik", version: "1.0.0" }, { capabilities: {} });
+  }
+  async connect() {
+    if (this.connected) return;
+    await this.client.connect(this.transport);
+    this.connected = true;
+  }
+  /** The tools this server exposes. */
+  async listTools() {
+    var _a;
+    await this.connect();
+    const res = await this.client.listTools();
+    return ((_a = res.tools) != null ? _a : []).map((t) => {
+      var _a2, _b;
+      return {
+        name: t.name,
+        description: (_a2 = t.description) != null ? _a2 : "",
+        inputSchema: (_b = t.inputSchema) != null ? _b : { type: "object", properties: {} }
+      };
     });
   }
+  /** Call a tool by name; returns its text output. Throws if the server flags an error. */
+  async callTool(name, args) {
+    await this.connect();
+    const res = await this.client.callTool({ name, arguments: args != null ? args : {} });
+    const text = extractText(res);
+    if (res.isError) {
+      throw new Error(`MCP tool "${name}" failed: ${text || "unknown error"}`);
+    }
+    return text;
+  }
+  async close() {
+    if (!this.connected) return;
+    try {
+      await this.client.close();
+    } catch (e) {
+    }
+    this.connected = false;
+  }
+};
+function extractText(res) {
+  const content = res.content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((c) => (c == null ? void 0 : c.type) === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
+}
+
+// src/infrastructure/mcp/mcp-tool-registry.ts
+var McpToolRegistry = class {
+  constructor(servers, createClient = (config) => new McpClient(config)) {
+    this.servers = servers;
+    this.createClient = createClient;
+    this.clients = [];
+  }
+  /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
+  async discoverTools() {
+    const tools = [];
+    for (const server of this.servers) {
+      const client = this.createClient(server);
+      this.clients.push(client);
+      for (const spec of await client.listTools()) {
+        tools.push({
+          type: "function",
+          name: spec.name,
+          description: spec.description,
+          parameters: spec.inputSchema,
+          strict: false,
+          invoke: (args) => client.callTool(spec.name, args != null ? args : {})
+        });
+      }
+    }
+    return tools;
+  }
+  /** Close all underlying MCP connections. */
+  async close() {
+    await Promise.all(this.clients.map((c) => c.close()));
+  }
 };
 
 // src/domain/model-context/context-item/client-item/system-message.ts
@@ -264,397 +301,598 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   }
 };
 
-// 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)) {
-      return;
-    }
-    environment.subscribe(this);
-    this.environments.push(environment);
-    this.active.set(environment, true);
+// src/domain/agentic-environment/semantic-event/event.ts
+var SemanticEvent = class _SemanticEvent {
+  constructor(type, producerId, occurredAt, payload) {
+    this.type = type;
+    this.producerId = producerId;
+    this.occurredAt = occurredAt;
+    this.payload = payload;
   }
-  leave(environment) {
-    if (!this.isJoinedTo(environment)) {
-      return;
-    }
-    environment.unsubscribe(this);
-    this.environments = this.environments.filter((e) => e !== environment);
-    this.active.delete(environment);
+  static create(type, producerId, payload) {
+    const occurredAt = /* @__PURE__ */ new Date();
+    return new _SemanticEvent(type, producerId, occurredAt, payload);
   }
-  isJoinedTo(environment) {
-    return this.environments.includes(environment);
+};
+var MessageSentEvent = class extends SemanticEvent {
+  static init(producerId, message) {
+    return SemanticEvent.create("message.sent", producerId, { message });
   }
-  getEnvironments() {
-    return this.environments;
+};
+
+// src/application/states/inference.ts
+var InferenceState = class {
+  constructor(inferenceRunner) {
+    this.inferenceRunner = inferenceRunner;
+    this.id = "inference";
+  }
+  async run(input, loopVisitor) {
+    loopVisitor.visitInferenceStarted(input);
+    const output = await this.inferenceRunner.run(input);
+    loopVisitor.visitInferenceCompleted(output);
+    return {
+      stateId: this.id,
+      input,
+      output
+    };
   }
-  getListeners() {
-    return this.listens;
+};
+
+// src/domain/agentic-environment/participant/participant.ts
+var Participant = class {
+  constructor(manifest, handlers) {
+    this.manifest = manifest;
+    this.handlers = handlers;
   }
-  getEnvironmentState(environment) {
-    return this.active.get(environment);
+  getManifest() {
+    return this.manifest;
   }
-  markInactive(environment) {
-    if (this.active.has(environment)) {
-      this.active.set(environment, false);
-    }
+  getId() {
+    return this.manifest.id;
   }
-  markActive(environment) {
-    if (this.active.has(environment)) {
-      this.active.set(environment, true);
-    }
+  getHandlers() {
+    return this.handlers;
   }
 };
 
-// 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;
+// src/domain/agentic-environment/participant/memory.ts
+var Memory = class _Memory {
+  constructor(context) {
+    this.context = context;
   }
-  getSource() {
-    return this.source;
+  getContext() {
+    return this.context;
   }
-  getEnvironment() {
-    return this.environment;
+  static create() {
+    const context = ModelContext.create();
+    return new _Memory(context);
   }
 };
 
-// src/domain/agentic-environment/agentic-environment.ts
-var AgenticEnvironment = class {
-  constructor(name, opts) {
-    this.subscribers = [];
-    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);
-    for (const subscriber of this.subscribers) {
-      if (participant === subscriber) {
-        participant.onJoined();
-      } else {
-        subscriber.onParticipantJoined(participant);
-      }
-    }
+// src/domain/agentic-environment/participant/agent.ts
+var Agent = class _Agent extends Participant {
+  constructor(manifest, developerMessage, tools, memory, handlers) {
+    super(manifest, handlers);
+    this.memory = memory;
+    this.developerMessage = developerMessage;
+    this.tools = tools;
+  }
+  static create({
+    name,
+    instruction,
+    tools,
+    capabilities,
+    handlers
+  }) {
+    const id = crypto.randomUUID();
+    const memory = Memory.create();
+    const manifest = { id, name, capabilities, role: "agent" };
+    const developerMessage = DeveloperMessageItem.create(instruction);
+    memory.getContext().addItem(developerMessage);
+    return new _Agent(manifest, instruction, tools, memory, handlers);
   }
-  unsubscribe(participant) {
-    const exists = this.subscribers.includes(participant);
-    if (!exists) {
-      return;
-    }
-    participant.onLeft();
-    this.subscribers = this.subscribers.filter((p) => p !== participant);
-    for (const subscriber of this.subscribers) {
-      subscriber.onParticipantLeft(participant);
-    }
+  getTools() {
+    return this.tools;
   }
-  deliverFunctionCall(source, item) {
-    this.deliverToSubscribers(source, {
-      internal: (src) => src.onFunctionCall(item),
-      external: (sub) => sub.onExternalFunctionCall(source, item)
-    });
+  getDeveloperMessage() {
+    return this.developerMessage;
   }
-  deliverModelMessage(source, item) {
-    this.deliverToSubscribers(source, {
-      internal: (src) => src.onModelMessage(item),
-      external: (sub) => sub.onExternalModelMessage(source, item)
-    });
+  getMemory() {
+    return this.memory;
   }
-  deliverReasoning(source, item) {
-    this.deliverToSubscribers(source, {
-      internal: (src) => src.onReasoning(item),
-      external: (sub) => sub.onExternalReasoning(source, item)
-    });
+};
+
+// src/application/use-cases/create-agent.ts
+function createAgent({
+  name,
+  capabilities,
+  instruction,
+  tools,
+  handlers
+}) {
+  return Agent.create({ name, instruction, capabilities, tools, handlers });
+}
+
+// src/domain/agentic-environment/participant/human.ts
+var Human = class _Human extends Participant {
+  constructor(manifest, handlers) {
+    super(manifest, handlers);
+  }
+  static create({
+    name,
+    capabilities,
+    handlers
+  }) {
+    const id = crypto.randomUUID();
+    const manifest = { id, name, capabilities, role: "human" };
+    return new _Human(manifest, handlers);
   }
-  deliverFunctionCallOutput(source, item) {
-    this.deliverToSubscribers(source, {
-      internal: (src) => src.onFunctionCallOutput(item),
-      external: (sub) => sub.onExternalFunctionCallOutput(source, item)
-    });
+};
+
+// src/application/use-cases/create-human.ts
+function createHuman({
+  name,
+  capabilities,
+  handlers
+}) {
+  return Human.create({ name, capabilities, handlers });
+}
+
+// src/domain/agentic-environment/runtime-state.ts
+var RuntimeState = class {
+  constructor() {
+    this.participants = /* @__PURE__ */ new Map();
   }
-  deliverMessage(source, message) {
-    this.deliverToSubscribers(source, {
-      external: (sub) => sub.onMessage(message)
-    });
+  addParticipant(participant) {
+    const isExists = this.participants.get(participant.getId());
+    if (isExists) return;
+    this.participants.set(participant.getId(), participant);
   }
-  deliverSemanticEvent(source, item) {
-    this.deliverToSubscribers(source, {
-      internal: (src) => src.onInternalEvent(item),
-      external: (sub) => sub.onExternalEvent(source, item)
-    });
+  removeParticipant(participant) {
+    this.participants.delete(participant.getId());
   }
-  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)}`
-            );
-          }
-        }
-      }
-    });
+  getParticipant(id) {
+    return this.participants.get(id);
   }
-  getListeningParticipants(source) {
-    return this.subscribers.filter(
-      (sub) => sub !== source && (sub.getListeners().length === 0 || sub.getListeners().some((listener) => source instanceof listener))
-    );
+  getParticipants() {
+    return [...this.participants.values()];
   }
-  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);
-        }
-      }
+};
+
+// src/application/services/runtime.ts
+var RuntimeService = class {
+  constructor(state, processor, inferenceRunner, functionCallRunner) {
+    this.state = state;
+    this.processor = processor;
+    this.inferenceRunner = inferenceRunner;
+    this.functionCallRunner = functionCallRunner;
+  }
+  join(participant) {
+    this.state.addParticipant(participant);
+  }
+  leave(participant) {
+    this.state.removeParticipant(participant);
+  }
+  publish(event) {
+    for (const participant of this.state.getParticipants()) {
+      this.processor.process(event, participant);
     }
   }
-  handleError(subscriber, error) {
-    if (error instanceof AgenticError) {
-      return this.deliverError(subscriber, error);
+  getParticipant(id) {
+    if (!this.state.getParticipant(id)) {
+      throw new Error(`Participant ${id} not found`);
     }
-    const agenticError = new AgenticError({
-      message: error.message,
-      stack: error.stack,
-      enviornment: this,
-      source: subscriber
-    });
-    return this.deliverError(subscriber, agenticError);
+    return this.state.getParticipant(id);
   }
-};
-
-// src/domain/model-context/semantic-event/semantic-event.ts
-var SemanticEvent = class {
-  constructor(type, data) {
-    this.type = type;
-    this.data = data;
+  getInferenceRunner() {
+    return this.inferenceRunner;
   }
-  getType() {
-    return this.type;
+  getFunctionCallRunner() {
+    return this.functionCallRunner;
   }
 };
 
-// src/domain/agentic-environment/inference/response.ts
-var InferenceResponse = class {
-  constructor(contextItems, tokenUsage) {
-    this.contextItems = contextItems;
-    this.tokenUsage = tokenUsage;
+// src/domain/agentic-environment/semantic-event/event-processor.ts
+var EventProcessor = class {
+  process(event, consumer) {
+    for (const handler of consumer.getHandlers()) {
+      const isSatisfied = handler.specification.isSatisfiedBy({
+        event,
+        participant: consumer
+      });
+      if (isSatisfied) {
+        handler.processor.apply({ event, participant: consumer });
+      }
+    }
   }
 };
 
-// src/application/services/inference-runner.ts
-var StreamingInference = class {
-  async *run(request, endpoint) {
-    var _a;
-    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-      return;
+// src/application/use-cases/join.ts
+function createJoin(resolveRuntime) {
+  return function join(participant) {
+    resolveRuntime().join(participant);
+  };
+}
+
+// src/application/use-cases/leave.ts
+function createLeave(resolveRuntime) {
+  return function leave(participant) {
+    resolveRuntime().leave(participant);
+  };
+}
+
+// src/application/use-cases/send-message.ts
+function createSendMessage(resolveRuntime) {
+  return function sendMessage(message, senderId) {
+    const runtime = resolveRuntime();
+    const participant = runtime.getParticipant(senderId);
+    if (!participant) {
+      throw new Error(`Participant ${senderId} not found`);
+    }
+    const userMessage = MessageSentEvent.init(senderId, message);
+    runtime.publish(userMessage);
+  };
+}
+
+// src/domain/agentic-environment/loop/agent-loop.ts
+var AgentLoop = class {
+  constructor(stateExecutor, transitionResolver, loopVisitor) {
+    this.stateExecutor = stateExecutor;
+    this.transitionResolver = transitionResolver;
+    this.loopVisitor = loopVisitor;
+  }
+  async run(message) {
+    let transition = {
+      nextStateId: "message_received",
+      input: message
+    };
+    while (transition.nextStateId !== "idle") {
+      const execution = await this.stateExecutor.execute(transition, this.loopVisitor);
+      transition = this.transitionResolver.resolve(execution);
     }
-    yield* endpoint.stream(request, request.signal);
   }
 };
-var NonStreamingInference = class {
-  async *run(request, endpoint) {
-    var _a, _b;
-    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
-      return;
-    }
-    const response = await endpoint.infer(request);
-    for (const item of response.contextItems) {
-      if ((_b = request.signal) == null ? void 0 : _b.aborted) {
-        break;
-      }
-      yield item;
+
+// src/domain/agentic-environment/loop/state-executor.ts
+var LoopStateExecutor = class {
+  constructor(messageReceivedState, inferenceState, functionCallState, modelMessageState) {
+    this.messageReceivedState = messageReceivedState;
+    this.inferenceState = inferenceState;
+    this.functionCallState = functionCallState;
+    this.modelMessageState = modelMessageState;
+  }
+  async execute(transition, loopVisitor) {
+    switch (transition.nextStateId) {
+      case "message_received":
+        return await this.messageReceivedState.run(transition.input, loopVisitor);
+      case "inference":
+        return await this.inferenceState.run(transition.input, loopVisitor);
+      case "function_call":
+        return await this.functionCallState.run(transition.input, loopVisitor);
+      case "model_message":
+        return await this.modelMessageState.run(transition.input, loopVisitor);
     }
   }
 };
 
-// src/application/use-cases/run-inference.ts
-var RunInference = class {
-  constructor(generativeModelRepository2, requestValidator) {
-    this.generativeModelRepository = generativeModelRepository2;
-    this.requestValidator = requestValidator;
+// src/application/states/function-call.ts
+var FunctionCallState = class {
+  constructor(functionCallRunner) {
+    this.functionCallRunner = functionCallRunner;
+    this.id = "function_call";
   }
-  async execute(inferenceParams) {
+  async run(input, loopVisitor) {
     var _a;
-    const { caller, environment, signal } = inferenceParams;
-    const generativeModel = await this.generativeModelRepository.getByModelName(inferenceParams.model);
-    this.requestValidator.validate(inferenceParams, generativeModel.specification);
-    const resolvedParams = {
-      ...inferenceParams,
-      maxOutputTokens: (_a = inferenceParams.maxOutputTokens) != null ? _a : generativeModel.specification.maxOutputTokens
-    };
-    const inferenceRunner = inferenceParams.streaming ? new StreamingInference() : new NonStreamingInference();
-    const result = inferenceRunner.run(resolvedParams, generativeModel.endpoint);
-    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);
-      }
+    loopVisitor.visitFunctionCallStarted(input);
+    const { call, inferenceInput } = input;
+    let tool = (_a = inferenceInput.tools) == null ? void 0 : _a.find((tool2) => tool2.name === call.name);
+    if (!tool) {
+      return {
+        stateId: this.id,
+        input,
+        output: {
+          item: FunctionCallOutputItem.create(call.callId, `Error: unknown tool "${call.name}"`)
+        }
+      };
     }
+    const item = await this.functionCallRunner.run(call, tool);
+    loopVisitor.visitFunctionCallCompleted(item);
+    return {
+      stateId: this.id,
+      input,
+      output: {
+        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/states/message-received.ts
+var MessageReceivedState = class {
+  constructor() {
+    this.id = "message_received";
+  }
+  async run(input, loopVisitor) {
+    loopVisitor.visitMessageReceivedStarted(input);
+    const userMessage = UserMessageItem.create(input.content);
+    const output = {
+      ...input.input,
+      context: input.input.context.addContextItems([userMessage])
+    };
+    loopVisitor.visitMessageReceivedCompleted(output);
+    return {
+      stateId: this.id,
+      input,
+      output
+    };
   }
 };
 
-// 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/states/model-message.ts
+var ModelMessageState = class {
+  constructor() {
+    this.id = "model_message";
+  }
+  async run(input, loopVisitor) {
+    loopVisitor.visitModelAnswer(input);
+    return {
+      stateId: this.id,
+      input,
+      output: void 0
+    };
   }
 };
 
-// src/application/participants/participant.ts
-var BaseParticipant = class extends Participant {
-  onFunctionCall(item) {
+// src/domain/agentic-environment/loop/transition-resolver.ts
+var TransitionResolver = class {
+  constructor(rules) {
+    this.rules = rules;
   }
-  onExternalFunctionCall(source, item) {
+  resolve(execution) {
+    const rule = this.rules.find((rule2) => rule2.specification.isSatisfiedBy(execution));
+    if (!rule) {
+      throw new Error(`No transition rule found after "${execution.stateId}"`);
+    }
+    return rule.createTransition(execution);
   }
-  onFunctionCallOutput(item) {
+};
+
+// src/domain/agentic-environment/loop/transition-specification.ts
+var MessageReceivedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "message_received";
   }
-  onExternalFunctionCallOutput(source, item) {
+};
+var InferenceProducedFunctionCallSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "inference" && execution.output.items.some((item) => item.type === "function_call");
   }
-  onReasoning(item) {
+};
+var InferenceProducedModelMessageSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "inference" && execution.output.items.some((item) => item.type === "message" && item.role === "assistant");
   }
-  onExternalReasoning(source, item) {
+};
+var FunctionCallCompletedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "function_call";
   }
-  onModelMessage(item) {
+};
+var ModelMessageCompletedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "model_message";
   }
-  onExternalModelMessage(source, item) {
+};
+
+// src/domain/agentic-environment/loop/transition-rule.ts
+var MessageReceivedToInferenceRule = class {
+  constructor() {
+    this.specification = new MessageReceivedSpecification();
   }
-  onMessage(message) {
+  createTransition(execution) {
+    if (execution.stateId !== "message_received") {
+      throw new Error("Expected message_received execution");
+    }
+    return {
+      nextStateId: "inference",
+      input: execution.output
+    };
   }
-  onJoined() {
+};
+var InferenceToFunctionCallRule = class {
+  constructor() {
+    this.specification = new InferenceProducedFunctionCallSpecification();
   }
-  onLeft() {
+  createTransition(execution) {
+    if (execution.stateId !== "inference" || !execution.output.items.some((item) => item.type === "function_call")) {
+      throw new Error("Expected inference function-call output");
+    }
+    const functionCallItem = execution.output.items.find((item) => item.type === "function_call");
+    if (!functionCallItem) {
+      throw new Error("Expected inference function-call output");
+    }
+    return {
+      nextStateId: "function_call",
+      input: {
+        call: functionCallItem,
+        inferenceInput: execution.input
+      }
+    };
   }
-  onParticipantJoined(participant) {
+};
+var InferenceToModelMessageRule = class {
+  constructor() {
+    this.specification = new InferenceProducedModelMessageSpecification();
   }
-  onParticipantLeft(participant) {
+  createTransition(execution) {
+    if (execution.stateId !== "inference" || !execution.output.items.some((item) => item.type === "message" && item.role === "assistant")) {
+      throw new Error("Expected inference model-message output");
+    }
+    const modelMessageItem = execution.output.items.find(
+      (item) => item.type === "message" && item.role === "assistant"
+    );
+    if (!modelMessageItem) {
+      throw new Error("Expected inference model-message output");
+    }
+    return {
+      nextStateId: "model_message",
+      input: {
+        answer: modelMessageItem
+      }
+    };
   }
-  onInternalEvent(item) {
+};
+var FunctionCallToInferenceRule = class {
+  constructor() {
+    this.specification = new FunctionCallCompletedSpecification();
   }
-  onExternalEvent(source, item) {
+  createTransition(execution) {
+    if (execution.stateId !== "function_call") {
+      throw new Error("Expected function_call execution");
+    }
+    const previousRequest = execution.input.inferenceInput;
+    previousRequest.context.addContextItems([execution.input.call, execution.output.item]);
+    return {
+      nextStateId: "inference",
+      input: {
+        ...previousRequest
+      }
+    };
   }
-  onError(error) {
+};
+var ModelMessageToIdleRule = class {
+  constructor() {
+    this.specification = new ModelMessageCompletedSpecification();
   }
-  onParticipantError(source, error) {
+  createTransition(execution) {
+    if (execution.stateId !== "model_message") {
+      throw new Error("Expected model_message execution");
+    }
+    return {
+      nextStateId: "idle",
+      input: void 0
+    };
   }
 };
 
-// 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/domain/agentic-environment/loop/event-publisher-visitor.ts
+var EventPublisherLoopVisitor = class {
+  constructor(agentId, runtime) {
+    this.agentId = agentId;
+    this.runtime = runtime;
+  }
+  visitMessageReceivedStarted(input) {
+    console.log("Visiting message received started: ", input);
+    this.publish("message_received.started", input);
+  }
+  visitMessageReceivedCompleted(output) {
+    console.log("Visiting message received completed: ", output);
+    this.publish("message_received.completed", output);
+  }
+  visitInferenceStarted(input) {
+    console.log("Visiting inference started: ", input);
+    this.publish("inference.started", input);
+  }
+  visitInferenceEvent(event) {
+    console.log("Visiting inference event: ", event);
+    this.publish("inference.stream", event);
+  }
+  visitInferenceCompleted(output) {
+    console.log("Visiting inference completed: ", output);
+    this.publish("inference.completed", output);
+  }
+  visitFunctionCallStarted(input) {
+    console.log("Visiting function call started: ", input);
+    this.publish("function_call.started", input);
+  }
+  visitFunctionCallCompleted(output) {
+    console.log("Visiting function call completed: ", output);
+    this.publish("function_call.completed", output);
+  }
+  visitModelAnswer(input) {
+    console.log("Visiting model answer: ", input.answer);
+    this.publish("model.answer", input);
+  }
+  publish(type, payload) {
+    this.runtime.publish({
+      type,
+      producerId: this.agentId,
+      occurredAt: /* @__PURE__ */ new Date(),
+      payload
+    });
   }
 };
 
+// src/application/use-cases/run-loop.ts
+function createRunLoop(resolveRuntime) {
+  return function runLoop(agentId, message, inferenceInput) {
+    const runtime = resolveRuntime();
+    const inferenceRunner = runtime.getInferenceRunner();
+    const functionCallRunner = runtime.getFunctionCallRunner();
+    const transitionResolver = new TransitionResolver([
+      // High-priority interception rules would go first.
+      new MessageReceivedToInferenceRule(),
+      new InferenceToFunctionCallRule(),
+      new InferenceToModelMessageRule(),
+      new FunctionCallToInferenceRule(),
+      new ModelMessageToIdleRule()
+    ]);
+    const stateExecutor = new LoopStateExecutor(
+      new MessageReceivedState(),
+      new InferenceState(inferenceRunner),
+      new FunctionCallState(functionCallRunner),
+      new ModelMessageState()
+    );
+    const agentLoop = new AgentLoop(
+      stateExecutor,
+      transitionResolver,
+      new EventPublisherLoopVisitor(agentId, runtime)
+    );
+    agentLoop.run({
+      content: message,
+      input: inferenceInput
+    });
+  };
+}
+
 // src/infrastructure/providers/anthropic/endpoints/anthropic-messages-mapper.ts
 var AnthropicMessagesMapper = class {
-  toRequest(inferenceParams) {
-    const { messages, system } = this.mapContextItems(inferenceParams);
+  toRequest(inferenceInput) {
+    const { messages, system } = this.mapContextItems(inferenceInput);
     const outputConfig = {};
     const request = {
-      model: inferenceParams.model,
+      model: inferenceInput.model,
       messages
     };
-    request.max_tokens = inferenceParams.maxOutputTokens;
+    request.max_tokens = inferenceInput.maxOutputTokens;
     if (system) {
       request.system = system;
     }
-    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
-      request.tools = inferenceParams.tools.map((tool) => ({
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
+      request.tools = inferenceInput.tools.map((tool) => ({
         name: tool.name,
         description: tool.description,
         input_schema: tool.parameters
       }));
     }
-    if (inferenceParams.structuredOutput) {
+    if (inferenceInput.structuredOutput) {
       outputConfig.format = {
         type: "json_schema",
-        json_schema: inferenceParams.structuredOutput.schema
+        json_schema: inferenceInput.structuredOutput.schema
       };
     }
-    if (inferenceParams.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       request.thinking = { type: "adaptive" };
-      outputConfig.effort = inferenceParams.reasoningEffort;
+      outputConfig.effort = inferenceInput.reasoningEffort;
     }
     if (Object.keys(outputConfig).length > 0) {
       request.output_config = outputConfig;
     }
-    if (inferenceParams.streaming) {
-      request.stream = inferenceParams.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  toResponse(response) {
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
   addContentBlock(messages, role, block) {
     const lastMessage = messages[messages.length - 1];
     if ((lastMessage == null ? void 0 : lastMessage.role) === role) {
@@ -666,9 +904,9 @@ var AnthropicMessagesMapper = class {
       content: [block]
     });
   }
-  mapContextItems(inferenceParams) {
+  mapContextItems(inferenceInput) {
     var _a, _b, _c;
-    const context = inferenceParams.context;
+    const context = inferenceInput.context;
     const messages = [];
     const system = [];
     for (const item of context.getItems()) {
@@ -735,7 +973,7 @@ var AnthropicMessagesMapper = class {
       new OutputTokenDetails(0)
     );
   }
-  extractContextItems(response) {
+  toResponse(response) {
     var _a;
     const items = [];
     for (const block of response.content) {
@@ -763,30 +1001,27 @@ var AnthropicMessagesMapper = class {
         );
       }
     }
-    return items;
+    return { items, rowResponse: response };
   }
 };
 
 // src/infrastructure/providers/anthropic/endpoints/anthropic-messages.ts
 import Anthropic from "@anthropic-ai/sdk";
 var AnthropicMessages = class {
-  constructor(endpointMapper = new AnthropicMessagesMapper()) {
+  constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
-    this.client = new Anthropic();
+    this.client = new Anthropic({ baseURL: config.baseURL, apiKey: config.apiKey });
   }
-  async infer(inferenceParams) {
-    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
-    const response = await this.client.messages.create(inferenceRequest);
+  async infer(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
+    const response = await this.client.messages.create(request);
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceParams, signal) {
-    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
-    const stream = await this.client.messages.create(inferenceRequest);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
+    const stream = await this.client.messages.create(request);
     for await (const event of stream) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield new SemanticEvent(event.type, event);
+      yield event;
     }
   }
 };
@@ -808,27 +1043,27 @@ var SummaryText = class _SummaryText extends ItemContent {
 
 // src/infrastructure/providers/openai/endpoints/openai-responses-mapper.ts
 var OpenAIResponsesMapper = class {
-  toRequest(inferenceParams) {
+  toRequest(inferenceInput) {
     var _a, _b;
     const request = {
-      model: inferenceParams.model,
-      input: this.mapContextItems(inferenceParams)
+      model: inferenceInput.model,
+      input: this.mapContextItems(inferenceInput)
     };
-    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
-      request.tools = inferenceParams.tools.map((tool) => ({
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
+      request.tools = inferenceInput.tools.map((tool) => ({
         type: tool.type,
         name: tool.name,
         description: tool.description,
         parameters: tool.parameters
       }));
     }
-    if (inferenceParams.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       request.reasoning = {
-        effort: inferenceParams.reasoningEffort
+        effort: inferenceInput.reasoningEffort
       };
     }
-    if (inferenceParams.structuredOutput) {
-      const format = inferenceParams.structuredOutput;
+    if (inferenceInput.structuredOutput) {
+      const format = inferenceInput.structuredOutput;
       request.text = {
         format: {
           type: "json_schema",
@@ -838,19 +1073,14 @@ var OpenAIResponsesMapper = class {
         }
       };
     }
-    if (inferenceParams.streaming) {
-      request.stream = inferenceParams.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  toResponse(response) {
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
-  mapContextItems(inferenceParams) {
+  mapContextItems(inferenceInput) {
     const input = [];
-    for (const item of inferenceParams.context.getItems()) {
+    for (const item of inferenceInput.context.getItems()) {
       if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem || item instanceof UserMessageItem) {
         input.push({
           type: item.type,
@@ -910,7 +1140,7 @@ var OpenAIResponsesMapper = class {
       new OutputTokenDetails((_d = (_c = response.usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
     );
   }
-  extractContextItems(response) {
+  toResponse(response) {
     var _a, _b, _c;
     const items = [];
     for (const item of (_a = response.output) != null ? _a : []) {
@@ -943,7 +1173,10 @@ var OpenAIResponsesMapper = class {
         );
       }
     }
-    return items;
+    return {
+      items,
+      rowResponse: response
+    };
   }
 };
 
@@ -953,19 +1186,16 @@ var OpenAIResponses = class {
     this.endpointMapper = endpointMapper;
     this.client = new OpenAI();
   }
-  async infer(inferenceParams) {
-    const request = this.endpointMapper.toRequest(inferenceParams);
+  async infer(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const response = await this.client.responses.create(request);
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceParams, signal) {
-    const request = this.endpointMapper.toRequest(inferenceParams);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const response = await this.client.responses.create(request);
     for await (const event of response) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield new SemanticEvent(event.type, event);
+      yield event;
     }
   }
 };
@@ -975,16 +1205,16 @@ import { GoogleGenAI } from "@google/genai";
 
 // src/infrastructure/providers/gemini/endpoints/gemini-generate-content-mapper.ts
 var GeminiGenerateContentMapper = class {
-  toRequest(inferenceParams) {
-    const { contents, systemInstruction } = this.mapContextItems(inferenceParams);
+  toRequest(inferenceInput) {
+    const { contents, systemInstruction } = this.mapContextItems(inferenceInput);
     const config = {};
     if (systemInstruction) {
       config.systemInstruction = systemInstruction;
     }
-    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
       config.tools = [
         {
-          functionDeclarations: inferenceParams.tools.map((tool) => ({
+          functionDeclarations: inferenceInput.tools.map((tool) => ({
             name: tool.name,
             description: tool.description,
             parametersJsonSchema: tool.parameters
@@ -992,34 +1222,29 @@ var GeminiGenerateContentMapper = class {
         }
       ];
     }
-    if (inferenceParams.structuredOutput) {
+    if (inferenceInput.structuredOutput) {
       config.responseMimeType = "application/json";
-      config.responseSchema = inferenceParams.structuredOutput.schema;
+      config.responseSchema = inferenceInput.structuredOutput.schema;
     }
-    if (inferenceParams.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       config.thinkingConfig = {
-        thinkingLevel: inferenceParams.reasoningEffort,
+        thinkingLevel: inferenceInput.reasoningEffort,
         includeThoughts: true
       };
     }
     const request = {
-      model: inferenceParams.model,
+      model: inferenceInput.model,
       contents,
       config
     };
-    if (inferenceParams.streaming) {
-      request.stream = inferenceParams.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  toResponse(response) {
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
-  mapContextItems(inferenceParams) {
+  mapContextItems(inferenceInput) {
     var _a;
-    const context = inferenceParams.context;
+    const context = inferenceInput.context;
     const contents = [];
     const system = [];
     const callNames = /* @__PURE__ */ new Map();
@@ -1092,7 +1317,7 @@ var GeminiGenerateContentMapper = class {
       new OutputTokenDetails((_e = usage.thoughtsTokenCount) != null ? _e : 0)
     );
   }
-  extractContextItems(response) {
+  toResponse(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 : [];
@@ -1121,42 +1346,43 @@ var GeminiGenerateContentMapper = class {
         );
       }
     }
-    return items;
+    return { items, rowResponse: response };
   }
 };
 
 // src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
 var GeminiGenerateContent = class {
-  constructor(endpointMapper = new GeminiGenerateContentMapper()) {
+  constructor(endpointMapper = new GeminiGenerateContentMapper(), config = {}) {
+    var _a;
     this.endpointMapper = endpointMapper;
-    this.client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+    this.client = new GoogleGenAI({
+      apiKey: (_a = config.apiKey) != null ? _a : process.env.GEMINI_API_KEY,
+      ...config.baseURL ? { httpOptions: { baseUrl: config.baseURL } } : {}
+    });
   }
-  async infer(inferenceParams) {
-    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
-    const response = await this.client.models.generateContent(inferenceRequest);
+  async infer(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
+    const response = await this.client.models.generateContent(request);
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceParams, signal) {
-    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
-    const stream = await this.client.models.generateContentStream(inferenceRequest);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
+    const stream = await this.client.models.generateContentStream(request);
     for await (const chunk of stream) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield new SemanticEvent("generate_content_chunk", chunk);
+      yield chunk;
     }
   }
 };
 
 // src/infrastructure/providers/openai/endpoints/openai-chat-completions-mapper.ts
 var OpenAIChatCompletionsMapper = class {
-  toRequest(inferenceParams) {
+  toRequest(inferenceInput) {
     const request = {
-      model: inferenceParams.model,
-      messages: this.mapContextItems(inferenceParams)
+      model: inferenceInput.model,
+      messages: this.mapContextItems(inferenceInput)
     };
-    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
-      request.tools = inferenceParams.tools.map((tool) => ({
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
+      request.tools = inferenceInput.tools.map((tool) => ({
         type: "function",
         function: {
           name: tool.name,
@@ -1165,23 +1391,18 @@ var OpenAIChatCompletionsMapper = class {
         }
       }));
     }
-    if (inferenceParams.reasoningEffort) {
-      request.reasoning_effort = inferenceParams.reasoningEffort;
+    if (inferenceInput.reasoningEffort) {
+      request.reasoning_effort = inferenceInput.reasoningEffort;
     }
-    if (inferenceParams.streaming) {
-      request.stream = inferenceParams.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  toResponse(response) {
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
-  }
-  mapContextItems(inferenceParams) {
+  mapContextItems(inferenceInput) {
     var _a;
     const messages = [];
-    for (const item of inferenceParams.context.getItems()) {
+    for (const item of inferenceInput.context.getItems()) {
       if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
         messages.push({ role: "system", content: item.content.text });
         continue;
@@ -1228,12 +1449,12 @@ var OpenAIChatCompletionsMapper = class {
       new OutputTokenDetails((_d = (_c = response.usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
     );
   }
-  extractContextItems(response) {
+  toResponse(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;
+      return { items: [], rowResponse: response };
     }
     if (message.reasoning_content) {
       items.push(
@@ -1256,7 +1477,7 @@ var OpenAIChatCompletionsMapper = class {
         })
       );
     }
-    return items;
+    return { items, rowResponse: response };
   }
 };
 
@@ -1272,24 +1493,20 @@ var OpenAIChatCompletions = class {
     });
     this.extraBody = (_a = config.extraBody) != null ? _a : {};
   }
-  buildRequest(inferenceParams) {
+  buildRequest(inferenceInput) {
     return {
       ...this.extraBody,
-      ...this.endpointMapper.toRequest(inferenceParams)
+      ...this.endpointMapper.toRequest(inferenceInput)
     };
   }
-  async infer(inferenceParams) {
-    const response = await this.client.chat.completions.create(this.buildRequest(inferenceParams));
+  async infer(inferenceInput) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceInput));
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceParams, signal) {
-    var _a;
-    const stream = await this.client.chat.completions.create(this.buildRequest(inferenceParams));
+  async *stream(inferenceInput) {
+    const stream = await this.client.chat.completions.create(this.buildRequest(inferenceInput));
     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);
+      yield event;
     }
   }
 };
@@ -1558,103 +1775,71 @@ var claudeHaiku45Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/repository/generative-model-repository.ts
-var InMemoryGenerativeModelRepository = class {
-  getByModelName(modelName) {
-    let generativeModel = void 0;
-    switch (modelName) {
-      case "gpt-5.4":
-        generativeModel = {
-          endpoint: new OpenAIResponses(),
-          specification: gpt54Specification
-        };
-        break;
-      case "gpt-5.4-mini":
-        generativeModel = {
-          endpoint: new OpenAIResponses(),
-          specification: gpt54MiniSpecification
-        };
-        break;
-      case "gpt-5.4-nano":
-        generativeModel = {
-          endpoint: new OpenAIResponses(),
-          specification: gpt54NanoSpecification
-        };
-        break;
-      case "gpt-5.5":
-        generativeModel = {
-          endpoint: new OpenAIResponses(),
-          specification: gpt55Specification
-        };
-        break;
-      case "claude-haiku-4-5":
-        generativeModel = {
-          endpoint: new AnthropicMessages(),
-          specification: claudeHaiku45Specification
-        };
-        break;
-      case "claude-sonnet-4-6":
-        generativeModel = {
-          endpoint: new AnthropicMessages(),
-          specification: claudeSonnet46Specification
-        };
-        break;
-      case "claude-opus-4-7":
-        generativeModel = {
-          endpoint: new AnthropicMessages(),
-          specification: claudeOpus47Specification
-        };
-        break;
-      case "claude-opus-4-8":
-        generativeModel = {
-          endpoint: new AnthropicMessages(),
-          specification: claudeOpus48Specification
-        };
-        break;
-      case "gemini-3.5-flash":
-        generativeModel = {
-          endpoint: new GeminiGenerateContent(),
-          specification: gemini35FlashSpecification
-        };
-        break;
-      case "gemini-3.1-pro-preview":
-        generativeModel = {
-          endpoint: new GeminiGenerateContent(),
-          specification: gemini31ProSpecification
-        };
-        break;
-      case "deepseek-v4-flash":
-        generativeModel = {
-          endpoint: new OpenAIChatCompletions(),
-          specification: deepSeekV4FlashSpecification
-        };
-        break;
-      case "deepseek-v4-pro":
-        generativeModel = {
-          endpoint: new OpenAIChatCompletions(),
-          specification: deepSeekV4ProSpecification
-        };
-    }
-    if (!generativeModel) {
-      throw new Error(`Unsupported model: ${modelName}`);
-    }
-    return Promise.resolve(generativeModel);
+// src/application/services/models.ts
+var supportedModels = [
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt54Specification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt54MiniSpecification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt54NanoSpecification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt55Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeHaiku45Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeSonnet46Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeOpus47Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeOpus48Specification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini35FlashSpecification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini31ProSpecification
+  },
+  {
+    endpoint: new OpenAIChatCompletions(),
+    specification: deepSeekV4FlashSpecification
+  },
+  {
+    endpoint: new OpenAIChatCompletions(),
+    specification: deepSeekV4ProSpecification
   }
-};
+];
 
 // src/domain/generative-model/request-validation/reasoning-effort.ts
 var ReasoningEffortValidation = class {
   constructor() {
     this.name = "reasoning-effort";
   }
-  isValid(inferenceParams, model) {
-    if (inferenceParams.reasoningEffort === void 0) {
+  isValid(inferenceInput, model) {
+    if (inferenceInput.reasoningEffort === void 0) {
       return true;
     }
     if (!model.supportsReasoningEffort) {
       return false;
     }
-    return model.supportedReasoningEfforts.includes(inferenceParams.reasoningEffort);
+    return model.supportedReasoningEfforts.includes(inferenceInput.reasoningEffort);
   }
 };
 
@@ -1663,8 +1848,8 @@ var ToolCallingValidation = class {
   constructor() {
     this.name = "tool-calling";
   }
-  isValid(inferenceParams, model) {
-    if (inferenceParams.tools === void 0) {
+  isValid(inferenceInput, model) {
+    if (inferenceInput.tools === void 0) {
       return true;
     }
     return model.supportsFunctionCalling;
@@ -1676,8 +1861,8 @@ var StreamingValidation = class {
   constructor() {
     this.name = "streaming";
   }
-  isValid(inferenceParams, model) {
-    if (!inferenceParams.streaming) {
+  isValid(inferenceInput, model) {
+    if (!inferenceInput.streaming) {
       return true;
     }
     return model.supportsStreaming;
@@ -1704,8 +1889,8 @@ var ContextValidation = class {
   constructor() {
     this.name = "context";
   }
-  isValid(inferenceParams, model) {
-    return inferenceParams.context.items.every(
+  isValid(inferenceInput, model) {
+    return inferenceInput.context.items.every(
       (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
     );
   }
@@ -1719,56 +1904,122 @@ var defaultRequestValidationRules = [
   new StructuredOutputValidation(),
   new ContextValidation()
 ];
-var InferenceRequestValidator = class {
+var InferenceInputValidator = class {
   constructor(rules = defaultRequestValidationRules) {
     this.rules = rules;
   }
-  validate(inferenceParams, model) {
+  validate(inferenceInput, model) {
     for (const rule of this.rules) {
-      if (!rule.isValid(inferenceParams, model)) {
+      if (!rule.isValid(inferenceInput, model)) {
         throw new Error(`Request validation "${rule.name}" failed for model "${model.name}"`);
       }
     }
   }
 };
 
-// src/index.ts
-var generativeModelRepository = new InMemoryGenerativeModelRepository();
-var inferenceRequestValidator = new InferenceRequestValidator();
-var runInferenceUseCase = new RunInference(generativeModelRepository, inferenceRequestValidator);
-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);
+// src/application/services/inference-runner.ts
+var DefaultInferenceRunner = class {
+  constructor(supportedModels2, requestValidator) {
+    this.supportedModels = supportedModels2;
+    this.requestValidator = requestValidator;
+  }
+  async run(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
+    }
+    this.requestValidator.validate(input, generativeModel.specification);
+    return await generativeModel.endpoint.infer(input);
+  }
+  async streamInference(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
+    }
+    this.requestValidator.validate(input, generativeModel.specification);
+    return await generativeModel.endpoint.stream(input);
+  }
 };
-var sendMessage = (environment, message, caller) => {
-  sendMessageUseCase.execute(environment, message, caller);
+
+// src/application/services/function-call.ts
+var DefaultFunctionCallRunner = class {
+  async run(input, tool) {
+    try {
+      const result = await tool.invoke(JSON.parse(input.args));
+      return FunctionCallOutputItem.create(input.callId, JSON.stringify(result));
+    } catch (error) {
+      return FunctionCallOutputItem.create(input.callId, `Error calling tool: ${error}`);
+    }
+  }
 };
+
+// src/define-runtime.ts
+function defineRuntime() {
+  let runtime = null;
+  const processor = new EventProcessor();
+  function initializeRuntime(config) {
+    var _a, _b, _c, _d;
+    if (runtime) {
+      throw new Error("Runtime already initialized");
+    }
+    const inferenceRunner = (_d = (_a = config.inferenceRunnerConfig) == null ? void 0 : _a.runner) != null ? _d : new DefaultInferenceRunner(
+      (_c = (_b = config.inferenceRunnerConfig) == null ? void 0 : _b.supportedModels) != null ? _c : supportedModels,
+      new InferenceInputValidator()
+    );
+    const functionCallRunner = new DefaultFunctionCallRunner();
+    runtime = new RuntimeService(config.state, processor, inferenceRunner, functionCallRunner);
+    return runtime;
+  }
+  function resolveRuntime() {
+    if (!runtime) {
+      throw new Error("Runtime not initialized");
+    }
+    return runtime;
+  }
+  function resolveParticipant(id) {
+    if (!runtime) {
+      throw new Error("Runtime not initialized");
+    }
+    const participant = runtime.state.getParticipant(id);
+    if (!participant) {
+      throw new Error(`Participant ${id} not found`);
+    }
+    return participant;
+  }
+  const join = createJoin(resolveRuntime);
+  const leave = createLeave(resolveRuntime);
+  const sendMessage = createSendMessage(resolveRuntime);
+  const runLoop = createRunLoop(resolveRuntime);
+  return {
+    initializeRuntime,
+    resolveRuntime,
+    resolveParticipant,
+    join,
+    leave,
+    sendMessage,
+    runLoop
+  };
+}
 export {
-  AgenticEnvironment,
-  AgenticError,
-  BaseParticipant,
   ContextItem,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
-  InMemoryModelContextRepository,
-  InferenceResponse,
   InputTokenDetails,
+  McpClient,
+  McpToolRegistry,
   ModelContext,
   ModelMessageItem,
   OutputTokenDetails,
   Participant,
   ReasoningItem,
+  RuntimeState,
   SemanticEvent,
   SystemMessageItem,
   TokenUsage,
   UserMessageItem,
-  executeFunctionCall,
-  runInference,
-  sendMessage
+  createAgent,
+  createHuman,
+  defineRuntime
 };
 //# sourceMappingURL=index.mjs.map