@mozaik-ai/core 3.12.0 → 3.13.1

package/dist/index.mjs

@@ -35,9 +35,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
@@ -64,14 +61,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
@@ -90,13 +79,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
@@ -107,13 +89,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);
@@ -134,14 +109,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
@@ -156,13 +123,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
@@ -177,14 +137,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
@@ -199,14 +151,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;
   }
 };
 
@@ -225,143 +181,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",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 4e5,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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();
-  }
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4.ts
-var Gpt54 = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.4",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 105e4,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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();
-  }
-};
-
-// src/infrastructure/providers/openai/models/gpt-5-4-mini.ts
-var Gpt54Mini = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.4-mini",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 4e5,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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;
-  }
 };
 
 // src/domain/generative-model/token-usage.ts
@@ -435,13 +254,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);
@@ -452,11 +264,12 @@ var SystemMessageItem = class _SystemMessageItem extends ContextItem {
   }
 };
 
-// src/domain/agentic-environment/participants/participant.ts
+// src/domain/agentic-environment/participant.ts
 var Participant = class {
   constructor() {
     this.environments = [];
     this.listens = [];
+    this.active = /* @__PURE__ */ new Map();
   }
   join(environment) {
     if (this.isJoinedTo(environment)) {
@@ -464,6 +277,7 @@ var Participant = class {
     }
     environment.subscribe(this);
     this.environments.push(environment);
+    this.active.set(environment, true);
   }
   leave(environment) {
     if (!this.isJoinedTo(environment)) {
@@ -471,6 +285,7 @@ var Participant = class {
     }
     environment.unsubscribe(this);
     this.environments = this.environments.filter((e) => e !== environment);
+    this.active.delete(environment);
   }
   isJoinedTo(environment) {
     return this.environments.includes(environment);
@@ -481,14 +296,46 @@ var Participant = class {
   getListeners() {
     return this.listens;
   }
+  getEnvironmentState(environment) {
+    return this.active.get(environment);
+  }
+  markInactive(environment) {
+    if (this.active.has(environment)) {
+      this.active.set(environment, false);
+    }
+  }
+  markActive(environment) {
+    if (this.active.has(environment)) {
+      this.active.set(environment, true);
+    }
+  }
+};
+
+// src/domain/agentic-environment/errors/base-error.ts
+var AgenticError = class extends Error {
+  constructor({ message, stack, source, enviornment }) {
+    super();
+    this.message = message;
+    this.stack = stack;
+    this.source = source;
+    this.environment = enviornment;
+  }
+  getSource() {
+    return this.source;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
 };
 
 // src/domain/agentic-environment/agentic-environment.ts
 var AgenticEnvironment = class {
-  constructor(name) {
+  constructor(name, opts) {
     this.subscribers = [];
-    this.isActive = false;
+    var _a;
     this.name = name;
+    this.options = opts;
+    this.showLogs = ((_a = this.options) == null ? void 0 : _a.silent) !== false;
   }
   subscribe(participant) {
     this.subscribers.push(participant);
@@ -546,6 +393,36 @@ var AgenticEnvironment = class {
       external: (sub) => sub.onExternalEvent(source, item)
     });
   }
+  deliverError(source, error) {
+    this.deliverToSubscribers(source, {
+      internal: (src) => {
+        try {
+          src.onError(error);
+        } catch (error2) {
+          if (this.showLogs) {
+            console.warn(
+              `[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`
+            );
+          }
+        } finally {
+          src.markInactive(this);
+        }
+      },
+      external: (sub) => {
+        try {
+          sub.onParticipantError(source, error);
+        } catch (error2) {
+          if (this.showLogs) {
+            console.warn(
+              `[AgenticEnvironment] Participant.onError() failed. Reason: ${error2}
+ ${JSON.stringify({ error: error2 }, null, 2)}`
+            );
+          }
+        }
+      }
+    });
+  }
   getListeningParticipants(source) {
     return this.subscribers.filter(
       (sub) => sub !== source && (sub.getListeners().length === 0 || sub.getListeners().some((listener) => source instanceof listener))
@@ -555,26 +432,32 @@ var AgenticEnvironment = class {
     var _a, _b;
     const authorizedListeners = this.getListeningParticipants(source);
     for (const subscriber of this.subscribers) {
-      if (subscriber === source) {
-        (_a = handlers == null ? void 0 : handlers.internal) == null ? void 0 : _a.call(handlers, subscriber);
-      } else if (authorizedListeners.includes(subscriber)) {
-        (_b = handlers == null ? void 0 : handlers.external) == null ? void 0 : _b.call(handlers, subscriber);
+      const isActive = subscriber.getEnvironmentState(this);
+      if (isActive) {
+        try {
+          if (subscriber === source) {
+            (_a = handlers == null ? void 0 : handlers.internal) == null ? void 0 : _a.call(handlers, subscriber);
+          } else if (authorizedListeners.includes(subscriber)) {
+            (_b = handlers == null ? void 0 : handlers.external) == null ? void 0 : _b.call(handlers, subscriber);
+          }
+        } catch (error) {
+          this.handleError(subscriber, error);
+        }
       }
     }
   }
-  async start() {
-    this.isActive = true;
-    while (this.isActive) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
+  handleError(subscriber, error) {
+    if (error instanceof AgenticError) {
+      return this.deliverError(subscriber, error);
     }
+    const agenticError = new AgenticError({
+      message: error.message,
+      stack: error.stack,
+      enviornment: this,
+      source: subscriber
+    });
+    return this.deliverError(subscriber, agenticError);
   }
-  stop() {
-    this.isActive = false;
-  }
-};
-
-// src/domain/agentic-environment/participants/agent.ts
-var Agent = class extends Participant {
 };
 
 // src/domain/model-context/semantic-event/semantic-event.ts
@@ -588,198 +471,101 @@ var SemanticEvent = class {
   }
 };
 
-// src/application/participants/agent.ts
-var BaseAgent = class extends Agent {
-  constructor(inferenceRunner, functionCallRunner) {
-    super();
-    this.inferenceRunner = inferenceRunner;
-    this.functionCallRunner = functionCallRunner;
-  }
-  onJoined() {
-  }
-  onLeft() {
-  }
-  onParticipantJoined(participant) {
-  }
-  onParticipantLeft(participant) {
-  }
-  onFunctionCall(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onReasoning(item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalModelMessage(source, item) {
-  }
-  onMessage(message) {
-  }
-  onInternalEvent(item) {
-  }
-  onExternalEvent(source, item) {
-  }
-  async executeFunctionCall(environment, functionCallItem, signal) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.functionCallRunner.run(functionCallItem, signal);
-    for await (const item of stream) {
-      environment.deliverFunctionCallOutput(this, item);
-    }
-  }
-  async runInference(environment, context, model, signal) {
-    if (!this.isJoinedTo(environment)) return;
-    const stream = this.inferenceRunner.run(context, model, signal);
-    for await (const item of stream) {
-      if (item instanceof ReasoningItem) {
-        environment.deliverReasoning(this, item);
-      } else if (item instanceof FunctionCallItem) {
-        environment.deliverFunctionCall(this, item);
-      } else if (item instanceof ModelMessageItem) {
-        environment.deliverModelMessage(this, item);
-      } else if (item instanceof SemanticEvent) {
-        environment.deliverSemanticEvent(this, item);
-      }
-    }
-  }
-};
-
-// src/domain/agentic-environment/participants/human.ts
-var Human = class extends Participant {
-  sendMessage(environment, message) {
-    if (!this.isJoinedTo(environment)) throw new Error("Not joined to environment");
-    environment.deliverMessage(this, message);
-  }
-};
-
-// src/application/participants/human.ts
-var BaseHuman = class extends Human {
-  onJoined() {
-  }
-  onLeft() {
-  }
-  onParticipantJoined(participant) {
-  }
-  onParticipantLeft(participant) {
-  }
-  onMessage(message) {
-  }
-  onFunctionCall(item) {
-  }
-  onFunctionCallOutput(item) {
-  }
-  onReasoning(item) {
-  }
-  onModelMessage(item) {
-  }
-  onExternalFunctionCall(source, item) {
-  }
-  onExternalFunctionCallOutput(source, item) {
-  }
-  onExternalReasoning(source, item) {
-  }
-  onExternalModelMessage(source, item) {
-  }
-  onInternalEvent(item) {
-  }
-  onExternalEvent(source, item) {
+// src/domain/agentic-environment/inference/response.ts
+var InferenceResponse = class {
+  constructor(contextItems, tokenUsage) {
+    this.contextItems = contextItems;
+    this.tokenUsage = tokenUsage;
   }
 };
 
-// src/domain/generative-model/inference-request.ts
-var InferenceRequest = class {
-  constructor(model, context) {
-    this.model = model;
-    this.context = context;
+// 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);
   }
 };
-
-// src/application/runners/inference-runner.ts
-var DefaultInferenceRunner = class {
-  constructor(runtime) {
-    this.runtime = runtime;
-  }
-  async *run(context, model, signal) {
-    const request = new InferenceRequest(model, context);
-    if (model.getStreaming() && this.isStreamingRuntime(this.runtime)) {
-      yield* this.runtime.stream(request, signal);
+var NonStreamingInference = class {
+  async *run(request, endpoint) {
+    var _a, _b;
+    if ((_a = request.signal) == null ? void 0 : _a.aborted) {
       return;
     }
-    const response = await this.runtime.infer(request);
+    const response = await endpoint.infer(request);
     for (const item of response.contextItems) {
-      if (signal == null ? void 0 : signal.aborted) {
+      if ((_b = request.signal) == null ? void 0 : _b.aborted) {
         break;
       }
       yield item;
     }
   }
-  isStreamingRuntime(runtime) {
-    return typeof runtime.stream === "function";
-  }
 };
 
-// src/application/runners/function-call-runner.ts
-var DefaultFunctionCallRunner = class {
-  constructor(tools) {
-    this.tools = tools;
+// src/application/use-cases/run-inference.ts
+var RunInference = class {
+  constructor(generativeModelRepository2, requestValidator) {
+    this.generativeModelRepository = generativeModelRepository2;
+    this.requestValidator = requestValidator;
   }
-  async *run(call, signal) {
-    const tool = this.tools.find((t) => t.name === call.name);
-    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));
+  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
+    };
+    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);
+      }
+    }
   }
 };
 
-// src/infrastructure/providers/openai/models/gpt-5-5.ts
-var Gpt55 = class {
-  constructor() {
-    this.specification = {
-      name: "gpt-5.5",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 105e4,
-      maxOutputTokens: 128e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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);
+// src/application/use-cases/execute-function-call.ts
+var ExecuteFunctionCall = class {
+  constructor(functionCallRunner) {
+    this.functionCallRunner = functionCallRunner;
   }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
+  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/domain/agentic-environment/participants/observer.ts
-var Observer = class extends Participant {
+// src/application/services/function-call-runner.ts
+var FunctionCallRunner = class {
+  async *run(call, tool, signal) {
+    if (signal == null ? void 0 : signal.aborted) {
+      return;
+    }
+    if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+    const result = await tool.invoke(JSON.parse(call.args));
+    yield FunctionCallOutputItem.create(call.callId, JSON.stringify(result));
+  }
 };
 
-// src/application/participants/observer.ts
-var BaseObserver = class extends Observer {
+// src/application/participants/participant.ts
+var BaseParticipant = class extends Participant {
   onFunctionCall(item) {
   }
   onExternalFunctionCall(source, item) {
@@ -810,310 +596,79 @@ var BaseObserver = class extends Observer {
   }
   onExternalEvent(source, item) {
   }
+  onError(error) {
+  }
+  onParticipantError(source, error) {
+  }
 };
 
-// src/domain/generative-model/inference-response.ts
-var InferenceResponse = class {
-  constructor(contextItems, tokenUsage) {
-    this.contextItems = contextItems;
-    this.tokenUsage = tokenUsage;
+// src/application/use-cases/send-message.ts
+var SendMessage = class {
+  async execute(environment, message, caller) {
+    if (!caller.isJoinedTo(environment)) {
+      throw new Error("Not joined to environment");
+    }
+    environment.deliverMessage(caller, message);
   }
 };
 
-// src/infrastructure/providers/openai/runtime/openai-responses.ts
-import OpenAI from "openai";
-var OpenAIResponses = class {
-  constructor() {
-    this.client = new OpenAI();
+// 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;
   }
-  async infer(inferenceRequest) {
-    const request = this.buildRequest(inferenceRequest);
-    const response = await this.client.responses.create(request);
+  toResponse(response) {
     const contextItems = this.extractContextItems(response);
     const tokenUsage = this.extractTokenUsage(response);
     return new InferenceResponse(contextItems, tokenUsage);
   }
-  async *stream(inferenceRequest, signal) {
-    const specification = inferenceRequest.model.specification;
-    if (!specification.supportStreaming) {
-      throw new Error("Streaming is not supported for this model");
+  addContentBlock(messages, role, block) {
+    const lastMessage = messages[messages.length - 1];
+    if ((lastMessage == null ? void 0 : lastMessage.role) === role) {
+      lastMessage.content.push(block);
+      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) {
-        break;
-      }
-      yield new SemanticEvent(event.type, event);
-    }
-  }
-  buildRequest(inferenceRequest) {
-    const specification = inferenceRequest.model.specification;
-    const input = this.mapContextToRequest(inferenceRequest.context);
-    const request = {
-      model: specification.name,
-      input
-    };
-    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()
-      };
-    }
-    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)
-    );
-  }
-  mapContextToRequest(context) {
-    return context.getItems().map((item) => item.toJSON());
-  }
-  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/infrastructure/providers/openai/runtime/openai-compatible-chat-completions.ts
-import OpenAI2 from "openai";
-var OpenAICompatibleChatCompletions = class {
-  constructor(config = {}) {
-    var _a;
-    this.client = new OpenAI2({
-      baseURL: config.baseURL,
-      apiKey: config.apiKey
-    });
-    this.extraBody = (_a = config.extraBody) != null ? _a : {};
-  }
-  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 *stream(inferenceRequest, signal) {
-    var _a;
-    const stream = await this.client.chat.completions.create({
-      ...this.buildRequest(inferenceRequest),
-      stream: true
+    messages.push({
+      role,
+      content: [block]
     });
-    for await (const event of stream) {
-      if (signal == null ? void 0 : signal.aborted) {
-        break;
-      }
-      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
-    }
   }
-  buildRequest(inferenceRequest) {
-    const specification = inferenceRequest.model.specification;
-    const request = {
-      ...this.extraBody,
-      model: specification.name,
-      messages: this.mapContextToRequest(inferenceRequest.context)
-    };
-    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 (specification.supportReasoningEffort) {
-      request.reasoning_effort = inferenceRequest.model.getReasoningEffort();
-    }
-    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)
-    );
-  }
-  mapContextToRequest(context) {
-    var _a;
-    const messages = [];
-    for (const item of context.getItems()) {
-      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
-        messages.push({ role: "system", content: item.content.text });
-        continue;
-      }
-      if (item instanceof UserMessageItem) {
-        messages.push({ role: "user", content: item.content.text });
-        continue;
-      }
-      if (item instanceof ModelMessageItem) {
-        messages.push({ role: "assistant", content: item.content.text });
-        continue;
-      }
-      if (item instanceof FunctionCallItem) {
-        const toolCall = {
-          id: item.callId,
-          type: "function",
-          function: { name: item.name, arguments: item.args }
-        };
-        const last = messages[messages.length - 1];
-        if ((last == null ? void 0 : last.role) === "assistant") {
-          last.tool_calls = (_a = last.tool_calls) != null ? _a : [];
-          last.tool_calls.push(toolCall);
-        } else {
-          messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
-        }
-        continue;
-      }
-      if (item instanceof FunctionCallOutputItem) {
-        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
-      }
-    }
-    return messages;
-  }
-  extractContextItems(response) {
+  mapContextItems(inferenceParams) {
     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;
-    }
-    if (message.reasoning_content) {
-      items.push(
-        ReasoningItem.rehydrate({
-          content: InputText.rehydrate({ text: message.reasoning_content }),
-          encryptedContent: void 0,
-          summary: []
-        })
-      );
-    }
-    if (message.content) {
-      items.push(ModelMessageItem.rehydrate({ text: message.content }));
-    }
-    for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
-      items.push(
-        FunctionCallItem.rehydrate({
-          callId: toolCall.id,
-          name: toolCall.function.name,
-          args: toolCall.function.arguments
-        })
-      );
-    }
-    return items;
-  }
-};
-
-// src/infrastructure/providers/anthropic/runtime/anthropic-messages.ts
-import Anthropic from "@anthropic-ai/sdk";
-var AnthropicMessages = class {
-  constructor() {
-    this.client = new Anthropic();
-  }
-  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);
-  }
-  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);
-    }
-  }
-  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)
-        };
-      }
-    }
-    return request;
-  }
-  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)
-    );
-  }
-  mapContextToRequest(context) {
+    const context = inferenceParams.context;
     const messages = [];
     const system = [];
     for (const item of context.getItems()) {
@@ -1129,6 +684,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 {
@@ -1157,6 +720,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 = [];
@@ -1179,7 +757,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: []
           })
         );
@@ -1187,343 +765,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
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicMessages = class {
+  constructor(endpointMapper = new AnthropicMessagesMapper()) {
+    this.endpointMapper = endpointMapper;
+    this.client = new Anthropic();
   }
-  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",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 32e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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();
   }
 };
 
-// src/infrastructure/providers/anthropic/models/claude-4-7-opus.ts
-var ClaudeOpus47 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-opus-4-7",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 32e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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();
-  }
-};
+// src/infrastructure/providers/openai/endpoints/openai-responses.ts
+import OpenAI from "openai";
 
-// src/infrastructure/providers/anthropic/models/claude-4-6-sonnet.ts
-var ClaudeSonnet46 = class {
-  constructor() {
-    this.specification = {
-      name: "claude-sonnet-4-6",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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);
+// 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";
   }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
+  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",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "none",
-      supportStreaming: true,
-      contextWindowSize: 2e5,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: 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.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();
-  }
-};
-
-// 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",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1e6,
-      maxOutputTokens: 384e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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;
+    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;
   }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
