@mozaik-ai/core 4.0.6 → 4.2.0-beta.0

package/dist/index.mjs

@@ -1,354 +1,17 @@
-// src/domain/model-context/model-context.ts
-var ModelContext = class _ModelContext {
-  constructor(id, items) {
-    this.id = id;
-    this.items = items;
-  }
-  getItems() {
-    return this.items;
-  }
-  addContextItems(contextItems) {
-    this.items.push(...contextItems);
-    return this;
-  }
-  addContextItem(item) {
-    this.items.push(item);
-    return this;
-  }
-  static create() {
-    const id = crypto.randomUUID();
-    return new _ModelContext(id, []);
-  }
-  static rehydrate(data) {
-    return new _ModelContext(data.id, data.items);
-  }
-};
-
-// src/domain/model-context/context-item/context-item.ts
-var ContextItem = class {
-  getType() {
-    return this.type;
-  }
-};
-
-// src/domain/model-context/context-item/item-content/item-content.ts
-var ItemContent = class {
-};
-
-// 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";
-  }
-  static create(text) {
-    return new _InputText(text);
-  }
-  static rehydrate(data) {
-    return new _InputText(data.text);
-  }
-};
-
-// 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;
-  }
-  static create(text) {
-    const content = InputText.create(text);
-    return new _UserMessageItem(content);
-  }
-  static rehydrate(data) {
-    const content = InputText.rehydrate(data);
-    return new _UserMessageItem(content);
-  }
-};
-
-// 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;
-  }
-  static create(text) {
-    const content = InputText.create(text);
-    return new _DeveloperMessageItem(content);
-  }
-  static rehydrate(data) {
-    const content = InputText.rehydrate(data);
-    return new _DeveloperMessageItem(content);
-  }
-};
-
-// 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";
-  }
-  static rehydrate(data) {
-    return new _OutputText(data.text);
-  }
-};
-
-// 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/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.args = args;
-  }
-  static rehydrate(data) {
-    return new _FunctionCallItem(data.callId, data.name, data.args);
-  }
-};
-
-// 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;
-  }
-  static rehydrate(data) {
-    return new _ReasoningItem(data.content, data.encryptedContent, data.summary);
-  }
-};
-
-// src/domain/generative-model/request-validation/structured-output.ts
-var StructuredOutputValidation = class {
-  constructor() {
-    this.name = "structured-output";
-  }
-  isValid(inferenceInput, model) {
-    if (inferenceInput.structuredOutput === void 0) {
-      return true;
-    }
-    return model.supportsStructuredOutput;
-  }
-};
-
-// 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;
-  }
-  static create(callId, output) {
-    const outputText = InputText.create(output);
-    return new _FunctionCallOutputItem(callId, outputText);
-  }
-  static rehydrate(data) {
-    return new _FunctionCallOutputItem(data.callId, data.output);
-  }
-};
-
-// src/domain/generative-model/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/infrastructure/mcp/mcp-client.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-var McpClient = class {
-  constructor(config) {
-    this.config = config;
-    this.connected = false;
-    var _a, _b;
-    const headers = { ...(_a = config.headers) != null ? _a : {} };
-    if (config.authToken) headers.Authorization = `Bearer ${config.authToken}`;
-    this.transport = new StreamableHTTPClientTransport(
-      new URL(config.url),
-      Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0
-    );
-    this.client = new Client({ name: (_b = config.name) != null ? _b : "mozaik", version: "1.0.0" }, { capabilities: {} });
-  }
-  async connect() {
-    if (this.connected) return;
-    await this.client.connect(this.transport);
-    this.connected = true;
-  }
-  /** The tools this server exposes. */
-  async listTools() {
-    var _a;
-    await this.connect();
-    const res = await this.client.listTools();
-    return ((_a = res.tools) != null ? _a : []).map((t) => {
-      var _a2, _b;
-      return {
-        name: t.name,
-        description: (_a2 = t.description) != null ? _a2 : "",
-        inputSchema: (_b = t.inputSchema) != null ? _b : { type: "object", properties: {} }
-      };
-    });
-  }
-  /** Call a tool by name; returns its text output. Throws if the server flags an error. */
-  async callTool(name, args) {
-    await this.connect();
-    const res = await this.client.callTool({ name, arguments: args != null ? args : {} });
-    const text = extractText(res);
-    if (res.isError) {
-      throw new Error(`MCP tool "${name}" failed: ${text || "unknown error"}`);
-    }
-    return text;
-  }
-  async close() {
-    if (!this.connected) return;
-    try {
-      await this.client.close();
-    } catch (e) {
-    }
-    this.connected = false;
-  }
-};
-function extractText(res) {
-  const content = res.content;
-  if (!Array.isArray(content)) return "";
-  return content.filter((c) => (c == null ? void 0 : c.type) === "text" && typeof c.text === "string").map((c) => c.text).join("\n");
-}
-
-// src/infrastructure/mcp/mcp-tool-registry.ts
-var McpToolRegistry = class {
-  constructor(servers, createClient = (config) => new McpClient(config)) {
-    this.servers = servers;
-    this.createClient = createClient;
-    this.clients = [];
-  }
-  /** Discover every tool across the configured servers, as FunctionTools ready to pass to a model. */
-  async discoverTools() {
-    const tools = [];
-    for (const server of this.servers) {
-      const client = this.createClient(server);
-      this.clients.push(client);
-      for (const spec of await client.listTools()) {
-        tools.push({
-          type: "function",
-          name: spec.name,
-          description: spec.description,
-          parameters: spec.inputSchema,
-          strict: false,
-          invoke: (args) => client.callTool(spec.name, args != null ? args : {})
-        });
-      }
-    }
-    return tools;
-  }
-  /** Close all underlying MCP connections. */
-  async close() {
-    await Promise.all(this.clients.map((c) => c.close()));
-  }
-};
-
-// src/domain/model-context/context-item/client-item/system-message.ts
-var SystemMessageItem = class _SystemMessageItem extends ContextItem {
-  constructor(content) {
-    super();
-    this.type = "message";
-    this.role = "system";
-    this.content = content;
-  }
-  static create(text) {
-    const content = InputText.create(text);
-    return new _SystemMessageItem(content);
-  }
-  static rehydrate(data) {
-    const content = InputText.rehydrate(data);
-    return new _SystemMessageItem(content);
-  }
-};
-
-// src/domain/agentic-environment/semantic-event/event.ts
-var SemanticEvent = class _SemanticEvent {
+// 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, payload) {
-    const occurredAt = /* @__PURE__ */ new Date();
-    return new _SemanticEvent(type, producerId, occurredAt, payload);
-  }
-};
-var ParticipantJoinedEvent = class extends SemanticEvent {
-  static init(manifest) {
-    return SemanticEvent.create("participant.joined", manifest.id, manifest);
-  }
-};
-var ParticipantLeftEvent = class extends SemanticEvent {
-  static init(manifest) {
-    return SemanticEvent.create("participant.left", manifest.id, manifest);
-  }
-};
-var MessageSentEvent = class extends SemanticEvent {
-  static init(producerId, message) {
-    return SemanticEvent.create("message.sent", producerId, { message });
+  static create(type, producerId, occurredAt, payload) {
+    return new _SpaceEvent(type, producerId, occurredAt, payload);
   }
 };
 
-// src/application/states/inference.ts
-var InferenceState = class {
-  constructor(inferenceRunner) {
-    this.inferenceRunner = inferenceRunner;
-    this.id = "inference";
-  }
-  async run(input, loopVisitor) {
-    loopVisitor.visitInferenceStarted(input);
-    const output = await this.inferenceRunner.run(input);
-    loopVisitor.visitInferenceCompleted(output);
-    return {
-      stateId: this.id,
-      input,
-      output
-    };
-  }
-};
-
-// src/domain/agentic-environment/participant/participant.ts
+// src/domain/space/participant.ts
 var Participant = class {
   constructor(manifest, handlers) {
     this.manifest = manifest;
@@ -357,6 +20,9 @@ var Participant = class {
   getManifest() {
     return this.manifest;
   }
+  setManifest(manifest) {
+    this.manifest = manifest;
+  }
   getId() {
     return this.manifest.id;
   }
@@ -368,1764 +34,143 @@ var Participant = class {
   }
 };
 
-// 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/agentic-environment/participant/agent.ts
-var Agent = class _Agent extends Participant {
-  constructor(manifest, developerMessage, tools, memory, handlers) {
-    super(manifest, handlers);
-    this.memory = memory;
-    this.developerMessage = developerMessage;
-    this.tools = tools;
-  }
-  static create({
-    name,
-    instruction,
-    tools,
-    capabilities,
-    handlers
-  }) {
-    const id = crypto.randomUUID();
-    const memory = Memory.create();
-    const manifest = { id, name, capabilities, role: "agent" };
-    const developerMessage = DeveloperMessageItem.create(instruction);
-    memory.getContext().addContextItem(developerMessage);
-    return new _Agent(manifest, instruction, tools, memory, handlers);
-  }
-  getTools() {
-    return this.tools;
-  }
-  getDeveloperMessage() {
-    return this.developerMessage;
-  }
-  getMemory() {
-    return this.memory;
-  }
-};
-
-// src/application/use-cases/create-agent.ts
-function createAgent({
-  name,
-  capabilities,
-  instruction,
-  tools,
-  handlers
-}) {
-  return Agent.create({ name, instruction, capabilities, tools, handlers });
-}
-
-// src/domain/agentic-environment/participant/human.ts
-var Human = class _Human extends Participant {
-  constructor(manifest, handlers) {
-    super(manifest, handlers);
-  }
-  static create({
-    name,
-    capabilities,
-    handlers
-  }) {
-    const id = crypto.randomUUID();
-    const manifest = { id, name, capabilities, role: "human" };
-    return new _Human(manifest, handlers);
-  }
-};
-
-// 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();
-  }
-  addParticipant(participant) {
-    const isExists = this.participants.get(participant.getId());
-    if (isExists) return;
-    this.participants.set(participant.getId(), participant);
-  }
-  removeParticipant(participant) {
-    this.participants.delete(participant.getId());
-  }
-  getParticipant(id) {
-    return this.participants.get(id);
-  }
-  getParticipants() {
-    return [...this.participants.values()];
-  }
-};
-
-// src/application/services/runtime.ts
+// src/domain/space/runtime.ts
 var RuntimeService = class {
-  constructor(state, processor, inferenceRunner, functionCallRunner) {
+  constructor(state) {
     this.state = state;
-    this.processor = processor;
-    this.inferenceRunner = inferenceRunner;
-    this.functionCallRunner = functionCallRunner;
-  }
-  join(participant) {
-    this.state.addParticipant(participant);
-    this.publish(ParticipantJoinedEvent.init(participant.getManifest()));
-  }
-  leave(participant) {
-    this.state.removeParticipant(participant);
-    this.publish(ParticipantLeftEvent.init(participant.getManifest()));
-  }
-  publish(event) {
-    for (const participant of this.state.getParticipants()) {
-      this.processor.process(event, participant);
-    }
-  }
-  getParticipant(id) {
-    if (!this.state.getParticipant(id)) {
-      throw new Error(`Participant ${id} not found`);
-    }
-    return this.state.getParticipant(id);
-  }
-  getInferenceRunner() {
-    return this.inferenceRunner;
-  }
-  getFunctionCallRunner() {
-    return this.functionCallRunner;
   }
 };
 
-// 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/util/uuid-generator.ts
+var UuidGenerator = class {
+  static create() {
+    return crypto.randomUUID();
   }
 };
 
-// src/application/use-cases/join.ts
-function createJoin(resolveRuntime) {
-  return function join(participant) {
-    resolveRuntime().join(participant);
-  };
-}
-
-// src/application/use-cases/leave.ts
-function createLeave(resolveRuntime) {
-  return function leave(participant) {
-    resolveRuntime().leave(participant);
-  };
-}
-
-// src/application/use-cases/send-message.ts
-function createSendMessage(resolveRuntime) {
-  return function sendMessage(message, senderId) {
-    const runtime = resolveRuntime();
-    const participant = runtime.getParticipant(senderId);
-    if (!participant) {
-      throw new Error(`Participant ${senderId} not found`);
-    }
-    const userMessage = MessageSentEvent.init(senderId, message);
-    runtime.publish(userMessage);
-  };
-}
-
-// src/domain/agentic-environment/loop/agent-loop.ts
-var AgentLoop = class _AgentLoop {
-  constructor(loopId, stateExecutor, transitionResolver, interceptionHandler) {
-    this.loopId = loopId;
-    this.stateExecutor = stateExecutor;
-    this.transitionResolver = transitionResolver;
-    this.interceptionHandler = interceptionHandler;
-  }
-  async run(message, loopVisitor) {
-    var _a;
-    let transition = {
-      nextStateId: "message_received",
-      input: message
+// src/application/use-cases/create-participant.ts
+var CreateParticipantUseCase = class {
+  async execute(name, capabilities, handlers) {
+    const manifest = {
+      id: UuidGenerator.create(),
+      name,
+      capabilities,
+      role: "external"
     };
-    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);
-    }
-  }
-  getLoopId() {
-    return this.loopId;
-  }
-  static create(stateExecutor, transitionResolver, interceptionHandler) {
-    const loopId = crypto.randomUUID();
-    return new _AgentLoop(loopId, stateExecutor, transitionResolver, interceptionHandler);
+    const participant = new Participant(manifest, handlers);
+    return participant;
   }
 };
 
-// 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;
+// src/application/use-cases/participant-joined.ts
+var ParticipantJoinedUseCase = class {
+  constructor(spaceRepository, eventPublisher) {
+    this.spaceRepository = spaceRepository;
+    this.eventPublisher = eventPublisher;
   }
-  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);
+  async execute(spaceId, participantId, occurredAt) {
+    const space = await this.spaceRepository.findById(spaceId);
+    if (!space) {
+      throw new Error("Space not found");
     }
-  }
-};
-
-// src/application/states/function-call.ts
-var FunctionCallState = class {
-  constructor(functionCallRunner) {
-    this.functionCallRunner = functionCallRunner;
-    this.id = "function_call";
-  }
-  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 participant = space.getParticipant(participantId);
+    if (!participant) {
+      throw new Error("Participant not found");
     }
-    const item = await this.functionCallRunner.run(call, tool);
-    loopVisitor.visitFunctionCallCompleted(item);
-    return {
-      stateId: this.id,
-      input,
-      output: {
-        item
-      }
-    };
-  }
-};
-
-// src/application/states/message-received.ts
-var MessageReceivedState = class {
-  constructor() {
-    this.id = "message_received";
-  }
-  async run(input, loopVisitor) {
-    loopVisitor.visitMessageReceivedStarted(input);
-    const userMessage = UserMessageItem.create(input.content);
-    const output = {
-      ...input.input,
-      context: input.input.context.addContextItems([userMessage])
-    };
-    loopVisitor.visitMessageReceivedCompleted(output);
-    return {
-      stateId: this.id,
-      input,
-      output
-    };
-  }
-};
-
-// src/application/states/model-message.ts
-var ModelMessageState = class {
-  constructor() {
-    this.id = "model_message";
-  }
-  async run(input, loopVisitor) {
-    loopVisitor.visitModelAnswer(input);
-    return {
-      stateId: this.id,
-      input,
-      output: void 0
-    };
-  }
-};
-
-// src/domain/agentic-environment/loop/transition-resolver.ts
-var TransitionResolver = class {
-  constructor(rules) {
-    this.rules = rules;
-  }
-  resolve(execution) {
-    const rule = this.rules.find((rule2) => rule2.specification.isSatisfiedBy(execution));
-    if (!rule) {
-      throw new Error(`No transition rule found after "${execution.stateId}"`);
+    const event = space.addParticipant(participant, occurredAt);
+    if (event) {
+      this.eventPublisher.publish(event, space.getParticipants());
     }
-    return rule.createTransition(execution);
-  }
-};
-
-// src/domain/agentic-environment/loop/transition-specification.ts
-var MessageReceivedSpecification = class {
-  isSatisfiedBy(execution) {
-    return execution.stateId === "message_received";
-  }
-};
-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");
-  }
-};
-var InferenceProducedModelMessageSpecification = class {
-  isSatisfiedBy(execution) {
-    return isInferenceExecution(execution) && execution.output.items.some((item) => item.type === "message" && item.role === "assistant");
-  }
-};
-var FunctionCallCompletedSpecification = class {
-  isSatisfiedBy(execution) {
-    return execution.stateId === "function_call";
-  }
-};
-var ModelMessageCompletedSpecification = class {
-  isSatisfiedBy(execution) {
-    return execution.stateId === "model_message";
+    await this.spaceRepository.save(space);
   }
 };
 
