@mozaik-ai/core 4.2.0-beta.1 → 4.2.0-beta.10

package/dist/index.mjs

@@ -77,20 +77,20 @@ var CreateParticipantUseCase = class {
   }
 };
 
-// src/application/use-cases/participant-joined.ts
-var ParticipantJoinedUseCase = class {
+// src/application/use-cases/participant-join.ts
+var ParticipantJoinUseCase = class {
   constructor(spaceRepository, eventPublisher) {
     this.spaceRepository = spaceRepository;
     this.eventPublisher = eventPublisher;
   }
-  async execute(spaceId, participantId) {
+  async execute(spaceId, participant) {
     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 existingParticipant = space.getParticipant(participant.getId());
+    if (existingParticipant) {
+      throw new Error("Participant already joined");
     }
     const event = space.addParticipant(participant);
     if (event) {
@@ -129,8 +129,8 @@ var EventPublisher = class {
   }
 };
 
-// src/application/use-cases/participant-left.ts
-var ParticipantLefUseCase = class {
+// src/application/use-cases/participant-leave.ts
+var ParticipantLeaveUseCase = class {
   constructor(spaceRepository, eventPublisher) {
     this.spaceRepository = spaceRepository;
     this.eventPublisher = eventPublisher;
@@ -205,9 +205,6 @@ var Space = class _Space {
   }
   getParticipant(id) {
     const participant = this.getParticipants().find((p) => p.getId() === id);
-    if (!participant) {
-      throw new Error(`Participant ${id} not found`);
-    }
     return participant;
   }
   removeParticipant(participant) {
@@ -281,13 +278,13 @@ function defineRuntime() {
   const createSpace = async (name) => {
     return await createSpaceUseCase.execute(name);
   };
-  const participantJoinedUseCase = new ParticipantJoinedUseCase(spaceRepository, eventPublisher);
-  const join = async (spaceId, participantId) => {
-    return await participantJoinedUseCase.execute(spaceId, participantId);
+  const participantJoinUseCase = new ParticipantJoinUseCase(spaceRepository, eventPublisher);
+  const join = async (spaceId, participant) => {
+    return await participantJoinUseCase.execute(spaceId, participant);
   };
-  const participantLeftUseCase = new ParticipantLefUseCase(spaceRepository, eventPublisher);
+  const participantLeaveUseCase = new ParticipantLeaveUseCase(spaceRepository, eventPublisher);
   const leave = async (spaceId, participantId) => {
-    return await participantLeftUseCase.execute(spaceId, participantId);
+    return await participantLeaveUseCase.execute(spaceId, participantId);
   };
   const sendMessageUseCase = new SendMessageUseCase(spaceRepository, eventPublisher);
   const sendMessage = async (spaceId, participantId, message) => {
@@ -365,10 +362,2220 @@ var NotSituationSpecification = class extends SituationSpecification {
     return !this.rule.isSatisfiedBy(situationContext);
   }
 };
+
+// src/domain/agent/agent.ts
+var Agent = class _Agent {
+  constructor(id, name, instruction, tools, memory) {
+    this._id = id;
+    this._name = name;
+    this._instruction = instruction;
+    this._memory = memory;
+    this._tools = tools;
+  }
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this._name;
+  }
+  get instruction() {
+    return this._instruction;
+  }
+  get tools() {
+    return this._tools;
+  }
+  get memory() {
+    return this._memory;
+  }
+  static create({
+    name,
+    instruction,
+    tools,
+    memory
+  }) {
+    const id = UuidGenerator.create();
+    return new _Agent(id, name, instruction, tools, memory);
+  }
+  static rehydrate(record) {
+    return new _Agent(record.id, record.name, record.instruction, record.tools, record.memory);
+  }
+};
+
+// src/application/use-cases/create-agent.ts
+var CreateAgentUseCase = class {
+  constructor(agentRepository, memoryFactory) {
+    this.agentRepository = agentRepository;
+    this.memoryFactory = memoryFactory;
+  }
+  async execute(name, instruction, tools) {
+    const memory = this.memoryFactory.create();
+    const agent = Agent.create({ name, instruction, tools, memory });
+    await this.agentRepository.save(agent);
+    return agent;
+  }
+};
+
+// 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));
+  }
+  findAll() {
+    return Promise.resolve(this.agents);
+  }
+  async save(agent) {
+    this.agents.push(agent);
+  }
+};
+
+// src/domain/agent/loop/specification.ts
+var LoopSpecification = class {
+  and(other) {
+    return new AndLoopSpecification(this, other);
+  }
+  or(other) {
+    return new OrLoopSpecification(this, other);
+  }
+  not() {
+    return new NotLoopSpecification(this);
+  }
+};
+var AndLoopSpecification = class extends LoopSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(agentLoop) {
+    return this.left.isSatisfiedBy(agentLoop) && this.right.isSatisfiedBy(agentLoop);
+  }
+};
+var OrLoopSpecification = class extends LoopSpecification {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  isSatisfiedBy(agentLoop) {
+    return this.left.isSatisfiedBy(agentLoop) || this.right.isSatisfiedBy(agentLoop);
+  }
+};
+var NotLoopSpecification = class extends LoopSpecification {
+  constructor(rule) {
+    super();
+    this.rule = rule;
+  }
+  isSatisfiedBy(agentLoop) {
+    return !this.rule.isSatisfiedBy(agentLoop);
+  }
+};
+var AwaitingInference = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_inference";
+  }
+};
+var AwaitingRequest = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_inference_request";
+  }
+};
+var AwaitingToolOutput = class extends LoopSpecification {
+  isSatisfiedBy(agentLoop) {
+    return agentLoop.loop.stateId === "awaiting_tool_output";
+  }
+};
+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/agent/loop/action.ts
+var LoopAction = class {
+};
+var RequestPreparationAction = class extends LoopAction {
+  constructor(request) {
+    super();
+    this.request = request;
+  }
+  execute(agentLoop) {
+    return {
+      type: "inference",
+      request: this.request
+    };
+  }
+};
+var InferenceAction = class extends LoopAction {
+  execute(agentLoop) {
+    const request = agentLoop.loop.request;
+    if (!request) {
+      return { type: "wait", reason: "no request" };
+    }
+    return { type: "inference", request };
+  }
+};
+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" };
+  }
+};
+var CompleteAction = class extends LoopAction {
+  constructor(reason) {
+    super();
+    this.reason = reason;
+  }
+  execute() {
+    return { type: "complete", reason: this.reason };
+  }
+};
+
+// 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;
+  }
+  get condition() {
+    return this._condition;
+  }
+  get action() {
+    return this._action;
+  }
+  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);
+  }
+  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;
+  }
+};
+var RuleBook = class _RuleBook {
+  constructor(rules) {
+    this.rules = rules;
+  }
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+  removeRule(rule) {
+    this.rules = this.rules.filter((r) => r.id !== rule.id);
+  }
+  getRules() {
+    return this.rules;
+  }
+  static create(loopRuleParams) {
+    const rules = loopRuleParams.map((param) => LoopRule.create(param));
+    return new _RuleBook(rules);
+  }
+  static rehydrate(record) {
+    const rules = record.rules.map((rule) => LoopRule.rehydrate(rule));
+    return new _RuleBook(rules);
+  }
+  record() {
+    return {
+      rules: this.rules.map((rule) => ({
+        id: rule.id,
+        priority: rule.priority,
+        condition: rule.condition,
+        action: rule.action
+      }))
+    };
+  }
+};
+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/agent/loop/loop.ts
+var Loop = class _Loop {
+  constructor(loopId, agentId, subject, createdAt, state, inferenceRequest, pendingOperation, transitionHistory, operationHistory, ruleBook) {
+    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;
+  }
+  get pending() {
+    return this.pendingOperation;
+  }
+  get history() {
+    return this.transitionHistory;
+  }
+  get completedOperations() {
+    return this.operationHistory;
+  }
+  get request() {
+    return this.inferenceRequest;
+  }
+  get ruleBook() {
+    return this._ruleBook;
+  }
+  getSubject() {
+    return this.subject;
+  }
+  getAgentId() {
+    return this.agentId;
+  }
+  record() {
+    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()
+    };
+  }
+  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
+    };
+    this.moveToAwaitingInference(operation);
+    return operation;
+  }
+  requestToolUse(operationId, call, requestedAt) {
+    this.assertIdle();
+    const operation = {
+      id: operationId,
+      type: "tool_execution",
+      requestedAt,
+      call
+    };
+    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
+    );
+  }
+  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)
+    );
+  }
+};
+
+// src/application/use-cases/create-loop.ts
+var CreateAgentLoopUseCase = class {
+  constructor(loopRepository) {
+    this.loopRepository = loopRepository;
+  }
+  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;
+    }
+  }
+};
+
+// src/infrastructure/repositories/in-memory-loop-repository.ts
+var InMemoryLoopRepository = class {
+  constructor() {
+    this.loops = [];
+  }
+  findById(id) {
+    return Promise.resolve(this.loops.find((loop) => loop.id === id));
+  }
+  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();
+  }
+};
+
+// 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;
+  }
+};
+
+// src/application/runners/local-tool-runner.ts
+var LocalToolRunner = class {
+  constructor() {
+    this.toolUseItemFactory = new ToolUseItemFactory();
+  }
+  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);
+    }
+  }
+};
+
+// src/application/runners/inference-runner.ts
+var DefaultInferenceRunner = class {
+  constructor(supportedModels2, requestValidator) {
+    this.supportedModels = supportedModels2;
+    this.requestValidator = requestValidator;
+  }
+  async run(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
+    }
+    this.requestValidator.validate(input, generativeModel.specification);
+    return await generativeModel.endpoint.infer(input);
+  }
+  async *stream(input) {
+    const generativeModel = this.supportedModels.find((model) => model.specification.name === input.model);
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${input.model}`);
+    }
+    this.requestValidator.validate(input, generativeModel.specification);
+    yield* generativeModel.endpoint.stream(input);
+  }
+};
+
+// src/domain/inference/request-validation/reasoning-effort.ts
+var ReasoningEffortValidation = class {
+  constructor() {
+    this.name = "reasoning-effort";
+  }
+  isValid(inferenceRequest, model) {
+    if (inferenceRequest.reasoningEffort === void 0) {
+      return true;
+    }
+    if (!model.supportsReasoningEffort) {
+      return false;
+    }
+    return model.supportedReasoningEfforts.includes(inferenceRequest.reasoningEffort);
+  }
+};
+
+// src/domain/inference/request-validation/tool-calling.ts
+var ToolUseRequestingValidation = class {
+  constructor() {
+    this.name = "tool-calling";
+  }
+  isValid(inferenceRequest, model) {
+    if (inferenceRequest.tools === void 0) {
+      return true;
+    }
+    return model.supportsFunctionCalling;
+  }
+};
+
+// src/domain/inference/request-validation/streaming.ts
+var StreamingValidation = class {
+  constructor() {
+    this.name = "streaming";
+  }
+  isValid(inferenceRequest, model) {
+    if (!inferenceRequest.streaming) {
+      return true;
+    }
+    return model.supportsStreaming;
+  }
+};
+
+// src/domain/inference/request-validation/structured-output.ts
+var StructuredOutputValidation = class {
+  constructor() {
+    this.name = "structured-output";
+  }
+  isValid(inferenceRequest, model) {
+    if (inferenceRequest.structuredOutput === void 0) {
+      return true;
+    }
+    return model.supportsStructuredOutput;
+  }
+};
+
+// src/domain/inference/request-validation/context.ts
+function getContextItemValidationKey(item) {
+  if (item.type === "user_message") {
+    return "user_message";
+  }
+  if (item.type === "system_message") {
+    return "system_message";
+  }
+  if (item.type === "developer_message") {
+    return "developer_message";
+  }
+  if (item.type === "model_message") {
+    return "model_message";
+  }
+  return item.type;
+}
+var ContextValidation = class {
+  constructor() {
+    this.name = "context";
+  }
+  isValid(inferenceRequest, model) {
+    return inferenceRequest.context.items.every(
+      (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
+    );
+  }
+};
+
+// 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;
+  }
+  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}"`);
+      }
+    }
+  }
+};
+
+// 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/infrastructure/providers/anthropic/anthropic-messages-mapper.ts
+var AnthropicMessagesMapper = class {
+  toRequest(inferenceRequest) {
+    const { messages, system } = this.mapContextItems(inferenceRequest);
+    const outputConfig = {};
+    const request = {
+      model: inferenceRequest.model,
+      messages
+    };
+    request.max_tokens = inferenceRequest.maxOutputTokens;
+    if (system) {
+      request.system = system;
+    }
+    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
+      request.tools = inferenceRequest.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    if (inferenceRequest.structuredOutput) {
+      outputConfig.format = {
+        type: "json_schema",
+        schema: inferenceRequest.structuredOutput.schema
+      };
+    }
+    if (inferenceRequest.reasoningEffort) {
+      request.thinking = { type: "adaptive" };
+      outputConfig.effort = inferenceRequest.reasoningEffort;
+    }
+    if (Object.keys(outputConfig).length > 0) {
+      request.output_config = outputConfig;
+    }
+    if (inferenceRequest.streaming) {
+      request.stream = inferenceRequest.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(inferenceRequest) {
+    var _a, _b, _c;
+    const context = inferenceRequest.context;
+    const messages = [];
+    const system = [];
+    for (const item of context.items) {
+      if (item.type === "developer_message" || item.type === "system_message") {
+        system.push(item.text);
+        continue;
+      }
+      if (item.type === "user_message") {
+        this.addContentBlock(messages, "user", { type: "text", text: item.text });
+        continue;
+      }
+      if (item.type === "model_message") {
+        this.addContentBlock(messages, "assistant", { type: "text", text: item.text });
+        continue;
+      }
+      if (item.type === "reasoning") {
+        const reasoning = item;
+        this.addContentBlock(messages, "assistant", {
+          type: "thinking",
+          thinking: (_b = (_a = reasoning.content) == null ? void 0 : _a.text) != null ? _b : "",
+          signature: (_c = reasoning.encryptedContent) != null ? _c : ""
+        });
+        continue;
+      }
+      if (item.type === "tool_use_request") {
+        const toolUseRequest = item;
+        let input;
+        try {
+          input = JSON.parse(toolUseRequest.toolArguments);
+        } catch (e) {
+          input = toolUseRequest.toolArguments;
+        }
+        this.addContentBlock(messages, "assistant", {
+          type: "tool_use",
+          id: toolUseRequest.requestId,
+          name: toolUseRequest.toolName,
+          input
+        });
+        continue;
+      }
+      if (item.type === "tool_use_result") {
+        const toolUseResult = item;
+        this.addContentBlock(messages, "user", {
+          type: "tool_result",
+          tool_use_id: toolUseResult.requestId,
+          content: toolUseResult.result.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({
+          type: "model_message",
+          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 : {})
+        });
+        continue;
+      }
+      if (block.type === "thinking") {
+        items.push({
+          type: "reasoning",
+          content: block.thinking ? { type: "input_text", text: block.thinking } : void 0,
+          encryptedContent: block.signature,
+          summary: []
+        });
+      }
+    }
+    return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
+  }
+};
+
+// src/infrastructure/providers/anthropic/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(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    const response = await this.client.messages.create(request);
+    return this.endpointMapper.toResponse(response);
+  }
+  async *stream(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    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/openai-responses-mapper.ts
+var OpenAIResponsesMapper = class {
+  toRequest(inferenceRequest) {
+    var _a, _b;
+    const request = {
+      model: inferenceRequest.model,
+      input: this.mapContextItems(inferenceRequest)
+    };
+    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
+      request.tools = inferenceRequest.tools.map((tool) => ({
+        type: tool.type,
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }));
+    }
+    if (inferenceRequest.reasoningEffort) {
+      request.reasoning = {
+        effort: inferenceRequest.reasoningEffort
+      };
+    }
+    if (inferenceRequest.structuredOutput) {
+      const format = inferenceRequest.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 (inferenceRequest.streaming) {
+      request.stream = inferenceRequest.streaming;
+    }
+    return request;
+  }
+  mapContextItems(inferenceRequest) {
+    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";
+        input.push({
+          type: "message",
+          role,
+          content: [{ type: "input_text", text: item.text }]
+        });
+        continue;
+      }
+      if (item.type === "model_message") {
+        input.push({
+          type: "message",
+          role: "assistant",
+          content: [{ type: "output_text", text: item.text }]
+        });
+        continue;
+      }
+      if (item.type === "tool_use_request") {
+        const toolUseRequest = item;
+        input.push({
+          type: "function_call",
+          call_id: toolUseRequest.requestId,
+          name: toolUseRequest.toolName,
+          arguments: toolUseRequest.toolArguments
+        });
+        continue;
+      }
+      if (item.type === "tool_use_result") {
+        const toolUseResult = item;
+        input.push({
+          type: "function_call_output",
+          call_id: toolUseResult.requestId,
+          output: [{ type: "input_text", text: toolUseResult.result.text }]
+        });
+        continue;
+      }
+      if (item.type === "reasoning") {
+        const reasoning = item;
+        const reasoningInput = {
+          type: "reasoning",
+          summary: reasoning.summary.map((summary) => ({ type: "summary_text", text: summary.text }))
+        };
+        if (reasoning.encryptedContent !== void 0) {
+          reasoningInput.encrypted_content = reasoning.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({
+            type: "model_message",
+            text: firstContent.text
+          });
+        }
+        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);
+        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
+          }))
+        });
+      }
+    }
+    return {
+      items,
+      tokenUsage: this.extractTokenUsage(response),
+      rowResponse: response
+    };
+  }
+};
+
+// src/infrastructure/providers/openai/openai-responses.ts
+import OpenAI from "openai";
+var OpenAIResponses = class {
+  constructor(endpointMapper = new OpenAIResponsesMapper(), config = {}) {
+    this.endpointMapper = endpointMapper;
+    this.clientConfig = config;
+  }
+  get client() {
+    var _a;
+    return (_a = this._client) != null ? _a : this._client = new OpenAI({
+      baseURL: this.clientConfig.baseURL,
+      apiKey: this.clientConfig.apiKey
+    });
+  }
+  async infer(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    const response = await this.client.responses.create(request);
+    return this.endpointMapper.toResponse(response);
+  }
+  async *stream(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    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: inferenceRequest.model
+    };
+  }
+};
+
+// src/infrastructure/providers/gemini/gemini-generate-content.ts
+import { GoogleGenAI } from "@google/genai";
+
+// src/infrastructure/providers/gemini/gemini-generate-content-mapper.ts
+var GeminiGenerateContentMapper = class {
+  toRequest(inferenceRequest) {
+    const { contents, systemInstruction } = this.mapContextItems(inferenceRequest);
+    const config = {};
+    if (systemInstruction) {
+      config.systemInstruction = systemInstruction;
+    }
+    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
+      config.tools = [
+        {
+          functionDeclarations: inferenceRequest.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parametersJsonSchema: tool.parameters
+          }))
+        }
+      ];
+    }
+    if (inferenceRequest.structuredOutput) {
+      config.responseMimeType = "application/json";
+      config.responseSchema = inferenceRequest.structuredOutput.schema;
+    }
+    if (inferenceRequest.reasoningEffort) {
+      config.thinkingConfig = {
+        thinkingLevel: inferenceRequest.reasoningEffort,
+        includeThoughts: true
+      };
+    }
+    const request = {
+      model: inferenceRequest.model,
+      contents,
+      config
+    };
+    if (inferenceRequest.streaming) {
+      request.stream = inferenceRequest.streaming;
+    }
+    return request;
+  }
+  mapContextItems(inferenceRequest) {
+    var _a;
+    const context = inferenceRequest.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);
+        continue;
+      }
+      if (item.type === "user_message") {
+        this.addPart(contents, "user", { text: item.text });
+        continue;
+      }
+      if (item.type === "model_message") {
+        this.addPart(contents, "model", { text: item.text });
+        continue;
+      }
+      if (item.type === "tool_use_request") {
+        const toolUseRequest = item;
+        callNames.set(toolUseRequest.requestId, toolUseRequest.toolName);
+        let args;
+        try {
+          args = JSON.parse(toolUseRequest.toolArguments);
+        } catch (e) {
+          args = {};
+        }
+        this.addPart(contents, "model", {
+          functionCall: { id: toolUseRequest.requestId, name: toolUseRequest.toolName, args }
+        });
+        continue;
+      }
+      if (item.type === "tool_use_result") {
+        const toolUseResult = item;
+        this.addPart(contents, "user", {
+          functionResponse: {
+            id: toolUseResult.requestId,
+            name: (_a = callNames.get(toolUseResult.requestId)) != null ? _a : "",
+            response: this.parseResponse(toolUseResult.result.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({
+          type: "reasoning",
+          content: { type: "input_text", text: part.text },
+          encryptedContent: void 0,
+          summary: []
+        });
+        continue;
+      }
+      if (part.text) {
+        items.push({
+          type: "model_message",
+          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 : {})
+        });
+      }
+    }
+    return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
+  }
+};
+
+// src/infrastructure/providers/gemini/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(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    const response = await this.client.models.generateContent(request);
+    return this.endpointMapper.toResponse(response);
+  }
+  async *stream(inferenceRequest) {
+    const request = this.endpointMapper.toRequest(inferenceRequest);
+    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/openai-chat-completions-mapper.ts
+var OpenAIChatCompletionsMapper = class {
+  toRequest(inferenceRequest) {
+    const request = {
+      model: inferenceRequest.model,
+      messages: this.mapContextItems(inferenceRequest)
+    };
+    if (inferenceRequest.tools && inferenceRequest.tools.length > 0) {
+      request.tools = inferenceRequest.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      }));
+    }
+    if (inferenceRequest.reasoningEffort) {
+      request.reasoning_effort = inferenceRequest.reasoningEffort;
+    }
+    if (inferenceRequest.streaming) {
+      request.stream = inferenceRequest.streaming;
+    }
+    return request;
+  }
+  mapContextItems(inferenceRequest) {
+    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 });
+        continue;
+      }
+      if (item.type === "user_message") {
+        messages.push({ role: "user", content: item.text });
+        continue;
+      }
+      if (item.type === "model_message") {
+        messages.push({ role: "assistant", content: item.text });
+        continue;
+      }
+      if (item.type === "tool_use_request") {
+        const toolUseRequest = item;
+        const toolCall = {
+          id: toolUseRequest.requestId,
+          type: "function",
+          function: { name: toolUseRequest.toolName, arguments: toolUseRequest.toolArguments }
+        };
+        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.type === "tool_use_result") {
+        const toolUseResult = item;
+        messages.push({
+          role: "tool",
+          tool_call_id: toolUseResult.requestId,
+          content: toolUseResult.result.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({
+        type: "reasoning",
+        content: { type: "input_text", text: message.reasoning_content },
+        encryptedContent: void 0,
+        summary: []
+      });
+    }
+    if (message.content) {
+      items.push({
+        type: "model_message",
+        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
+      });
+    }
+    return { items, tokenUsage: this.extractTokenUsage(response), rowResponse: response };
+  }
+};
+
+// src/infrastructure/providers/openai/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(inferenceRequest) {
+    return {
+      ...this.extraBody,
+      ...this.endpointMapper.toRequest(inferenceRequest)
+    };
+  }
+  async infer(inferenceRequest) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceRequest));
+    return this.endpointMapper.toResponse(response);
+  }
+  async *stream(inferenceRequest) {
+    const stream = this.client.chat.completions.stream(this.buildRequest(inferenceRequest));
+    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: inferenceRequest.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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "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",
+    "tool_use_request",
+    "tool_use_result",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 2e5,
+  maxOutputTokens: 64e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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", "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-6-sol.ts
+var gpt6SolSpecification = {
+  name: "gpt-6-sol",
+  provider: "openai",
+  supportsReasoningEffort: true,
+  supportedReasoningEfforts: ["max", "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-6-1-sol.ts
+var gpt61SolSpecification = {
+  name: "gpt-6.1-sol",
+  provider: "openai",
+  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: 105e4,
+  maxOutputTokens: 128e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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"],
+  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-5-sonnet.ts
+var claudeSonnet5Specification = {
+  name: "claude-sonnet-5",
+  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: 1e6,
+  maxOutputTokens: 128e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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"],
+  supportedContextItemTypes: [
+    "user_message",
+    "system_message",
+    "developer_message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 1e6,
+  maxOutputTokens: 128e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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"],
+  supportedContextItemTypes: [
+    "user_message",
+    "system_message",
+    "developer_message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 1e6,
+  maxOutputTokens: 128e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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"],
+  supportedContextItemTypes: [
+    "user_message",
+    "system_message",
+    "developer_message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 1e6,
+  maxOutputTokens: 128e3,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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", "minimal"],
+  supportedContextItemTypes: [
+    "user_message",
+    "system_message",
+    "developer_message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 1048576,
+  maxOutputTokens: 65536,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// 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"],
+  supportedContextItemTypes: [
+    "user_message",
+    "system_message",
+    "developer_message",
+    "reasoning",
+    "function_call",
+    "function_call_output",
+    "model_message"
+  ],
+  supportsStreaming: true,
+  contextWindowSize: 1048576,
+  maxOutputTokens: 65536,
+  supportsFunctionCalling: true,
+  supportsStructuredOutput: true
+};
+
+// src/infrastructure/providers/deepseek/models/deepseek-flash.ts
+var deepSeekFlashSpecification = {
+  name: "deepseek-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/supported-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 OpenAIResponses(),
+    specification: gpt6LunaSpecification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt6SolSpecification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt61SolSpecification
+  },
+  {
+    endpoint: new OpenAIResponses(),
+    specification: gpt6AstraSpecification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeHaiku45Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeSonnet46Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeOpus47Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeOpus48Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeSonnet5Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeSonnet55Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeOpus55Specification
+  },
+  {
+    endpoint: new AnthropicMessages(),
+    specification: claudeFable51Specification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini35FlashSpecification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini31ProSpecification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini35FlashLiteSpecification
+  },
+  {
+    endpoint: new GeminiGenerateContent(),
+    specification: gemini38FlashSpecification
+  },
+  {
+    endpoint: new OpenAIChatCompletions(),
+    specification: deepSeekV4FlashSpecification
+  },
+  {
+    endpoint: new OpenAIChatCompletions(),
+    specification: deepSeekV4ProSpecification
+  },
+  {
+    endpoint: new OpenAIChatCompletions(),
+    specification: deepSeekFlashSpecification
+  }
+];
+
+// 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;
+    }
+    const highestPriorityRule = satisfiedRules.reduce((highest, current) => {
+      return highest.priority > current.priority ? highest : current;
+    });
+    return highestPriorityRule.action.execute(agentLoop);
+  }
+};
+
+// 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();
+  }
+  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);
+    }
+    await this.loopRepository.save(loop);
+    return loop;
+  }
+};
+
+// src/infrastructure/memory/runtime-memory.ts
+var RuntimeMemory = class {
+  constructor(context) {
+    this.context = context;
+  }
+  remember(items, participantId) {
+    throw new Error("Method not implemented.");
+  }
+  recall(topic, participantId) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/infrastructure/memory/runtime-memory-factory.ts
+var RuntimeMemoryFactory = class {
+  create() {
+    const context = {
+      items: []
+    };
+    return new RuntimeMemory(context);
+  }
+};
+
+// src/application/directive-execution/directive-execution-strategy-resolver.ts
+var DirectiveExecutionStrategyResolver = class {
+  constructor(strategies) {
+    this.strategies = strategies;
+  }
+  resolve(directive) {
+    return this.strategies[directive.type];
+  }
+};
+
+// 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);
+  }
+};
+
+// src/application/directive-execution/inference-execution-strategy.ts
+var InferenceExecutionStrategy = class {
+  constructor(inferenceRunner) {
+    this.inferenceRunner = inferenceRunner;
+  }
+  async execute(directive, agent, loop) {
+    if (directive.type !== "inference") {
+      throw new Error("Expected an inference directive");
+    }
+    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;
+  }
+  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");
+    }
+    const tool = agent.getTools().find((tool2) => tool2.name === directive.call.toolName);
+    if (!tool) {
+      throw new Error(`Tool "${directive.call.toolName}" not found`);
+    }
+    const result = await this.toolRunner.run(directive.call, tool);
+    loop.receiveToolUseResult(pending.id, result);
+  }
+};
+
+// 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");
+    }
+    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);
+  }
+  async function createLoop(params) {
+    return await createLoopUseCase.execute(params);
+  }
+  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);
+  }
+  return {
+    createAgent,
+    createLoop,
+    runLoop
+  };
+}
 export {
+  Agent,
   Participant,
   SituationSpecification,
   SpaceEvent,
+  defineAgentModule,
   defineRuntime
 };
 //# sourceMappingURL=index.mjs.map