+  toResponse(response) {
+    const contextItems = this.extractContextItems(response);
+    const tokenUsage = this.extractTokenUsage(response);
+    return new InferenceResponse(contextItems, tokenUsage);
   }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
+  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",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1e6,
-      maxOutputTokens: 384e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    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();
+  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
-import { GoogleGenAI } from "@google/genai";
-var GeminiGenerateContent = class {
-  constructor() {
-    this.client = new 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 OpenAI();
   }
-  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
+import { GoogleGenAI } from "@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 (inferenceParams.structuredOutput) {
+      config.responseMimeType = "application/json";
+      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();
@@ -1566,6 +1062,36 @@ var GeminiGenerateContent = class {
       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)
+    );
+  }
   extractContextItems(response) {
     var _a, _b, _c, _d, _e, _f;
     const items = [];
@@ -1597,157 +1123,652 @@ var GeminiGenerateContent = class {
     }
     return items;
   }
-  parseResponse(output) {
-    try {
-      const parsed = JSON.parse(output);
-      return parsed && typeof parsed === "object" ? parsed : { output };
-    } catch (e) {
-      return { output };
-    }
+};
+
+// src/infrastructure/providers/gemini/endpoints/gemini-generate-content.ts
+var GeminiGenerateContent = class {
+  constructor(endpointMapper = new GeminiGenerateContentMapper()) {
+    this.endpointMapper = endpointMapper;
+    this.client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
   }
-  addPart(contents, role, part) {
-    const last = contents[contents.length - 1];
-    if ((last == null ? void 0 : last.role) === role) {
-      last.parts.push(part);
-      return;
+  async infer(inferenceParams) {
+    const inferenceRequest = this.endpointMapper.toRequest(inferenceParams);
+    const response = await this.client.models.generateContent(inferenceRequest);
+    return this.endpointMapper.toResponse(response);
+  }
+  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("generate_content_chunk", chunk);
     }
-    contents.push({ role, parts: [part] });
   }
 };
 
