@mozaik-ai/core 3.13.0 → 3.14.0

package/dist/index.js

@@ -32,33 +32,18 @@ var index_exports = {};
 __export(index_exports, {
   AgenticEnvironment: () => AgenticEnvironment,
   AgenticError: () => AgenticError,
-  AnthropicMessages: () => AnthropicMessages,
   BaseParticipant: () => BaseParticipant,
-  ClaudeHaiku45: () => ClaudeHaiku45,
-  ClaudeOpus47: () => ClaudeOpus47,
-  ClaudeOpus48: () => ClaudeOpus48,
-  ClaudeSonnet46: () => ClaudeSonnet46,
   ContextItem: () => ContextItem,
-  DeepSeekV4Flash: () => DeepSeekV4Flash,
-  DeepSeekV4Pro: () => DeepSeekV4Pro,
   DeveloperMessageItem: () => DeveloperMessageItem,
   FunctionCallItem: () => FunctionCallItem,
   FunctionCallOutputItem: () => FunctionCallOutputItem,
-  Gemini31Pro: () => Gemini31Pro,
-  Gemini35Flash: () => Gemini35Flash,
-  GeminiGenerateContent: () => GeminiGenerateContent,
-  Gpt54: () => Gpt54,
-  Gpt54Mini: () => Gpt54Mini,
-  Gpt54Nano: () => Gpt54Nano,
-  Gpt55: () => Gpt55,
   InMemoryModelContextRepository: () => InMemoryModelContextRepository,
-  InferenceRequest: () => InferenceRequest,
   InferenceResponse: () => InferenceResponse,
   InputTokenDetails: () => InputTokenDetails,
+  McpClient: () => McpClient,
+  McpToolRegistry: () => McpToolRegistry,
   ModelContext: () => ModelContext,
   ModelMessageItem: () => ModelMessageItem,
-  OpenAIChatCompletions: () => OpenAIChatCompletions,
-  OpenAIResponses: () => OpenAIResponses,
   OutputTokenDetails: () => OutputTokenDetails,
   Participant: () => Participant,
   ReasoningItem: () => ReasoningItem,
@@ -109,9 +94,6 @@ var ModelContext = class _ModelContext {
   static rehydrate(data) {
     return new _ModelContext(data.id, data.projectId, data.items);
   }
-  toJSON() {
-    return this.items.map((item) => item.toJSON());
-  }
 };
 
 // src/domain/model-context/context-item/context-item.ts
@@ -138,14 +120,6 @@ var InputText = class _InputText extends ItemContent {
   static rehydrate(data) {
     return new _InputText(data.text);
   }
-  toJSON() {
-    return [
-      {
-        type: this.type,
-        text: this.text
-      }
-    ];
-  }
 };
 
 // src/domain/model-context/context-item/client-item/user-message.ts
@@ -164,13 +138,6 @@ var UserMessageItem = class _UserMessageItem extends ContextItem {
     const content = InputText.rehydrate(data);
     return new _UserMessageItem(content);
   }
-  toJSON() {
-    return {
-      type: this.type,
-      role: this.role,
-      content: this.content.toJSON()
-    };
-  }
 };
 
 // src/domain/model-context/context-item/client-item/developer-message.ts
@@ -181,13 +148,6 @@ var DeveloperMessageItem = class _DeveloperMessageItem extends ContextItem {
     this.role = "developer";
     this.content = content;
   }
-  toJSON() {
-    return {
-      type: this.type,
-      role: this.role,
-      content: this.content.toJSON()
-    };
-  }
   static create(text) {
     const content = InputText.create(text);
     return new _DeveloperMessageItem(content);
@@ -208,14 +168,6 @@ var OutputText = class _OutputText extends ItemContent {
   static rehydrate(data) {
     return new _OutputText(data.text);
   }
-  toJSON() {
-    return [
-      {
-        type: this.type,
-        text: this.text
-      }
-    ];
-  }
 };
 
 // src/domain/model-context/context-item/model-item/model-message.ts
@@ -230,13 +182,6 @@ var ModelMessageItem = class _ModelMessageItem extends ContextItem {
     const content = OutputText.rehydrate(data);
     return new _ModelMessageItem(content);
   }
-  toJSON() {
-    return {
-      type: this.type,
-      role: this.role,
-      content: this.content.toJSON()
-    };
-  }
 };
 
 // src/domain/model-context/context-item/model-item/function-call.ts
@@ -251,14 +196,6 @@ var FunctionCallItem = class _FunctionCallItem extends ContextItem {
   static rehydrate(data) {
     return new _FunctionCallItem(data.callId, data.name, data.args);
   }
-  toJSON() {
-    return {
-      type: this.type,
-      call_id: this.callId,
-      name: this.name,
-      arguments: this.args
-    };
-  }
 };
 
 // src/domain/model-context/context-item/model-item/reasoning.ts
@@ -273,14 +210,18 @@ var ReasoningItem = class _ReasoningItem extends ContextItem {
   static rehydrate(data) {
     return new _ReasoningItem(data.content, data.encryptedContent, data.summary);
   }
-  toJSON() {
-    var _a;
-    return {
-      type: this.type,
-      content: (_a = this.content) == null ? void 0 : _a.toJSON(),
-      encryptedContent: this.encryptedContent,
-      summary: this.summary.map((s) => s.toJSON())
-    };
+};
+
+// src/domain/generative-model/request-validation/structured-output.ts
+var StructuredOutputValidation = class {
+  constructor() {
+    this.name = "structured-output";
+  }
+  isValid(inferenceParams, model) {
+    if (inferenceParams.structuredOutput === void 0) {
+      return true;
+    }
+    return model.supportsStructuredOutput;
   }
 };
 
@@ -299,179 +240,6 @@ var FunctionCallOutputItem = class _FunctionCallOutputItem extends ContextItem {
   static rehydrate(data) {
     return new _FunctionCallOutputItem(data.callId, data.output);
   }
-  toJSON() {
-    return {
-      type: this.type,
-      call_id: this.callId,
-      output: this.output.toJSON()
-    };
-  }
-};
-
-// src/infrastructure/providers/openai/reasoning-effort.ts
-var OpenAIReasoningEffort = class {
-  constructor(reasoningEffort) {
-    this.reasoningEffort = reasoningEffort;
-  }
-  setReasoningEffort(effort) {
-    this.reasoningEffort = effort;
-  }
-  getReasoningEffort() {
-    if (!this.reasoningEffort) {
-      throw new Error("Reasoning effort not supported");
-    }
-    return this.reasoningEffort;
-  }
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4-nano.ts
-var Gpt54Nano = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.4-nano",
-      provider: "openai",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 4e5,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new OpenAIReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4.ts
-var Gpt54 = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.4",
-      provider: "openai",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 105e4,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new OpenAIReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4-mini.ts
-var Gpt54Mini = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.4-mini",
-      provider: "openai",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 4e5,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new OpenAIReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
 };
 
 // src/domain/generative-model/token-usage.ts
@@ -495,6 +263,98 @@ var TokenUsage = class {
   }
 };
 
+// src/infrastructure/mcp/mcp-client.ts
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var McpClient = class {
+  constructor(config) {
+    this.config = config;
+    this.connected = false;
+    var _a, _b;
+    const headers = { ...(_a = config.headers) != null ? _a : {} };
+    if (config.authToken) headers.Authorization = `Bearer ${config.authToken}`;
+    this.transport = new import_streamableHttp.StreamableHTTPClientTransport(
+      new URL(config.url),
+      Object.keys(headers).length > 0 ? { requestInit: { headers } } : void 0
+    );
+    this.client = new import_client.Client({ name: (_b = config.name) != null ? _b : "mozaik", version: "1.0.0" }, { capabilities: {} });
+  }
+  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/infrastructure/repository/in-memory-model-context-repository.ts
 var InMemoryModelContextRepository = class {
   constructor() {
@@ -545,13 +405,6 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
     this.role = "system";
     this.content = content;
   }
-  toJSON() {
-    return {
-      type: this.type,
-      role: this.role,
-      content: this.content.toJSON()
-    };
-  }
   static create(text) {
     const content = InputText.create(text);
     return new _SystemMessageItem(content);
@@ -698,8 +551,10 @@ var AgenticEnvironment = class {
           src.onError(error);
         } catch (error2) {
           if (this.showLogs) {
-            console.warn(`[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
- ${JSON.stringify({ error: error2 }, null, 2)}`);
+            console.warn(
+              `[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`
+            );
           }
         } finally {
           src.markInactive(this);
@@ -710,8 +565,10 @@ var AgenticEnvironment = class {
           sub.onParticipantError(source, error);
         } catch (error2) {
           if (this.showLogs) {
-            console.warn(`[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
- ${JSON.stringify({ error: error2 }, null, 2)}`);
+            console.warn(
+              `[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`
+            );
           }
         }
       }
@@ -754,56 +611,6 @@ var AgenticEnvironment = class {
   }
 };
 
-// src/infrastructure/providers/openai/models/gpt-5-5.ts
-var Gpt55 = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.5",
-      provider: "openai",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 105e4,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new OpenAIReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
-
 // src/domain/model-context/semantic-event/semantic-event.ts
 var SemanticEvent = class {
   constructor(type, data) {
@@ -815,14 +622,6 @@ var SemanticEvent = class {
   }
 };
 
-// src/domain/agentic-environment/inference/request.ts
-var InferenceRequest = class {
-  constructor(model, context) {
-    this.model = model;
-    this.context = context;
-  }
-};
-
 // src/domain/agentic-environment/inference/response.ts
 var InferenceResponse = class {
   constructor(contextItems, tokenUsage) {
@@ -831,191 +630,196 @@ var InferenceResponse = class {
   }
 };
 
-// src/infrastructure/providers/openai/runtime/openai-responses.ts
-var import_openai = __toESM(require("openai"));
-var OpenAIResponses = class {
-  constructor() {
-    this.client = new import_openai.default();
-  }
-  async infer(inferenceRequest) {
-    const request = this.buildRequest(inferenceRequest);
-    const response = await this.client.responses.create(request);
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
+// src/application/services/inference-runner.ts
+var StreamingInference = class {
+  async *run(request, endpoint) {
+    var _a;
+    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
+      return;
+    }
+    yield* endpoint.stream(request, request.signal);
   }
-  async *stream(inferenceRequest, signal) {
-    const specification = inferenceRequest.model.specification;
-    if (!specification.supportStreaming) {
-      throw new Error("Streaming is not supported for this model");
+};
+var NonStreamingInference = class {
+  async *run(request, endpoint) {
+    var _a, _b;
+    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
+      return;
     }
-    const request = { ...this.buildRequest(inferenceRequest), stream: true };
-    const response = await this.client.responses.create(request);
-    for await (const event of response) {
-      if (signal == null ? void 0 : signal.aborted) {
+    const response = await endpoint.infer(request);
+    for (const item of response.contextItems) {
+      if ((_b = request.signal) == null ? void 0 : _b.aborted) {
         break;
       }
-      yield new SemanticEvent(event.type, event);
+      yield item;
     }
   }
-  buildRequest(inferenceRequest) {
-    var _a, _b;
-    const specification = inferenceRequest.model.specification;
-    const input = this.mapContextToRequest(inferenceRequest.context);
-    const request = {
-      model: specification.name,
-      input
+};
+
+// src/application/use-cases/run-inference.ts
+var RunInference = class {
+  constructor(generativeModelRepository2, requestValidator) {
+    this.generativeModelRepository = generativeModelRepository2;
+    this.requestValidator = requestValidator;
+  }
+  async execute(inferenceParams) {
+    var _a;
+    const { caller, environment, signal } = inferenceParams;
+    const generativeModel = await this.generativeModelRepository.getByModelName(inferenceParams.model);
+    this.requestValidator.validate(inferenceParams, generativeModel.specification);
+    const resolvedParams = {
+      ...inferenceParams,
+      maxOutputTokens: (_a = inferenceParams.maxOutputTokens) != null ? _a : generativeModel.specification.maxOutputTokens
     };
-    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
-      request.tools = inferenceRequest.model.getTools().map((tool) => {
-        return {
-          type: tool.type,
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        };
-      });
-    }
-    if (specification.supportReasoningEffort) {
-      request.reasoning = {
-        effort: inferenceRequest.model.getReasoningEffort()
-      };
-    }
-    if (inferenceRequest.model.hasStructuredOutput()) {
-      if (!specification.supportStructuredOutput) {
-        throw new Error(`Structured output is not supported for model: ${specification.name}`);
+    const inferenceRunner = inferenceParams.streaming ? new StreamingInference() : new NonStreamingInference();
+    const result = inferenceRunner.run(resolvedParams, generativeModel.endpoint);
+    for await (const item of result) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      if (item instanceof ReasoningItem) {
+        environment.deliverReasoning(caller, item);
+      } else if (item instanceof FunctionCallItem) {
+        environment.deliverFunctionCall(caller, item);
+      } else if (item instanceof ModelMessageItem) {
+        environment.deliverModelMessage(caller, item);
+      } else if (item instanceof SemanticEvent) {
+        environment.deliverSemanticEvent(caller, item);
       }
-      const format = inferenceRequest.model.getStructuredOutput();
-      request.text = {
-        format: {
-          type: "json_schema",
-          name: (_a = format.name) != null ? _a : "response",
-          schema: format.schema,
-          strict: (_b = format.strict) != null ? _b : true
-        }
-      };
     }
-    return request;
   }
-  extractTokenUsage(response) {
-    if (!response.usage) {
-      return void 0;
-    }
-    return new TokenUsage(
-      response.usage.input_tokens,
-      response.usage.output_tokens,
-      response.usage.total_tokens,
-      new InputTokenDetails(response.usage.input_tokens_details.cached_tokens),
-      new OutputTokenDetails(response.usage.output_tokens_details.reasoning_tokens)
-    );
+};
+
+// src/application/use-cases/execute-function-call.ts
+var ExecuteFunctionCall = class {
+  constructor(functionCallRunner) {
+    this.functionCallRunner = functionCallRunner;
   }
-  mapContextToRequest(context) {
-    return context.getItems().map((item) => item.toJSON());
+  async execute(environment, functionCallItem, tool, caller, signal) {
+    const stream = this.functionCallRunner.run(functionCallItem, tool, signal);
+    for await (const item of stream) {
+      environment.deliverFunctionCallOutput(caller, item);
+    }
   }
-  extractContextItems(response) {
-    return response.output.map((item) => {
-      if (item.type === "message" && item.role === "assistant") {
-        return ModelMessageItem.rehydrate(item.content[0]);
-      }
-      if (item.type === "function_call") {
-        return FunctionCallItem.rehydrate({
-          callId: item.call_id,
-          name: item.name,
-          args: item.arguments
-        });
-      }
-      if (item.type === "reasoning") {
-        return ReasoningItem.rehydrate(item);
-      }
-    });
+};
+
+// src/application/services/function-call-runner.ts
+var FunctionCallRunner = class {
+  async *run(call, tool, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      return;
+    }
+    if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+    const result = await tool.invoke(JSON.parse(call.args));
+    yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result));
   }
 };
 
-// src/infrastructure/providers/anthropic/runtime/anthropic-messages.ts
-var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var AnthropicMessages = class {
-  constructor() {
-    this.client = new import_sdk.default();
+// src/application/participants/participant.ts
+var BaseParticipant = class extends Participant {
+  onFunctionCall(_item) {
   }
-  async infer(inferenceRequest) {
-    const response = await this.client.messages.create(this.buildRequest(inferenceRequest));
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
+  onExternalFunctionCall(_source, _item) {
   }
-  async *stream(inferenceRequest, signal) {
-    const stream = await this.client.messages.create({
-      ...this.buildRequest(inferenceRequest),
-      stream: true
-    });
-    for await (const event of stream) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield new SemanticEvent(event.type, event);
-    }
+  onFunctionCallOutput(_item) {
   }
-  buildRequest(inferenceRequest) {
-    const { messages, system } = this.mapContextToRequest(inferenceRequest.context);
-    const specification = inferenceRequest.model.specification;
-    const request = {
-      model: specification.name,
-      max_tokens: specification.maxOutputTokens,
-      messages
-    };
-    if (system) {
-      request.system = system;
-    }
-    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
-      request.tools = inferenceRequest.model.getTools().map((tool) => {
-        return {
-          name: tool.name,
-          description: tool.description,
-          input_schema: tool.parameters
-        };
-      });
-    }
-    if (specification.supportReasoningEffort) {
-      const effort = inferenceRequest.model.getReasoningEffort();
-      const budgets = { low: 1024, medium: 4096, high: 8192 };
-      const budget = budgets[effort];
-      if (budget !== void 0) {
-        request.thinking = {
-          type: "enabled",
-          budget_tokens: Math.min(budget, specification.maxOutputTokens - 1)
-        };
-      }
+  onExternalFunctionCallOutput(_source, _item) {
+  }
+  onReasoning(_item) {
+  }
+  onExternalReasoning(_source, _item) {
+  }
+  onModelMessage(_item) {
+  }
+  onExternalModelMessage(_source, _item) {
+  }
+  onMessage(_message) {
+  }
+  onJoined() {
+  }
+  onLeft() {
+  }
+  onParticipantJoined(_participant) {
+  }
+  onParticipantLeft(_participant) {
+  }
+  onInternalEvent(_item) {
+  }
+  onExternalEvent(_source, _item) {
+  }
+  onError(_error) {
+  }
+  onParticipantError(_source, _error) {
+  }
+};
+
+// src/application/use-cases/send-message.ts
+var SendMessage = class {
+  async execute(environment, message, caller) {
+    if (!caller.isJoinedTo(environment)) {
+      throw new Error("Not joined to environment");
     }
-    if (inferenceRequest.model.hasStructuredOutput()) {
-      if (!specification.supportStructuredOutput) {
-        throw new Error(`Structured output is not supported for model: ${specification.name}`);
-      }
-      const format = inferenceRequest.model.getStructuredOutput();
-      request.output_config = {
-        format: {
-          type: "json_schema",
-          json_schema: format.schema
-        }
+    environment.deliverMessage(caller, message);
+  }
+};
+
+// src/infrastructure/providers/anthropic/endpoints/anthropic-messages-mapper.ts
+var AnthropicMessagesMapper = class {
+  toRequest(inferenceParams) {
+    const { messages, system } = this.mapContextItems(inferenceParams);
+    const outputConfig = {};
+    const request = {
+      model: inferenceParams.model,
+      messages
+    };
+    request.max_tokens = inferenceParams.maxOutputTokens;
+    if (system) {
+      request.system = system;
+    }
+    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
+      request.tools = inferenceParams.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters
+      }));
+    }
+    if (inferenceParams.structuredOutput) {
+      outputConfig.format = {
+        type: "json_schema",
+        json_schema: inferenceParams.structuredOutput.schema
       };
     }
+    if (inferenceParams.reasoningEffort) {
+      request.thinking = { type: "adaptive" };
+      outputConfig.effort = inferenceParams.reasoningEffort;
+    }
+    if (Object.keys(outputConfig).length > 0) {
+      request.output_config = outputConfig;
+    }
+    if (inferenceParams.streaming) {
+      request.stream = inferenceParams.streaming;
+    }
     return request;
   }
-  extractTokenUsage(response) {
-    var _a, _b;
-    if (!response.usage) {
-      return void 0;
+  toResponse(response) {
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
+  }
+  addContentBlock(messages, role, block) {
+    const lastMessage = messages[messages.length - 1];
+    if ((lastMessage == null ? void 0 : lastMessage.role) === role) {
+      lastMessage.content.push(block);
+      return;
     }
-    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)
-    );
+    messages.push({
+      role,
+      content: [block]
+    });
   }
-  mapContextToRequest(context) {
+  mapContextItems(inferenceParams) {
+    var _a, _b, _c;
+    const context = inferenceParams.context;
     const messages = [];
     const system = [];
     for (const item of context.getItems()) {
@@ -1031,6 +835,14 @@ var AnthropicMessages = class {
         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 {
@@ -1059,6 +871,21 @@ var AnthropicMessages = class {
       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)
+    );
+  }
   extractContextItems(response) {
     var _a;
     const items = [];
@@ -1081,7 +908,7 @@ var AnthropicMessages = class {
         items.push(
           ReasoningItem.rehydrate({
             content: block.thinking ? InputText.rehydrate({ text: block.thinking }) : void 0,
-            encryptedContent: void 0,
+            encryptedContent: block.signature,
             summary: []
           })
         );
@@ -1089,423 +916,261 @@ var AnthropicMessages = class {
     }
     return items;
   }
-  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]
-    });
-  }
 };
 
-// src/infrastructure/providers/anthropic/reasoning-effort.ts
-var AnthropicReasoningEffort = class {
-  constructor(reasoningEffort) {
-    this.reasoningEffort = reasoningEffort;
+// src/infrastructure/providers/anthropic/endpoints/anthropic-messages.ts
+var import_sdk = __toESM(require("@anthropic-ai/sdk"));
+var AnthropicMessages = class {
+  constructor(endpointMapper = new AnthropicMessagesMapper()) {
+    this.endpointMapper = endpointMapper;
+    this.client = new import_sdk.default();
   }
-  setReasoningEffort(effort) {
-    this.reasoningEffort = effort;
+  async infer(inferenceParams) {
+    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
+    const response = await this.client.messages.create(inferenceRequest);
+    return this.endpointMapper.toResponse(response);
   }
-  getReasoningEffort() {
-    if (!this.reasoningEffort) {
-      throw new Error("Reasoning effort not supported");
+  async *stream(inferenceParams, signal) {
+    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
+    const stream = await this.client.messages.create(inferenceRequest);
+    for await (const event of stream) {
+      if (signal == null ? void 0 : signal.aborted) {
+        break;
+      }
+      yield new SemanticEvent(event.type, event);
     }
-    return this.reasoningEffort;
-  }
-};
-
-// src/infrastructure/providers/anthropic/models/claude-4-8-opus.ts
-var ClaudeOpus48 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-opus-4-8",
-      provider: "anthropic",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 32e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new AnthropicReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
   }
 };
 
-// src/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
-var ClaudeOpus47 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-opus-4-7",
-      provider: "anthropic",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 32e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new AnthropicReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
+// src/infrastructure/providers/openai/endpoints/openai-responses.ts
+var import_openai = __toESM(require("openai"));
 
-// src/infrastructure/providers/anthropic/models/claude-4-6-sonnet.ts
-var ClaudeSonnet46 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-sonnet-4-6",
-      provider: "anthropic",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new AnthropicReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
+// 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";
   }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
+  static rehydrate(data) {
+    return new _SummaryText(data.text);
   }
 };
 
-// src/infrastructure/providers/anthropic/models/claude-4-5-haiku.ts
-var ClaudeHaiku45 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-haiku-4-5",
-      provider: "anthropic",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
+// src/infrastructure/providers/openai/endpoints/openai-responses-mapper.ts
+var OpenAIResponsesMapper = class {
+  toRequest(inferenceParams) {
+    var _a, _b;
+    const request = {
+      model: inferenceParams.model,
+      input: this.mapContextItems(inferenceParams)
     };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new AnthropicReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
-
-// src/infrastructure/providers/deepseek/reasoning-effort.ts
-var DeepSeekReasoningEffort = class {
-  constructor(reasoningEffort) {
-    this.reasoningEffort = reasoningEffort;
-  }
-  setReasoningEffort(effort) {
-    this.reasoningEffort = effort;
-  }
-  getReasoningEffort() {
-    if (!this.reasoningEffort) {
-      throw new Error("Reasoning effort not supported");
+    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
+      request.tools = inferenceParams.tools.map((tool) => ({
+        type: tool.type,
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }));
     }
-    return this.reasoningEffort;
-  }
-};
-
-// src/infrastructure/providers/deepseek/models/deepseek-v4-flash.ts
-var DeepSeekV4Flash = class {
-  constructor() {
-    this.specification = {
-      name: "deepseek-v4-flash",
-      provider: "deepseek",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1e6,
-      maxOutputTokens: 384e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: false
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new DeepSeekReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
+    if (inferenceParams.reasoningEffort) {
+      request.reasoning = {
+        effort: inferenceParams.reasoningEffort
+      };
+    }
+    if (inferenceParams.structuredOutput) {
+      const format = inferenceParams.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 (inferenceParams.streaming) {
+      request.stream = inferenceParams.streaming;
+    }
+    return request;
   }
-  getStructuredOutput() {
-    return this.structuredOutput;
+  toResponse(response) {
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
   }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
+  mapContextItems(inferenceParams) {
+    const input = [];
+    for (const item of inferenceParams.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;
   }
-};
-
-// src/infrastructure/providers/deepseek/models/deepseek-v4-pro.ts
-var DeepSeekV4Pro = class {
-  constructor() {
-    this.specification = {
-      name: "deepseek-v4-pro",
-      provider: "deepseek",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1e6,
-      maxOutputTokens: 384e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: false
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new DeepSeekReasoningEffort(
-      this.specification.defaultReasoningEffort
+  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)
     );
   }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
+  extractContextItems(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;
   }
 };
 
-// src/infrastructure/providers/gemini/runtime/gemini-generate-content.ts
-var import_genai = require("@google/genai");
-var GeminiGenerateContent = class {
-  constructor() {
-    this.client = new import_genai.GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+// src/infrastructure/providers/openai/endpoints/openai-responses.ts
+var OpenAIResponses = class {
+  constructor(endpointMapper = new OpenAIResponsesMapper()) {
+    this.endpointMapper = endpointMapper;
+    this.client = new import_openai.default();
   }
-  async infer(inferenceRequest) {
-    const response = await this.client.models.generateContent(this.buildRequest(inferenceRequest));
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
+  async infer(inferenceParams) {
+    const request = this.endpointMapper.toRequest(inferenceParams);
+    const response = await this.client.responses.create(request);
+    return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceRequest, signal) {
-    const stream = await this.client.models.generateContentStream(this.buildRequest(inferenceRequest));
-    for await (const chunk of stream) {
+  async *stream(inferenceParams, signal) {
+    const request = this.endpointMapper.toRequest(inferenceParams);
+    const response = await this.client.responses.create(request);
+    for await (const event of response) {
       if (signal == null ? void 0 : signal.aborted) {
         break;
       }
-      yield new SemanticEvent("generate_content_chunk", chunk);
+      yield new SemanticEvent(event.type, event);
     }
   }
-  buildRequest(inferenceRequest) {
-    const specification = inferenceRequest.model.specification;
-    const { contents, systemInstruction } = this.mapContextToRequest(inferenceRequest.context);
+};
+
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
+var import_genai = require("@google/genai");
+
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content-mapper.ts
+var GeminiGenerateContentMapper = class {
+  toRequest(inferenceParams) {
+    const { contents, systemInstruction } = this.mapContextItems(inferenceParams);
     const config = {};
     if (systemInstruction) {
       config.systemInstruction = systemInstruction;
     }
-    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
+    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
       config.tools = [
         {
-          functionDeclarations: inferenceRequest.model.getTools().map((tool) => {
-            return {
-              name: tool.name,
-              description: tool.description,
-              parametersJsonSchema: tool.parameters
-            };
-          })
+          functionDeclarations: inferenceParams.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parametersJsonSchema: tool.parameters
+          }))
         }
       ];
     }
-    if (specification.supportReasoningEffort) {
-      const effort = inferenceRequest.model.getReasoningEffort();
-      const thinkingLevel = effort === "none" ? "minimal" : effort;
-      config.thinkingConfig = { thinkingLevel, includeThoughts: true };
-    }
-    if (inferenceRequest.model.hasStructuredOutput()) {
-      if (!specification.supportStructuredOutput) {
-        throw new Error(`Structured output is not supported for model: ${specification.name}`);
-      }
-      const format = inferenceRequest.model.getStructuredOutput();
+    if (inferenceParams.structuredOutput) {
       config.responseMimeType = "application/json";
-      config.responseSchema = format.schema;
+      config.responseSchema = inferenceParams.structuredOutput.schema;
     }
-    return { model: specification.name, contents, config };
-  }
-  extractTokenUsage(response) {
-    var _a, _b, _c, _d, _e;
-    const usage = response.usageMetadata;
-    if (!usage) {
-      return void 0;
+    if (inferenceParams.reasoningEffort) {
+      config.thinkingConfig = {
+        thinkingLevel: inferenceParams.reasoningEffort,
+        includeThoughts: true
+      };
     }
-    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)
-    );
+    const request = {
+      model: inferenceParams.model,
+      contents,
+      config
+    };
+    if (inferenceParams.streaming) {
+      request.stream = inferenceParams.streaming;
+    }
+    return request;
+  }
+  toResponse(response) {
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
   }
-  mapContextToRequest(context) {
+  mapContextItems(inferenceParams) {
     var _a;
+    const context = inferenceParams.context;
     const contents = [];
     const system = [];
     const callNames = /* @__PURE__ */ new Map();
@@ -1548,45 +1213,6 @@ var GeminiGenerateContent = class {
       systemInstruction: system.length > 0 ? system.join("\n\n") : void 0
     };
   }
-  extractContextItems(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;
-  }
-  parseResponse(output) {
-    try {
-      const parsed = JSON.parse(output);
-      return parsed && typeof parsed === "object" ? parsed : { output };
-    } catch (e) {
-      return { output };
-    }
-  }
   addPart(contents, role, part) {
     const last = contents[contents.length - 1];
     if ((last == null ? void 0 : last.role) === role) {
@@ -1595,195 +1221,118 @@ var GeminiGenerateContent = class {
     }
     contents.push({ role, parts: [part] });
   }
-};
-
-// src/infrastructure/providers/gemini/reasoning-effort.ts
-var GeminiReasoningEffort = class {
-  constructor(reasoningEffort) {
-    this.reasoningEffort = reasoningEffort;
-  }
-  setReasoningEffort(effort) {
-    this.reasoningEffort = effort;
-  }
-  getReasoningEffort() {
-    if (!this.reasoningEffort) {
-      throw new Error("Reasoning effort not supported");
-    }
-    return this.reasoningEffort;
-  }
-};
-
-// src/infrastructure/providers/gemini/models/gemini-3-5-flash.ts
-var Gemini35Flash = class {
-  constructor() {
-    this.specification = {
-      name: "gemini-3.5-flash",
-      provider: "google",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "medium",
-      supportStreaming: true,
-      contextWindowSize: 1048576,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new GeminiReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
-  }
-  getStructuredOutput() {
-    return this.structuredOutput;
-  }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
-  }
-};
-
-// src/infrastructure/providers/gemini/models/gemini-3-1-pro.ts
-var Gemini31Pro = class {
-  constructor() {
-    this.specification = {
-      name: "gemini-3.1-pro-preview",
-      provider: "google",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1048576,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true,
-      supportStructuredOutput: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.structuredOutput = void 0;
-    this.effort = new GeminiReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
-  }
-  setStreaming(streaming) {
-    this.streaming = streaming;
-  }
-  getStreaming() {
-    return this.streaming;
-  }
-  setTools(tools) {
-    this.tools = tools;
-  }
-  getTools() {
-    return this.tools;
-  }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
-  }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
-  }
-  setStructuredOutput(format) {
-    this.structuredOutput = format;
+  parseResponse(output) {
+    try {
+      const parsed = JSON.parse(output);
+      return parsed && typeof parsed === "object" ? parsed : { output };
+    } catch (e) {
+      return { output };
+    }
   }
-  getStructuredOutput() {
-    return this.structuredOutput;
+  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)
+    );
   }
-  hasStructuredOutput() {
-    return this.structuredOutput !== void 0;
+  extractContextItems(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;
   }
 };
 
-// src/infrastructure/providers/openai/runtime/openai-chat-completions.ts
-var import_openai2 = __toESM(require("openai"));
-var OpenAIChatCompletions = class {
-  constructor(config = {}) {
-    var _a;
-    this.client = new import_openai2.default({
-      baseURL: config.baseURL,
-      apiKey: config.apiKey
-    });
-    this.extraBody = (_a = config.extraBody) != null ? _a : {};
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
+var GeminiGenerateContent = class {
+  constructor(endpointMapper = new GeminiGenerateContentMapper()) {
+    this.endpointMapper = endpointMapper;
+    this.client = new import_genai.GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
   }
-  async infer(inferenceRequest) {
-    const response = await this.client.chat.completions.create(this.buildRequest(inferenceRequest));
-    const contextItems = this.extractContextItems(response);
-    const tokenUsage = this.extractTokenUsage(response);
-    return new InferenceResponse(contextItems, tokenUsage);
+  async infer(inferenceParams) {
+    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
+    const response = await this.client.models.generateContent(inferenceRequest);
+    return this.endpointMapper.toResponse(response);
   }
-  async *stream(inferenceRequest, signal) {
-    var _a;
-    const stream = await this.client.chat.completions.create({
-      ...this.buildRequest(inferenceRequest),
-      stream: true
-    });
-    for await (const event of stream) {
+  async *stream(inferenceParams, signal) {
+    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
+    const stream = await this.client.models.generateContentStream(inferenceRequest);
+    for await (const chunk of stream) {
       if (signal == null ? void 0 : signal.aborted) {
         break;
       }
-      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
+      yield new SemanticEvent("generate_content_chunk", chunk);
     }
   }
-  buildRequest(inferenceRequest) {
-    const specification = inferenceRequest.model.specification;
+};
+
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions-mapper.ts
+var OpenAIChatCompletionsMapper = class {
+  toRequest(inferenceParams) {
     const request = {
-      ...this.extraBody,
-      model: specification.name,
-      messages: this.mapContextToRequest(inferenceRequest.context)
+      model: inferenceParams.model,
+      messages: this.mapContextItems(inferenceParams)
     };
-    if (specification.supportFunctionCalling && inferenceRequest.model.getTools().length > 0) {
-      request.tools = inferenceRequest.model.getTools().map((tool) => {
-        return {
-          type: "function",
-          function: {
-            name: tool.name,
-            description: tool.description,
-            parameters: tool.parameters
-          }
-        };
-      });
+    if (inferenceParams.tools && inferenceParams.tools.length > 0) {
+      request.tools = inferenceParams.tools.map((tool) => ({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        }
+      }));
+    }
+    if (inferenceParams.reasoningEffort) {
+      request.reasoning_effort = inferenceParams.reasoningEffort;
     }
-    if (specification.supportReasoningEffort) {
-      request.reasoning_effort = inferenceRequest.model.getReasoningEffort();
+    if (inferenceParams.streaming) {
+      request.stream = inferenceParams.streaming;
     }
     return request;
   }
-  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) {
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
   }
-  mapContextToRequest(context) {
+  mapContextItems(inferenceParams) {
     var _a;
     const messages = [];
-    for (const item of context.getItems()) {
+    for (const item of inferenceParams.context.getItems()) {
       if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
         messages.push({ role: "system", content: item.content.text });
         continue;
@@ -1817,6 +1366,19 @@ var OpenAIChatCompletions = class {
     }
     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)
+    );
+  }
   extractContextItems(response) {
     var _a, _b, _c;
     const items = [];
@@ -1849,179 +1411,482 @@ var OpenAIChatCompletions = class {
   }
 };
 
-// src/application/services/inference-runner.ts
-var InferenceRunner = class {
-  async *run(context, modelInfo, signal) {
-    const { model, endpoint } = modelInfo;
-    const request = new InferenceRequest(model, context);
-    if (model.getStreaming()) {
-      yield* endpoint.stream(request);
-      return;
-    }
-    const response = await endpoint.infer(request);
-    for (const item of response.contextItems) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield item;
-    }
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions.ts
+var import_openai2 = __toESM(require("openai"));
+var OpenAIChatCompletions = class {
+  constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
+    var _a;
+    this.endpointMapper = endpointMapper;
+    this.client = new import_openai2.default({
+      baseURL: config.baseURL,
+      apiKey: config.apiKey
+    });
+    this.extraBody = (_a = config.extraBody) != null ? _a : {};
   }
-};
-
-// src/application/use-cases/run-inference.ts
-var RunInference = class {
-  constructor(modelRepository, inferenceRunner) {
-    this.modelRepository = modelRepository;
-    this.inferenceRunner = inferenceRunner;
+  buildRequest(inferenceParams) {
+    return {
+      ...this.extraBody,
+      ...this.endpointMapper.toRequest(inferenceParams)
+    };
   }
-  setModelCapabilities(model, inferenceParams) {
-    const { streaming, tools, reasoningEffort, structuredOutput } = inferenceParams;
-    if (streaming) {
-      model.setStreaming(true);
-    }
-    if (tools) {
-      model.setTools(tools);
-    }
-    if (reasoningEffort) {
-      model.setReasoningEffort(reasoningEffort);
-    }
-    if (structuredOutput) {
-      model.setStructuredOutput(structuredOutput);
-    }
-    return model;
+  async infer(inferenceParams) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceParams));
+    return this.endpointMapper.toResponse(response);
   }
-  async execute(inferenceParams) {
-    const { model, context, caller, environment, signal } = inferenceParams;
-    const modelInfo = this.modelRepository.getModelInfo(model);
-    const generativeModel = this.setModelCapabilities(modelInfo.model, inferenceParams);
-    modelInfo.model = generativeModel;
-    const result = this.inferenceRunner.run(context, modelInfo, signal);
-    for await (const item of result) {
+  async *stream(inferenceParams, signal) {
+    var _a;
+    const stream = await this.client.chat.completions.create(this.buildRequest(inferenceParams));
+    for await (const event of stream) {
       if (signal == null ? void 0 : signal.aborted) {
         break;
       }
-      if (item instanceof ReasoningItem) {
-        environment.deliverReasoning(caller, item);
-      } else if (item instanceof FunctionCallItem) {
-        environment.deliverFunctionCall(caller, item);
-      } else if (item instanceof ModelMessageItem) {
-        environment.deliverModelMessage(caller, item);
-      } else if (item instanceof SemanticEvent) {
-        environment.deliverSemanticEvent(caller, item);
-      }
+      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
     }
   }
 };
 
-// src/application/use-cases/execute-function-call.ts
-var ExecuteFunctionCall = class {
-  constructor(functionCallRunner) {
-    this.functionCallRunner = functionCallRunner;
-  }
-  async execute(environment, functionCallItem, tool, caller, signal) {
-    const stream = this.functionCallRunner.run(functionCallItem, tool, signal);
-    for await (const item of stream) {
-      environment.deliverFunctionCallOutput(caller, item);
-    }
-  }
+// src/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/model-repository.ts
-var ModelRepository = class {
-  getModelInfo(model) {
-    switch (model) {
-      case "gpt-5-4":
-        return { endpoint: new OpenAIResponses(), model: new Gpt54() };
-      case "gpt-5-4-mini":
-        return { endpoint: new OpenAIResponses(), model: new Gpt54Mini() };
-      case "gpt-5-4-nano":
-        return { endpoint: new OpenAIResponses(), model: new Gpt54Nano() };
-      case "gpt-5-5":
-        return { endpoint: new OpenAIResponses(), model: new Gpt55() };
-      case "claude-4-5-haiku":
-        return { endpoint: new AnthropicMessages(), model: new ClaudeHaiku45() };
-      case "claude-4-6-sonnet":
-        return { endpoint: new AnthropicMessages(), model: new ClaudeSonnet46() };
-      case "claude-4-7-opus":
-        return { endpoint: new AnthropicMessages(), model: new ClaudeOpus47() };
-      case "claude-4-8-opus":
-        return { endpoint: new AnthropicMessages(), model: new ClaudeOpus48() };
-      case "gemini-3-5-flash":
-        return { endpoint: new GeminiGenerateContent(), model: new Gemini35Flash() };
-      case "gemini-3-1-pro":
-        return { endpoint: new GeminiGenerateContent(), model: new Gemini31Pro() };
+// src/infrastructure/repository/generative-model-repository.ts
+var InMemoryGenerativeModelRepository = class {
+  getByModelName(modelName) {
+    let generativeModel = void 0;
+    switch (modelName) {
+      case "gpt-5.4":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54Specification
+        };
+        break;
+      case "gpt-5.4-mini":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54MiniSpecification
+        };
+        break;
+      case "gpt-5.4-nano":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54NanoSpecification
+        };
+        break;
+      case "gpt-5.5":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt55Specification
+        };
+        break;
+      case "claude-haiku-4-5":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeHaiku45Specification
+        };
+        break;
+      case "claude-sonnet-4-6":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeSonnet46Specification
+        };
+        break;
+      case "claude-opus-4-7":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeOpus47Specification
+        };
+        break;
+      case "claude-opus-4-8":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeOpus48Specification
+        };
+        break;
+      case "gemini-3.5-flash":
+        generativeModel = {
+          endpoint: new GeminiGenerateContent(),
+          specification: gemini35FlashSpecification
+        };
+        break;
+      case "gemini-3.1-pro-preview":
+        generativeModel = {
+          endpoint: new GeminiGenerateContent(),
+          specification: gemini31ProSpecification
+        };
+        break;
       case "deepseek-v4-flash":
-        return { endpoint: new OpenAIChatCompletions(), model: new DeepSeekV4Flash() };
+        generativeModel = {
+          endpoint: new OpenAIChatCompletions(),
+          specification: deepSeekV4FlashSpecification
+        };
+        break;
       case "deepseek-v4-pro":
-        return { endpoint: new OpenAIChatCompletions(), model: new DeepSeekV4Pro() };
-      default:
-        throw new Error(`Unsupported model: ${model}`);
+        generativeModel = {
+          endpoint: new OpenAIChatCompletions(),
+          specification: deepSeekV4ProSpecification
+        };
     }
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${modelName}`);
+    }
+    return Promise.resolve(generativeModel);
   }
 };
 
-// src/application/services/function-call-runner.ts
-var FunctionCallRunner = class {
-  async *run(call, tool, signal) {
-    if (signal == null ? void 0 : signal.aborted) {
-      return;
+// src/domain/generative-model/request-validation/reasoning-effort.ts
+var ReasoningEffortValidation = class {
+  constructor() {
+    this.name = "reasoning-effort";
+  }
+  isValid(inferenceParams, model) {
+    if (inferenceParams.reasoningEffort === void 0) {
+      return true;
     }
-    if (!tool) throw new Error(`Unknown tool: ${call.name}`);
-    const result = await tool.invoke(JSON.parse(call.args));
-    yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result));
+    if (!model.supportsReasoningEffort) {
+      return false;
+    }
+    return model.supportedReasoningEfforts.includes(inferenceParams.reasoningEffort);
   }
 };
 
-// src/application/participants/participant.ts
-var BaseParticipant = class extends Participant {
-  onFunctionCall(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onReasoning(item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalModelMessage(source, item) {
+// src/domain/generative-model/request-validation/tool-calling.ts
+var ToolCallingValidation = class {
+  constructor() {
+    this.name = "tool-calling";
   }
-  onMessage(message) {
+  isValid(inferenceParams, model) {
+    if (inferenceParams.tools === void 0) {
+      return true;
+    }
+    return model.supportsFunctionCalling;
   }
-  onJoined() {
+};
+
+// src/domain/generative-model/request-validation/streaming.ts
+var StreamingValidation = class {
+  constructor() {
+    this.name = "streaming";
   }
-  onLeft() {
+  isValid(inferenceParams, model) {
+    if (!inferenceParams.streaming) {
+      return true;
+    }
+    return model.supportsStreaming;
   }
-  onParticipantJoined(participant) {
+};
+
+// src/domain/generative-model/request-validation/context.ts
+function getContextItemValidationKey(item) {
+  if (item instanceof UserMessageItem) {
+    return "user_message";
   }
-  onParticipantLeft(participant) {
+  if (item instanceof SystemMessageItem) {
+    return "system_message";
   }
-  onInternalEvent(item) {
+  if (item instanceof DeveloperMessageItem) {
+    return "developer_message";
   }
-  onExternalEvent(source, item) {
+  if (item instanceof ModelMessageItem) {
+    return "model_message";
   }
-  onError(error) {
+  return item.getType();
+}
+var ContextValidation = class {
+  constructor() {
+    this.name = "context";
   }
-  onParticipantError(source, error) {
+  isValid(inferenceParams, model) {
+    return inferenceParams.context.items.every(
+      (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
+    );
   }
 };
 
-// src/application/use-cases/send-message.ts
-var SendMessage = class {
-  async execute(environment, message, caller) {
-    if (!caller.isJoinedTo(environment)) {
-      throw new Error("Not joined to environment");
+// src/domain/generative-model/request-validation/inference-request-validator.ts
+var defaultRequestValidationRules = [
+  new ReasoningEffortValidation(),
+  new ToolCallingValidation(),
+  new StreamingValidation(),
+  new StructuredOutputValidation(),
+  new ContextValidation()
+];
+var InferenceRequestValidator = class {
+  constructor(rules = defaultRequestValidationRules) {
+    this.rules = rules;
+  }
+  validate(inferenceParams, model) {
+    for (const rule of this.rules) {
+      if (!rule.isValid(inferenceParams, model)) {
+        throw new Error(`Request validation "${rule.name}" failed for model "${model.name}"`);
+      }
     }
-    environment.deliverMessage(caller, message);
   }
 };
 
 // src/index.ts
-var runInferenceUseCase = new RunInference(new ModelRepository(), new InferenceRunner());
+var generativeModelRepository = new InMemoryGenerativeModelRepository();
+var inferenceRequestValidator = new InferenceRequestValidator();
+var runInferenceUseCase = new RunInference(generativeModelRepository, inferenceRequestValidator);
 var executeFunctionCallUseCase = new ExecuteFunctionCall(new FunctionCallRunner());
 var sendMessageUseCase = new SendMessage();
 var runInference = (inferenceParams) => {
@@ -2037,33 +1902,18 @@ var sendMessage = (environment, message, caller) => {
 0 && (module.exports = {
   AgenticEnvironment,
   AgenticError,
-  AnthropicMessages,
   BaseParticipant,
-  ClaudeHaiku45,
-  ClaudeOpus47,
-  ClaudeOpus48,
-  ClaudeSonnet46,
   ContextItem,
-  DeepSeekV4Flash,
-  DeepSeekV4Pro,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
-  Gemini31Pro,
-  Gemini35Flash,
-  GeminiGenerateContent,
-  Gpt54,
-  Gpt54Mini,
-  Gpt54Nano,
-  Gpt55,
   InMemoryModelContextRepository,
-  InferenceRequest,
   InferenceResponse,
   InputTokenDetails,
+  McpClient,
+  McpToolRegistry,
   ModelContext,
   ModelMessageItem,
-  OpenAIChatCompletions,
-  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,