-// src/domain/agentic-environment/loop/transition-rule.ts
-var ContextPreparationToInferenceRule = class {
-  constructor() {
-    this.specification = new MessageReceivedSpecification();
-  }
-  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
-    };
-  }
-};
-var InferenceToFunctionCallRule = class {
+// src/infrastructure/repositories/in-memory-space-repository.ts
+var InMemorySpaceRepository = class {
   constructor() {
-    this.specification = new InferenceProducedFunctionCallSpecification();
-  }
-  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");
-    }
-    const functionCallItem = execution.output.items.find((item) => item.type === "function_call");
-    if (!functionCallItem) {
-      throw new Error("Expected inference function-call output");
-    }
-    return {
-      nextStateId: "function_call",
-      input: {
-        call: functionCallItem,
-        inferenceInput: execution.input
-      }
-    };
+    this.spaces = [];
   }
-};
-var InferenceToModelMessageRule = class {
-  constructor() {
-    this.specification = new InferenceProducedModelMessageSpecification();
+  async save(space) {
+    this.spaces.push(space);
   }
-  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");
-    }
-    const modelMessageItem = execution.output.items.find(
-      (item) => item.type === "message" && item.role === "assistant"
-    );
-    if (!modelMessageItem) {
-      throw new Error("Expected inference model-message output");
-    }
-    execution.input.context.addContextItem(modelMessageItem);
-    return {
-      nextStateId: "model_message",
-      input: {
-        answer: modelMessageItem
-      }
-    };
+  async findById(id) {
+    return this.spaces.find((space) => space.getId() === id);
   }
-};
-var FunctionCallToInferenceRule = class {
-  constructor() {
-    this.specification = new FunctionCallCompletedSpecification();
+  async findAllByOwnerId(ownerId) {
+    return this.spaces.filter((space) => space.getOwnerId() === ownerId);
   }
-  createTransition(execution) {
-    if (execution.stateId !== "function_call") {
-      throw new Error("Expected function_call execution");
-    }
-    const previousRequest = execution.input.inferenceInput;
-    previousRequest.context.addContextItems([execution.input.call, execution.output.item]);
-    return {
-      nextStateId: previousRequest.streaming ? "inference_streaming" : "inference",
-      input: {
-        ...previousRequest
-      }
-    };
-  }
-};
-var ModelMessageToIdleRule = class {
-  constructor() {
-    this.specification = new ModelMessageCompletedSpecification();
-  }
-  createTransition(execution) {
-    if (execution.stateId !== "model_message") {
-      throw new Error("Expected model_message execution");
-    }
-    return {
-      nextStateId: "idle",
-      input: void 0
-    };
-  }
-};
-
-// src/domain/agentic-environment/loop/event-publisher-visitor.ts
-import { createCloudClient } from "@mozaik-ai/cloud-sdk";
-var EventPublisherLoopVisitor = class {
-  constructor(agentId, loopId, runtime) {
-    this.agentId = agentId;
-    this.loopId = loopId;
-    this.runtime = runtime;
-    this.cloud = createCloudClient();
-  }
-  visitMessageReceivedStarted(input) {
-    this.publish("message_received.started", input);
-  }
-  visitMessageReceivedCompleted(output) {
-    this.publish("message_received.completed", output);
-  }
-  visitInferenceStarted(input) {
-    this.publish("inference.started", input);
-  }
-  visitInferenceEvent(event) {
-    this.publish("inference.stream", event);
-  }
-  visitInferenceCompleted(output) {
-    this.publish("inference.completed", output);
-  }
-  visitFunctionCallStarted(input) {
-    this.publish("function_call.started", input);
-  }
-  visitFunctionCallCompleted(output) {
-    this.publish("function_call.completed", output);
-  }
-  visitModelAnswer(input) {
-    this.publish("model.answer", input);
-  }
-  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/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/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(inferenceInput) {
-    const { messages, system } = this.mapContextItems(inferenceInput);
-    const outputConfig = {};
-    const request = {
-      model: inferenceInput.model,
-      messages
-    };
-    request.max_tokens = inferenceInput.maxOutputTokens;
-    if (system) {
-      request.system = system;
-    }
-    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
-      request.tools = inferenceInput.tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        input_schema: tool.parameters
-      }));
-    }
-    if (inferenceInput.structuredOutput) {
-      outputConfig.format = {
-        type: "json_schema",
-        schema: inferenceInput.structuredOutput.schema
-      };
-    }
-    if (inferenceInput.reasoningEffort) {
-      request.thinking = { type: "adaptive" };
-      outputConfig.effort = inferenceInput.reasoningEffort;
-    }
-    if (Object.keys(outputConfig).length > 0) {
-      request.output_config = outputConfig;
-    }
-    if (inferenceInput.streaming) {
-      request.stream = inferenceInput.streaming;
-    }
-    return request;
-  }
-  addContentBlock(messages, role, block) {
-    const lastMessage = messages[messages.length - 1];
-    if ((lastMessage == null ? void 0 : lastMessage.role) === role) {
-      lastMessage.content.push(block);
-      return;
-    }
-    messages.push({
-      role,
-      content: [block]
-    });
-  }
-  mapContextItems(inferenceInput) {
-    var _a, _b, _c;
-    const context = inferenceInput.context;
-    const messages = [];
-    const system = [];
-    for (const item of context.getItems()) {
-      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
-        system.push(item.content.text);
-        continue;
-      }
-      if (item instanceof UserMessageItem) {
-        this.addContentBlock(messages, "user", { type: "text", text: item.content.text });
-        continue;
-      }
-      if (item instanceof ModelMessageItem) {
-        this.addContentBlock(messages, "assistant", { type: "text", text: item.content.text });
-        continue;
-      }
-      if (item instanceof ReasoningItem) {
-        this.addContentBlock(messages, "assistant", {
-          type: "thinking",
-          thinking: (_b = (_a = item.content) == null ? void 0 : _a.text) != null ? _b : "",
-          signature: (_c = item.encryptedContent) != null ? _c : ""
-        });
-        continue;
-      }
-      if (item instanceof FunctionCallItem) {
-        let input;
-        try {
-          input = JSON.parse(item.args);
-        } catch (e) {
-          input = item.args;
-        }
-        this.addContentBlock(messages, "assistant", {
-          type: "tool_use",
-          id: item.callId,
-          name: item.name,
-          input
-        });
-        continue;
-      }
-      if (item instanceof FunctionCallOutputItem) {
-        this.addContentBlock(messages, "user", {
-          type: "tool_result",
-          tool_use_id: item.callId,
-          content: item.output.text
-        });
-      }
-    }
-    return {
-      messages,
-      system: system.length > 0 ? system.join("\n\n") : void 0
-    };
-  }
-  extractTokenUsage(response) {
-    var _a, _b;
-    if (!response.usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      response.usage.input_tokens,
-      response.usage.output_tokens,
-      response.usage.input_tokens + response.usage.output_tokens,
-      new InputTokenDetails(
-        ((_a = response.usage.cache_creation_input_tokens) != null ? _a : 0) + ((_b = response.usage.cache_read_input_tokens) != null ? _b : 0)
-      ),
-      new OutputTokenDetails(0)
-    );
-  }
-  toResponse(response) {
-    var _a;
-    const items = [];
-    for (const block of response.content) {
-      if (block.type === "text") {
-        items.push(ModelMessageItem.rehydrate({ text: block.text }));
-        continue;
-      }
-      if (block.type === "tool_use") {
-        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(
-          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/endpoints/anthropic-messages.ts
-import Anthropic from "@anthropic-ai/sdk";
-var AnthropicMessages = class {
-  constructor(endpointMapper = new AnthropicMessagesMapper(), config = {}) {
-    this.endpointMapper = endpointMapper;
-    this.clientConfig = config;
-  }
-  get client() {
-    var _a;
-    return (_a = this._client) != null ? _a : this._client = new Anthropic({
-      baseURL: this.clientConfig.baseURL,
-      apiKey: this.clientConfig.apiKey
-    });
-  }
-  async infer(inferenceInput) {
-    const request = this.endpointMapper.toRequest(inferenceInput);
-    const response = await this.client.messages.create(request);
-    return this.endpointMapper.toResponse(response);
-  }
-  async *stream(inferenceInput) {
-    const request = this.endpointMapper.toRequest(inferenceInput);
-    const stream = this.client.messages.stream(request);
-    for await (const event of stream) {
-      yield event;
-    }
-    const output = this.endpointMapper.toResponse(await stream.finalMessage());
-    yield {
-      type: "inference.output",
-      producerId: request.model,
-      occurredAt: /* @__PURE__ */ new Date(),
-      payload: output
-    };
-  }
-};
-
-// src/infrastructure/providers/openai/endpoints/openai-responses.ts
-import OpenAI from "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(inferenceInput) {
-    var _a, _b;
-    const request = {
-      model: inferenceInput.model,
-      input: this.mapContextItems(inferenceInput)
-    };
-    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 (inferenceInput.reasoningEffort) {
-      request.reasoning = {
-        effort: inferenceInput.reasoningEffort
-      };
-    }
-    if (inferenceInput.structuredOutput) {
-      const format = inferenceInput.structuredOutput;
-      request.text = {
-        format: {
-          type: "json_schema",
-          name: (_a = format.name) != null ? _a : "response",
-          schema: format.schema,
-          strict: (_b = format.strict) != null ? _b : true
-        }
-      };
-    }
-    if (inferenceInput.streaming) {
-      request.stream = inferenceInput.streaming;
-    }
-    return request;
-  }
-  mapContextItems(inferenceInput) {
-    const input = [];
-    for (const item of inferenceInput.context.getItems()) {
-      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem || item instanceof UserMessageItem) {
-        input.push({
-          type: item.type,
-          role: item.role,
-          content: [{ type: "input_text", text: item.content.text }]
-        });
-        continue;
-      }
-      if (item instanceof ModelMessageItem) {
-        input.push({
-          type: item.type,
-          role: item.role,
-          content: [{ type: "output_text", text: item.content.text }]
-        });
-        continue;
-      }
-      if (item instanceof FunctionCallItem) {
-        input.push({
-          type: item.type,
-          call_id: item.callId,
-          name: item.name,
-          arguments: item.args
-        });
-        continue;
-      }
-      if (item instanceof FunctionCallOutputItem) {
-        input.push({
-          type: item.type,
-          call_id: item.callId,
-          output: [{ type: "input_text", text: item.output.text }]
-        });
-        continue;
-      }
-      if (item instanceof ReasoningItem) {
-        const reasoningInput = {
-          type: item.type,
-          summary: item.summary.map((summary) => ({ type: "summary_text", text: summary.text }))
-        };
-        if (item.encryptedContent !== void 0) {
-          reasoningInput.encrypted_content = item.encryptedContent;
-        }
-        input.push(reasoningInput);
-      }
-    }
-    return input;
-  }
-  extractTokenUsage(response) {
-    var _a, _b, _c, _d;
-    if (!response.usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      response.usage.input_tokens,
-      response.usage.output_tokens,
-      response.usage.total_tokens,
-      new InputTokenDetails((_b = (_a = response.usage.input_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0),
-      new OutputTokenDetails((_d = (_c = response.usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
-    );
-  }
-  toResponse(response) {
-    var _a, _b, _c;
-    const items = [];
-    for (const item of (_a = response.output) != null ? _a : []) {
-      if (item.type === "message" && item.role === "assistant") {
-        const firstContent = (_b = item.content) == null ? void 0 : _b[0];
-        if (firstContent) {
-          items.push(ModelMessageItem.rehydrate(firstContent));
-        }
-        continue;
-      }
-      if (item.type === "function_call") {
-        items.push(
-          FunctionCallItem.rehydrate({
-            callId: item.call_id,
-            name: item.name,
-            args: item.arguments
-          })
-        );
-        continue;
-      }
-      if (item.type === "reasoning") {
-        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 {
-      items,
-      tokenUsage: this.extractTokenUsage(response),
-      rowResponse: response
-    };
-  }
-};
-
-// src/infrastructure/providers/openai/endpoints/openai-responses.ts
-var OpenAIResponses = class {
-  constructor(endpointMapper = new OpenAIResponsesMapper()) {
-    this.endpointMapper = endpointMapper;
-  }
-  get client() {
-    var _a;
-    return (_a = this._client) != null ? _a : this._client = new OpenAI();
-  }
-  async infer(inferenceInput) {
-    const request = this.endpointMapper.toRequest(inferenceInput);
-    const response = await this.client.responses.create(request);
-    return this.endpointMapper.toResponse(response);
-  }
-  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) {
-      if (event.type === "response.completed") {
-        completedResponse = event.response;
-      }
-      yield event;
-    }
-    if (!completedResponse) {
-      throw new Error("Stream ended without a completed response");
-    }
-    const output = this.endpointMapper.toResponse(completedResponse);
-    yield {
-      type: "inference.output",
-      payload: output,
-      occurredAt: /* @__PURE__ */ new Date(),
-      producerId: inferenceInput.model
-    };
-  }
-};
-
-// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
-import { GoogleGenAI } from "@google/genai";
-
-// src/infrastructure/providers/gemini/endpoints/gemini-generate-content-mapper.ts
-var GeminiGenerateContentMapper = class {
-  toRequest(inferenceInput) {
-    const { contents, systemInstruction } = this.mapContextItems(inferenceInput);
-    const config = {};
-    if (systemInstruction) {
-      config.systemInstruction = systemInstruction;
-    }
-    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
-      config.tools = [
-        {
-          functionDeclarations: inferenceInput.tools.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            parametersJsonSchema: tool.parameters
-          }))
-        }
-      ];
-    }
-    if (inferenceInput.structuredOutput) {
-      config.responseMimeType = "application/json";
-      config.responseSchema = inferenceInput.structuredOutput.schema;
-    }
-    if (inferenceInput.reasoningEffort) {
-      config.thinkingConfig = {
-        thinkingLevel: inferenceInput.reasoningEffort,
-        includeThoughts: true
-      };
-    }
-    const request = {
-      model: inferenceInput.model,
-      contents,
-      config
-    };
-    if (inferenceInput.streaming) {
-      request.stream = inferenceInput.streaming;
-    }
-    return request;
-  }
-  mapContextItems(inferenceInput) {
-    var _a;
-    const context = inferenceInput.context;
-    const contents = [];
-    const system = [];
-    const callNames = /* @__PURE__ */ new Map();
-    for (const item of context.getItems()) {
-      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
-        system.push(item.content.text);
-        continue;
-      }
-      if (item instanceof UserMessageItem) {
-        this.addPart(contents, "user", { text: item.content.text });
-        continue;
-      }
-      if (item instanceof ModelMessageItem) {
-        this.addPart(contents, "model", { text: item.content.text });
-        continue;
-      }
-      if (item instanceof FunctionCallItem) {
-        callNames.set(item.callId, item.name);
-        let args;
-        try {
-          args = JSON.parse(item.args);
-        } catch (e) {
-          args = {};
-        }
-        this.addPart(contents, "model", { functionCall: { id: item.callId, name: item.name, args } });
-        continue;
-      }
-      if (item instanceof FunctionCallOutputItem) {
-        this.addPart(contents, "user", {
-          functionResponse: {
-            id: item.callId,
-            name: (_a = callNames.get(item.callId)) != null ? _a : "",
-            response: this.parseResponse(item.output.text)
-          }
-        });
-      }
-    }
-    return {
-      contents,
-      systemInstruction: system.length > 0 ? system.join("\n\n") : void 0
-    };
-  }
-  addPart(contents, role, part) {
-    const last = contents[contents.length - 1];
-    if ((last == null ? void 0 : last.role) === role) {
-      last.parts.push(part);
-      return;
-    }
-    contents.push({ role, parts: [part] });
-  }
-  parseResponse(output) {
-    try {
-      const parsed = JSON.parse(output);
-      return parsed && typeof parsed === "object" ? parsed : { output };
-    } catch (e) {
-      return { output };
-    }
-  }
-  extractTokenUsage(response) {
-    var _a, _b, _c, _d, _e;
-    const usage = response.usageMetadata;
-    if (!usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      (_a = usage.promptTokenCount) != null ? _a : 0,
-      (_b = usage.candidatesTokenCount) != null ? _b : 0,
-      (_c = usage.totalTokenCount) != null ? _c : 0,
-      new InputTokenDetails((_d = usage.cachedContentTokenCount) != null ? _d : 0),
-      new OutputTokenDetails((_e = usage.thoughtsTokenCount) != null ? _e : 0)
-    );
-  }
-  toResponse(response) {
-    var _a, _b, _c, _d, _e, _f;
-    const items = [];
-    const parts = (_d = (_c = (_b = (_a = response.candidates) == null ? void 0 : _a[0]) == null ? void 0 : _b.content) == null ? void 0 : _c.parts) != null ? _d : [];
-    for (const part of parts) {
-      if (part.thought && part.text) {
-        items.push(
-          ReasoningItem.rehydrate({
-            content: InputText.rehydrate({ text: part.text }),
-            encryptedContent: void 0,
-            summary: []
-          })
-        );
-        continue;
-      }
-      if (part.text) {
-        items.push(ModelMessageItem.rehydrate({ text: part.text }));
-        continue;
-      }
-      if (part.functionCall) {
-        items.push(
-          FunctionCallItem.rehydrate({
-            callId: (_e = part.functionCall.id) != null ? _e : "",
-            name: part.functionCall.name,
-            args: JSON.stringify((_f = part.functionCall.args) != null ? _f : {})
-          })
-        );
-      }
-    }
-    return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
+  async delete(id) {
+    this.spaces = this.spaces.filter((space) => space.getId() !== id);
   }
 };
 
-// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
-var GeminiGenerateContent = class {
-  constructor(endpointMapper = new GeminiGenerateContentMapper(), config = {}) {
-    this.endpointMapper = endpointMapper;
-    this.clientConfig = config;
-  }
-  get client() {
-    var _a, _b;
-    return (_b = this._client) != null ? _b : this._client = new GoogleGenAI({
-      apiKey: (_a = this.clientConfig.apiKey) != null ? _a : process.env.GEMINI_API_KEY,
-      ...this.clientConfig.baseURL ? { httpOptions: { baseUrl: this.clientConfig.baseURL } } : {}
-    });
-  }
-  async infer(inferenceInput) {
-    const request = this.endpointMapper.toRequest(inferenceInput);
-    const response = await this.client.models.generateContent(request);
-    return this.endpointMapper.toResponse(response);
-  }
-  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) {
-      lastEvent = chunk;
-      yield chunk;
-    }
-    if (!lastEvent) {
-      throw new Error("Last event not found");
-    }
-    const output = this.endpointMapper.toResponse(lastEvent);
-    yield {
-      type: "inference.output",
-      producerId: request.model,
-      occurredAt: /* @__PURE__ */ new Date(),
-      payload: output
-    };
-  }
-};
-
-// src/infrastructure/providers/openai/endpoints/openai-chat-completions-mapper.ts
-var OpenAIChatCompletionsMapper = class {
-  toRequest(inferenceInput) {
-    const request = {
-      model: inferenceInput.model,
-      messages: this.mapContextItems(inferenceInput)
-    };
-    if (inferenceInput.tools && inferenceInput.tools.length > 0) {
-      request.tools = inferenceInput.tools.map((tool) => ({
-        type: "function",
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
+// 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 });
         }
-      }));
-    }
-    if (inferenceInput.reasoningEffort) {
-      request.reasoning_effort = inferenceInput.reasoningEffort;
-    }
-    if (inferenceInput.streaming) {
-      request.stream = inferenceInput.streaming;
-    }
-    return request;
-  }
-  mapContextItems(inferenceInput) {
-    var _a;
-    const messages = [];
-    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 instanceof UserMessageItem) {
-        messages.push({ role: "user", content: item.content.text });
-        continue;
-      }
-      if (item instanceof ModelMessageItem) {
-        messages.push({ role: "assistant", content: item.content.text });
-        continue;
-      }
-      if (item instanceof FunctionCallItem) {
-        const toolCall = {
-          id: item.callId,
-          type: "function",
-          function: { name: item.name, arguments: item.args }
-        };
-        const last = messages[messages.length - 1];
-        if ((last == null ? void 0 : last.role) === "assistant") {
-          last.tool_calls = (_a = last.tool_calls) != null ? _a : [];
-          last.tool_calls.push(toolCall);
-        } else {
-          messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
-        }
-        continue;
-      }
-      if (item instanceof FunctionCallOutputItem) {
-        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
-      }
-    }
-    return messages;
-  }
-  extractTokenUsage(response) {
-    var _a, _b, _c, _d;
-    if (!response.usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      response.usage.prompt_tokens,
-      response.usage.completion_tokens,
-      response.usage.total_tokens,
-      new InputTokenDetails((_b = (_a = response.usage.prompt_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0),
-      new OutputTokenDetails((_d = (_c = response.usage.completion_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0)
-    );
-  }
-  toResponse(response) {
-    var _a, _b, _c;
-    const items = [];
-    const message = (_b = (_a = response.choices) == null ? void 0 : _a[0]) == null ? void 0 : _b.message;
-    if (!message) {
-      return { items: [], tokenUsage: this.extractTokenUsage(response), rowResponse: response };
-    }
-    if (message.reasoning_content) {
-      items.push(
-        ReasoningItem.rehydrate({
-          content: InputText.rehydrate({ text: message.reasoning_content }),
-          encryptedContent: void 0,
-          summary: []
-        })
-      );
-    }
-    if (message.content) {
-      items.push(ModelMessageItem.rehydrate({ text: message.content }));
-    }
-    for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
-      items.push(
-        FunctionCallItem.rehydrate({
-          callId: toolCall.id,
-          name: toolCall.function.name,
-          args: toolCall.function.arguments
-        })
-      );
-    }
-    return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
-  }
-};
-
-// src/infrastructure/providers/openai/endpoints/openai-chat-completions.ts
-import OpenAI2 from "openai";
-var OpenAIChatCompletions = class {
-  constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
-    var _a;
-    this.endpointMapper = endpointMapper;
-    this.clientConfig = config;
-    this.extraBody = (_a = config.extraBody) != null ? _a : {};
-  }
-  get client() {
-    var _a;
-    return (_a = this._client) != null ? _a : this._client = new OpenAI2({
-      baseURL: this.clientConfig.baseURL,
-      apiKey: this.clientConfig.apiKey
-    });
-  }
-  buildRequest(inferenceInput) {
-    return {
-      ...this.extraBody,
-      ...this.endpointMapper.toRequest(inferenceInput)
-    };
-  }
-  async infer(inferenceInput) {
-    const response = await this.client.chat.completions.create(this.buildRequest(inferenceInput));
-    return this.endpointMapper.toResponse(response);
-  }
-  async *stream(inferenceInput) {
-    const stream = this.client.chat.completions.stream(this.buildRequest(inferenceInput));
-    for await (const chunk of stream) {
-      yield chunk;
-    }
-    const output = this.endpointMapper.toResponse(await stream.finalChatCompletion());
-    yield {
-      type: "inference.output",
-      payload: output,
-      occurredAt: /* @__PURE__ */ new Date(),
-      producerId: inferenceInput.model
-    };
-  }
-};
-
-// src/infrastructure/providers/anthropic/models/claude-4-6-sonnet.ts
-var claudeSonnet46Specification = {
-  name: "claude-sonnet-4-6",
-  provider: "anthropic",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "high", "medium", "low"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 2e5,
-  maxOutputTokens: 64e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/anthropic/models/claude-4-8-opus.ts
-var claudeOpus48Specification = {
-  name: "claude-opus-4-8",
-  provider: "anthropic",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 2e5,
-  maxOutputTokens: 32e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
-var claudeOpus47Specification = {
-  name: "claude-opus-4-7",
-  provider: "anthropic",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "xhigh", "high", "medium", "low"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 2e5,
-  maxOutputTokens: 32e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/gemini/models/gemini-3-5-flash.ts
-var gemini35FlashSpecification = {
-  name: "gemini-3.5-flash",
-  provider: "google",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["high", "medium", "low", "minimal", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 1048576,
-  maxOutputTokens: 64e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/gemini/models/gemini-3-1-pro.ts
-var gemini31ProSpecification = {
-  name: "gemini-3.1-pro-preview",
-  provider: "google",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["high", "medium", "low", "minimal", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 1048576,
-  maxOutputTokens: 64e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/deepseek/models/deepseek-v4-flash.ts
-var deepSeekV4FlashSpecification = {
-  name: "deepseek-v4-flash",
-  provider: "deepseek",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 1e6,
-  maxOutputTokens: 384e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: false
-};
-
-// src/infrastructure/providers/deepseek/models/deepseek-v4-pro.ts
-var deepSeekV4ProSpecification = {
-  name: "deepseek-v4-pro",
-  provider: "deepseek",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["max", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 1e6,
-  maxOutputTokens: 384e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: false
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4.ts
-var gpt54Specification = {
-  name: "gpt-5.4",
-  provider: "openai",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["xhigh", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 105e4,
-  maxOutputTokens: 128e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4-mini.ts
-var gpt54MiniSpecification = {
-  name: "gpt-5.4-mini",
-  provider: "openai",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["xhigh", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 4e5,
-  maxOutputTokens: 128e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4-nano.ts
-var gpt54NanoSpecification = {
-  name: "gpt-5.4-nano",
-  provider: "openai",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["xhigh", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 4e5,
-  maxOutputTokens: 128e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-5.ts
-var gpt55Specification = {
-  name: "gpt-5.5",
-  provider: "openai",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["xhigh", "high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 105e4,
-  maxOutputTokens: 128e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/infrastructure/providers/anthropic/models/claude-4-5-haiku.ts
-var claudeHaiku45Specification = {
-  name: "claude-haiku-4-5",
-  provider: "anthropic",
-  supportsReasoningEffort: true,
-  supportedReasoningEfforts: ["high", "medium", "low", "none"],
-  supportedContextItemTypes: [
-    "user_message",
-    "system_message",
-    "developer_message",
-    "reasoning",
-    "function_call",
-    "function_call_output",
-    "model_message"
-  ],
-  supportsStreaming: true,
-  contextWindowSize: 2e5,
-  maxOutputTokens: 64e3,
-  supportsFunctionCalling: true,
-  supportsStructuredOutput: true
-};
-
-// src/application/services/models.ts
-var supportedModels = [
-  {
-    endpoint: new OpenAIResponses(),
-    specification: gpt54Specification
-  },
-  {
-    endpoint: new OpenAIResponses(),
-    specification: gpt54MiniSpecification
-  },
-  {
-    endpoint: new OpenAIResponses(),
-    specification: gpt54NanoSpecification
-  },
-  {
-    endpoint: new OpenAIResponses(),
-    specification: gpt55Specification
-  },
-  {
-    endpoint: new AnthropicMessages(),
-    specification: claudeHaiku45Specification
-  },
-  {
-    endpoint: new AnthropicMessages(),
-    specification: claudeSonnet46Specification
-  },
-  {
-    endpoint: new AnthropicMessages(),
-    specification: claudeOpus47Specification
-  },
-  {
-    endpoint: new AnthropicMessages(),
-    specification: claudeOpus48Specification
-  },
-  {
-    endpoint: new GeminiGenerateContent(),
-    specification: gemini35FlashSpecification
-  },
-  {
-    endpoint: new GeminiGenerateContent(),
-    specification: gemini31ProSpecification
-  },
-  {
-    endpoint: new OpenAIChatCompletions(),
-    specification: deepSeekV4FlashSpecification
-  },
-  {
-    endpoint: new OpenAIChatCompletions(),
-    specification: deepSeekV4ProSpecification
-  }
-];
-
-// src/domain/generative-model/request-validation/reasoning-effort.ts
-var ReasoningEffortValidation = class {
-  constructor() {
-    this.name = "reasoning-effort";
-  }
-  isValid(inferenceInput, model) {
-    if (inferenceInput.reasoningEffort === void 0) {
-      return true;
-    }
-    if (!model.supportsReasoningEffort) {
-      return false;
+      });
     }
-    return model.supportedReasoningEfforts.includes(inferenceInput.reasoningEffort);
   }
 };
 
-// src/domain/generative-model/request-validation/tool-calling.ts
-var ToolCallingValidation = class {
-  constructor() {
-    this.name = "tool-calling";
+// src/application/use-cases/participant-left.ts
+var ParticipantLefUseCase = class {
+  constructor(spaceRepository, eventPublisher) {
+    this.spaceRepository = spaceRepository;
+    this.eventPublisher = eventPublisher;
   }
-  isValid(inferenceInput, model) {
-    if (inferenceInput.tools === void 0) {
-      return true;
+  async execute(spaceId, participantId, occurredAt) {
+    const space = await this.spaceRepository.findById(spaceId);
+    if (!space) {
+      throw new Error("Space not found");
     }
-    return model.supportsFunctionCalling;
-  }
-};
-
-// src/domain/generative-model/request-validation/streaming.ts
-var StreamingValidation = class {
-  constructor() {
-    this.name = "streaming";
-  }
-  isValid(inferenceInput, model) {
-    if (!inferenceInput.streaming) {
-      return true;
+    const participant = space.getParticipant(participantId);
+    if (!participant) {
+      throw new Error("Participant not found");
     }
-    return model.supportsStreaming;
-  }
-};
-
-// src/domain/generative-model/request-validation/context.ts
-function getContextItemValidationKey(item) {
-  if (item instanceof UserMessageItem) {
-    return "user_message";
-  }
-  if (item instanceof SystemMessageItem) {
-    return "system_message";
-  }
-  if (item instanceof DeveloperMessageItem) {
-    return "developer_message";
-  }
-  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/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;
-  }
-  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 event = space.removeParticipant(participant, occurredAt);
+    if (event) {
+      this.eventPublisher.publish(event, space.getParticipants());
     }
+    await this.spaceRepository.save(space);
   }
 };
 
-// src/application/services/inference-runner.ts
-var DefaultInferenceRunner = class {
-  constructor(supportedModels2, requestValidator) {
-    this.supportedModels = supportedModels2;
-    this.requestValidator = requestValidator;
+// src/application/use-cases/send-message.ts
+var SendMessageUseCase = class {
+  constructor(spaceRepository, eventPublisher) {
+    this.spaceRepository = spaceRepository;
+    this.eventPublisher = eventPublisher;
   }
-  async run(input) {
-    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
-    if (!generativeModel) {
-      throw new Error(`Unsupported model: ${input.model}`);
+  async execute(spaceId, participantId, message) {
+    const space = await this.spaceRepository.findById(spaceId);
+    if (!space) {
+      throw new Error("Space 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 participant = space.getParticipant(participantId);
+    if (!participant) {
+      throw new Error("Participant not found");
     }
-    this.requestValidator.validate(input, generativeModel.specification);
-    yield* generativeModel.endpoint.stream(input);
-  }
-};
-
-// 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}`);
+    const event = space.sendMessage(participant, message, /* @__PURE__ */ new Date());
+    if (event) {
+      this.eventPublisher.publish(event, space.getParticipants());
     }
+    await this.spaceRepository.save(space);
   }
 };
 
-// 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);
+    runtime = new RuntimeService(config.state);
     return runtime;
   }
   function resolveRuntime() {
@@ -2134,34 +179,55 @@ function defineRuntime() {
     }
     return runtime;
   }
-  function resolveParticipant(id) {
-    if (!runtime) {
-      throw new Error("Runtime not initialized");
-    }
-    const participant = runtime.state.getParticipant(id);
-    if (!participant) {
-      throw new Error(`Participant ${id} not found`);
+  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 participantJoinedUseCase = new ParticipantJoinedUseCase(spaceRepository, eventPublisher);
+  const join = async (spaceId, participantId) => {
+    return await participantJoinedUseCase.execute(spaceId, participantId, /* @__PURE__ */ new Date());
+  };
+  const participantLeftUseCase = new ParticipantLefUseCase(spaceRepository, eventPublisher);
+  const leave = async (spaceId, participantId) => {
+    return await participantLeftUseCase.execute(spaceId, participantId, /* @__PURE__ */ new Date());
+  };
+  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 participant;
-  }
-  const join = createJoin(resolveRuntime);
-  const leave = createLeave(resolveRuntime);
-  const sendMessage = createSendMessage(resolveRuntime);
-  const sendEvent = createSendEvent(resolveRuntime);
-  const runLoop = createRunLoop(resolveRuntime);
+  };
   return {
     initializeRuntime,
     resolveRuntime,
-    resolveParticipant,
+    createParticipant,
     join,
     leave,
     sendMessage,
-    sendEvent,
-    runLoop
+    sendMessageTool
   };
 }
 
-// src/domain/agentic-environment/situation/situation-specification.ts
+// src/domain/space/situation-specification.ts
 var SituationSpecification = class {
   and(other) {
     return new AndSituationSpecification(this, other);
@@ -2203,34 +269,9 @@ var NotSituationSpecification = class extends SituationSpecification {
   }
 };
 export {
-  Agent,
-  AnthropicMessages,
-  ContextItem,
-  DefaultInferenceRunner,
-  DeveloperMessageItem,
-  FunctionCallItem,
-  FunctionCallOutputItem,
-  GeminiGenerateContent,
-  Human,
-  InputTokenDetails,
-  McpClient,
-  McpToolRegistry,
-  ModelContext,
-  ModelMessageItem,
-  OpenAIChatCompletions,
-  OpenAIResponses,
-  OutputTokenDetails,
   Participant,
-  ReasoningItem,
-  RuntimeState,
-  SemanticEvent,
   SituationSpecification,
-  SystemMessageItem,
-  TokenUsage,
-  UserMessageItem,
-  createAgent,
-  createHuman,
-  defineRuntime,
-  supportedModels
+  SpaceEvent,
+  defineRuntime
 };
 //# sourceMappingURL=index.mjs.map