-// src/infrastructure/providers/gemini/reasoning-effort.ts
-var GeminiReasoningEffort = class {
-  constructor(reasoningEffort) {
-    this.reasoningEffort = reasoningEffort;
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions-mapper.ts
+var OpenAIChatCompletionsMapper = class {
+  toRequest(inferenceParams) {
+    const request = {
+      model: inferenceParams.model,
+      messages: this.mapContextItems(inferenceParams)
+    };
+    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 (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);
+  }
+  mapContextItems(inferenceParams) {
+    var _a;
+    const messages = [];
+    for (const item of inferenceParams.context.getItems()) {
+      if (item instanceof DeveloperMessageItem || item instanceof SystemMessageItem) {
+        messages.push({ role: "system", content: item.content.text });
+        continue;
+      }
+      if (item instanceof UserMessageItem) {
+        messages.push({ role: "user", content: item.content.text });
+        continue;
+      }
+      if (item instanceof ModelMessageItem) {
+        messages.push({ role: "assistant", content: item.content.text });
+        continue;
+      }
+      if (item instanceof FunctionCallItem) {
+        const toolCall = {
+          id: item.callId,
+          type: "function",
+          function: { name: item.name, arguments: item.args }
+        };
+        const last = messages[messages.length - 1];
+        if ((last == null ? void 0 : last.role) === "assistant") {
+          last.tool_calls = (_a = last.tool_calls) != null ? _a : [];
+          last.tool_calls.push(toolCall);
+        } else {
+          messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
+        }
+        continue;
+      }
+      if (item instanceof FunctionCallOutputItem) {
+        messages.push({ role: "tool", tool_call_id: item.callId, content: item.output.text });
+      }
+    }
+    return messages;
   }
-  setReasoningEffort(effort) {
-    this.reasoningEffort = effort;
+  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)
+    );
   }
-  getReasoningEffort() {
-    if (!this.reasoningEffort) {
-      throw new Error("Reasoning effort not supported");
+  extractContextItems(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;
+    }
+    if (message.reasoning_content) {
+      items.push(
+        ReasoningItem.rehydrate({
+          content: InputText.rehydrate({ text: message.reasoning_content }),
+          encryptedContent: void 0,
+          summary: []
+        })
+      );
+    }
+    if (message.content) {
+      items.push(ModelMessageItem.rehydrate({ text: message.content }));
+    }
+    for (const toolCall of (_c = message.tool_calls) != null ? _c : []) {
+      items.push(
+        FunctionCallItem.rehydrate({
+          callId: toolCall.id,
+          name: toolCall.function.name,
+          args: toolCall.function.arguments
+        })
+      );
     }
-    return this.reasoningEffort;
+    return items;
   }
 };
 
-// src/infrastructure/providers/gemini/models/gemini-3-5-flash.ts
-var Gemini35Flash = class {
-  constructor() {
-    this.specification = {
-      name: "gemini-3.5-flash",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "medium",
-      supportStreaming: true,
-      contextWindowSize: 1048576,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true
+// src/infrastructure/providers/openai/endpoints/openai-chat-completions.ts
+import OpenAI2 from "openai";
+var OpenAIChatCompletions = class {
+  constructor(endpointMapper = new OpenAIChatCompletionsMapper(), config = {}) {
+    var _a;
+    this.endpointMapper = endpointMapper;
+    this.client = new OpenAI2({
+      baseURL: config.baseURL,
+      apiKey: config.apiKey
+    });
+    this.extraBody = (_a = config.extraBody) != null ? _a : {};
+  }
+  buildRequest(inferenceParams) {
+    return {
+      ...this.extraBody,
+      ...this.endpointMapper.toRequest(inferenceParams)
     };
-    this.tools = [];
-    this.streaming = false;
-    this.effort = new GeminiReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
   }
-  setStreaming(streaming) {
-    this.streaming = streaming;
+  async infer(inferenceParams) {
+    const response = await this.client.chat.completions.create(this.buildRequest(inferenceParams));
+    return this.endpointMapper.toResponse(response);
+  }
+  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;
+      }
+      yield new SemanticEvent((_a = event.object) != null ? _a : "chat.completion.chunk", event);
+    }
   }
-  getStreaming() {
-    return this.streaming;
+};
+
+// 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/infrastructure/repository/generative-model-repository.ts
+var InMemoryGenerativeModelRepository = class {
+  getByModelName(modelName) {
+    let generativeModel = void 0;
+    switch (modelName) {
+      case "gpt-5.4":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54Specification
+        };
+        break;
+      case "gpt-5.4-mini":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54MiniSpecification
+        };
+        break;
+      case "gpt-5.4-nano":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt54NanoSpecification
+        };
+        break;
+      case "gpt-5.5":
+        generativeModel = {
+          endpoint: new OpenAIResponses(),
+          specification: gpt55Specification
+        };
+        break;
+      case "claude-haiku-4-5":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeHaiku45Specification
+        };
+        break;
+      case "claude-sonnet-4-6":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeSonnet46Specification
+        };
+        break;
+      case "claude-opus-4-7":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeOpus47Specification
+        };
+        break;
+      case "claude-opus-4-8":
+        generativeModel = {
+          endpoint: new AnthropicMessages(),
+          specification: claudeOpus48Specification
+        };
+        break;
+      case "gemini-3.5-flash":
+        generativeModel = {
+          endpoint: new GeminiGenerateContent(),
+          specification: gemini35FlashSpecification
+        };
+        break;
+      case "gemini-3.1-pro-preview":
+        generativeModel = {
+          endpoint: new GeminiGenerateContent(),
+          specification: gemini31ProSpecification
+        };
+        break;
+      case "deepseek-v4-flash":
+        generativeModel = {
+          endpoint: new OpenAIChatCompletions(),
+          specification: deepSeekV4FlashSpecification
+        };
+        break;
+      case "deepseek-v4-pro":
+        generativeModel = {
+          endpoint: new OpenAIChatCompletions(),
+          specification: deepSeekV4ProSpecification
+        };
+    }
+    if (!generativeModel) {
+      throw new Error(`Unsupported model: ${modelName}`);
+    }
+    return Promise.resolve(generativeModel);
   }
