@mozaik-ai/core 0.7.0

package/dist/index.js

@@ -0,0 +1,1039 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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, {
+  Agent: () => Agent,
+  PlanningAgent: () => PlanningAgent,
+  Task: () => Task,
+  WorkUnit: () => WorkUnit,
+  Workflow: () => Workflow
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/workflow/work-unit.ts
+var WorkUnit = class {
+  constructor() {
+  }
+};
+
+// src/core/endpoint/request-gateway.ts
+var RequestGateway = class {
+  constructor(endpointResolver) {
+    this.endpointResolver = endpointResolver;
+  }
+  async invoke(command) {
+    this.endpoint = this.endpointResolver.resolve(command.model);
+    return await this.endpoint.sendRequest(command);
+  }
+};
+
+// 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"];
+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/command-handler/capability.ts
+var CapabilityHandler = class {
+  setNextHandler(capability) {
+    this.nextHandler = capability;
+    return this.nextHandler;
+  }
+  handle(command, builder) {
+    this.apply(command, builder);
+    if (this.nextHandler) {
+      this.nextHandler.handle(command, builder);
+    }
+  }
+};
+
+// src/core/command-handler/messages.ts
+var MessagesHandler = class extends CapabilityHandler {
+  apply(command, builder) {
+    if (command.messages) {
+      builder.addMessages(command.messages);
+    }
+  }
+};
+
+// src/core/command-handler/task.ts
+var TaskHandler = class extends CapabilityHandler {
+  apply(command, builder) {
+    if (command.task) {
+      builder.addTask(command.task);
+    }
+  }
+};
+
+// src/core/command-handler/model.ts
+var ModelHandler = class extends CapabilityHandler {
+  apply(command, builder) {
+    if (command.model) {
+      builder.addModel(command.model);
+    }
+  }
+};
+
+// src/core/command-handler/structured-output.ts
+var StructuredOutputlHandler = class extends CapabilityHandler {
+  apply(command, builder) {
+    if (command.structuredOutput) {
+      builder.addStructuredOutput(command.structuredOutput);
+    }
+  }
+};
+
+// src/core/command-handler/tools.ts
+var ToolsHandler = class extends CapabilityHandler {
+  apply(command, requestBuilder) {
+    if (command.tools && command.tools.length > 0) {
+      requestBuilder.addTools(command.tools);
+    }
+  }
+};
+
+// src/core/endpoint/endpoint.ts
+var Endpoint = class {
+  constructor() {
+    this.command = null;
+  }
+  buildRequest(command) {
+    this.command = command;
+    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(command, 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");
+var OpenAIResponsesBuilder = class extends RequestBuilder {
+  constructor(mapper = new OpenAIResponsesMapper()) {
+    super();
+    this.mapper = mapper;
+  }
+  addModel(model) {
+    this.request.model = model;
+    return this;
+  }
+  addTask(task) {
+    this.request.input = task;
+    return this;
+  }
+  addMessages(messages) {
+    const instructions = this.mapper.toInstructions(messages);
+    if (instructions && instructions !== "You are a helpful assistant.") {
+      this.request.instructions = instructions;
+    }
+    return this;
+  }
+  addStructuredOutput(schema) {
+    this.request.text = {
+      format: (0, import_zod.zodTextFormat)(schema, "outputSchema")
+    };
+    return this;
+  }
+  addTools(tools) {
+    this.request.tools = tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.schema
+    }));
+    return this;
+  }
+};
+
+// 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/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/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/core/endpoint/response-handler.ts
+var ResponseHandler = class {
+  setNextHandler(responseHandler) {
+    this.nextHandler = responseHandler;
+    return this.nextHandler;
+  }
+};
+
+// src/providers/openai/response-handler/output-parsed.ts
+var OutputParsedHandler = class extends ResponseHandler {
+  async handle(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    if (providerResponse.output_parsed) {
+      responseContext.setResponse(providerResponse.output_parsed);
+      return responseContext;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/openai/response-handler/content.ts
+var ContentHandler = class extends ResponseHandler {
+  async handle(responseContext) {
+    var _a, _b;
+    const providerResponse = responseContext.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) {
+        responseContext.setResponse(firstContent.text);
+        return responseContext;
+      }
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/openai/response-handler/output-text.ts
+var OutputTextHandler = class extends ResponseHandler {
+  async handle(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    if (providerResponse.output_text) {
+      responseContext.setResponse(providerResponse.output_text);
+      return responseContext;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/core/endpoint/usage.ts
+var UsageEntry = class {
+  constructor(inputTokens, outputTokens, model) {
+    this.inputTokens = inputTokens;
+    this.outputTokens = outputTokens;
+    this.model = model;
+    this.totalTokens = inputTokens + outputTokens;
+  }
+};
+
+// src/providers/openai/response-handler/function-calls.ts
+var FunctionCallsHandler = class extends ResponseHandler {
+  constructor(request, tools) {
+    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")) || [];
+  }
+  resolveTool(call, tools) {
+    var _a;
+    return (_a = tools.find((t) => t.name === call.name)) != null ? _a : null;
+  }
+  async executeTool(tool, rawArgs) {
+    const args = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
+    return await tool.invoke(args);
+  }
+  formatToolResult(callId, payload) {
+    return {
+      type: "function_call_output",
+      call_id: callId,
+      output: JSON.stringify(payload)
+    };
+  }
+  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(responseContext) {
+    let providerResponse = responseContext.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);
+      responseContext.addUsageEntry(
+        new UsageEntry(
+          toolCallingResponse.usage.input_tokens,
+          toolCallingResponse.usage.output_tokens,
+          toolCallingResponse.model
+        )
+      );
+      responseContext.setProviderResponse(toolCallingResponse);
+      responseContext.setResponse(toolCallingResponse);
+      providerResponse = toolCallingResponse;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/core/endpoint/response-context.ts
+var ResponseContext = class {
+  constructor() {
+    this.usageEntries = [];
+  }
+  setProviderResponse(providerResponse) {
+    this.providerResponse = providerResponse;
+    return this;
+  }
+  addUsageEntry(usageEntry) {
+    this.usageEntries.push(usageEntry);
+    return this;
+  }
+  setResponse(response) {
+    this.response = response;
+    return this;
+  }
+};
+
+// src/providers/openai/response-handler/usage.ts
+var UsageHandler = class extends ResponseHandler {
+  async handle(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    const usage = providerResponse.usage;
+    if (usage) {
+      responseContext.addUsageEntry(
+        new UsageEntry(usage.input_tokens, usage.output_tokens, providerResponse.model)
+      );
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/openai/endpoint.ts
+var OpenAIResponses = class extends Endpoint {
+  constructor() {
+    super();
+    this.requestBuilder = new OpenAIResponsesBuilder();
+  }
+  async sendRequest(command) {
+    try {
+      const request = this.buildRequest(command);
+      const client = OpenAIClientResolver.resolve(request);
+      const response = await client.send(request);
+      const responseContext = new ResponseContext();
+      responseContext.setProviderResponse(response);
+      const usageHandler = new UsageHandler();
+      const functionCallsHandler = new FunctionCallsHandler(
+        request,
+        command.tools ? command.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;
+      return await responseHandler.handle(responseContext);
+    } 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
+    };
+  }
+  /**
+   * 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;
+      }
+    }
+    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;
+  }
+  addTools(tools) {
+    this.request.tools = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.schema
+    }));
+    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(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    if (providerResponse.parsed_output) {
+      responseContext.setResponse(providerResponse.parsed_output);
+      return responseContext;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/anthropic/response-handler/content.ts
+var ContentHandler2 = class extends ResponseHandler {
+  async handle(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    const content = providerResponse.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("");
+    if (content) {
+      responseContext.setResponse(content);
+      return responseContext;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/anthropic/response-handler/tool-use.ts
+var ToolUseHandler = class extends ResponseHandler {
+  constructor(request, tools) {
+    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(responseContext) {
+    let providerResponse = responseContext.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);
+      responseContext.addUsageEntry(
+        new UsageEntry(
+          toolCallingResponse.usage.input_tokens,
+          toolCallingResponse.usage.output_tokens,
+          toolCallingResponse.model
+        )
+      );
+      responseContext.setProviderResponse(toolCallingResponse);
+      providerResponse = toolCallingResponse;
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/anthropic/response-handler/usage.ts
+var UsageHandler2 = class extends ResponseHandler {
+  async handle(responseContext) {
+    const providerResponse = responseContext.providerResponse;
+    const usage = providerResponse.usage;
+    if (usage) {
+      responseContext.addUsageEntry(
+        new UsageEntry(usage.input_tokens, usage.output_tokens, providerResponse.model)
+      );
+    }
+    return await this.nextHandler.handle(responseContext);
+  }
+};
+
+// src/providers/anthropic/response-handler/undhandled.ts
+var UnhandledResponseHandler = class extends ResponseHandler {
+  async handle(responseContext) {
+    var _a, _b;
+    const providerResponse = responseContext.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(command) {
+    const request = this.buildRequest(command);
+    const client = AnthropicClientResolver.resolve(request);
+    const response = await client.send(request);
+    const responseContext = new ResponseContext();
+    responseContext.setProviderResponse(response);
+    const usageHandler = new UsageHandler2();
+    const toolUseHandler = new ToolUseHandler(request, command.tools ? command.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;
+    return await responseHandler.handle(responseContext);
+  }
+};
+
+// 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 Agent = class {
+  constructor(command) {
+    this.gateway = new RequestGateway(new DefaultEndpointResolver());
+    this.command = command;
+  }
+  setModel(model) {
+    this.command.model = model;
+  }
+  setMessages(messages) {
+    this.command.messages = messages;
+  }
+  setTask(task) {
+    this.command.task = task;
+  }
+  setStructuredOutput(schema) {
+    this.command.structuredOutput = schema;
+  }
+  async act(task) {
+    if (task) {
+      this.command.task = task;
+    }
+    return await this.gateway.invoke(this.command);
+  }
+};
+
+// 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));
+  }
+  beforeWorkflow(wf) {
+    this.hooks.forEach((h) => h.beforeWorkflow(wf));
+  }
+  afterWorkflow(wf, result) {
+    this.hooks.forEach((h) => h.afterWorkflow(wf, result));
+  }
+};
+
+// 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}`);
+  }
+  beforeTask(task) {
+    console.log(`[Task:end]: Model: ${task.getModel()} Task: ${task.getTask()}`);
+  }
+  afterTask(task, result) {
+    console.log(`[Task:end]: Model: ${task.getModel()} Task: ${task.getTask()}`);
+  }
+};
+
+// 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/core/workflow/task.ts
+var Task = class extends WorkUnit {
+  constructor(task, model) {
+    super();
+    this.task = task;
+    this.model = model;
+  }
+  getTask() {
+    return this.task;
+  }
+  getModel() {
+    return this.model;
+  }
+  async execute(hook = DEFAULT_CLUSTER_HOOK) {
+    hook.beforeTask(this);
+    const command = {
+      model: this.model,
+      task: this.task
+    };
+    const agent = new Agent(command);
+    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 Agent {
+  constructor(command) {
+    super(command);
+  }
+  async planFromGoal(goal) {
+    this.setStructuredOutput(PlanSchema);
+    const plan = await this.act(`${PROMPT}
+Goal: ${goal}`);
+    return PlanWorkflowMapper.fromPlan(plan);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Agent,
+  PlanningAgent,
+  Task,
+  WorkUnit,
+  Workflow
+});
+//# sourceMappingURL=index.js.map