@mozaik-ai/core 0.7.1 → 0.8.0

package/dist/index.mjs

@@ -9,9 +9,9 @@ var RequestGateway = class {
   constructor(endpointResolver) {
     this.endpointResolver = endpointResolver;
   }
-  async invoke(command) {
-    this.endpoint = this.endpointResolver.resolve(command.model);
-    return await this.endpoint.sendRequest(command);
+  async invoke(request) {
+    this.endpoint = this.endpointResolver.resolve(request.model);
+    return await this.endpoint.sendRequest(request);
   }
 };
 
@@ -37,55 +37,55 @@ var CapabilityHandler = class {
     this.nextHandler = capability;
     return this.nextHandler;
   }
-  handle(command, builder) {
-    this.apply(command, builder);
+  handle(request, builder) {
+    this.apply(request, builder);
     if (this.nextHandler) {
-      this.nextHandler.handle(command, builder);
+      this.nextHandler.handle(request, builder);
     }
   }
 };
 
 // src/core/command-handler/messages.ts
 var MessagesHandler = class extends CapabilityHandler {
-  apply(command, builder) {
-    if (command.messages) {
-      builder.addMessages(command.messages);
+  apply(request, builder) {
+    if (request.messages) {
+      builder.addMessages(request.messages);
     }
   }
 };
 
 // src/core/command-handler/task.ts
 var TaskHandler = class extends CapabilityHandler {
-  apply(command, builder) {
-    if (command.task) {
-      builder.addTask(command.task);
+  apply(request, builder) {
+    if (request.task) {
+      builder.addTask(request.task);
     }
   }
 };
 
 // src/core/command-handler/model.ts
 var ModelHandler = class extends CapabilityHandler {
-  apply(command, builder) {
-    if (command.model) {
-      builder.addModel(command.model);
+  apply(request, builder) {
+    if (request.model) {
+      builder.addModel(request.model);
     }
   }
 };
 
 // src/core/command-handler/structured-output.ts
 var StructuredOutputlHandler = class extends CapabilityHandler {
-  apply(command, builder) {
-    if (command.structuredOutput) {
-      builder.addStructuredOutput(command.structuredOutput);
+  apply(request, builder) {
+    if (request.structuredOutput) {
+      builder.addStructuredOutput(request.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);
+  apply(mozaikRequest, requestBuilder) {
+    if (mozaikRequest.tools && mozaikRequest.tools.length > 0) {
+      requestBuilder.addTools(mozaikRequest.tools);
     }
   }
 };
@@ -93,10 +93,10 @@ var ToolsHandler = class extends CapabilityHandler {
 // src/core/endpoint/endpoint.ts
 var Endpoint = class {
   constructor() {
-    this.command = null;
+    this.request = null;
   }
-  buildRequest(command) {
-    this.command = command;
+  buildRequest(request) {
+    this.request = request;
     this.requestBuilder.initialize();
     const messagesHandler = new MessagesHandler();
     const taskHandler = new TaskHandler();
@@ -104,7 +104,7 @@ var Endpoint = class {
     const structuredOutputHandler = new StructuredOutputlHandler();
     const toolsHandler = new ToolsHandler();
     messagesHandler.setNextHandler(taskHandler).setNextHandler(modelHandler).setNextHandler(structuredOutputHandler).setNextHandler(toolsHandler);
-    messagesHandler.handle(command, this.requestBuilder);
+    messagesHandler.handle(request, this.requestBuilder);
     return this.requestBuilder.build();
   }
 };
@@ -254,7 +254,7 @@ var OutputParsedHandler = class extends ResponseHandler {
   async handle(responseContext) {
     const providerResponse = responseContext.providerResponse;
     if (providerResponse.output_parsed) {
-      responseContext.setResponse(providerResponse.output_parsed);
+      responseContext.setResponseData(providerResponse.output_parsed);
       return responseContext;
     }
     return await this.nextHandler.handle(responseContext);
@@ -263,40 +263,72 @@ var OutputParsedHandler = class extends ResponseHandler {
 
 // src/providers/openai/response-handler/content.ts
 var ContentHandler = class extends ResponseHandler {
-  async handle(responseContext) {
+  async handle(mozaikResponse) {
     var _a, _b;
-    const providerResponse = responseContext.providerResponse;
+    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) {
-        responseContext.setResponse(firstContent.text);
-        return responseContext;
+        mozaikResponse.setResponseData(firstContent.text);
+        return mozaikResponse;
       }
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
 // src/providers/openai/response-handler/output-text.ts
 var OutputTextHandler = class extends ResponseHandler {
-  async handle(responseContext) {
-    const providerResponse = responseContext.providerResponse;
+  async handle(mozaikResponse) {
+    const providerResponse = mozaikResponse.providerResponse;
     if (providerResponse.output_text) {
-      responseContext.setResponse(providerResponse.output_text);
-      return responseContext;
+      mozaikResponse.setResponseData(providerResponse.output_text);
+      return mozaikResponse;
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
-// src/core/endpoint/usage.ts
+// src/core/usage-entry.ts
 var UsageEntry = class {
-  constructor(inputTokens, outputTokens, model) {
-    this.inputTokens = inputTokens;
-    this.outputTokens = outputTokens;
+  constructor(priceInUsd, model) {
+    this.priceInUsd = priceInUsd;
     this.model = model;
-    this.totalTokens = inputTokens + outputTokens;
+  }
+};
+
+// 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 === "gpt-5") {
+      this.inputPricePer1MToken = 1.25;
+      this.outputPricePer1MToken = 10;
+      this.cachedPricePer1MToken = 0.125;
+      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
+    } else if (modelName === "gpt-5-mini") {
+      this.inputPricePer1MToken = 0.25;
+      this.outputPricePer1MToken = 2;
+      this.cachedPricePer1MToken = 0.025;
+      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
+    } else if (modelName === "gpt-5-nano") {
+      this.inputPricePer1MToken = 0.05;
+      this.outputPricePer1MToken = 0.4;
+      this.cachedPricePer1MToken = 5e-3;
+      return this.calculateTotalCost(inputTokens, outputTokens, cachedInputTokens);
+    } else if (modelName === "gpt-5.1") {
+      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`);
   }
 };
 
@@ -357,8 +389,9 @@ var FunctionCallsHandler = class extends ResponseHandler {
     }
     return results;
   }
-  async handle(responseContext) {
-    let providerResponse = responseContext.providerResponse;
+  async handle(mozaikResponse) {
+    var _a, _b;
+    let providerResponse = mozaikResponse.providerResponse;
     let toolCallingResponse;
     while (this.hasToolCalls(providerResponse)) {
       const toolCalls = this.extractToolCalls(providerResponse);
@@ -366,23 +399,25 @@ var FunctionCallsHandler = class extends ResponseHandler {
       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
-        )
+      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
       );
-      responseContext.setProviderResponse(toolCallingResponse);
-      responseContext.setResponse(toolCallingResponse);
+      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, providerResponse.model));
+      mozaikResponse.setProviderResponse(toolCallingResponse);
+      mozaikResponse.setResponseData(toolCallingResponse);
       providerResponse = toolCallingResponse;
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
-// src/core/endpoint/response-context.ts
-var ResponseContext = class {
+// src/core/response.ts
+var MozaikResponse = class {
   constructor() {
     this.usageEntries = [];
   }
@@ -394,23 +429,39 @@ var ResponseContext = class {
     this.usageEntries.push(usageEntry);
     return this;
   }
-  setResponse(response) {
-    this.response = response;
+  setResponseData(response) {
+    this.responseData = response;
     return this;
   }
+  getResponse() {
+    return {
+      data: this.responseData,
+      usage: {
+        entries: this.usageEntries
+      },
+      totalCost: this.usageEntries.reduce((acc, entry) => acc + entry.priceInUsd, 0)
+    };
+  }
+  getUsageEntries() {
+    return this.usageEntries;
+  }
 };
 
 // src/providers/openai/response-handler/usage.ts
 var UsageHandler = class extends ResponseHandler {
-  async handle(responseContext) {
-    const providerResponse = responseContext.providerResponse;
+  async handle(mozaikResponse) {
+    var _a, _b;
+    const providerResponse = mozaikResponse.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);
+    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);
   }
 };
 
@@ -425,8 +476,8 @@ var OpenAIResponses = class extends Endpoint {
       const request = this.buildRequest(command);
       const client = OpenAIClientResolver.resolve(request);
       const response = await client.send(request);
-      const responseContext = new ResponseContext();
-      responseContext.setProviderResponse(response);
+      const mozaikResponse = new MozaikResponse();
+      mozaikResponse.setProviderResponse(response);
       const usageHandler = new UsageHandler();
       const functionCallsHandler = new FunctionCallsHandler(
         request,
@@ -437,7 +488,8 @@ var OpenAIResponses = class extends Endpoint {
       const contentHandler = new ContentHandler();
       usageHandler.setNextHandler(functionCallsHandler).setNextHandler(outputParsedHandler).setNextHandler(outputTextHandler).setNextHandler(contentHandler);
       const responseHandler = usageHandler;
-      return await responseHandler.handle(responseContext);
+      const result = await responseHandler.handle(mozaikResponse);
+      return result.getResponse();
     } catch (error) {
       console.warn("[OpenAIProvider] Responses API request failed:", error);
       throw error;
@@ -628,26 +680,51 @@ var AnthropicClientResolver = class {
 
 // src/providers/anthropic/response-handler/parsed-output.ts
 var ParsedOutputHandler = class extends ResponseHandler {
-  async handle(responseContext) {
-    const providerResponse = responseContext.providerResponse;
+  async handle(mozaikResponse) {
+    const providerResponse = mozaikResponse.providerResponse;
     if (providerResponse.parsed_output) {
-      responseContext.setResponse(providerResponse.parsed_output);
-      return responseContext;
+      mozaikResponse.setResponseData(providerResponse.parsed_output);
+      return mozaikResponse;
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
 // src/providers/anthropic/response-handler/content.ts
 var ContentHandler2 = class extends ResponseHandler {
-  async handle(responseContext) {
-    const providerResponse = responseContext.providerResponse;
+  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) {
-      responseContext.setResponse(content);
-      return responseContext;
+      mozaikResponse.setResponseData(content);
+      return mozaikResponse;
     }
-    return await this.nextHandler.handle(responseContext);
+    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 === "claude-sonnet-4.5") {
+      this.inputPricePer1MToken = 3;
+      this.outputPricePer1MToken = 15;
+      return this.calculateTotalCost(inputTokens, outputTokens);
+    } else if (modelName === "claude-haiku-4.5") {
+      this.inputPricePer1MToken = 1;
+      this.outputPricePer1MToken = 5;
+      return this.calculateTotalCost(inputTokens, outputTokens);
+    } else if (modelName === "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`);
   }
 };
 
@@ -688,8 +765,8 @@ var ToolUseHandler = class extends ResponseHandler {
     }
     return results;
   }
-  async handle(responseContext) {
-    let providerResponse = responseContext.providerResponse;
+  async handle(mozaikResponse) {
+    let providerResponse = mozaikResponse.providerResponse;
     while (providerResponse.stop_reason === "tool_use") {
       const toolUseBlocks = providerResponse.content.filter(
         (block) => block.type === "tool_use"
@@ -704,39 +781,44 @@ var ToolUseHandler = class extends ResponseHandler {
         content: toolResults
       });
       const toolCallingResponse = await this.client.send(this.request);
-      responseContext.addUsageEntry(
-        new UsageEntry(
-          toolCallingResponse.usage.input_tokens,
-          toolCallingResponse.usage.output_tokens,
-          toolCallingResponse.model
-        )
+      const usage = toolCallingResponse.usage;
+      const anthropicModelPricing = new AnthropicModelPricing();
+      const totalCost = anthropicModelPricing.getPriceInUsd(
+        providerResponse.model,
+        usage.input_tokens,
+        usage.output_tokens
       );
-      responseContext.setProviderResponse(toolCallingResponse);
+      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, toolCallingResponse.model.name));
+      mozaikResponse.setProviderResponse(toolCallingResponse);
       providerResponse = toolCallingResponse;
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
 // src/providers/anthropic/response-handler/usage.ts
 var UsageHandler2 = class extends ResponseHandler {
-  async handle(responseContext) {
-    const providerResponse = responseContext.providerResponse;
+  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) {
-      responseContext.addUsageEntry(
-        new UsageEntry(usage.input_tokens, usage.output_tokens, providerResponse.model)
-      );
+      mozaikResponse.addUsageEntry(new UsageEntry(totalCost, providerResponse.model));
     }
-    return await this.nextHandler.handle(responseContext);
+    return await this.nextHandler.handle(mozaikResponse);
   }
 };
 
 // src/providers/anthropic/response-handler/undhandled.ts
 var UnhandledResponseHandler = class extends ResponseHandler {
-  async handle(responseContext) {
+  async handle(mozaikResponse) {
     var _a, _b;
-    const providerResponse = responseContext.providerResponse;
+    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}`);
@@ -749,20 +831,24 @@ var AnthropicEndpoint = class extends Endpoint {
     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);
+  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(request, command.tools ? command.tools : []);
+    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;
-    return await responseHandler.handle(responseContext);
+    const result = await responseHandler.handle(mozaikResponse);
+    return result.getResponse();
   }
 };
 
@@ -785,28 +871,28 @@ var DefaultEndpointResolver = class extends EndpointResolver {
 };
 
 // src/core/agents/agent.ts
-var Agent = class {
-  constructor(command) {
+var MozaikAgent = class {
+  constructor(request) {
     this.gateway = new RequestGateway(new DefaultEndpointResolver());
-    this.command = command;
+    this.request = request;
   }
   setModel(model) {
-    this.command.model = model;
+    this.request.model = model;
   }
   setMessages(messages) {
-    this.command.messages = messages;
+    this.request.messages = messages;
   }
   setTask(task) {
-    this.command.task = task;
+    this.request.task = task;
   }
   setStructuredOutput(schema) {
-    this.command.structuredOutput = schema;
+    this.request.structuredOutput = schema;
   }
   async act(task) {
     if (task) {
-      this.command.task = task;
+      this.request.task = task;
     }
-    return await this.gateway.invoke(this.command);
+    return await this.gateway.invoke(this.request);
   }
 };
 
@@ -938,11 +1024,11 @@ var Task = class extends WorkUnit {
   }
   async execute(hook = DEFAULT_CLUSTER_HOOK) {
     hook.beforeTask(this);
-    const command = {
+    const request = {
       model: this.model,
       task: this.task
     };
-    const agent = new Agent(command);
+    const agent = new MozaikAgent(request);
     const result = await agent.act(this.task);
     hook.afterTask(this, result);
     return result;
@@ -977,9 +1063,9 @@ Rules:
 - 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);
+var PlanningAgent = class extends MozaikAgent {
+  constructor(request) {
+    super(request);
   }
   async planFromGoal(goal) {
     this.setStructuredOutput(PlanSchema);
@@ -989,7 +1075,7 @@ Goal: ${goal}`);
   }
 };
 export {
-  Agent,
+  MozaikAgent,
   PlanningAgent,
   Task,
   WorkUnit,