-  setTools(tools) {
-    this.tools = tools;
+};
+
+// src/domain/generative-model/request-validation/reasoning-effort.ts
+var ReasoningEffortValidation = class {
+  constructor() {
+    this.name = "reasoning-effort";
   }
-  getTools() {
-    return this.tools;
+  isValid(inferenceParams, model) {
+    if (inferenceParams.reasoningEffort === void 0) {
+      return true;
+    }
+    if (!model.supportsReasoningEffort) {
+      return false;
+    }
+    return model.supportedReasoningEfforts.includes(inferenceParams.reasoningEffort);
   }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
+};
+
+// src/domain/generative-model/request-validation/tool-calling.ts
+var ToolCallingValidation = class {
+  constructor() {
+    this.name = "tool-calling";
   }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
+  isValid(inferenceParams, model) {
+    if (inferenceParams.tools === void 0) {
+      return true;
+    }
+    return model.supportsFunctionCalling;
   }
 };
 
-// src/infrastructure/providers/gemini/models/gemini-3-1-pro.ts
-var Gemini31Pro = class {
+// src/domain/generative-model/request-validation/streaming.ts
+var StreamingValidation = class {
   constructor() {
-    this.specification = {
-      name: "gemini-3.1-pro-preview",
-      supportReasoningEffort: true,
-      defaultReasoningEffort: "high",
-      supportStreaming: true,
-      contextWindowSize: 1048576,
-      maxOutputTokens: 64e3,
-      supportFunctionCalling: true
-    };
-    this.tools = [];
-    this.streaming = false;
-    this.effort = new GeminiReasoningEffort(
-      this.specification.defaultReasoningEffort
-    );
+    this.name = "streaming";
+  }
+  isValid(inferenceParams, model) {
+    if (!inferenceParams.streaming) {
+      return true;
+    }
+    return model.supportsStreaming;
+  }
+};
+
+// src/domain/generative-model/request-validation/context.ts
+function getContextItemValidationKey(item) {
+  if (item instanceof UserMessageItem) {
+    return "user_message";
   }
-  setStreaming(streaming) {
-    this.streaming = streaming;
+  if (item instanceof SystemMessageItem) {
+    return "system_message";
   }
-  getStreaming() {
-    return this.streaming;
+  if (item instanceof DeveloperMessageItem) {
+    return "developer_message";
   }
-  setTools(tools) {
-    this.tools = tools;
+  if (item instanceof ModelMessageItem) {
+    return "model_message";
   }
-  getTools() {
-    return this.tools;
+  return item.getType();
+}
+var ContextValidation = class {
+  constructor() {
+    this.name = "context";
   }
-  setReasoningEffort(effort) {
-    this.effort.setReasoningEffort(effort);
+  isValid(inferenceParams, model) {
+    return inferenceParams.context.items.every(
+      (item) => model.supportedContextItemTypes.includes(getContextItemValidationKey(item))
+    );
   }
-  getReasoningEffort() {
-    return this.effort.getReasoningEffort();
+};
+
+// 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}"`);
+      }
+    }
   }
 };
+
+// src/index.ts
+var generativeModelRepository = new InMemoryGenerativeModelRepository();
+var inferenceRequestValidator = new InferenceRequestValidator();
+var runInferenceUseCase = new RunInference(generativeModelRepository, inferenceRequestValidator);
+var executeFunctionCallUseCase = new ExecuteFunctionCall(new FunctionCallRunner());
+var sendMessageUseCase = new SendMessage();
+var runInference = (inferenceParams) => {
+  runInferenceUseCase.execute(inferenceParams);
+};
+var executeFunctionCall = (environment, functionCallItem, tool, caller) => {
+  executeFunctionCallUseCase.execute(environment, functionCallItem, tool, caller);
+};
+var sendMessage = (environment, message, caller) => {
+  sendMessageUseCase.execute(environment, message, caller);
+};
 export {
-  Agent,
   AgenticEnvironment,
-  AnthropicMessages,
-  BaseAgent,
-  BaseHuman,
-  BaseObserver,
-  ClaudeHaiku45,
-  ClaudeOpus47,
-  ClaudeOpus48,
-  ClaudeSonnet46,
+  AgenticError,
+  BaseParticipant,
   ContextItem,
-  DeepSeekV4Flash,
-  DeepSeekV4Pro,
-  DefaultFunctionCallRunner,
-  DefaultInferenceRunner,
   DeveloperMessageItem,
   FunctionCallItem,
   FunctionCallOutputItem,
-  Gemini31Pro,
-  Gemini35Flash,
-  GeminiGenerateContent,
-  Gpt54,
-  Gpt54Mini,
-  Gpt54Nano,
-  Gpt55,
-  Human,
   InMemoryModelContextRepository,
-  InferenceRequest,
   InferenceResponse,
   InputTokenDetails,
   ModelContext,
   ModelMessageItem,
-  Observer,
-  OpenAICompatibleChatCompletions,
-  OpenAIResponses,
   OutputTokenDetails,
   Participant,
   ReasoningItem,
   SemanticEvent,
   SystemMessageItem,
   TokenUsage,
-  UserMessageItem
+  UserMessageItem,
+  executeFunctionCall,
+  runInference,
+  sendMessage
 };
 //# sourceMappingURL=index.mjs.map