@mozaik-ai/core 4.2.0-beta.8 → 4.2.0

package/dist/index.js

@@ -31,1115 +31,1014 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Agent: () => Agent,
+  AnthropicMessages: () => AnthropicMessages,
+  ContextItem: () => ContextItem,
+  DefaultInferenceRunner: () => DefaultInferenceRunner,
+  DeveloperMessageItem: () => DeveloperMessageItem,
+  FunctionCallItem: () => FunctionCallItem,
+  FunctionCallOutputItem: () => FunctionCallOutputItem,
+  GeminiGenerateContent: () => GeminiGenerateContent,
+  Human: () => Human,
+  InputTokenDetails: () => InputTokenDetails,
+  McpClient: () => McpClient,
+  McpToolRegistry: () => McpToolRegistry,
+  ModelContext: () => ModelContext,
+  ModelMessageItem: () => ModelMessageItem,
+  OpenAIChatCompletions: () => OpenAIChatCompletions,
+  OpenAIResponses: () => OpenAIResponses,
+  OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
+  ReasoningItem: () => ReasoningItem,
+  RuntimeState: () => RuntimeState,
+  SemanticEvent: () => SemanticEvent,
   SituationSpecification: () => SituationSpecification,
-  SpaceEvent: () => SpaceEvent,
-  defineAgentModule: () => defineAgentModule,
-  defineRuntime: () => defineRuntime
+  SystemMessageItem: () => SystemMessageItem,
+  TokenUsage: () => TokenUsage,
+  UserMessageItem: () => UserMessageItem,
+  createAgent: () => createAgent,
+  createHuman: () => createHuman,
+  defineRuntime: () => defineRuntime,
+  supportedModels: () => supportedModels
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/domain/space/event.ts
-var SpaceEvent = class _SpaceEvent {
-  constructor(type, producerId, occurredAt, payload) {
-    this.type = type;
-    this.producerId = producerId;
-    this.occurredAt = occurredAt;
-    this.payload = payload;
-  }
-  static create(type, producerId, occurredAt, payload) {
-    return new _SpaceEvent(type, producerId, occurredAt, payload);
-  }
-};
-var ParticipantJoinedEvent = class extends SpaceEvent {
-  static init(manifest, occurredAt) {
-    return SpaceEvent.create("participant.joined", manifest.id, occurredAt, manifest);
-  }
-};
-var ParticipantLeftEvent = class extends SpaceEvent {
-  static init(manifest, occurredAt) {
-    return SpaceEvent.create("participant.left", manifest.id, occurredAt, manifest);
-  }
-};
-var MessageSentEvent = class extends SpaceEvent {
-  static init(producerId, message, occurredAt) {
-    return SpaceEvent.create("message.sent", producerId, occurredAt, { message });
-  }
-};
-
-// src/domain/space/participant.ts
-var Participant = class {
-  constructor(manifest, handlers) {
-    this.manifest = manifest;
-    this.handlers = handlers;
+// src/domain/model-context/model-context.ts
+var ModelContext = class _ModelContext {
+  constructor(id, items) {
+    this.id = id;
+    this.items = items;
   }
-  getManifest() {
-    return this.manifest;
+  getItems() {
+    return this.items;
   }
-  setManifest(manifest) {
-    this.manifest = manifest;
+  addContextItems(contextItems) {
+    this.items.push(...contextItems);
+    return this;
   }
-  getId() {
-    return this.manifest.id;
+  addContextItem(item) {
+    this.items.push(item);
+    return this;
   }
-  getHandlers() {
-    return this.handlers;
+  static create() {
+    const id = crypto.randomUUID();
+    return new _ModelContext(id, []);
   }
-  setHandlers(handlers) {
-    this.handlers = handlers;
+  static rehydrate(data) {
+    return new _ModelContext(data.id, data.items);
   }
 };
 
-// src/domain/space/runtime.ts
-var RuntimeService = class {
-  constructor(state) {
-    this.state = state;
+// src/domain/model-context/context-item/context-item.ts
+var ContextItem = class {
+  getType() {
+    return this.type;
   }
 };
 
-// src/util/uuid-generator.ts
-var UuidGenerator = class {
-  static create() {
-    return crypto.randomUUID();
-  }
+// src/domain/model-context/context-item/item-content/item-content.ts
+var ItemContent = class {
 };
 
-// src/application/use-cases/create-participant.ts
-var CreateParticipantUseCase = class {
-  async execute(name, capabilities, handlers) {
-    const manifest = {
-      id: UuidGenerator.create(),
-      name,
-      capabilities,
-      role: "external"
-    };
-    const participant = new Participant(manifest, handlers);
-    return participant;
+// src/domain/model-context/context-item/item-content/input-text.ts
+var InputText = class _InputText extends ItemContent {
+  constructor(text) {
+    super();
+    this.text = text;
+    this.type = "input_text";
   }
-};
-
-// src/application/use-cases/participant-join.ts
-var ParticipantJoinUseCase = class {
-  constructor(spaceRepository, eventPublisher) {
-    this.spaceRepository = spaceRepository;
-    this.eventPublisher = eventPublisher;
+  static create(text) {
+    return new _InputText(text);
   }
-  async execute(spaceId, participant) {
-    const space = await this.spaceRepository.findById(spaceId);
-    if (!space) {
-      throw new Error("Space not found");
-    }
-    const existingParticipant = space.getParticipant(participant.getId());
-    if (existingParticipant) {
-      throw new Error("Participant already joined");
-    }
-    const event = space.addParticipant(participant);
-    if (event) {
-      this.eventPublisher.publish(event, space.getParticipants());
-    }
-    await this.spaceRepository.save(space);
+  static rehydrate(data) {
+    return new _InputText(data.text);
   }
 };
 
-// src/infrastructure/repositories/in-memory-space-repository.ts
-var InMemorySpaceRepository = class {
-  constructor() {
-    this.spaces = [];
-  }
-  async save(space) {
-    this.spaces.push(space);
+// src/domain/model-context/context-item/client-item/user-message.ts
+var UserMessageItem = class _UserMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "user";
+    this.content = content;
   }
-  async findById(id) {
-    return this.spaces.find((space) => space.getId() === id);
+  static create(text) {
+    const content = InputText.create(text);
+    return new _UserMessageItem(content);
   }
-  async delete(id) {
-    this.spaces = this.spaces.filter((space) => space.getId() !== id);
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _UserMessageItem(content);
   }
 };
 
-// src/domain/space/event-publisher.ts
-var EventPublisher = class {
-  publish(event, participants) {
-    for (const participant of participants) {
-      participant.getHandlers().forEach((handler) => {
-        if (handler.specification.isSatisfiedBy({ event, participant })) {
-          handler.processor.apply({ event, participant });
-        }
-      });
-    }
+// src/domain/model-context/context-item/client-item/developer-message.ts
+var DeveloperMessageItem = class _DeveloperMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "developer";
+    this.content = content;
   }
-};
-
-// src/application/use-cases/participant-leave.ts
-var ParticipantLeaveUseCase = class {
-  constructor(spaceRepository, eventPublisher) {
-    this.spaceRepository = spaceRepository;
-    this.eventPublisher = eventPublisher;
+  static create(text) {
+    const content = InputText.create(text);
+    return new _DeveloperMessageItem(content);
   }
-  async execute(spaceId, participantId) {
-    const space = await this.spaceRepository.findById(spaceId);
-    if (!space) {
-      throw new Error("Space not found");
-    }
-    const participant = space.getParticipant(participantId);
-    if (!participant) {
-      throw new Error("Participant not found");
-    }
-    const event = space.removeParticipant(participant);
-    if (event) {
-      this.eventPublisher.publish(event, space.getParticipants());
-    }
-    await this.spaceRepository.save(space);
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _DeveloperMessageItem(content);
   }
 };
 
-// src/application/use-cases/send-message.ts
-var SendMessageUseCase = class {
-  constructor(spaceRepository, eventPublisher) {
-    this.spaceRepository = spaceRepository;
-    this.eventPublisher = eventPublisher;
+// src/domain/model-context/context-item/item-content/output-text.ts
+var OutputText = class _OutputText extends ItemContent {
+  constructor(text) {
+    super();
+    this.text = text;
+    this.type = "output_text";
   }
-  async execute(spaceId, participantId, message) {
-    const space = await this.spaceRepository.findById(spaceId);
-    if (!space) {
-      throw new Error("Space not found");
-    }
-    const participant = space.getParticipant(participantId);
-    if (!participant) {
-      throw new Error("Participant not found");
-    }
-    const event = space.sendMessage(participant, message, /* @__PURE__ */ new Date());
-    if (event) {
-      this.eventPublisher.publish(event, space.getParticipants());
-    }
-    await this.spaceRepository.save(space);
+  static rehydrate(data) {
+    return new _OutputText(data.text);
   }
 };
 
-// src/util/system-clock.ts
-var SystemClock = class {
-  static now() {
-    return /* @__PURE__ */ new Date();
+// src/domain/model-context/context-item/model-item/model-message.ts
+var ModelMessageItem = class _ModelMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "assistant";
+    this.content = content;
+  }
+  static rehydrate(data) {
+    const content = OutputText.rehydrate(data);
+    return new _ModelMessageItem(content);
   }
 };
 
-// src/domain/space/space.ts
-var Space = class _Space {
-  constructor(id, name, participants, events = []) {
-    this.id = id;
+// src/domain/model-context/context-item/model-item/function-call.ts
+var FunctionCallItem = class _FunctionCallItem extends ContextItem {
+  constructor(callId, name, args) {
+    super();
+    this.type = "function_call";
+    this.callId = callId;
     this.name = name;
-    this.participants = participants;
-    this.events = events;
-  }
-  getId() {
-    return this.id;
-  }
-  getName() {
-    return this.name;
+    this.args = args;
   }
-  addParticipant(participant) {
-    const alreadyExists = this.participants.find((p) => p.getId() === participant.getId());
-    if (alreadyExists) return;
-    this.participants.push(participant);
-    const occurredAt = SystemClock.now();
-    return ParticipantJoinedEvent.init(participant.getManifest(), occurredAt);
-  }
-  getParticipant(id) {
-    const participant = this.getParticipants().find((p) => p.getId() === id);
-    return participant;
-  }
-  removeParticipant(participant) {
-    this.participants = this.participants.filter((p) => p.getId() !== participant.getId());
-    const occurredAt = SystemClock.now();
-    return ParticipantLeftEvent.init(participant.getManifest(), occurredAt);
-  }
-  getParticipants() {
-    return [...this.participants];
-  }
-  sendMessage(participant, message, occurredAt) {
-    const event = MessageSentEvent.init(participant.getId(), message, occurredAt);
-    this.events.push(event);
-    return event;
-  }
-  getEvents() {
-    return [...this.events];
-  }
-  static create(name, participants = []) {
-    const id = UuidGenerator.create();
-    return new _Space(id, name, participants);
-  }
-  get record() {
-    return {
-      id: this.id,
-      name: this.name,
-      participants: this.participants
-    };
-  }
-  static rehydrate({ id, name, participants }) {
-    return new _Space(id, name, participants);
+  static rehydrate(data) {
+    return new _FunctionCallItem(data.callId, data.name, data.args);
   }
 };
 
-// src/application/use-cases/create-space.ts
-var CreateSpaceUseCase = class {
-  constructor(spaceRepository) {
-    this.spaceRepository = spaceRepository;
+// src/domain/model-context/context-item/model-item/reasoning.ts
+var ReasoningItem = class _ReasoningItem extends ContextItem {
+  constructor(content, encryptedContent, summary = []) {
+    super();
+    this.type = "reasoning";
+    this.content = content;
+    this.encryptedContent = encryptedContent;
+    this.summary = summary;
   }
-  async execute(name) {
-    const participants = [];
-    const space = Space.create(name, participants);
-    await this.spaceRepository.save(space);
-    return space;
+  static rehydrate(data) {
+    return new _ReasoningItem(data.content, data.encryptedContent, data.summary);
   }
 };
 
-// src/define-runtime.ts
-function defineRuntime() {
-  let runtime = null;
-  function initializeRuntime(config) {
-    if (runtime) {
-      throw new Error("Runtime already initialized");
-    }
-    runtime = new RuntimeService(config.state);
-    return runtime;
+// src/domain/generative-model/request-validation/structured-output.ts
+var StructuredOutputValidation = class {
+  constructor() {
+    this.name = "structured-output";
   }
-  function resolveRuntime() {
-    if (!runtime) {
-      throw new Error("Runtime not initialized");
+  isValid(inferenceInput, model) {
+    if (inferenceInput.structuredOutput === void 0) {
+      return true;
     }
-    return runtime;
+    return model.supportsStructuredOutput;
   }
-  const createParticipantUseCase = new CreateParticipantUseCase();
-  const createParticipant = async (name, capabilities, handlers) => {
-    return await createParticipantUseCase.execute(name, capabilities, handlers);
-  };
-  const spaceRepository = new InMemorySpaceRepository();
-  const eventPublisher = new EventPublisher();
-  const createSpaceUseCase = new CreateSpaceUseCase(spaceRepository);
-  const createSpace = async (name) => {
-    return await createSpaceUseCase.execute(name);
-  };
-  const participantJoinUseCase = new ParticipantJoinUseCase(spaceRepository, eventPublisher);
-  const join = async (spaceId, participant) => {
-    return await participantJoinUseCase.execute(spaceId, participant);
-  };
-  const participantLeaveUseCase = new ParticipantLeaveUseCase(spaceRepository, eventPublisher);
-  const leave = async (spaceId, participantId) => {
-    return await participantLeaveUseCase.execute(spaceId, participantId);
-  };
-  const sendMessageUseCase = new SendMessageUseCase(spaceRepository, eventPublisher);
-  const sendMessage = async (spaceId, participantId, message) => {
-    return await sendMessageUseCase.execute(spaceId, participantId, message);
-  };
-  const sendMessageTool = {
-    type: "function",
-    name: "send_message",
-    description: "Send a message to the space. The message will be sent to all participants in the space.",
-    parameters: {
-      spaceId: { type: "string" },
-      senderId: { type: "string" },
-      message: { type: "string" }
-    },
-    strict: true,
-    invoke: async (args) => {
-      const sendMessageUseCase2 = new SendMessageUseCase(spaceRepository, eventPublisher);
-      await sendMessageUseCase2.execute(args.spaceId, args.senderId, args.message);
-      return {
-        success: true,
-        message: "Message sent successfully"
-      };
-    }
-  };
-  return {
-    initializeRuntime,
-    resolveRuntime,
-    createParticipant,
-    createSpace,
-    join,
-    leave,
-    sendMessage,
-    sendMessageTool
-  };
-}
+};
 
-// src/domain/space/situation-specification.ts
-var SituationSpecification = class {
-  and(other) {
-    return new AndSituationSpecification(this, other);
+// src/domain/model-context/context-item/client-item/function-call-output.ts
+var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
+  constructor(callId, output) {
+    super();
+    this.type = "function_call_output";
+    this.callId = callId;
+    this.output = output;
   }
-  or(other) {
-    return new OrSituationSpecification(this, other);
+  static create(callId, output) {
+    const outputText = InputText.create(output);
+    return new _FunctionCallOutputItem(callId, outputText);
   }
-  not() {
-    return new NotSituationSpecification(this);
+  static rehydrate(data) {
+    return new _FunctionCallOutputItem(data.callId, data.output);
   }
 };
-var AndSituationSpecification = class extends SituationSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(situationContext) {
-    return this.left.isSatisfiedBy(situationContext) && this.right.isSatisfiedBy(situationContext);
+
+// src/domain/generative-model/token-usage.ts
+var InputTokenDetails = class {
+  constructor(cached_tokens) {
+    this.cached_tokens = cached_tokens;
   }
 };
-var OrSituationSpecification = class extends SituationSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
-  }
-  isSatisfiedBy(situationContext) {
-    return this.left.isSatisfiedBy(situationContext) || this.right.isSatisfiedBy(situationContext);
+var OutputTokenDetails = class {
+  constructor(reasoning_tokens) {
+    this.reasoning_tokens = reasoning_tokens;
   }
 };
-var NotSituationSpecification = class extends SituationSpecification {
-  constructor(rule) {
-    super();
-    this.rule = rule;
-  }
-  isSatisfiedBy(situationContext) {
-    return !this.rule.isSatisfiedBy(situationContext);
+var TokenUsage = class {
+  constructor(inputTokens, outputTokens, totalTokens, inputTokenDetails, outputTokenDetails) {
+    this.inputTokens = inputTokens;
+    this.outputTokens = outputTokens;
+    this.totalTokens = totalTokens;
+    this.inputTokenDetails = inputTokenDetails;
+    this.outputTokenDetails = outputTokenDetails;
   }
 };
 
-// src/domain/agent/agent.ts
-var Agent = class _Agent extends Participant {
-  constructor(manifest, tools, memory, handlers) {
-    super(manifest, handlers);
-    this.memory = memory;
-    this.tools = tools;
+// src/infrastructure/mcp/mcp-client.ts
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp = require("@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 import_streamableHttp.StreamableHTTPClientTransport(
+      new URL(config.url),
+      Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0
+    );
+    this.client = new import_client.Client({ name: (_b = config.name) != null ? _b : "mozaik", version: "1.0.0" }, { capabilities: {} });
   }
-  getTools() {
-    return this.tools;
+  async connect() {
+    if (this.connected) return;
+    await this.client.connect(this.transport);
+    this.connected = true;
   }
-  getMemory() {
-    return this.memory;
+  /** 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: {} }
+      };
+    });
   }
-  static create({
-    manifest,
-    tools,
-    memory,
-    handlers
-  }) {
-    return new _Agent(manifest, tools, memory, handlers);
+  /** 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;
   }
-  static rehydrate(record) {
-    return new _Agent(record.manifest, record.tools, record.memory, record.handlers);
+  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/application/use-cases/create-agent.ts
-var CreateAgentUseCase = class {
-  constructor(agentRepository, memoryFactory) {
-    this.agentRepository = agentRepository;
-    this.memoryFactory = memoryFactory;
+// 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;
   }
-  async execute(name, instruction, tools, handlers) {
-    const id = UuidGenerator.create();
-    const manifest = { id, name, role: "agent" };
-    const memory = this.memoryFactory.create();
-    const agentRecord = { id, manifest, tools, memory, handlers };
-    const agent = Agent.create(agentRecord);
-    await this.agentRepository.save(agent);
-    return agentRecord;
+  /** Close all underlying MCP connections. */
+  async close() {
+    await Promise.all(this.clients.map((c) => c.close()));
   }
 };
 
-// src/infrastructure/repositories/in-memory-agent-repository.ts
-var InMemoryAgentRepository = class {
-  constructor() {
-    this.agents = [];
-  }
-  exists(id) {
-    return Promise.resolve(this.agents.some((agent) => agent.getManifest().id === id));
-  }
-  findById(id) {
-    return Promise.resolve(this.agents.find((agent) => agent.getManifest().id === id));
+// src/domain/model-context/context-item/client-item/system-message.ts
+var SystemMessageItem = class _SystemMessageItem extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "system";
+    this.content = content;
   }
-  findAll() {
-    return Promise.resolve(this.agents);
+  static create(text) {
+    const content = InputText.create(text);
+    return new _SystemMessageItem(content);
   }
-  async save(agent) {
-    this.agents.push(agent);
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _SystemMessageItem(content);
   }
 };
 
-// src/domain/agent/loop/specification.ts
-var LoopSpecification = class {
-  and(other) {
-    return new AndLoopSpecification(this, other);
+// 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;
   }
-  or(other) {
-    return new OrLoopSpecification(this, other);
+  static create(type, producerId, payload) {
+    const occurredAt = /* @__PURE__ */ new Date();
+    return new _SemanticEvent(type, producerId, occurredAt, payload);
   }
-  not() {
-    return new NotLoopSpecification(this);
+};
+var ParticipantJoinedEvent = class extends SemanticEvent {
+  static init(manifest) {
+    return SemanticEvent.create("participant.joined", manifest.id, manifest);
   }
 };
-var AndLoopSpecification = class extends LoopSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
+var ParticipantLeftEvent = class extends SemanticEvent {
+  static init(manifest) {
+    return SemanticEvent.create("participant.left", manifest.id, manifest);
   }
-  isSatisfiedBy(agentLoop) {
-    return this.left.isSatisfiedBy(agentLoop) && this.right.isSatisfiedBy(agentLoop);
+};
+var MessageSentEvent = class extends SemanticEvent {
+  static init(producerId, message) {
+    return SemanticEvent.create("message.sent", producerId, { message });
   }
 };
-var OrLoopSpecification = class extends LoopSpecification {
-  constructor(left, right) {
-    super();
-    this.left = left;
-    this.right = right;
+
+// src/application/states/inference.ts
+var InferenceState = class {
+  constructor(inferenceRunner) {
+    this.inferenceRunner = inferenceRunner;
+    this.id = "inference";
   }
-  isSatisfiedBy(agentLoop) {
-    return this.left.isSatisfiedBy(agentLoop) || this.right.isSatisfiedBy(agentLoop);
+  async run(input, loopVisitor) {
+    loopVisitor.visitInferenceStarted(input);
+    const output = await this.inferenceRunner.run(input);
+    loopVisitor.visitInferenceCompleted(output);
+    return {
+      stateId: this.id,
+      input,
+      output
+    };
   }
 };
-var NotLoopSpecification = class extends LoopSpecification {
-  constructor(rule) {
-    super();
-    this.rule = rule;
+
+// src/domain/agentic-environment/participant/participant.ts
+var Participant = class {
+  constructor(manifest, handlers) {
+    this.manifest = manifest;
+    this.handlers = handlers;
   }
-  isSatisfiedBy(agentLoop) {
-    return !this.rule.isSatisfiedBy(agentLoop);
+  getManifest() {
+    return this.manifest;
   }
-};
-var AwaitingInference = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_inference";
+  getId() {
+    return this.manifest.id;
   }
-};
-var AwaitingRequest = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_inference_request";
+  getHandlers() {
+    return this.handlers;
   }
-};
-var AwaitingToolOutput = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    return agentLoop.loop.stateId === "awaiting_tool_output";
+  setHandlers(handlers) {
+    this.handlers = handlers;
   }
 };
-var ModelAnswered = class extends LoopSpecification {
-  isSatisfiedBy(agentLoop) {
-    const operations = agentLoop.loop.completedOperations;
-    const lastOperation = operations[operations.length - 1];
-    if ((lastOperation == null ? void 0 : lastOperation.type) !== "inference") {
-      return false;
-    }
-    return lastOperation.result.items.some((item) => item.type === "model_message");
+
+// src/domain/agentic-environment/participant/memory.ts
+var Memory = class _Memory {
+  constructor(context) {
+    this.context = context;
+  }
+  getContext() {
+    return this.context;
+  }
+  static create() {
+    const context = ModelContext.create();
+    return new _Memory(context);
   }
 };
 
-// src/domain/agent/loop/action.ts
-var LoopAction = class {
-};
-var RequestPreparationAction = class extends LoopAction {
-  constructor(request) {
-    super();
-    this.request = request;
+// 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;
   }
-  execute(agentLoop) {
-    return {
-      type: "inference",
-      request: this.request
-    };
+  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().addContextItem(developerMessage);
+    return new _Agent(manifest, instruction, tools, memory, handlers);
   }
-};
-var InferenceAction = class extends LoopAction {
-  execute(agentLoop) {
-    const request = agentLoop.loop.request;
-    if (!request) {
-      return { type: "wait", reason: "no request" };
-    }
-    return { type: "inference", request };
+  getTools() {
+    return this.tools;
   }
-};
-var ToolUseAction = class extends LoopAction {
-  execute(agentLoop) {
-    if (!agentLoop.loop.pending) {
-      return { type: "wait" };
-    }
-    const pendingOperation = agentLoop.loop.pending;
-    if (pendingOperation.type === "tool_execution") {
-      return { type: "tool_use", call: pendingOperation.call };
-    }
-    return { type: "wait" };
+  getDeveloperMessage() {
+    return this.developerMessage;
+  }
+  getMemory() {
+    return this.memory;
   }
 };
-var CompleteAction = class extends LoopAction {
-  constructor(reason) {
-    super();
-    this.reason = reason;
+
+// 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);
   }
-  execute() {
-    return { type: "complete", reason: this.reason };
+  static create({
+    name,
+    capabilities,
+    handlers
+  }) {
+    const id = crypto.randomUUID();
+    const manifest = { id, name, capabilities, role: "human" };
+    return new _Human(manifest, handlers);
   }
 };
 
-// src/domain/agent/loop/rule.ts
-var LoopRule = class _LoopRule {
-  constructor(id, condition, action, priority) {
-    this._id = id;
-    this._priority = priority;
-    this._condition = condition;
-    this._action = action;
-  }
-  get id() {
-    return this._id;
-  }
-  get priority() {
-    return this._priority;
+// 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();
   }
-  get condition() {
-    return this._condition;
+  addParticipant(participant) {
+    const isExists = this.participants.get(participant.getId());
+    if (isExists) return;
+    this.participants.set(participant.getId(), participant);
   }
-  get action() {
-    return this._action;
+  removeParticipant(participant) {
+    this.participants.delete(participant.getId());
   }
-  static create(spec) {
-    var _a;
-    const priority = (_a = spec.priority) != null ? _a : 0;
-    const id = crypto.randomUUID();
-    return new _LoopRule(id, spec.when, spec.then, priority);
+  getParticipant(id) {
+    return this.participants.get(id);
   }
-  static rehydrate(spec) {
-    var _a;
-    const priority = (_a = spec.priority) != null ? _a : 0;
-    const rule = new _LoopRule(spec.id, spec.condition, spec.action, priority);
-    return rule;
+  getParticipants() {
+    return [...this.participants.values()];
   }
 };
-var RuleBook = class _RuleBook {
-  constructor(rules) {
-    this.rules = rules;
+
+// 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;
   }
-  addRule(rule) {
-    this.rules.push(rule);
+  join(participant) {
+    this.state.addParticipant(participant);
+    this.publish(ParticipantJoinedEvent.init(participant.getManifest()));
   }
-  removeRule(rule) {
-    this.rules = this.rules.filter((r) => r.id !== rule.id);
+  leave(participant) {
+    this.state.removeParticipant(participant);
+    this.publish(ParticipantLeftEvent.init(participant.getManifest()));
   }
-  getRules() {
-    return this.rules;
+  publish(event) {
+    for (const participant of this.state.getParticipants()) {
+      this.processor.process(event, participant);
+    }
   }
-  static create(loopRuleParams) {
-    const rules = loopRuleParams.map((param) => LoopRule.create(param));
-    return new _RuleBook(rules);
+  getParticipant(id) {
+    if (!this.state.getParticipant(id)) {
+      throw new Error(`Participant ${id} not found`);
+    }
+    return this.state.getParticipant(id);
   }
-  static rehydrate(record) {
-    const rules = record.rules.map((rule) => LoopRule.rehydrate(rule));
-    return new _RuleBook(rules);
+  getInferenceRunner() {
+    return this.inferenceRunner;
   }
-  record() {
-    return {
-      rules: this.rules.map((rule) => ({
-        id: rule.id,
-        priority: rule.priority,
-        condition: rule.condition,
-        action: rule.action
-      }))
-    };
+  getFunctionCallRunner() {
+    return this.functionCallRunner;
   }
 };
-var defaultRules = (request) => [
-  {
-    when: new AwaitingRequest(),
-    then: new RequestPreparationAction(request)
-  },
-  {
-    when: new AwaitingInference(),
-    then: new InferenceAction()
-  },
-  {
-    when: new AwaitingToolOutput(),
-    then: new ToolUseAction()
-  },
-  {
-    when: new ModelAnswered(),
-    then: new CompleteAction("completed")
+
+// 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/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/agent/loop/loop.ts
-var Loop = class _Loop {
-  constructor(loopId, agentId, subject, createdAt, state, inferenceRequest, pendingOperation, transitionHistory, operationHistory, ruleBook) {
+// src/domain/agentic-environment/loop/agent-loop.ts
+var AgentLoop = class _AgentLoop {
+  constructor(loopId, stateExecutor, transitionResolver, interceptionHandler) {
     this.loopId = loopId;
-    this.agentId = agentId;
-    this.subject = subject;
-    this.createdAt = createdAt;
-    this.state = state;
-    this.inferenceRequest = inferenceRequest;
-    this.pendingOperation = pendingOperation;
-    this.transitionHistory = transitionHistory;
-    this.operationHistory = operationHistory;
-    this._ruleBook = ruleBook;
-  }
-  get id() {
-    return this.loopId;
-  }
-  get stateId() {
-    return this.state;
+    this.stateExecutor = stateExecutor;
+    this.transitionResolver = transitionResolver;
+    this.interceptionHandler = interceptionHandler;
   }
-  get pending() {
-    return this.pendingOperation;
-  }
-  get history() {
-    return this.transitionHistory;
+  async run(message, loopVisitor) {
+    var _a;
+    let transition = {
+      nextStateId: "message_received",
+      input: message
+    };
+    while (transition.nextStateId !== "idle") {
+      const isInterceptionSatisfied = (_a = this.interceptionHandler) == null ? void 0 : _a.isSatisfiedBy(transition);
+      if (isInterceptionSatisfied && this.interceptionHandler) {
+        loopVisitor.visitInterceptionStarted(transition);
+        transition = await this.interceptionHandler.handle(transition);
+        loopVisitor.visitInterceptionFinished(transition);
+      }
+      const execution = await this.stateExecutor.execute(transition, loopVisitor);
+      transition = this.transitionResolver.resolve(execution);
+    }
   }
-  get completedOperations() {
-    return this.operationHistory;
+  getLoopId() {
+    return this.loopId;
   }
-  get request() {
-    return this.inferenceRequest;
+  static create(stateExecutor, transitionResolver, interceptionHandler) {
+    const loopId = crypto.randomUUID();
+    return new _AgentLoop(loopId, stateExecutor, transitionResolver, interceptionHandler);
   }
-  get ruleBook() {
-    return this._ruleBook;
+};
+
+// src/domain/agentic-environment/loop/state-executor.ts
+var LoopStateExecutor = class {
+  constructor(messageReceivedState, inferenceState, inferenceStreamingState, functionCallState, modelMessageState) {
+    this.messageReceivedState = messageReceivedState;
+    this.inferenceState = inferenceState;
+    this.inferenceStreamingState = inferenceStreamingState;
+    this.functionCallState = functionCallState;
+    this.modelMessageState = modelMessageState;
   }
-  getSubject() {
-    return this.subject;
+  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 "inference_streaming":
+        return await this.inferenceStreamingState.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);
+    }
   }
-  getAgentId() {
-    return this.agentId;
+};
+
+// src/application/states/function-call.ts
+var FunctionCallState = class {
+  constructor(functionCallRunner) {
+    this.functionCallRunner = functionCallRunner;
+    this.id = "function_call";
   }
-  record() {
+  async run(input, loopVisitor) {
+    var _a;
+    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 {
-      id: this.id,
-      agentId: this.agentId,
-      subject: this.subject,
-      createdAt: this.createdAt,
-      state: this.state,
-      inferenceRequest: this.inferenceRequest,
-      pendingOperation: this.pendingOperation,
-      transitionHistory: [...this.transitionHistory],
-      operationHistory: [...this.operationHistory],
-      ruleBook: this.ruleBook.record()
+      stateId: this.id,
+      input,
+      output: {
+        item
+      }
     };
   }
-  moveToIdle(reason, transitionId) {
-    this.transitionTo("idle", reason, transitionId);
-    this.pendingOperation = void 0;
-  }
-  moveToAwaitingInference(operation) {
-    this.assertAwaitingInferenceRequest();
-    this.pendingOperation = operation;
-    this.transitionTo("awaiting_inference", "inference_requested", operation.id);
-  }
-  moveToAwaitingToolOutput(operation, occurredAt) {
-    this.assertIdle();
-    this.pendingOperation = operation;
-    this.transitionTo("awaiting_tool_output", "tool_execution_requested", operation.id);
-  }
-  requestInference(request) {
-    this.assertAwaitingInferenceRequest();
-    this.inferenceRequest = request;
-    const operation = {
-      id: UuidGenerator.create(),
-      type: "inference",
-      requestedAt: SystemClock.now(),
-      request: this.inferenceRequest
+};
+
+// 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])
     };
-    this.moveToAwaitingInference(operation);
-    return operation;
-  }
-  requestToolUse(operationId, call, requestedAt) {
-    this.assertIdle();
-    const operation = {
-      id: operationId,
-      type: "tool_execution",
-      requestedAt,
-      call
+    loopVisitor.visitMessageReceivedCompleted(output);
+    return {
+      stateId: this.id,
+      input,
+      output
     };
-    this.moveToAwaitingToolOutput(operation, requestedAt);
-    return operation;
-  }
-  transitionTo(nextState, reason, operationId) {
-    const occurredAt = SystemClock.now();
-    const previousState = this.state;
-    this.state = nextState;
-    this.transitionHistory.push({
-      occurredAt,
-      previousState,
-      nextState,
-      reason,
-      operationId
-    });
-  }
-  assertIdle() {
-    if (this.state !== "idle") {
-      throw new Error(`Expected idle loop, but loop is ${this.state}`);
-    }
-  }
-  assertAwaitingInferenceRequest() {
-    if (this.state !== "awaiting_inference_request") {
-      throw new Error(`Expected awaiting inference request loop, but loop is ${this.state}`);
-    }
-  }
-  receiveInferenceResult(operationId, result) {
-    if (this.state !== "awaiting_inference") {
-      throw new Error(`Cannot receive inference result while loop is ${this.state}`);
-    }
-    const operation = this.pendingOperation;
-    if ((operation == null ? void 0 : operation.type) !== "inference" || operation.id !== operationId) {
-      throw new Error(`Inference result does not match pending operation ${operationId}`);
-    }
-    if (!this.inferenceRequest) {
-      throw new Error("Inference request is not provided");
-    }
-    this.moveToIdle("inference_completed", operationId);
-    this.operationHistory.push({
-      type: "inference",
-      operationId,
-      requestedAt: operation.requestedAt,
-      completedAt: SystemClock.now(),
-      request: operation.request,
-      result
-    });
-    this.inferenceRequest.context.items.push(...result.items);
-    const call = result.items.find((item) => item.type === "tool_use_request");
-    if (call) {
-      this.pendingOperation = {
-        id: call.requestId,
-        type: "tool_execution",
-        requestedAt: SystemClock.now(),
-        call
-      };
-      this.transitionTo("awaiting_tool_output", "tool_use_requested", call.requestId);
-      return;
-    }
-    this.pendingOperation = void 0;
   }
-  receiveToolUseResult(operationId, result) {
-    if (this.state !== "awaiting_tool_output") {
-      throw new Error(`Cannot receive tool output while loop is ${this.state}`);
-    }
-    const operation = this.pendingOperation;
-    if ((operation == null ? void 0 : operation.type) !== "tool_execution" || operation.id !== operationId) {
-      throw new Error(`Tool output does not match pending operation ${operationId}`);
-    }
-    if (!this.inferenceRequest) {
-      throw new Error("Inference request is not provided");
-    }
-    this.operationHistory.push({
-      type: "tool_use",
-      operationId,
-      requestedAt: operation.requestedAt,
-      completedAt: SystemClock.now(),
-      call: operation.call,
-      result
-    });
-    this.inferenceRequest.context.items.push(result);
-    this.pendingOperation = void 0;
-    this.transitionTo("awaiting_inference_request", "tool_use_completed", operationId);
-  }
-  complete(reason) {
-    this.assertNotSettled("complete");
-    this.pendingOperation = void 0;
-    this.transitionTo("completed", reason);
-  }
-  stop(reason) {
-    this.assertNotSettled("stop");
-    this.pendingOperation = void 0;
-    this.transitionTo("stopped", reason);
-  }
-  wait(reason) {
-    this.assertNotSettled("wait");
-    this.pendingOperation = void 0;
-    this.transitionTo("idle", reason);
-  }
-  assertNotSettled(intent) {
-    if (this.state === "completed" || this.state === "stopped") {
-      throw new Error(`Cannot ${intent} a loop that is already ${this.state}`);
-    }
-  }
-  static create(agentId, subject, ruleBook) {
-    const createdAt = SystemClock.now();
-    const id = UuidGenerator.create();
-    return new _Loop(
-      id,
-      agentId,
-      subject,
-      createdAt,
-      "awaiting_inference_request",
-      void 0,
-      void 0,
-      [],
-      [],
-      ruleBook
-    );
+};
+
+// src/application/states/model-message.ts
+var ModelMessageState = class {
+  constructor() {
+    this.id = "model_message";
   }
-  static rehydrate(record) {
-    return new _Loop(
-      record.id,
-      record.agentId,
-      record.subject,
-      record.createdAt,
-      record.state,
-      record.inferenceRequest,
-      record.pendingOperation,
-      [...record.transitionHistory],
-      [...record.operationHistory],
-      RuleBook.rehydrate(record.ruleBook)
-    );
+  async run(input, loopVisitor) {
+    loopVisitor.visitModelAnswer(input);
+    return {
+      stateId: this.id,
+      input,
+      output: void 0
+    };
   }
 };
 
-// src/application/use-cases/create-loop.ts
-var CreateAgentLoopUseCase = class {
-  constructor(loopRepository) {
-    this.loopRepository = loopRepository;
+// src/domain/agentic-environment/loop/transition-resolver.ts
+var TransitionResolver = class {
+  constructor(rules) {
+    this.rules = rules;
   }
-  async execute(params) {
-    if ("rules" in params) {
-      const ruleBook = RuleBook.create(params.rules);
-      const loop = Loop.create(params.agentId, params.subject, ruleBook);
-      await this.loopRepository.save(loop);
-      return loop;
-    } else {
-      const ruleBook = RuleBook.create(defaultRules(params.request));
-      const loop = Loop.create(params.agentId, params.subject, ruleBook);
-      await this.loopRepository.save(loop);
-      return loop;
+  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);
   }
 };
 
-// src/infrastructure/repositories/in-memory-loop-repository.ts
-var InMemoryLoopRepository = class {
-  constructor() {
-    this.loops = [];
+// src/domain/agentic-environment/loop/transition-specification.ts
+var MessageReceivedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "message_received";
   }
-  findById(id) {
-    return Promise.resolve(this.loops.find((loop) => loop.id === id));
+};
+function isInferenceExecution(execution) {
+  return execution.stateId === "inference" || execution.stateId === "inference_streaming";
+}
+var InferenceProducedFunctionCallSpecification = class {
+  isSatisfiedBy(execution) {
+    return isInferenceExecution(execution) && execution.output.items.some((item) => item.type === "function_call");
   }
-  save(loop) {
-    const index = this.loops.findIndex((stored) => stored.id === loop.id);
-    if (index === -1) {
-      this.loops.push(loop);
-    } else {
-      this.loops[index] = loop;
-    }
-    return Promise.resolve();
+};
+var InferenceProducedModelMessageSpecification = class {
+  isSatisfiedBy(execution) {
+    return isInferenceExecution(execution) && execution.output.items.some((item) => item.type === "message" && item.role === "assistant");
   }
 };
-
-// src/domain/inference/tool-use-item-factory.ts
-var ToolUseItemFactory = class {
-  create(toolUseRequest, result) {
-    const toolUseResult = {
-      type: "tool_use_result",
-      requestId: toolUseRequest.requestId,
-      result: {
-        type: "input_text",
-        text: result
-      }
-    };
-    return toolUseResult;
+var FunctionCallCompletedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "function_call";
+  }
+};
+var ModelMessageCompletedSpecification = class {
+  isSatisfiedBy(execution) {
+    return execution.stateId === "model_message";
   }
 };
 
-// src/application/runners/local-tool-runner.ts
-var LocalToolRunner = class {
+// src/domain/agentic-environment/loop/transition-rule.ts
+var ContextPreparationToInferenceRule = class {
   constructor() {
-    this.toolUseItemFactory = new ToolUseItemFactory();
+    this.specification = new MessageReceivedSpecification();
   }
-  async run(input, tool) {
-    try {
-      const result = await tool.invoke(JSON.parse(input.toolArguments));
-      const resultText = typeof result === "string" ? result : JSON.stringify(result);
-      return this.toolUseItemFactory.create(input, resultText);
-    } catch (error) {
-      const errorText = `Error calling tool: ${error}`;
-      return this.toolUseItemFactory.create(input, errorText);
+  createTransition(execution) {
+    if (execution.stateId !== "message_received") {
+      throw new Error("Expected context_preparation execution");
     }
+    const nextStateId = execution.output.streaming ? "inference_streaming" : "inference";
+    return {
+      nextStateId,
+      input: execution.output
+    };
   }
 };
-
-// src/application/runners/inference-runner.ts
-var DefaultInferenceRunner = class {
-  constructor(supportedModels2, requestValidator) {
-    this.supportedModels = supportedModels2;
-    this.requestValidator = requestValidator;
+var InferenceToFunctionCallRule = class {
+  constructor() {
+    this.specification = new InferenceProducedFunctionCallSpecification();
   }
-  async run(input) {
-    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
-    if (!generativeModel) {
-      throw new Error(`Unsupported model: ${input.model}`);
+  createTransition(execution) {
+    if (execution.stateId !== "inference" && execution.stateId !== "inference_streaming" || !execution.output.items.some((item) => item.type === "function_call")) {
+      throw new Error("Expected inference function-call output");
     }
-    this.requestValidator.validate(input, generativeModel.specification);
-    return await generativeModel.endpoint.infer(input);
-  }
-  async *stream(input) {
-    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
-    if (!generativeModel) {
-      throw new Error(`Unsupported model: ${input.model}`);
+    const functionCallItem = execution.output.items.find((item) => item.type === "function_call");
+    if (!functionCallItem) {
+      throw new Error("Expected inference function-call output");
     }
-    this.requestValidator.validate(input, generativeModel.specification);
-    yield* generativeModel.endpoint.stream(input);
+    return {
+      nextStateId: "function_call",
+      input: {
+        call: functionCallItem,
+        inferenceInput: execution.input
+      }
+    };
   }
 };
-
-// src/domain/inference/request-validation/reasoning-effort.ts
-var ReasoningEffortValidation = class {
+var InferenceToModelMessageRule = class {
   constructor() {
-    this.name = "reasoning-effort";
+    this.specification = new InferenceProducedModelMessageSpecification();
   }
-  isValid(inferenceRequest, model) {
-    if (inferenceRequest.reasoningEffort === void 0) {
-      return true;
+  createTransition(execution) {
+    if (execution.stateId !== "inference" && execution.stateId !== "inference_streaming" || !execution.output.items.some((item) => item.type === "message" && item.role === "assistant")) {
+      throw new Error("Expected inference model-message output");
     }
-    if (!model.supportsReasoningEffort) {
-      return false;
+    const modelMessageItem = execution.output.items.find(
+      (item) => item.type === "message" && item.role === "assistant"
+    );
+    if (!modelMessageItem) {
+      throw new Error("Expected inference model-message output");
     }
-    return model.supportedReasoningEfforts.includes(inferenceRequest.reasoningEffort);
+    execution.input.context.addContextItem(modelMessageItem);
+    return {
+      nextStateId: "model_message",
+      input: {
+        answer: modelMessageItem
+      }
+    };
   }
 };
-
-// src/domain/inference/request-validation/tool-calling.ts
-var ToolUseRequestingValidation = class {
+var FunctionCallToInferenceRule = class {
   constructor() {
-    this.name = "tool-calling";
+    this.specification = new FunctionCallCompletedSpecification();
   }
-  isValid(inferenceRequest, model) {
-    if (inferenceRequest.tools === void 0) {
-      return true;
+  createTransition(execution) {
+    if (execution.stateId !== "function_call") {
+      throw new Error("Expected function_call execution");
     }
-    return model.supportsFunctionCalling;
+    const previousRequest = execution.input.inferenceInput;
+    previousRequest.context.addContextItems([execution.input.call, execution.output.item]);
+    return {
+      nextStateId: previousRequest.streaming ? "inference_streaming" : "inference",
+      input: {
+        ...previousRequest
+      }
+    };
   }
 };
-
-// src/domain/inference/request-validation/streaming.ts
-var StreamingValidation = class {
+var ModelMessageToIdleRule = class {
   constructor() {
-    this.name = "streaming";
+    this.specification = new ModelMessageCompletedSpecification();
   }
-  isValid(inferenceRequest, model) {
-    if (!inferenceRequest.streaming) {
-      return true;
+  createTransition(execution) {
+    if (execution.stateId !== "model_message") {
+      throw new Error("Expected model_message execution");
     }
-    return model.supportsStreaming;
+    return {
+      nextStateId: "idle",
+      input: void 0
+    };
   }
 };
 
-// src/domain/inference/request-validation/structured-output.ts
-var StructuredOutputValidation = class {
-  constructor() {
-    this.name = "structured-output";
+// src/domain/agentic-environment/loop/event-publisher-visitor.ts
+var import_cloud_sdk = require("@mozaik-ai/cloud-sdk");
+var EventPublisherLoopVisitor = class {
+  constructor(agentId, loopId, runtime) {
+    this.agentId = agentId;
+    this.loopId = loopId;
+    this.runtime = runtime;
+    this.cloud = (0, import_cloud_sdk.createCloudClient)();
   }
-  isValid(inferenceRequest, model) {
-    if (inferenceRequest.structuredOutput === void 0) {
-      return true;
-    }
-    return model.supportsStructuredOutput;
+  visitMessageReceivedStarted(input) {
+    this.publish("message_received.started", input);
   }
-};
-
-// src/domain/inference/request-validation/context.ts
-function getContextItemValidationKey(item) {
-  if (item.type === "user_message") {
-    return "user_message";
+  visitMessageReceivedCompleted(output) {
+    this.publish("message_received.completed", output);
   }
-  if (item.type === "system_message") {
-    return "system_message";
+  visitInferenceStarted(input) {
+    this.publish("inference.started", input);
   }
-  if (item.type === "developer_message") {
-    return "developer_message";
+  visitInferenceEvent(event) {
+    this.publish("inference.stream", event);
   }
-  if (item.type === "model_message") {
-    return "model_message";
+  visitInferenceCompleted(output) {
+    this.publish("inference.completed", output);
   }
-  return item.type;
-}
-var ContextValidation = class {
-  constructor() {
-    this.name = "context";
+  visitFunctionCallStarted(input) {
+    this.publish("function_call.started", input);
   }
-  isValid(inferenceRequest, model) {
-    return inferenceRequest.context.items.every(
-      (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
-    );
+  visitFunctionCallCompleted(output) {
+    this.publish("function_call.completed", output);
   }
-};
-
-// src/domain/inference/request-validation/inference-request-validator.ts
-var defaultRequestValidationRules = [
-  new ReasoningEffortValidation(),
-  new ToolUseRequestingValidation(),
-  new StreamingValidation(),
-  new StructuredOutputValidation(),
-  new ContextValidation()
-];
-var InferenceRequestValidator = class {
-  constructor(rules = defaultRequestValidationRules) {
-    this.rules = rules;
+  visitModelAnswer(input) {
+    this.publish("model.answer", input);
   }
-  validate(inferenceRequest, model) {
-    for (const rule of this.rules) {
-      if (!rule.isValid(inferenceRequest, model)) {
-        throw new Error(`Request validation "${rule.name}" failed for model "${model.name}"`);
+  visitInterceptionStarted(transition) {
+    this.publish("interception.started", transition);
+  }
+  visitInterceptionFinished(transition) {
+    this.publish("interception.finished", transition);
+  }
+  publish(type, payload) {
+    const event = new SemanticEvent(type, this.agentId, /* @__PURE__ */ new Date(), {
+      ...payload,
+      loopId: this.loopId
+    });
+    this.runtime.publish(event);
+    if (this.cloud.enabled) {
+      const participant = this.runtime.getParticipant(this.agentId);
+      const agent = participant;
+      if (agent) {
+        this.cloud.send({
+          ...event,
+          payload: {
+            ...payload,
+            loopId: this.loopId,
+            agent: {
+              manifest: agent.getManifest(),
+              developerMessage: agent.getDeveloperMessage(),
+              tools: agent.getTools(),
+              memory: agent.getMemory().getContext().getItems()
+            }
+          }
+        });
       }
     }
   }
 };
 
-// src/domain/inference/token-usage.ts
-var InputTokenDetails = class {
-  constructor(cached_tokens) {
-    this.cached_tokens = cached_tokens;
-  }
-};
-var OutputTokenDetails = class {
-  constructor(reasoning_tokens) {
-    this.reasoning_tokens = reasoning_tokens;
-  }
-};
-var TokenUsage = class {
-  constructor(inputTokens, outputTokens, totalTokens, inputTokenDetails, outputTokenDetails) {
-    this.inputTokens = inputTokens;
-    this.outputTokens = outputTokens;
-    this.totalTokens = totalTokens;
-    this.inputTokenDetails = inputTokenDetails;
-    this.outputTokenDetails = outputTokenDetails;
+// src/application/states/inference-streaming.ts
+var InferenceStreamingState = class {
+  constructor(inferenceRunner) {
+    this.inferenceRunner = inferenceRunner;
+    this.id = "inference_streaming";
+  }
+  async run(input, loopVisitor) {
+    loopVisitor.visitInferenceStarted(input);
+    let output = void 0;
+    for await (const event of this.inferenceRunner.stream(input)) {
+      loopVisitor.visitInferenceEvent(event);
+      if (event.type === "inference.output") {
+        output = event.payload;
+      }
+    }
+    if (!output) {
+      throw new Error("Inference output not found");
+    }
+    loopVisitor.visitInferenceCompleted(output);
+    return {
+      stateId: "inference_streaming",
+      input,
+      output
+    };
   }
 };
 
-// src/infrastructure/providers/anthropic/anthropic-messages-mapper.ts
+// src/application/use-cases/run-loop.ts
+function createRunLoop(resolveRuntime) {
+  return function runLoop(agentId, message, inferenceInput, interceptionHandler) {
+    const runtime = resolveRuntime();
+    const inferenceRunner = runtime.getInferenceRunner();
+    const functionCallRunner = runtime.getFunctionCallRunner();
+    const transitionResolver = new TransitionResolver([
+      // High-priority interception rules would go first.
+      new ContextPreparationToInferenceRule(),
+      new InferenceToFunctionCallRule(),
+      new InferenceToModelMessageRule(),
+      new FunctionCallToInferenceRule(),
+      new ModelMessageToIdleRule()
+    ]);
+    const stateExecutor = new LoopStateExecutor(
+      new MessageReceivedState(),
+      new InferenceState(inferenceRunner),
+      new InferenceStreamingState(inferenceRunner),
+      new FunctionCallState(functionCallRunner),
+      new ModelMessageState()
+    );
+    const agentLoop = AgentLoop.create(stateExecutor, transitionResolver, interceptionHandler);
+    const loopVisitor = new EventPublisherLoopVisitor(agentId, agentLoop.getLoopId(), runtime);
+    agentLoop.run(
+      {
+        content: message,
+        input: inferenceInput
+      },
+      loopVisitor
+    );
+  };
+}
+
+// src/infrastructure/providers/anthropic/endpoints/anthropic-messages-mapper.ts
 var AnthropicMessagesMapper = class {
-  toRequest(inferenceRequest) {
-    const { messages, system } = this.mapContextItems(inferenceRequest);
+  toRequest(inferenceInput) {
+    const { messages, system } = this.mapContextItems(inferenceInput);
     const outputConfig = {};
     const request = {
-      model: inferenceRequest.model,
+      model: inferenceInput.model,
       messages
     };
-    request.max_tokens = inferenceRequest.maxOutputTokens;
+    request.max_tokens = inferenceInput.maxOutputTokens;
     if (system) {
       request.system = system;
     }
-    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
-      request.tools = inferenceRequest.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 (inferenceRequest.structuredOutput) {
+    if (inferenceInput.structuredOutput) {
       outputConfig.format = {
         type: "json_schema",
-        schema: inferenceRequest.structuredOutput.schema
+        schema: inferenceInput.structuredOutput.schema
       };
     }
-    if (inferenceRequest.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       request.thinking = { type: "adaptive" };
-      outputConfig.effort = inferenceRequest.reasoningEffort;
+      outputConfig.effort = inferenceInput.reasoningEffort;
     }
     if (Object.keys(outputConfig).length > 0) {
       request.output_config = outputConfig;
     }
-    if (inferenceRequest.streaming) {
-      request.stream = inferenceRequest.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
@@ -1154,55 +1053,52 @@ var AnthropicMessagesMapper = class {
       content: [block]
     });
   }
-  mapContextItems(inferenceRequest) {
+  mapContextItems(inferenceInput) {
     var _a, _b, _c;
-    const context = inferenceRequest.context;
+    const context = inferenceInput.context;
     const messages = [];
     const system = [];
-    for (const item of context.items) {
-      if (item.type === "developer_message" || item.type === "system_message") {
-        system.push(item.text);
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        system.push(item.content.text);
         continue;
       }
-      if (item.type === "user_message") {
-        this.addContentBlock(messages, "user", { type: "text", text: item.text });
+      if (item instanceof UserMessageItem) {
+        this.addContentBlock(messages, "user", { type: "text", text: item.content.text });
         continue;
       }
-      if (item.type === "model_message") {
-        this.addContentBlock(messages, "assistant", { type: "text", text: item.text });
+      if (item instanceof ModelMessageItem) {
+        this.addContentBlock(messages, "assistant", { type: "text", text: item.content.text });
         continue;
       }
-      if (item.type === "reasoning") {
-        const reasoning = item;
+      if (item instanceof ReasoningItem) {
         this.addContentBlock(messages, "assistant", {
           type: "thinking",
-          thinking: (_b = (_a = reasoning.content) == null ? void 0 : _a.text) != null ? _b : "",
-          signature: (_c = reasoning.encryptedContent) != null ? _c : ""
+          thinking: (_b = (_a = item.content) == null ? void 0 : _a.text) != null ? _b : "",
+          signature: (_c = item.encryptedContent) != null ? _c : ""
         });
         continue;
       }
-      if (item.type === "tool_use_request") {
-        const toolUseRequest = item;
+      if (item instanceof FunctionCallItem) {
         let input;
         try {
-          input = JSON.parse(toolUseRequest.toolArguments);
+          input = JSON.parse(item.args);
         } catch (e) {
-          input = toolUseRequest.toolArguments;
+          input = item.args;
         }
         this.addContentBlock(messages, "assistant", {
           type: "tool_use",
-          id: toolUseRequest.requestId,
-          name: toolUseRequest.toolName,
+          id: item.callId,
+          name: item.name,
           input
         });
         continue;
       }
-      if (item.type === "tool_use_result") {
-        const toolUseResult = item;
+      if (item instanceof FunctionCallOutputItem) {
         this.addContentBlock(messages, "user", {
           type: "tool_result",
-          tool_use_id: toolUseResult.requestId,
-          content: toolUseResult.result.text
+          tool_use_id: item.callId,
+          content: item.output.text
         });
       }
     }
@@ -1231,35 +1127,34 @@ var AnthropicMessagesMapper = class {
     const items = [];
     for (const block of response.content) {
       if (block.type === "text") {
-        items.push({
-          type: "model_message",
-          text: block.text
-        });
+        items.push(ModelMessageItem.rehydrate({ text: block.text }));
         continue;
       }
       if (block.type === "tool_use") {
-        items.push({
-          type: "tool_use_request",
-          requestId: block.id,
-          toolName: block.name,
-          toolArguments: JSON.stringify((_a = block.input) != null ? _a : {})
-        });
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: block.id,
+            name: block.name,
+            args: JSON.stringify((_a = block.input) != null ? _a : {})
+          })
+        );
         continue;
       }
       if (block.type === "thinking") {
-        items.push({
-          type: "reasoning",
-          content: block.thinking ? { type: "input_text", text: block.thinking } : void 0,
-          encryptedContent: block.signature,
-          summary: []
-        });
+        items.push(
+          ReasoningItem.rehydrate({
+            content: block.thinking ? InputText.rehydrate({ text: block.thinking }) : void 0,
+            encryptedContent: block.signature,
+            summary: []
+          })
+        );
       }
     }
     return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
   }
 };
 
-// src/infrastructure/providers/anthropic/anthropic-messages.ts
+// src/infrastructure/providers/anthropic/endpoints/anthropic-messages.ts
 var import_sdk = __toESM(require("@anthropic-ai/sdk"));
 var AnthropicMessages = class {
   constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
@@ -1273,13 +1168,13 @@ var AnthropicMessages = class {
       apiKey: this.clientConfig.apiKey
     });
   }
-  async infer(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(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(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(inferenceRequest);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const stream = this.client.messages.stream(request);
     for await (const event of stream) {
       yield event;
@@ -1294,29 +1189,44 @@ var AnthropicMessages = class {
   }
 };
 
-// src/infrastructure/providers/openai/openai-responses-mapper.ts
+// src/infrastructure/providers/openai/endpoints/openai-responses.ts
+var import_openai = __toESM(require("openai"));
+
+// src/domain/model-context/context-item/item-content/summary-text.ts
+var SummaryText = class _SummaryText extends ItemContent {
+  constructor(text) {
+    super();
+    this.text = text;
+    this.type = "summary_text";
+  }
+  static rehydrate(data) {
+    return new _SummaryText(data.text);
+  }
+};
+
+// src/infrastructure/providers/openai/endpoints/openai-responses-mapper.ts
 var OpenAIResponsesMapper = class {
-  toRequest(inferenceRequest) {
+  toRequest(inferenceInput) {
     var _a, _b;
     const request = {
-      model: inferenceRequest.model,
-      input: this.mapContextItems(inferenceRequest)
+      model: inferenceInput.model,
+      input: this.mapContextItems(inferenceInput)
     };
-    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
-      request.tools = inferenceRequest.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 (inferenceRequest.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       request.reasoning = {
-        effort: inferenceRequest.reasoningEffort
+        effort: inferenceInput.reasoningEffort
       };
     }
-    if (inferenceRequest.structuredOutput) {
-      const format = inferenceRequest.structuredOutput;
+    if (inferenceInput.structuredOutput) {
+      const format = inferenceInput.structuredOutput;
       request.text = {
         format: {
           type: "json_schema",
@@ -1326,58 +1236,54 @@ var OpenAIResponsesMapper = class {
         }
       };
     }
-    if (inferenceRequest.streaming) {
-      request.stream = inferenceRequest.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  mapContextItems(inferenceRequest) {
+  mapContextItems(inferenceInput) {
     const input = [];
-    for (const item of inferenceRequest.context.items) {
-      if (item.type === "developer_message" || item.type === "system_message" || item.type === "user_message") {
-        const role = item.type === "developer_message" ? "developer" : item.type === "system_message" ? "system" : "user";
+    for (const item of inferenceInput.context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem || item instanceof UserMessageItem) {
         input.push({
-          type: "message",
-          role,
-          content: [{ type: "input_text", text: item.text }]
+          type: item.type,
+          role: item.role,
+          content: [{ type: "input_text", text: item.content.text }]
         });
         continue;
       }
-      if (item.type === "model_message") {
+      if (item instanceof ModelMessageItem) {
         input.push({
-          type: "message",
-          role: "assistant",
-          content: [{ type: "output_text", text: item.text }]
+          type: item.type,
+          role: item.role,
+          content: [{ type: "output_text", text: item.content.text }]
         });
         continue;
       }
-      if (item.type === "tool_use_request") {
-        const toolUseRequest = item;
+      if (item instanceof FunctionCallItem) {
         input.push({
-          type: "function_call",
-          call_id: toolUseRequest.requestId,
-          name: toolUseRequest.toolName,
-          arguments: toolUseRequest.toolArguments
+          type: item.type,
+          call_id: item.callId,
+          name: item.name,
+          arguments: item.args
         });
         continue;
       }
-      if (item.type === "tool_use_result") {
-        const toolUseResult = item;
+      if (item instanceof FunctionCallOutputItem) {
         input.push({
-          type: "function_call_output",
-          call_id: toolUseResult.requestId,
-          output: [{ type: "input_text", text: toolUseResult.result.text }]
+          type: item.type,
+          call_id: item.callId,
+          output: [{ type: "input_text", text: item.output.text }]
         });
         continue;
       }
-      if (item.type === "reasoning") {
-        const reasoning = item;
+      if (item instanceof ReasoningItem) {
         const reasoningInput = {
-          type: "reasoning",
-          summary: reasoning.summary.map((summary) => ({ type: "summary_text", text: summary.text }))
+          type: item.type,
+          summary: item.summary.map((summary) => ({ type: "summary_text", text: summary.text }))
         };
-        if (reasoning.encryptedContent !== void 0) {
-          reasoningInput.encrypted_content = reasoning.encryptedContent;
+        if (item.encryptedContent !== void 0) {
+          reasoningInput.encrypted_content = item.encryptedContent;
         }
         input.push(reasoningInput);
       }
@@ -1404,33 +1310,30 @@ var OpenAIResponsesMapper = class {
       if (item.type === "message" && item.role === "assistant") {
         const firstContent = (_b = item.content) == null ? void 0 : _b[0];
         if (firstContent) {
-          items.push({
-            type: "model_message",
-            text: firstContent.text
-          });
+          items.push(ModelMessageItem.rehydrate(firstContent));
         }
         continue;
       }
       if (item.type === "function_call") {
-        const toolUseRequest = {
-          type: "tool_use_request",
-          requestId: item.call_id,
-          toolName: item.name,
-          toolArguments: item.arguments
-        };
-        items.push(toolUseRequest);
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: item.call_id,
+            name: item.name,
+            args: item.arguments
+          })
+        );
         continue;
       }
       if (item.type === "reasoning") {
-        items.push({
-          type: "reasoning",
-          content: void 0,
-          encryptedContent: item.encrypted_content,
-          summary: ((_c = item.summary) != null ? _c : []).map((summary) => ({
-            type: "summary_text",
-            text: summary.text
-          }))
-        });
+        items.push(
+          ReasoningItem.rehydrate({
+            content: void 0,
+            encryptedContent: item.encrypted_content,
+            summary: ((_c = item.summary) != null ? _c : []).map(
+              (summary) => SummaryText.rehydrate({ text: summary.text })
+            )
+          })
+        );
       }
     }
     return {
@@ -1441,8 +1344,7 @@ var OpenAIResponsesMapper = class {
   }
 };
 
-// src/infrastructure/providers/openai/openai-responses.ts
-var import_openai = __toESM(require("openai"));
+// src/infrastructure/providers/openai/endpoints/openai-responses.ts
 var OpenAIResponses = class {
   constructor(endpointMapper = new OpenAIResponsesMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
@@ -1455,13 +1357,13 @@ var OpenAIResponses = class {
       apiKey: this.clientConfig.apiKey
     });
   }
-  async infer(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(inferenceRequest);
+  async infer(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const response = await this.client.responses.create(request);
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(inferenceRequest);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const stream = await this.client.responses.create({ ...request, stream: true });
     let completedResponse = void 0;
     for await (const event of stream) {
@@ -1478,26 +1380,26 @@ var OpenAIResponses = class {
       type: "inference.output",
       payload: output,
       occurredAt: /* @__PURE__ */ new Date(),
-      producerId: inferenceRequest.model
+      producerId: inferenceInput.model
     };
   }
 };
 
-// src/infrastructure/providers/gemini/gemini-generate-content.ts
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
 var import_genai = require("@google/genai");
 
-// src/infrastructure/providers/gemini/gemini-generate-content-mapper.ts
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content-mapper.ts
 var GeminiGenerateContentMapper = class {
-  toRequest(inferenceRequest) {
-    const { contents, systemInstruction } = this.mapContextItems(inferenceRequest);
+  toRequest(inferenceInput) {
+    const { contents, systemInstruction } = this.mapContextItems(inferenceInput);
     const config = {};
     if (systemInstruction) {
       config.systemInstruction = systemInstruction;
     }
-    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
       config.tools = [
         {
-          functionDeclarations: inferenceRequest.tools.map((tool) => ({
+          functionDeclarations: inferenceInput.tools.map((tool) => ({
             name: tool.name,
             description: tool.description,
             parametersJsonSchema: tool.parameters
@@ -1505,66 +1407,62 @@ var GeminiGenerateContentMapper = class {
         }
       ];
     }
-    if (inferenceRequest.structuredOutput) {
+    if (inferenceInput.structuredOutput) {
       config.responseMimeType = "application/json";
-      config.responseSchema = inferenceRequest.structuredOutput.schema;
+      config.responseSchema = inferenceInput.structuredOutput.schema;
     }
-    if (inferenceRequest.reasoningEffort) {
+    if (inferenceInput.reasoningEffort) {
       config.thinkingConfig = {
-        thinkingLevel: inferenceRequest.reasoningEffort,
+        thinkingLevel: inferenceInput.reasoningEffort,
         includeThoughts: true
       };
     }
     const request = {
-      model: inferenceRequest.model,
+      model: inferenceInput.model,
       contents,
       config
     };
-    if (inferenceRequest.streaming) {
-      request.stream = inferenceRequest.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  mapContextItems(inferenceRequest) {
+  mapContextItems(inferenceInput) {
     var _a;
-    const context = inferenceRequest.context;
+    const context = inferenceInput.context;
     const contents = [];
     const system = [];
     const callNames = /* @__PURE__ */ new Map();
-    for (const item of context.items) {
-      if (item.type === "developer_message" || item.type === "system_message") {
-        system.push(item.text);
+    for (const item of context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        system.push(item.content.text);
         continue;
       }
-      if (item.type === "user_message") {
-        this.addPart(contents, "user", { text: item.text });
+      if (item instanceof UserMessageItem) {
+        this.addPart(contents, "user", { text: item.content.text });
         continue;
       }
-      if (item.type === "model_message") {
-        this.addPart(contents, "model", { text: item.text });
+      if (item instanceof ModelMessageItem) {
+        this.addPart(contents, "model", { text: item.content.text });
         continue;
       }
-      if (item.type === "tool_use_request") {
-        const toolUseRequest = item;
-        callNames.set(toolUseRequest.requestId, toolUseRequest.toolName);
+      if (item instanceof FunctionCallItem) {
+        callNames.set(item.callId, item.name);
         let args;
         try {
-          args = JSON.parse(toolUseRequest.toolArguments);
+          args = JSON.parse(item.args);
         } catch (e) {
           args = {};
         }
-        this.addPart(contents, "model", {
-          functionCall: { id: toolUseRequest.requestId, name: toolUseRequest.toolName, args }
-        });
+        this.addPart(contents, "model", { functionCall: { id: item.callId, name: item.name, args } });
         continue;
       }
-      if (item.type === "tool_use_result") {
-        const toolUseResult = item;
+      if (item instanceof FunctionCallOutputItem) {
         this.addPart(contents, "user", {
           functionResponse: {
-            id: toolUseResult.requestId,
-            name: (_a = callNames.get(toolUseResult.requestId)) != null ? _a : "",
-            response: this.parseResponse(toolUseResult.result.text)
+            id: item.callId,
+            name: (_a = callNames.get(item.callId)) != null ? _a : "",
+            response: this.parseResponse(item.output.text)
           }
         });
       }
@@ -1610,35 +1508,34 @@ var GeminiGenerateContentMapper = class {
     const parts = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) != null ? _d : [];
     for (const part of parts) {
       if (part.thought && part.text) {
-        items.push({
-          type: "reasoning",
-          content: { type: "input_text", text: part.text },
-          encryptedContent: void 0,
-          summary: []
-        });
+        items.push(
+          ReasoningItem.rehydrate({
+            content: InputText.rehydrate({ text: part.text }),
+            encryptedContent: void 0,
+            summary: []
+          })
+        );
         continue;
       }
       if (part.text) {
-        items.push({
-          type: "model_message",
-          text: part.text
-        });
+        items.push(ModelMessageItem.rehydrate({ text: part.text }));
         continue;
       }
       if (part.functionCall) {
-        items.push({
-          type: "tool_use_request",
-          requestId: (_e = part.functionCall.id) != null ? _e : "",
-          toolName: part.functionCall.name,
-          toolArguments: JSON.stringify((_f = part.functionCall.args) != null ? _f : {})
-        });
+        items.push(
+          FunctionCallItem.rehydrate({
+            callId: (_e = part.functionCall.id) != null ? _e : "",
+            name: part.functionCall.name,
+            args: JSON.stringify((_f = part.functionCall.args) != null ? _f : {})
+          })
+        );
       }
     }
     return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
   }
 };
 
-// src/infrastructure/providers/gemini/gemini-generate-content.ts
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
 var GeminiGenerateContent = class {
   constructor(endpointMapper = new GeminiGenerateContentMapper(), config = {}) {
     this.endpointMapper = endpointMapper;
@@ -1651,13 +1548,13 @@ var GeminiGenerateContent = class {
       ...this.clientConfig.baseURL ? { httpOptions: { baseUrl: this.clientConfig.baseURL } } : {}
     });
   }
-  async infer(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(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(inferenceRequest) {
-    const request = this.endpointMapper.toRequest(inferenceRequest);
+  async *stream(inferenceInput) {
+    const request = this.endpointMapper.toRequest(inferenceInput);
     const stream = await this.client.models.generateContentStream(request);
     let lastEvent = void 0;
     for await (const chunk of stream) {
@@ -1677,15 +1574,15 @@ var GeminiGenerateContent = class {
   }
 };
 
-// src/infrastructure/providers/openai/openai-chat-completions-mapper.ts
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions-mapper.ts
 var OpenAIChatCompletionsMapper = class {
-  toRequest(inferenceRequest) {
+  toRequest(inferenceInput) {
     const request = {
-      model: inferenceRequest.model,
-      messages: this.mapContextItems(inferenceRequest)
+      model: inferenceInput.model,
+      messages: this.mapContextItems(inferenceInput)
     };
-    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
-      request.tools = inferenceRequest.tools.map((tool) => ({
+    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
+      request.tools = inferenceInput.tools.map((tool) => ({
         type: "function",
         function: {
           name: tool.name,
@@ -1694,36 +1591,35 @@ var OpenAIChatCompletionsMapper = class {
         }
       }));
     }
-    if (inferenceRequest.reasoningEffort) {
-      request.reasoning_effort = inferenceRequest.reasoningEffort;
+    if (inferenceInput.reasoningEffort) {
+      request.reasoning_effort = inferenceInput.reasoningEffort;
     }
-    if (inferenceRequest.streaming) {
-      request.stream = inferenceRequest.streaming;
+    if (inferenceInput.streaming) {
+      request.stream = inferenceInput.streaming;
     }
     return request;
   }
-  mapContextItems(inferenceRequest) {
+  mapContextItems(inferenceInput) {
     var _a;
     const messages = [];
-    for (const item of inferenceRequest.context.items) {
-      if (item.type === "developer_message" || item.type === "system_message") {
-        messages.push({ role: "system", content: item.text });
+    for (const item of inferenceInput.context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        messages.push({ role: "system", content: item.content.text });
         continue;
       }
-      if (item.type === "user_message") {
-        messages.push({ role: "user", content: item.text });
+      if (item instanceof UserMessageItem) {
+        messages.push({ role: "user", content: item.content.text });
         continue;
       }
-      if (item.type === "model_message") {
-        messages.push({ role: "assistant", content: item.text });
+      if (item instanceof ModelMessageItem) {
+        messages.push({ role: "assistant", content: item.content.text });
         continue;
       }
-      if (item.type === "tool_use_request") {
-        const toolUseRequest = item;
+      if (item instanceof FunctionCallItem) {
         const toolCall = {
-          id: toolUseRequest.requestId,
+          id: item.callId,
           type: "function",
-          function: { name: toolUseRequest.toolName, arguments: toolUseRequest.toolArguments }
+          function: { name: item.name, arguments: item.args }
         };
         const last = messages[messages.length - 1];
         if ((last == null ? void 0 : last.role) === "assistant") {
@@ -1734,13 +1630,8 @@ var OpenAIChatCompletionsMapper = class {
         }
         continue;
       }
-      if (item.type === "tool_use_result") {
-        const toolUseResult = item;
-        messages.push({
-          role: "tool",
-          tool_call_id: toolUseResult.requestId,
-          content: toolUseResult.result.text
-        });
+      if (item instanceof FunctionCallOutputItem) {
+        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
       }
     }
     return messages;
@@ -1766,32 +1657,31 @@ var OpenAIChatCompletionsMapper = class {
       return { items: [], tokenUsage: this.extractTokenUsage(response), rowResponse: response };
     }
     if (message.reasoning_content) {
-      items.push({
-        type: "reasoning",
-        content: { type: "input_text", text: message.reasoning_content },
-        encryptedContent: void 0,
-        summary: []
-      });
+      items.push(
+        ReasoningItem.rehydrate({
+          content: InputText.rehydrate({ text: message.reasoning_content }),
+          encryptedContent: void 0,
+          summary: []
+        })
+      );
     }
     if (message.content) {
-      items.push({
-        type: "model_message",
-        text: message.content
-      });
+      items.push(ModelMessageItem.rehydrate({ text: message.content }));
     }
     for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
-      items.push({
-        type: "tool_use_request",
-        requestId: toolCall.id,
-        toolName: toolCall.function.name,
-        toolArguments: toolCall.function.arguments
-      });
+      items.push(
+        FunctionCallItem.rehydrate({
+          callId: toolCall.id,
+          name: toolCall.function.name,
+          args: toolCall.function.arguments
+        })
+      );
     }
     return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
   }
 };
 
-// src/infrastructure/providers/openai/openai-chat-completions.ts
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions.ts
 var import_openai2 = __toESM(require("openai"));
 var OpenAIChatCompletions = class {
   constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
@@ -1807,18 +1697,18 @@ var OpenAIChatCompletions = class {
       apiKey: this.clientConfig.apiKey
     });
   }
-  buildRequest(inferenceRequest) {
+  buildRequest(inferenceInput) {
     return {
       ...this.extraBody,
-      ...this.endpointMapper.toRequest(inferenceRequest)
+      ...this.endpointMapper.toRequest(inferenceInput)
     };
   }
-  async infer(inferenceRequest) {
-    const response = await this.client.chat.completions.create(this.buildRequest(inferenceRequest));
+  async infer(inferenceInput) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceInput));
     return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceRequest) {
-    const stream = this.client.chat.completions.stream(this.buildRequest(inferenceRequest));
+  async *stream(inferenceInput) {
+    const stream = this.client.chat.completions.stream(this.buildRequest(inferenceInput));
     for await (const chunk of stream) {
       yield chunk;
     }
@@ -1827,7 +1717,7 @@ var OpenAIChatCompletions = class {
       type: "inference.output",
       payload: output,
       occurredAt: /* @__PURE__ */ new Date(),
-      producerId: inferenceRequest.model
+      producerId: inferenceInput.model
     };
   }
 };
@@ -1843,8 +1733,8 @@ var claudeSonnet46Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1865,8 +1755,8 @@ var claudeOpus48Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1887,8 +1777,8 @@ var claudeOpus47Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1909,8 +1799,8 @@ var gemini35FlashSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1931,8 +1821,8 @@ var gemini31ProSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1953,8 +1843,8 @@ var deepSeekV4FlashSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1975,8 +1865,8 @@ var deepSeekV4ProSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -1997,8 +1887,8 @@ var gpt54Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -2019,8 +1909,8 @@ var gpt54MiniSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -2041,8 +1931,8 @@ var gpt54NanoSpecification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -2063,8 +1953,8 @@ var gpt55Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -2085,8 +1975,8 @@ var claudeHaiku45Specification = {
     "system_message",
     "developer_message",
     "reasoning",
-    "tool_use_request",
-    "tool_use_result",
+    "function_call",
+    "function_call_output",
     "model_message"
   ],
   supportsStreaming: true,
@@ -2096,12 +1986,12 @@ var claudeHaiku45Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/openai/models/gpt-6-luna.ts
-var gpt6LunaSpecification = {
-  name: "gpt-6-luna",
+// src/infrastructure/providers/openai/models/gpt-6-astra.ts
+var gpt6AstraSpecification = {
+  name: "gpt-6-astra",
   provider: "openai",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low", "none"],
+  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2118,12 +2008,12 @@ var gpt6LunaSpecification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/openai/models/gpt-6-sol.ts
-var gpt6SolSpecification = {
-  name: "gpt-6-sol",
+// src/infrastructure/providers/openai/models/gpt-6-1-sol.ts
+var gpt61SolSpecification = {
+  name: "gpt-6.1-sol",
   provider: "openai",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low", "none"],
+  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2140,12 +2030,12 @@ var gpt6SolSpecification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/openai/models/gpt-6-1-sol.ts
-var gpt61SolSpecification = {
-  name: "gpt-6.1-sol",
+// src/infrastructure/providers/openai/models/gpt-6-sol.ts
+var gpt6SolSpecification = {
+  name: "gpt-6-sol",
   provider: "openai",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
+  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low", "none"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2162,12 +2052,12 @@ var gpt61SolSpecification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/openai/models/gpt-6-astra.ts
-var gpt6AstraSpecification = {
-  name: "gpt-6-astra",
+// src/infrastructure/providers/openai/models/gpt-6-luna.ts
+var gpt6LunaSpecification = {
+  name: "gpt-6-luna",
   provider: "openai",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
+  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low", "none"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2184,9 +2074,9 @@ var gpt6AstraSpecification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/anthropic/models/claude-5-sonnet.ts
-var claudeSonnet5Specification = {
-  name: "claude-sonnet-5",
+// src/infrastructure/providers/anthropic/models/claude-5-1-fable.ts
+var claudeFable51Specification = {
+  name: "claude-fable-5-1",
   provider: "anthropic",
   supportsReasoningEffort: true,
   supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
@@ -2206,9 +2096,9 @@ var claudeSonnet5Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/anthropic/models/claude-5-5-sonnet.ts
-var claudeSonnet55Specification = {
-  name: "claude-sonnet-5-5",
+// src/infrastructure/providers/anthropic/models/claude-5-5-opus.ts
+var claudeOpus55Specification = {
+  name: "claude-opus-5-5",
   provider: "anthropic",
   supportsReasoningEffort: true,
   supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
@@ -2228,9 +2118,9 @@ var claudeSonnet55Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/anthropic/models/claude-5-5-opus.ts
-var claudeOpus55Specification = {
-  name: "claude-opus-5-5",
+// src/infrastructure/providers/anthropic/models/claude-5-5-sonnet.ts
+var claudeSonnet55Specification = {
+  name: "claude-sonnet-5-5",
   provider: "anthropic",
   supportsReasoningEffort: true,
   supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
@@ -2250,9 +2140,9 @@ var claudeOpus55Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/anthropic/models/claude-5-1-fable.ts
-var claudeFable51Specification = {
-  name: "claude-fable-5-1",
+// src/infrastructure/providers/anthropic/models/claude-5-sonnet.ts
+var claudeSonnet5Specification = {
+  name: "claude-sonnet-5",
   provider: "anthropic",
   supportsReasoningEffort: true,
   supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
@@ -2272,12 +2162,12 @@ var claudeFable51Specification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/gemini/models/gemini-3-5-flash-lite.ts
-var gemini35FlashLiteSpecification = {
-  name: "gemini-3.5-flash-lite",
+// src/infrastructure/providers/gemini/models/gemini-3-8-flash.ts
+var gemini38FlashSpecification = {
+  name: "gemini-3.8-flash",
   provider: "google",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["high", "medium", "low", "minimal"],
+  supportedReasoningEfforts: ["high", "medium", "low"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2294,12 +2184,12 @@ var gemini35FlashLiteSpecification = {
   supportsStructuredOutput: true
 };
 
-// src/infrastructure/providers/gemini/models/gemini-3-8-flash.ts
-var gemini38FlashSpecification = {
-  name: "gemini-3.8-flash",
+// src/infrastructure/providers/gemini/models/gemini-3-5-flash-lite.ts
+var gemini35FlashLiteSpecification = {
+  name: "gemini-3.5-flash-lite",
   provider: "google",
   supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["high", "medium", "low"],
+  supportedReasoningEfforts: ["high", "medium", "low", "minimal"],
   supportedContextItemTypes: [
     "user_message",
     "system_message",
@@ -2338,7 +2228,7 @@ var deepSeekFlashSpecification = {
   supportsStructuredOutput: false
 };
 
-// src/infrastructure/providers/supported-models.ts
+// src/application/services/models.ts
 var supportedModels = [
   {
     endpoint: new OpenAIResponses(),
@@ -2434,181 +2324,268 @@ var supportedModels = [
   }
 ];
 
-// src/domain/agent/loop/rule-engine.ts
-var RuleEngine = class {
-  decide(agent, loop) {
-    const agentLoop = { agent, loop };
-    const satisfiedRules = loop.ruleBook.getRules().filter((rule) => rule.condition.isSatisfiedBy(agentLoop));
-    if (satisfiedRules.length === 0) {
-      return void 0;
+// src/domain/generative-model/request-validation/reasoning-effort.ts
+var ReasoningEffortValidation = class {
+  constructor() {
+    this.name = "reasoning-effort";
+  }
+  isValid(inferenceInput, model) {
+    if (inferenceInput.reasoningEffort === void 0) {
+      return true;
     }
-    const highestPriorityRule = satisfiedRules.reduce((highest, current) => {
-      return highest.priority > current.priority ? highest : current;
-    });
-    return highestPriorityRule.action.execute(agentLoop);
+    if (!model.supportsReasoningEffort) {
+      return false;
+    }
+    return model.supportedReasoningEfforts.includes(inferenceInput.reasoningEffort);
   }
 };
 
-// src/application/use-cases/run-loop.ts
-var RunLoopUseCase = class {
-  constructor(agentRepository, loopRepository, directiveExecutionStrategyResolver) {
-    this.agentRepository = agentRepository;
-    this.loopRepository = loopRepository;
-    this.directiveExecutionStrategyResolver = directiveExecutionStrategyResolver;
-    this.ruleEngine = new RuleEngine();
+// src/domain/generative-model/request-validation/tool-calling.ts
+var ToolCallingValidation = class {
+  constructor() {
+    this.name = "tool-calling";
   }
-  async execute(loopId) {
-    const loop = await this.loopRepository.findById(loopId);
-    if (!loop) {
-      throw new Error("Loop not found");
-    }
-    const agent = await this.agentRepository.findById(loop.getAgentId());
-    if (!agent) {
-      throw new Error("Agent not found");
-    }
-    while (loop.stateId !== "completed") {
-      const directive = this.ruleEngine.decide(agent, loop);
-      if (!directive) return loop;
-      const strategy = this.directiveExecutionStrategyResolver.resolve(directive);
-      await strategy.execute(directive, agent, loop);
+  isValid(inferenceInput, model) {
+    if (inferenceInput.tools === void 0) {
+      return true;
     }
-    await this.loopRepository.save(loop);
-    return loop;
+    return model.supportsFunctionCalling;
   }
 };
 
-// src/infrastructure/memory/runtime-memory.ts
-var RuntimeMemory = class {
-  constructor(context) {
-    this.context = context;
-  }
-  remember(items, participantId) {
-    throw new Error("Method not implemented.");
+// src/domain/generative-model/request-validation/streaming.ts
+var StreamingValidation = class {
+  constructor() {
+    this.name = "streaming";
   }
-  recall(topic, participantId) {
-    throw new Error("Method not implemented.");
+  isValid(inferenceInput, model) {
+    if (!inferenceInput.streaming) {
+      return true;
+    }
+    return model.supportsStreaming;
   }
 };
 
-// src/infrastructure/memory/runtime-memory-factory.ts
-var RuntimeMemoryFactory = class {
-  create() {
-    const context = {
-      items: []
-    };
-    return new RuntimeMemory(context);
+// src/domain/generative-model/request-validation/context.ts
+function getContextItemValidationKey(item) {
+  if (item instanceof UserMessageItem) {
+    return "user_message";
   }
-};
-
-// src/application/directive-execution/directive-execution-strategy-resolver.ts
-var DirectiveExecutionStrategyResolver = class {
-  constructor(strategies) {
-    this.strategies = strategies;
+  if (item instanceof SystemMessageItem) {
+    return "system_message";
   }
-  resolve(directive) {
-    return this.strategies[directive.type];
+  if (item instanceof DeveloperMessageItem) {
+    return "developer_message";
   }
-};
-
-// src/application/directive-execution/complete-execution-strategy.ts
-var CompleteExecutionStrategy = class {
-  async execute(directive, agent, loop) {
-    if (directive.type !== "complete") {
-      throw new Error("Expected a completion directive");
-    }
-    loop.complete(directive.reason);
+  if (item instanceof ModelMessageItem) {
+    return "model_message";
+  }
+  return item.getType();
+}
+var ContextValidation = class {
+  constructor() {
+    this.name = "context";
+  }
+  isValid(inferenceInput, model) {
+    return inferenceInput.context.items.every(
+      (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
+    );
   }
 };
 
-// src/application/directive-execution/inference-execution-strategy.ts
-var InferenceExecutionStrategy = class {
-  constructor(inferenceRunner) {
-    this.inferenceRunner = inferenceRunner;
+// src/domain/generative-model/request-validation/inference-request-validator.ts
+var defaultRequestValidationRules = [
+  new ReasoningEffortValidation(),
+  new ToolCallingValidation(),
+  new StreamingValidation(),
+  new StructuredOutputValidation(),
+  new ContextValidation()
+];
+var InferenceInputValidator = class {
+  constructor(rules = defaultRequestValidationRules) {
+    this.rules = rules;
   }
-  async execute(directive, agent, loop) {
-    if (directive.type !== "inference") {
-      throw new Error("Expected an inference directive");
+  validate(inferenceInput, model) {
+    for (const rule of this.rules) {
+      if (!rule.isValid(inferenceInput, model)) {
+        throw new Error(`Request validation "${rule.name}" failed for model "${model.name}"`);
+      }
     }
-    const pending = loop.requestInference(directive.request);
-    const result = await this.inferenceRunner.run(directive.request);
-    loop.receiveInferenceResult(pending.id, result);
   }
 };
 
-// src/application/directive-execution/tool-use-execution-strategy.ts
-var ToolUseExecutionStrategy = class {
-  constructor(toolRunner) {
-    this.toolRunner = toolRunner;
+// src/application/services/inference-runner.ts
+var DefaultInferenceRunner = class {
+  constructor(supportedModels2, requestValidator) {
+    this.supportedModels = supportedModels2;
+    this.requestValidator = requestValidator;
   }
-  async execute(directive, agent, loop) {
-    if (directive.type !== "tool_use") {
-      throw new Error("Expected a tool-use directive");
-    }
-    const pending = loop.pending;
-    if ((pending == null ? void 0 : pending.type) !== "tool_execution") {
-      throw new Error("The loop has no pending tool execution");
+  async run(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
     }
-    const tool = agent.getTools().find((tool2) => tool2.name === directive.call.toolName);
-    if (!tool) {
-      throw new Error(`Tool "${directive.call.toolName}" not found`);
+    this.requestValidator.validate(input, generativeModel.specification);
+    return await generativeModel.endpoint.infer(input);
+  }
+  async *stream(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
     }
-    const result = await this.toolRunner.run(directive.call, tool);
-    loop.receiveToolUseResult(pending.id, result);
+    this.requestValidator.validate(input, generativeModel.specification);
+    yield* generativeModel.endpoint.stream(input);
   }
 };
 
-// src/application/directive-execution/wait-execution-strategy.ts
-var WaitExecutionStrategy = class {
-  async execute(directive, agent, loop) {
-    if (directive.type !== "wait") {
-      throw new Error("Expected a wait directive");
+// 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,
+        typeof result === "string" ? result : JSON.stringify(result)
+      );
+    } catch (error) {
+      return FunctionCallOutputItem.create(input.callId, `Error calling tool: ${error}`);
     }
-    loop.wait(directive.reason);
   }
 };
 
-// src/agent-module.ts
-function defineAgentModule(config) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const agentRepository = (_a = config.agentRepository) != null ? _a : new InMemoryAgentRepository();
-  const agentLoopRepository = (_b = config.agentLoopRepository) != null ? _b : new InMemoryLoopRepository();
-  const inferenceRunner = (_f = (_c = config.inferenceRunnerConfig) == null ? void 0 : _c.runner) != null ? _f : new DefaultInferenceRunner(
-    (_e = (_d = config.inferenceRunnerConfig) == null ? void 0 : _d.supportedModels) != null ? _e : supportedModels,
-    new InferenceRequestValidator()
-  );
-  const toolRunner = (_g = config.toolRunner) != null ? _g : new LocalToolRunner();
-  const memoryFactory = new RuntimeMemoryFactory();
-  const createAgentUseCase = new CreateAgentUseCase(agentRepository, memoryFactory);
-  const createLoopUseCase = new CreateAgentLoopUseCase(agentLoopRepository);
-  async function createAgent(config2) {
-    return await createAgentUseCase.execute(config2.name, config2.instruction, config2.tools, config2.handlers);
+// src/application/use-cases/send-event.ts
+function createSendEvent(resolveRuntime) {
+  return function sendEvent(event, senderId) {
+    const runtime = resolveRuntime();
+    const participant = runtime.getParticipant(senderId);
+    if (!participant) {
+      throw new Error(`Participant ${senderId} not found`);
+    }
+    runtime.publish(event);
+  };
+}
+
+// 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;
   }
-  async function createLoop(params) {
-    return await createLoopUseCase.execute(params);
+  function resolveRuntime() {
+    if (!runtime) {
+      throw new Error("Runtime not initialized");
+    }
+    return runtime;
   }
-  const directiveExecutionStrategyResolver = new DirectiveExecutionStrategyResolver({
-    inference: new InferenceExecutionStrategy(inferenceRunner),
-    tool_use: new ToolUseExecutionStrategy(toolRunner),
-    complete: new CompleteExecutionStrategy(),
-    wait: new WaitExecutionStrategy()
-  });
-  const runLoopUseCase = new RunLoopUseCase(agentRepository, agentLoopRepository, directiveExecutionStrategyResolver);
-  async function runLoop(loopId) {
-    return await runLoopUseCase.execute(loopId);
+  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 sendEvent = createSendEvent(resolveRuntime);
+  const runLoop = createRunLoop(resolveRuntime);
   return {
-    createAgent,
-    createLoop,
+    initializeRuntime,
+    resolveRuntime,
+    resolveParticipant,
+    join,
+    leave,
+    sendMessage,
+    sendEvent,
     runLoop
   };
 }
+
+// src/domain/agentic-environment/situation/situation-specification.ts
+var SituationSpecification = class {
+  and(other) {
+    return new AndSituationSpecification(this, other);
+  }
+  or(other) {
+    return new OrSituationSpecification(this, other);
+  }
+  not() {
+    return new NotSituationSpecification(this);
+  }
+};
+var AndSituationSpecification = class extends SituationSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(situationContext) {
+    return this.left.isSatisfiedBy(situationContext) && this.right.isSatisfiedBy(situationContext);
+  }
+};
+var OrSituationSpecification = class extends SituationSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(situationContext) {
+    return this.left.isSatisfiedBy(situationContext) || this.right.isSatisfiedBy(situationContext);
+  }
+};
+var NotSituationSpecification = class extends SituationSpecification {
+  constructor(rule) {
+    super();
+    this.rule = rule;
+  }
+  isSatisfiedBy(situationContext) {
+    return !this.rule.isSatisfiedBy(situationContext);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Agent,
+  AnthropicMessages,
+  ContextItem,
+  DefaultInferenceRunner,
+  DeveloperMessageItem,
+  FunctionCallItem,
+  FunctionCallOutputItem,
+  GeminiGenerateContent,
+  Human,
+  InputTokenDetails,
+  McpClient,
+  McpToolRegistry,
+  ModelContext,
+  ModelMessageItem,
+  OpenAIChatCompletions,
+  OpenAIResponses,
+  OutputTokenDetails,
   Participant,
+  ReasoningItem,
+  RuntimeState,
+  SemanticEvent,
   SituationSpecification,
-  SpaceEvent,
-  defineAgentModule,
-  defineRuntime
+  SystemMessageItem,
+  TokenUsage,
+  UserMessageItem,
+  createAgent,
+  createHuman,
+  defineRuntime,
+  supportedModels
 });
 //# sourceMappingURL=index.js.map