@mozaik-ai/core 0.9.4 → 2.0.1

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,1160 +15,264 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  MozaikAgent: () => MozaikAgent,
-  PlanningAgent: () => PlanningAgent,
-  ReasoningEffort: () => ReasoningEffort,
-  Task: () => Task,
-  WorkUnit: () => WorkUnit,
-  Workflow: () => Workflow
+  Context: () => Context,
+  ContextItem: () => ContextItem,
+  DeveloperMessage: () => DeveloperMessage,
+  FunctionCall: () => FunctionCall,
+  FunctionCallOutput: () => FunctionCallOutput,
+  GenerativeModel: () => GenerativeModel,
+  ModelMessage: () => ModelMessage,
+  Reasoning: () => Reasoning,
+  UserMessage: () => UserMessage
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/workflow/work-unit.ts
-var WorkUnit = class {
-  constructor() {
+// src/domain/context-runtime/context.ts
+var Context = class _Context {
+  constructor(id, projectId, items) {
+    this.projectId = projectId;
+    this.id = id;
+    this.items = items;
   }
-};
-
-// src/core/endpoint/request-gateway.ts
-var RequestGateway = class {
-  constructor(endpointResolver) {
-    this.endpointResolver = endpointResolver;
-  }
-  async invoke(request) {
-    this.endpoint = this.endpointResolver.resolve(request.model);
-    return await this.endpoint.sendRequest(request);
-  }
-};
-
-// src/core/endpoint/endpoint-resolver.ts
-var EndpointResolver = class {
-};
-
-// src/types/model.ts
-var OPENAI_MODELS = ["gpt-5", "gpt-5-mini", "gpt-5-nano", "gpt-5.1", "gpt-5.2", "gpt-5.4"];
-var latest_sonnet = "claude-sonnet-4-5-20250929";
-var latest_haiku = "claude-haiku-4-5-20251001";
-var latest_opus = "claude-opus-4-5-20251101";
-var ANTHROPIC_MODELS = ["claude-sonnet-4.5", "claude-haiku-4.5", "claude-opus-4.5"];
-var ANTHROPIC_MODEL_MAP = {
-  "claude-sonnet-4.5": latest_sonnet,
-  "claude-haiku-4.5": latest_haiku,
-  "claude-opus-4.5": latest_opus
-};
-
-// src/core/request-handler/capability.ts
-var CapabilityHandler = class {
-  setNextHandler(capability) {
-    this.nextHandler = capability;
-    return this.nextHandler;
-  }
-  handle(request, builder) {
-    this.apply(request, builder);
-    if (this.nextHandler) {
-      this.nextHandler.handle(request, builder);
-    }
-  }
-};
-
-// src/core/request-handler/messages.ts
-var MessagesHandler = class extends CapabilityHandler {
-  apply(request, builder) {
-    if (request.messages) {
-      builder.addMessages(request.messages);
-    }
-  }
-};
-
-// src/core/request-handler/task.ts
-var TaskHandler = class extends CapabilityHandler {
-  apply(request, builder) {
-    if (request.task) {
-      builder.addTask(request.task);
-    }
-  }
-};
-
-// src/core/request-handler/model.ts
-var ModelHandler = class extends CapabilityHandler {
-  apply(request, builder) {
-    if (request.model) {
-      builder.addModel(request.model);
-    }
-  }
-};
-
-// src/core/request-handler/structured-output.ts
-var StructuredOutputlHandler = class extends CapabilityHandler {
-  apply(request, builder) {
-    if (request.structuredOutput) {
-      builder.addStructuredOutput(request.structuredOutput);
-    }
-  }
-};
-
-// src/core/request-handler/tools.ts
-var ToolsHandler = class extends CapabilityHandler {
-  apply(mozaikRequest, requestBuilder) {
-    if (mozaikRequest.tools && mozaikRequest.tools.length > 0) {
-      requestBuilder.addTools(mozaikRequest.tools);
-    }
-  }
-};
-
-// src/core/endpoint/endpoint.ts
-var Endpoint = class {
-  constructor() {
-    this.request = null;
-  }
-  buildRequest(request) {
-    this.request = request;
-    this.requestBuilder.initialize();
-    const messagesHandler = new MessagesHandler();
-    const taskHandler = new TaskHandler();
-    const modelHandler = new ModelHandler();
-    const structuredOutputHandler = new StructuredOutputlHandler();
-    const toolsHandler = new ToolsHandler();
-    messagesHandler.setNextHandler(taskHandler).setNextHandler(modelHandler).setNextHandler(structuredOutputHandler).setNextHandler(toolsHandler);
-    messagesHandler.handle(request, this.requestBuilder);
-    return this.requestBuilder.build();
-  }
-};
-
-// src/core/endpoint/request-builder.ts
-var RequestBuilder = class {
-  initialize() {
-    this.request = {};
-  }
-  build() {
-    return this.request;
-  }
-};
-
-// src/providers/openai/mapper.ts
-var OpenAIResponsesMapper = class {
-  /**
-   * Convert domain Messages to Responses API instructions format
-   *
-   * The Responses API uses 'instructions' (system prompt) rather than messages array.
-   * For multi-turn conversations, use conversation.id or previous_response_id parameters.
-   */
-  toInstructions(messages) {
-    if (messages.length === 0) {
-      throw new Error("[ResponsesMapper] Cannot create instructions from empty messages");
-    }
-    const systemMessage = messages.find((m) => m.role === "system");
-    if (systemMessage) {
-      return typeof systemMessage.content === "string" ? systemMessage.content : this.extractTextFromContent(systemMessage.content);
-    }
-    return "You are a helpful assistant.";
-  }
-  /**
-   * Extract the user's input from messages
-   * Returns the last user message content for use in prompt variables.
-   * In Responses API, the actual user query is typically passed via prompt variables
-   * or handled through conversation continuation.
-   */
-  extractUserInput(messages) {
-    const userMessages = messages.filter((m) => m.role === "user");
-    if (userMessages.length === 0) {
-      return "";
-    }
-    const lastUserMessage = userMessages[userMessages.length - 1];
-    return typeof lastUserMessage.content === "string" ? lastUserMessage.content : this.extractTextFromContent(lastUserMessage.content);
-  }
-  extractTextFromContent(content) {
-    return content.filter((part) => part.type === "text").map((part) => part.text).join(" ");
-  }
-  /**
-   * Map tools to Responses API format
-   */
-  toTools(tools) {
-    return tools.map((t) => ({
-      type: "function",
-      name: t.name,
-      description: t.description,
-      parameters: t.schema,
-      strict: true
-      // Enable strict mode by default for better validation
-    }));
-  }
-};
-
-// src/providers/openai/builder.ts
-var import_zod = require("openai/helpers/zod");
-
-// src/types/request.ts
-var ReasoningEffort = /* @__PURE__ */ ((ReasoningEffort2) => {
-  ReasoningEffort2["NONE"] = "none";
-  ReasoningEffort2["LOW"] = "low";
-  ReasoningEffort2["MEDIUM"] = "medium";
-  ReasoningEffort2["HIGH"] = "high";
-  ReasoningEffort2["MAX"] = "max";
-  return ReasoningEffort2;
-})(ReasoningEffort || {});
-
-// src/providers/openai/builder.ts
-var OpenAIResponsesBuilder = class extends RequestBuilder {
-  constructor(mapper = new OpenAIResponsesMapper()) {
-    super();
-    this.mapper = mapper;
-  }
-  addModel(model) {
-    this.request.model = model;
+  addItem(item) {
+    this.items.push(item);
     return this;
   }
-  addTask(task) {
-    this.request.input = task;
+  addItems(items) {
+    this.items.push(...items);
     return this;
   }
-  addMessages(messages) {
-    const instructions = this.mapper.toInstructions(messages);
-    if (instructions && instructions !== "You are a helpful assistant.") {
-      this.request.instructions = instructions;
-    }
-    return this;
+  getItems() {
+    return this.items;
   }
-  addStructuredOutput(schema) {
-    this.request.text = {
-      format: (0, import_zod.zodTextFormat)(schema, "outputSchema")
-    };
-    return this;
+  static create(projectId) {
+    const id = crypto.randomUUID();
+    return new _Context(id, projectId, []);
   }
-  addTools(tools) {
-    this.request.tools = tools.map((tool) => ({
-      type: "function",
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.schema
-    }));
-    return this;
+  static rehydrate(data) {
+    return new _Context(data.id, data.projectId, data.items);
   }
-  addReasoningEffort(effort) {
-    let reasoningEffort = "";
-    if (effort === "none" /* NONE */) {
-      reasoningEffort = "none";
-    } else if (effort === "low" /* LOW */) {
-      reasoningEffort = "low";
-    } else if (effort === "medium" /* MEDIUM */) {
-      reasoningEffort = "medium";
-    } else if (effort === "high" /* HIGH */) {
-      reasoningEffort = "high";
-    } else if (effort === "max" /* MAX */) {
-      reasoningEffort = "xhigh";
-    }
-    this.request.reasoning = {
-      effort: reasoningEffort
-    };
-    return this;
+  toJSON() {
+    return this.items.map((item) => item.toJSON());
   }
 };
 
-// src/providers/openai/client/default.ts
-var import_openai = __toESM(require("openai"));
-var OpenAIDefaultClient = class {
-  constructor(client = new import_openai.default()) {
-    this.client = client;
-  }
-  async send(request) {
-    return await this.client.responses.create(request);
+// src/domain/context-runtime/context-item.ts
+var ContextItem = class {
+  getType() {
+    return this.type;
   }
 };
 
-// src/providers/openai/client/parser.ts
-var import_openai2 = __toESM(require("openai"));
-var OpenAIParserClient = class {
-  constructor(client = new import_openai2.default()) {
-    this.client = client;
-  }
-  async send(request) {
-    return await this.client.responses.parse(request);
-  }
+// src/domain/context-runtime/content.ts
+var Content = class {
 };
 
-// src/providers/openai/client/resolver.ts
-var OpenAIClientResolver = class {
-  static resolve(request) {
-    if (request.text && request.text.format) {
-      return new OpenAIParserClient();
-    } else {
-      return new OpenAIDefaultClient();
-    }
+// src/domain/context-runtime/content/input-text.ts
+var InputText = class _InputText extends Content {
+  constructor(text) {
+    super();
+    this.text = text;
+    this.type = "input_text";
   }
-};
-
-// src/core/endpoint/response-handler.ts
-var ResponseHandler = class {
-  setNextHandler(responseHandler) {
-    this.nextHandler = responseHandler;
-    return this.nextHandler;
+  static create(text) {
+    return new _InputText(text);
   }
-};
-
-// src/providers/openai/response-handler/output-parsed.ts
-var OutputParsedHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    const providerResponse = mozaikResponse.providerResponse;
-    if (providerResponse.output_parsed) {
-      mozaikResponse.setResponseData(providerResponse.output_parsed);
-      return mozaikResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
+  static rehydrate(data) {
+    return new _InputText(data.text);
   }
-};
-
-// src/providers/openai/response-handler/content.ts
-var ContentHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    var _a, _b;
-    const providerResponse = mozaikResponse.providerResponse;
-    const firstOutput = (_a = providerResponse.output) == null ? void 0 : _a[0];
-    if (firstOutput && "content" in firstOutput) {
-      const firstContent = (_b = firstOutput.content) == null ? void 0 : _b[0];
-      if (firstContent && "text" in firstContent) {
-        mozaikResponse.setResponseData(firstContent.text);
-        return mozaikResponse;
+  toJSON() {
+    return [
+      {
+        type: this.type,
+        text: this.text
       }
-    }
-    return await this.nextHandler.handle(mozaikResponse);
+    ];
   }
 };
 
-// src/providers/openai/response-handler/output-text.ts
-var OutputTextHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    const providerResponse = mozaikResponse.providerResponse;
-    if (providerResponse.output_text) {
-      mozaikResponse.setResponseData(providerResponse.output_text);
-      return mozaikResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
-};
-
-// src/core/usage-entry.ts
-var UsageEntry = class {
-  constructor(priceInUsd, model) {
-    this.priceInUsd = priceInUsd;
-    this.model = model;
-  }
-};
-
-// src/providers/openai/model-pricing.ts
-var OpenAIModelPricing = class {
-  calculateTotalCost(inputTokens, outputTokens, cachedInputTokens) {
-    const inputCost = (inputTokens - cachedInputTokens) * this.inputPricePer1MToken / 1e6;
-    const outputCost = outputTokens * this.outputPricePer1MToken / 1e6;
-    const cachedCost = cachedInputTokens * this.cachedPricePer1MToken / 1e6;
-    return inputCost + outputCost + cachedCost;
-  }
-  getPriceInUsd(modelName, inputTokens, outputTokens, cachedInputTokens) {
-    if (modelName.startsWith("gpt-5-mini")) {
-      this.inputPricePer1MToken = 0.25;
-      this.outputPricePer1MToken = 2;
-      this.cachedPricePer1MToken = 0.025;
-      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
-    } else if (modelName.startsWith("gpt-5-nano")) {
-      this.inputPricePer1MToken = 0.05;
-      this.outputPricePer1MToken = 0.4;
-      this.cachedPricePer1MToken = 5e-3;
-      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
-    } else if (modelName.startsWith("gpt-5.1")) {
-      this.inputPricePer1MToken = 1.25;
-      this.outputPricePer1MToken = 10;
-      this.cachedPricePer1MToken = 0.125;
-      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
-    } else if (modelName.startsWith("gpt-5")) {
-      this.inputPricePer1MToken = 1.25;
-      this.outputPricePer1MToken = 10;
-      this.cachedPricePer1MToken = 0.125;
-      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
-    }
-    throw new Error(`Model name ${modelName} is not supported for this pricing`);
-  }
-};
-
-// src/providers/openai/response-handler/function-calls.ts
-var FunctionCallsHandler = class extends ResponseHandler {
-  constructor(request, tools) {
+// src/domain/context-runtime/input/user-message.ts
+var UserMessage = class _UserMessage extends ContextItem {
+  constructor(content) {
     super();
-    this.request = request;
-    this.tools = tools;
-    this.client = new OpenAIDefaultClient();
-  }
-  hasToolCalls(response) {
-    var _a;
-    return (_a = response.output) == null ? void 0 : _a.some((item) => item.type === "function_call");
-  }
-  extractToolCalls(response) {
-    var _a;
-    return ((_a = response.output) == null ? void 0 : _a.filter((item) => item.type === "function_call")) || [];
+    this.type = "message";
+    this.role = "user";
+    this.content = content;
   }
-  resolveTool(call, tools) {
-    var _a;
-    return (_a = tools.find((t) => t.name === call.name)) != null ? _a : null;
+  static create(text) {
+    const content = InputText.create(text);
+    return new _UserMessage(content);
   }
-  async executeTool(tool, rawArgs) {
-    const args = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
-    return await tool.invoke(args);
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _UserMessage(content);
   }
-  formatToolResult(callId, payload) {
+  toJSON() {
     return {
-      type: "function_call_output",
-      call_id: callId,
-      output: JSON.stringify(payload)
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
     };
   }
-  async executeToolCalls(toolCalls, tools) {
-    var _a;
-    const results = [];
-    for (const call of toolCalls) {
-      const tool = this.resolveTool(call, tools);
-      if (!tool) {
-        results.push(
-          this.formatToolResult(call.call_id, {
-            error: `Unknown tool: ${call.name}`
-          })
-        );
-        continue;
-      }
-      try {
-        const result = await this.executeTool(tool, call.arguments);
-        results.push(this.formatToolResult(call.call_id, result));
-      } catch (err) {
-        results.push(
-          this.formatToolResult(call.call_id, {
-            error: (_a = err.message) != null ? _a : "Tool execution failed"
-          })
-        );
-      }
-    }
-    return results;
-  }
-  async handle(mozaikResponse) {
-    var _a, _b;
-    let providerResponse = mozaikResponse.providerResponse;
-    let toolCallingResponse;
-    while (this.hasToolCalls(providerResponse)) {
-      const toolCalls = this.extractToolCalls(providerResponse);
-      const toolResults = await this.executeToolCalls(toolCalls, this.tools);
-      this.request.input = toolResults;
-      this.request.previous_response_id = providerResponse.id;
-      toolCallingResponse = await this.client.send(this.request);
-      const openAIModelPricing = new OpenAIModelPricing();
-      const usage = toolCallingResponse.usage;
-      const totalCost = openAIModelPricing.getPriceInUsd(
-        providerResponse.model,
-        usage.input_tokens,
-        usage.output_tokens,
-        (_b = (_a = usage.input_token_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0
-      );
-      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, providerResponse.model));
-      mozaikResponse.setProviderResponse(toolCallingResponse);
-      mozaikResponse.setResponseData(toolCallingResponse);
-      providerResponse = toolCallingResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
 };
 
-// src/core/response.ts
-var MozaikResponse = class {
-  constructor() {
-    this.usageEntries = [];
-  }
-  setProviderResponse(providerResponse) {
-    this.providerResponse = providerResponse;
-    return this;
-  }
-  addUsageEntry(usageEntry) {
-    this.usageEntries.push(usageEntry);
-    return this;
-  }
-  setResponseData(response) {
-    this.responseData = response;
-    return this;
+// src/domain/context-runtime/input/developer-message.ts
+var DeveloperMessage = class _DeveloperMessage extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "developer";
+    this.content = content;
   }
-  getResponse() {
+  toJSON() {
     return {
-      data: this.responseData,
-      usage: {
-        entries: this.usageEntries
-      },
-      totalCost: this.usageEntries.reduce((acc, entry) => acc + entry.priceInUsd, 0)
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
     };
   }
-  getUsageEntries() {
-    return this.usageEntries;
+  static create(text) {
+    const content = InputText.create(text);
+    return new _DeveloperMessage(content);
   }
-};
-
-// src/providers/openai/response-handler/usage.ts
-var UsageHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    var _a, _b;
-    const providerResponse = mozaikResponse.providerResponse;
-    const usage = providerResponse.usage;
-    const openAIModelPricing = new OpenAIModelPricing();
-    const totalCost = openAIModelPricing.getPriceInUsd(
-      providerResponse.model,
-      usage.input_tokens,
-      usage.output_tokens,
-      (_b = (_a = usage.input_token_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0
-    );
-    mozaikResponse.addUsageEntry(new UsageEntry(totalCost, providerResponse.model));
-    return await this.nextHandler.handle(mozaikResponse);
+  static rehydrate(data) {
+    const content = InputText.rehydrate(data);
+    return new _DeveloperMessage(content);
   }
 };
 
-// src/providers/openai/endpoint.ts
-var OpenAIResponses = class extends Endpoint {
-  constructor() {
+// src/domain/context-runtime/content/output-text.ts
+var OutputText = class _OutputText extends Content {
+  constructor(text) {
     super();
-    this.requestBuilder = new OpenAIResponsesBuilder();
+    this.text = text;
+    this.type = "output_text";
   }
-  async sendRequest(mozaikRequest) {
-    try {
-      const request = this.buildRequest(mozaikRequest);
-      const client = OpenAIClientResolver.resolve(request);
-      const response = await client.send(request);
-      const mozaikResponse = new MozaikResponse();
-      mozaikResponse.setProviderResponse(response);
-      const usageHandler = new UsageHandler();
-      const functionCallsHandler = new FunctionCallsHandler(
-        request,
-        mozaikRequest.tools ? mozaikRequest.tools : []
-      );
-      const outputParsedHandler = new OutputParsedHandler();
-      const outputTextHandler = new OutputTextHandler();
-      const contentHandler = new ContentHandler();
-      usageHandler.setNextHandler(functionCallsHandler).setNextHandler(outputParsedHandler).setNextHandler(outputTextHandler).setNextHandler(contentHandler);
-      const responseHandler = usageHandler;
-      const result = await responseHandler.handle(mozaikResponse);
-      return result.getResponse();
-    } catch (error) {
-      console.warn("[OpenAIProvider] Responses API request failed:", error);
-      throw error;
-    }
-  }
-};
-
-// src/providers/anthropic/mapper.ts
-var AnthropicMapper = class {
-  /**
-   * Transforms domain messages to Anthropic API format.
-   * Separates system messages from conversation messages.
-   */
-  toMessages(messages) {
-    const anthropicMessages = [];
-    let systemPrompt;
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        const content = typeof msg.content === "string" ? msg.content : msg.content.map((p) => p.text).join("\n");
-        systemPrompt = systemPrompt ? `${systemPrompt}
-
-${content}` : content;
-        continue;
-      }
-      if (msg.role === "tool") {
-        continue;
-      }
-      if (msg.role === "user" || msg.role === "assistant") {
-        if (typeof msg.content === "string") {
-          anthropicMessages.push({
-            role: msg.role,
-            content: msg.content
-          });
-        } else {
-          const contentBlocks = msg.content.map((part) => {
-            if (part.type === "text") {
-              return {
-                type: "text",
-                text: part.text
-              };
-            } else if (part.type === "image_url") {
-              const imageUrl = part.url;
-              if (imageUrl.startsWith("data:image")) {
-                const matches = imageUrl.match(/data:image\/(\w+);base64,(.+)/);
-                if (matches) {
-                  const [, mediaType, data] = matches;
-                  return {
-                    type: "image",
-                    source: {
-                      type: "base64",
-                      media_type: `image/${mediaType}`,
-                      data
-                    }
-                  };
-                }
-              }
-              throw new Error(
-                "[AnthropicMapper] Image URLs must be base64-encoded. Convert to data:image/[type];base64,[data] format."
-              );
-            }
-            return { type: "text", text: "" };
-          });
-          anthropicMessages.push({
-            role: msg.role,
-            content: contentBlocks
-          });
-        }
-      }
-    }
-    const validated = this.ensureAlternatingRoles(anthropicMessages);
-    return {
-      messages: validated,
-      system: systemPrompt
-    };
+  static rehydrate(data) {
+    return new _OutputText(data.text);
   }
-  /**
-   * Ensures messages alternate between user and assistant roles.
-   * Anthropic API requires this constraint.
-   */
-  ensureAlternatingRoles(messages) {
-    if (messages.length === 0) return messages;
-    const result = [];
-    let lastRole;
-    for (const msg of messages) {
-      if (lastRole === msg.role && result.length > 0) {
-        const lastMsg = result[result.length - 1];
-        if (typeof lastMsg.content === "string" && typeof msg.content === "string") {
-          lastMsg.content = `${lastMsg.content}
-${msg.content}`;
-        } else {
-          const lastContent = Array.isArray(lastMsg.content) ? lastMsg.content : [{ type: "text", text: lastMsg.content }];
-          const newContent = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
-          lastMsg.content = [...lastContent, ...newContent];
-        }
-      } else {
-        result.push(msg);
-        lastRole = msg.role;
+  toJSON() {
+    return [
+      {
+        type: this.type,
+        text: this.text
       }
-    }
-    if (result.length > 0 && result[0].role !== "user") {
-      throw new Error(
-        "[AnthropicMapper] First message must be from user. Anthropic API requires conversations to start with a user message."
-      );
-    }
-    return result;
+    ];
   }
 };
 
-// src/providers/anthropic/builder.ts
-var import_zod2 = require("@anthropic-ai/sdk/helpers/beta/zod");
-var AnthropicRequestBuilder = class extends RequestBuilder {
-  constructor() {
-    super(...arguments);
-    this.mapper = new AnthropicMapper();
-  }
-  addModel(model) {
-    this.request.model = ANTHROPIC_MODEL_MAP[model];
-    return this;
-  }
-  addTask(task) {
-    const message = {
-      role: "user",
-      content: task
-    };
-    if (!this.request.messages) {
-      this.request.messages = [];
-    }
-    this.request.messages.push(message);
-    return this;
-  }
-  addMessages(messages) {
-    const { messages: anthropicMessages, system } = this.mapper.toMessages(messages);
-    this.request.messages = anthropicMessages;
-    if (system) {
-      this.request.system = system;
-    }
-    return this;
-  }
-  addStructuredOutput(schema) {
-    this.request.betas = ["structured-outputs-2025-11-13"];
-    this.request.output_format = (0, import_zod2.betaZodOutputFormat)(schema);
-    return this;
+// src/domain/context-runtime/output/model-message.ts
+var ModelMessage = class _ModelMessage extends ContextItem {
+  constructor(content) {
+    super();
+    this.type = "message";
+    this.role = "assistant";
+    this.content = content;
   }
-  addTools(tools) {
-    this.request.tools = tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      input_schema: tool.schema
-    }));
-    return this;
+  static rehydrate(data) {
+    const content = OutputText.rehydrate(data);
+    return new _ModelMessage(content);
   }
-  addReasoningEffort(effort) {
-    let reasoningEffort = "";
-    if (effort === "none" /* NONE */) {
-      return this;
-    } else if (effort === "low" /* LOW */) {
-      reasoningEffort = "low";
-    } else if (effort === "medium" /* MEDIUM */) {
-      reasoningEffort = "medium";
-    } else if (effort === "high" /* HIGH */) {
-      reasoningEffort = "high";
-    } else if (effort === "max" /* MAX */) {
-      reasoningEffort = "max";
-    }
-    this.request.output_config = {
-      effort: reasoningEffort
+  toJSON() {
+    return {
+      type: this.type,
+      role: this.role,
+      content: this.content.toJSON()
     };
-    return this;
-  }
-  build() {
-    if (!this.request.max_tokens) {
-      this.request.max_tokens = 1024;
-    }
-    return this.request;
-  }
-};
-
-// src/providers/anthropic/client/default.ts
-var import_sdk = __toESM(require("@anthropic-ai/sdk"));
-var AnthropicDefaultClient = class {
-  constructor(client = new import_sdk.default()) {
-    this.client = client;
-  }
-  async send(request) {
-    return await this.client.messages.create(request);
-  }
-};
-
-// src/providers/anthropic/client/parser.ts
-var import_sdk2 = __toESM(require("@anthropic-ai/sdk"));
-var AnthropicParserClient = class {
-  constructor(client = new import_sdk2.default()) {
-    this.client = client;
-  }
-  async send(request) {
-    return await this.client.beta.messages.parse(request);
-  }
-};
-
-// src/providers/anthropic/client/resolver.ts
-var AnthropicClientResolver = class {
-  static resolve(request) {
-    return request.output_format ? new AnthropicParserClient() : new AnthropicDefaultClient();
   }
 };
 
-// src/providers/anthropic/response-handler/parsed-output.ts
-var ParsedOutputHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    const providerResponse = mozaikResponse.providerResponse;
-    if (providerResponse.parsed_output) {
-      mozaikResponse.setResponseData(providerResponse.parsed_output);
-      return mozaikResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
-};
-
-// src/providers/anthropic/response-handler/content.ts
-var ContentHandler2 = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    const providerResponse = mozaikResponse.providerResponse;
-    const content = providerResponse.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("");
-    if (content) {
-      mozaikResponse.setResponseData(content);
-      return mozaikResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
-};
-
-// src/providers/anthropic/model-pricing.ts
-var AnthropicModelPricing = class {
-  calculateTotalCost(inputTokens, outputTokens) {
-    const inputCost = inputTokens * this.inputPricePer1MToken / 1e6;
-    const outputCost = outputTokens * this.outputPricePer1MToken / 1e6;
-    return inputCost + outputCost;
-  }
-  getPriceInUsd(modelName, inputTokens, outputTokens) {
-    if (modelName.startsWith("claude-sonnet-4-5")) {
-      this.inputPricePer1MToken = 3;
-      this.outputPricePer1MToken = 15;
-      return this.calculateTotalCost(inputTokens, outputTokens);
-    } else if (modelName.startsWith("claude-haiku-4-5")) {
-      this.inputPricePer1MToken = 1;
-      this.outputPricePer1MToken = 5;
-      return this.calculateTotalCost(inputTokens, outputTokens);
-    } else if (modelName.startsWith("claude-opus-4-5")) {
-      this.inputPricePer1MToken = 5;
-      this.outputPricePer1MToken = 25;
-      return this.calculateTotalCost(inputTokens, outputTokens);
-    }
-    throw new Error(`Model name ${modelName} is not supported for this pricing`);
-  }
-};
-
-// src/providers/anthropic/response-handler/tool-use.ts
-var ToolUseHandler = class extends ResponseHandler {
-  constructor(request, tools) {
+// src/domain/context-runtime/output/function-call.ts
+var FunctionCall = class _FunctionCall extends ContextItem {
+  constructor(callId, name, args) {
     super();
-    this.tools = tools;
-    this.request = request;
-    this.client = new AnthropicDefaultClient();
-  }
-  async executeToolCalls(tools, toolUseBlocks) {
-    const results = [];
-    for (const toolUse of toolUseBlocks) {
-      const tool = tools == null ? void 0 : tools.find((t) => t.name === toolUse.name);
-      if (!tool) {
-        results.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: JSON.stringify({ error: `Unknown tool: ${toolUse.name}` })
-        });
-        continue;
-      }
-      try {
-        const result = await tool.invoke(toolUse.input);
-        results.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: JSON.stringify(result)
-        });
-      } catch (error) {
-        results.push({
-          type: "tool_result",
-          tool_use_id: toolUse.id,
-          content: JSON.stringify({ error: error.message })
-        });
-      }
-    }
-    return results;
-  }
-  async handle(mozaikResponse) {
-    let providerResponse = mozaikResponse.providerResponse;
-    while (providerResponse.stop_reason === "tool_use") {
-      const toolUseBlocks = providerResponse.content.filter(
-        (block) => block.type === "tool_use"
-      );
-      this.request.messages.push({
-        role: "assistant",
-        content: providerResponse.content
-      });
-      const toolResults = await this.executeToolCalls(this.tools, toolUseBlocks);
-      this.request.messages.push({
-        role: "user",
-        content: toolResults
-      });
-      const toolCallingResponse = await this.client.send(this.request);
-      const usage = toolCallingResponse.usage;
-      const anthropicModelPricing = new AnthropicModelPricing();
-      const totalCost = anthropicModelPricing.getPriceInUsd(
-        providerResponse.model,
-        usage.input_tokens,
-        usage.output_tokens
-      );
-      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, toolCallingResponse.model.name));
-      mozaikResponse.setProviderResponse(toolCallingResponse);
-      providerResponse = toolCallingResponse;
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
-};
-
-// src/providers/anthropic/response-handler/usage.ts
-var UsageHandler2 = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    const providerResponse = mozaikResponse.providerResponse;
-    const usage = providerResponse.usage;
-    const anthropicModelPricing = new AnthropicModelPricing();
-    const totalCost = anthropicModelPricing.getPriceInUsd(
-      providerResponse.model,
-      usage.input_tokens,
-      usage.output_tokens
-    );
-    if (usage) {
-      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, providerResponse.model));
-    }
-    return await this.nextHandler.handle(mozaikResponse);
-  }
-};
-
-// src/providers/anthropic/response-handler/undhandled.ts
-var UnhandledResponseHandler = class extends ResponseHandler {
-  async handle(mozaikResponse) {
-    var _a, _b;
-    const providerResponse = mozaikResponse.providerResponse;
-    const id = (_a = providerResponse == null ? void 0 : providerResponse.id) != null ? _a : "unknown";
-    const model = (_b = providerResponse == null ? void 0 : providerResponse.model) != null ? _b : "unknown";
-    throw new Error(`No response handler matched. response_id=${id} model=${model}`);
-  }
-};
-
-// src/providers/anthropic/endpoint.ts
-var AnthropicEndpoint = class extends Endpoint {
-  constructor() {
-    super(...arguments);
-    this.requestBuilder = new AnthropicRequestBuilder();
-  }
-  async sendRequest(mozaikRequest) {
-    const providerRequest = this.buildRequest(mozaikRequest);
-    const client = AnthropicClientResolver.resolve(providerRequest);
-    const response = await client.send(providerRequest);
-    const mozaikResponse = new MozaikResponse();
-    mozaikResponse.setProviderResponse(response);
-    const usageHandler = new UsageHandler2();
-    const toolUseHandler = new ToolUseHandler(
-      providerRequest,
-      mozaikRequest.tools ? mozaikRequest.tools : []
-    );
-    const parsedOutputHandler = new ParsedOutputHandler();
-    const contentHandler = new ContentHandler2();
-    const unhandledResponseHandler = new UnhandledResponseHandler();
-    usageHandler.setNextHandler(toolUseHandler).setNextHandler(parsedOutputHandler).setNextHandler(contentHandler).setNextHandler(unhandledResponseHandler);
-    const responseHandler = usageHandler;
-    const result = await responseHandler.handle(mozaikResponse);
-    return result.getResponse();
-  }
-};
-
-// src/providers/endpoint-resolver.ts
-var DefaultEndpointResolver = class extends EndpointResolver {
-  isOpenAIModel(value) {
-    return OPENAI_MODELS.includes(value);
-  }
-  isAnthropicModel(value) {
-    return ANTHROPIC_MODELS.includes(value);
-  }
-  resolve(model) {
-    if (this.isOpenAIModel(model)) {
-      return new OpenAIResponses();
-    } else if (this.isAnthropicModel(model)) {
-      return new AnthropicEndpoint();
-    }
-    throw new Error("Provider not found");
-  }
-};
-
-// src/core/agents/agent.ts
-var MozaikAgent = class {
-  constructor(request) {
-    this.gateway = new RequestGateway(new DefaultEndpointResolver());
-    this.request = request;
-  }
-  setModel(model) {
-    this.request.model = model;
-  }
-  setMessages(messages) {
-    this.request.messages = messages;
-  }
-  setTask(task) {
-    this.request.task = task;
-  }
-  setStructuredOutput(schema) {
-    this.request.structuredOutput = schema;
-  }
-  async act(task) {
-    if (task) {
-      this.request.task = task;
-    }
-    return await this.gateway.invoke(this.request);
-  }
-};
-
-// src/core/workflow/schema/plan.ts
-var import_zod3 = __toESM(require("zod"));
-var ModelSchema = import_zod3.default.enum([...OPENAI_MODELS, ...ANTHROPIC_MODELS]);
-var TaskPlanNodeSchema = import_zod3.default.object({
-  kind: import_zod3.default.literal("task"),
-  task: import_zod3.default.string(),
-  model: ModelSchema
-});
-var WorkflowPlanNodeSchema = import_zod3.default.lazy(
-  () => import_zod3.default.object({
-    kind: import_zod3.default.literal("workflow"),
-    mode: import_zod3.default.enum(["sequential", "parallel"]),
-    units: import_zod3.default.array(PlanNodeSchema)
-  })
-);
-var PlanNodeSchema = TaskPlanNodeSchema.or(WorkflowPlanNodeSchema);
-var PlanSchema = import_zod3.default.object({
-  root: PlanNodeSchema
-});
-
-// src/core/workflow/execution/parallel.ts
-var ParallelExecution = class {
-  async execute(workflow, hook) {
-    const promises = [];
-    for (const u of workflow.units) {
-      promises.push(u.execute(hook));
-    }
-    const results = await Promise.all(promises);
-    return results;
-  }
-};
-
-// src/core/workflow/execution/sequential.ts
-var SequentalExecution = class {
-  async execute(workflow, hook) {
-    const results = [];
-    for (const u of workflow.units) {
-      results.push(await u.execute(hook));
-    }
-    return results;
-  }
-};
-
-// src/core/workflow/execution/strategy-factory.ts
-var ExecutionStrategyFactory = class {
-  static create(mode) {
-    let strategy;
-    if (mode == "parallel") {
-      strategy = new ParallelExecution();
-    } else {
-      strategy = new SequentalExecution();
-    }
-    return strategy;
-  }
-};
-
-// src/core/workflow/hooks/cluster.ts
-var ClusterHook = class {
-  constructor(hooks) {
-    this.hooks = hooks;
-  }
-  beforeTask(task) {
-    this.hooks.forEach((h) => h.beforeTask(task));
-  }
-  afterTask(task, result) {
-    this.hooks.forEach((h) => h.afterTask(task, result));
+    this.type = "function_call";
+    this.callId = callId;
+    this.name = name;
+    this.args = args;
   }
-  beforeWorkflow(wf) {
-    this.hooks.forEach((h) => h.beforeWorkflow(wf));
+  static rehydrate(data) {
+    return new _FunctionCall(data.callId, data.name, data.args);
   }
-  afterWorkflow(wf, result) {
-    this.hooks.forEach((h) => h.afterWorkflow(wf, result));
+  toJSON() {
+    return {
+      type: this.type,
+      callId: this.callId,
+      name: this.name,
+      arguments: this.args
+    };
   }
 };
 
-// src/core/workflow/hooks/logger.ts
-var Logger = class {
-  beforeWorkflow(workflow) {
-    console.log(`[Workflow:start], Mode: ${workflow.mode}`);
-  }
-  afterWorkflow(workflow) {
-    console.log(`[Workflow:end], Mode: ${workflow.mode}`);
+// src/domain/context-runtime/output/reasoning.ts
+var Reasoning = class _Reasoning extends ContextItem {
+  constructor(content, encryptedContent, summary = []) {
+    super();
+    this.type = "reasoning";
+    this.content = content;
+    this.encryptedContent = encryptedContent;
+    this.summary = summary;
   }
-  beforeTask(task) {
-    console.log(`[Task:end]: Model: ${task.getModel()} Task: ${task.getTask()}`);
+  static rehydrate(data) {
+    return new _Reasoning(data.content, data.encryptedContent, data.summary);
   }
-  afterTask(task, result) {
-    console.log(`[Task:end]: Model: ${task.getModel()} Task: ${task.getTask()}`);
+  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/core/workflow/hooks/index.ts
-var loggingHook = new Logger();
-var defaultHooks = [loggingHook];
-var clusterHook = new ClusterHook(defaultHooks);
-var DEFAULT_CLUSTER_HOOK = clusterHook;
-
-// src/core/workflow/workflow.ts
-var Workflow = class extends WorkUnit {
-  constructor(mode, units) {
-    super();
-    this.mode = mode;
-    this.units = units;
-  }
-  async execute(hook = DEFAULT_CLUSTER_HOOK) {
-    hook.beforeWorkflow(this);
-    const executionStrategy = ExecutionStrategyFactory.create(this.mode);
-    const result = await executionStrategy.execute(this, hook);
-    hook.afterWorkflow(this, result);
-    return result;
+// src/domain/generative-model/generative-model.ts
+var GenerativeModel = class {
+  async call(context) {
+    const request = this.mapContextToRequest(context);
+    const response = await this.infer(request);
+    return this.extractContextItems(response);
   }
 };
 
-// src/core/workflow/task.ts
-var Task = class extends WorkUnit {
-  constructor(task, model) {
+// src/domain/context-runtime/input/function-call-output.ts
+var FunctionCallOutput = class _FunctionCallOutput extends ContextItem {
+  constructor(callId, output) {
     super();
-    this.task = task;
-    this.model = model;
+    this.type = "function_call_output";
+    this.callId = callId;
+    this.output = output;
   }
-  getTask() {
-    return this.task;
+  static create(callId, output) {
+    return new _FunctionCallOutput(callId, output);
   }
-  getModel() {
-    return this.model;
+  static rehydrate(data) {
+    return new _FunctionCallOutput(data.callId, data.output);
   }
-  async execute(hook = DEFAULT_CLUSTER_HOOK) {
-    hook.beforeTask(this);
-    const request = {
-      model: this.model,
-      task: this.task
+  toJSON() {
+    return {
+      type: this.type,
+      callId: this.callId,
+      output: this.output.map((o) => o.toJSON())
     };
-    const agent = new MozaikAgent(request);
-    const result = await agent.act(this.task);
-    hook.afterTask(this, result);
-    return result;
-  }
-};
-
-// src/core/workflow/mapper.ts
-var PlanWorkflowMapper = class {
-  static fromPlan(plan) {
-    return this.fromNode(plan.root);
-  }
-  static fromNode(node) {
-    if (node.kind !== "workflow") {
-      throw new Error("Root must be workflow");
-    }
-    return new Workflow(node.mode, node.units.map(this.mapNode));
-  }
-  static mapNode(node) {
-    if (node.kind === "task") {
-      return new Task(node.task, node.model);
-    }
-    return new Workflow(node.mode, node.units.map(this.mapNode));
-  }
-};
-
-// src/core/agents/planner.ts
-var PROMPT = `You are a planner.
-
-Rules:
-- Use 'parallel' for the task that can be run in parallel.
-- Pick model based on the task complexity
-- Keep prompts actionable.
-- Don't ask user for any input, just do the thing with available data you have.
-`;
-var PlanningAgent = class extends MozaikAgent {
-  constructor(request) {
-    super(request);
-  }
-  async planFromGoal(goal) {
-    this.setStructuredOutput(PlanSchema);
-    const response = await this.act(`${PROMPT}
-Goal: ${goal}`);
-    const plan = response.data;
-    return PlanWorkflowMapper.fromPlan(plan);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MozaikAgent,
-  PlanningAgent,
-  ReasoningEffort,
-  Task,
-  WorkUnit,
-  Workflow
+  Context,
+  ContextItem,
+  DeveloperMessage,
+  FunctionCall,
+  FunctionCallOutput,
+  GenerativeModel,
+  ModelMessage,
+  Reasoning,
+  UserMessage
 });
 //# sourceMappingURL=index.js.map