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

package/dist/index.js

@@ -30,15 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AgenticEnvironment: () => AgenticEnvironment,
-  AgenticError: () => AgenticError,
-  BaseParticipant: () => BaseParticipant,
   ContextItem: () => ContextItem,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
-  InMemoryModelContextRepository: () => InMemoryModelContextRepository,
-  InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
   McpClient: () => McpClient,
   McpToolRegistry: () => McpToolRegistry,
@@ -47,52 +42,40 @@ __export(index_exports, {
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
   ReasoningItem: () => ReasoningItem,
+  RuntimeState: () => RuntimeState,
   SemanticEvent: () => SemanticEvent,
   SystemMessageItem: () => SystemMessageItem,
   TokenUsage: () => TokenUsage,
   UserMessageItem: () => UserMessageItem,
-  executeFunctionCall: () => executeFunctionCall,
-  runInference: () => runInference,
-  sendMessage: () => sendMessage
+  createAgent: () => createAgent,
+  createHuman: () => createHuman,
+  defineRuntime: () => defineRuntime
 });
 module.exports = __toCommonJS(index_exports);
 
 // 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);
   }
 };
 
@@ -217,8 +200,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;
@@ -355,48 +338,6 @@ var McpToolRegistry = 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/domain/model-context/context-item/client-item/system-message.ts
 var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   constructor(content) {
@@ -415,397 +356,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();
+// 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;
   }
-  join(environment) {
-    if (this.isJoinedTo(environment)) {
-      return;
-    }
-    environment.subscribe(this);
-    this.environments.push(environment);
-    this.active.set(environment, true);
+  static create(type, producerId, payload) {
+    const occurredAt = /* @__PURE__ */ new Date();
+    return new _SemanticEvent(type, producerId, occurredAt, payload);
   }
-  leave(environment) {
-    if (!this.isJoinedTo(environment)) {
-      return;
-    }
-    environment.unsubscribe(this);
-    this.environments = this.environments.filter((e) => e !== environment);
-    this.active.delete(environment);
-  }
-  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) {
@@ -817,9 +959,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()) {
@@ -886,7 +1028,7 @@ var AnthropicMessagesMapper = class {
       new OutputTokenDetails(0)
     );
   }
-  extractContextItems(response) {
+  toResponse(response) {
     var _a;
     const items = [];
     for (const block of response.content) {
@@ -914,30 +1056,27 @@ var AnthropicMessagesMapper = class {
         );
       }
     }
-    return items;
+    return { items, rowResponse: response };
   }
 };
 
 // src/infrastructure/providers/anthropic/endpoints/anthropic-messages.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var AnthropicMessages = class {
-  constructor(endpointMapper = new AnthropicMessagesMapper()) {
+  constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
-    this.client = new import_sdk.default();
+    this.client = new import_sdk.default({ 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;
     }
   }
 };
@@ -959,27 +1098,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",
@@ -989,19 +1128,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,
@@ -1061,7 +1195,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 : []) {
@@ -1094,7 +1228,10 @@ var OpenAIResponsesMapper = class {
         );
       }
     }
-    return items;
+    return {
+      items,
+      rowResponse: response
+    };
   }
 };
 
@@ -1104,19 +1241,16 @@ var OpenAIResponses = class {
     this.endpointMapper = endpointMapper;
     this.client = new import_openai.default();
   }
-  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;
     }
   }
 };
@@ -1126,16 +1260,16 @@ var import_genai = require("@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
@@ -1143,34 +1277,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();
@@ -1243,7 +1372,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 : [];
@@ -1272,42 +1401,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 import_genai.GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+    this.client = new import_genai.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,
@@ -1316,23 +1446,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;
@@ -1379,12 +1504,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(
@@ -1407,7 +1532,7 @@ var OpenAIChatCompletionsMapper = class {
         })
       );
     }
-    return items;
+    return { items, rowResponse: response };
   }
 };
 
@@ -1423,24 +1548,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;
     }
   }
 };
@@ -1709,103 +1830,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);
   }
 };
 
@@ -1814,8 +1903,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;
@@ -1827,8 +1916,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;
@@ -1855,8 +1944,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))
     );
   }
@@ -1870,45 +1959,108 @@ 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
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AgenticEnvironment,
-  AgenticError,
-  BaseParticipant,
   ContextItem,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
-  InMemoryModelContextRepository,
-  InferenceResponse,
   InputTokenDetails,
   McpClient,
   McpToolRegistry,
@@ -1917,12 +2069,13 @@ var sendMessage = (environment, message, caller) => {
   OutputTokenDetails,
   Participant,
   ReasoningItem,
+  RuntimeState,
   SemanticEvent,
   SystemMessageItem,
   TokenUsage,
   UserMessageItem,
-  executeFunctionCall,
-  runInference,
-  sendMessage
+  createAgent,
+  createHuman,
+  defineRuntime
 });
 //# sourceMappingURL=index.js.map