@pompeii-labs/magma
Version:
The Typescript framework to build AI agents quickly and easily
1,277 lines (1,258 loc) • 132 kB
JavaScript
'use strict';
var core = require('@anthropic-ai/sdk/core');
var core$1 = require('groq-sdk/core');
var core$2 = require('openai/core');
var generativeAi = require('@google/generative-ai');
var dotenv = require('dotenv');
var OpenAI = require('openai');
var Anthropic = require('@anthropic-ai/sdk');
var Groq = require('groq-sdk');
var cron = require('node-cron');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
var OpenAI__default = /*#__PURE__*/_interopDefault(OpenAI);
var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
var Groq__default = /*#__PURE__*/_interopDefault(Groq);
var cron__default = /*#__PURE__*/_interopDefault(cron);
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
// src/helpers/trace.ts
var _TraceAnalyzer; exports.TraceAnalyzer = void 0;
var init_trace = __esm({
"src/helpers/trace.ts"() {
_TraceAnalyzer = class _TraceAnalyzer {
constructor(trace) {
__publicField(this, "trace");
this.trace = trace;
}
/**
* Convert trace events into spans by matching start/end event pairs
*/
createSpans(eventType) {
const spans = [];
const startEvents = /* @__PURE__ */ new Map();
for (const event of this.trace) {
if (event.type !== eventType) continue;
const key = `${event.requestId}-${event.type}`;
if (event.phase === "start") {
startEvents.set(key, event);
} else if (event.phase === "end") {
const startEvent = startEvents.get(key);
if (startEvent && startEvent.phase === "start") {
const span = {
type: eventType,
startEvent,
endEvent: event
};
spans.push(span);
startEvents.delete(key);
}
}
}
return spans;
}
/**
* Get all middleware executions with their execution times and statuses
*/
getMiddlewareExecutions() {
const middlewareSpans = this.createSpans("middleware");
return middlewareSpans.map((span) => ({
name: span.startEvent.data.middleware,
duration: span.endEvent.timestamp - span.startEvent.timestamp,
status: span.endEvent.data.status,
requestId: this.getRequestIdFromSpan(span),
startTime: span.startEvent.timestamp,
endTime: span.endEvent.timestamp,
payload: span.startEvent.data.middlewarePayload,
result: span.endEvent.data.middlewareResult,
error: span.endEvent.data.error
}));
}
/**
* Get all tool executions with their execution times and statuses
*/
getToolExecutions() {
const toolSpans = this.createSpans("tool_execution");
return toolSpans.map((span) => ({
toolName: span.startEvent.data.toolName,
duration: span.endEvent.timestamp - span.startEvent.timestamp,
status: span.endEvent.data.status,
requestId: this.getRequestIdFromSpan(span),
startTime: span.startEvent.timestamp,
endTime: span.endEvent.timestamp,
args: span.startEvent.data.args,
result: span.endEvent.data.result,
error: span.endEvent.data.error,
toolCallId: span.startEvent.data.toolCallId
}));
}
/**
* Helper method to extract request ID from span data
*/
getRequestIdFromSpan(span) {
return span.startEvent.requestId;
}
/**
* Get all events for a specific request ID
*/
getEventsByRequestId(requestId) {
return this.trace.filter((event) => event.requestId === requestId);
}
/**
* Get the chronological flow of events
*/
getEventFlow() {
return this.trace.sort((a, b) => a.timestamp - b.timestamp).map((event) => ({
timestamp: event.timestamp,
type: event.type,
phase: event.phase,
requestId: event.requestId,
details: this.getEventDetails(event)
}));
}
/**
* Helper to get human-readable details for an event
*/
getEventDetails(event) {
var _a;
switch (event.type) {
case "completion":
return event.phase === "start" ? "Completion started" : `Completion ended with status: ${event.status}`;
case "tool_execution":
const toolName = event.data.toolName || ((_a = event.data.toolCall) == null ? void 0 : _a.fn_name);
return event.phase === "start" ? `Tool execution started: ${toolName}` : `Tool execution ended: ${toolName} (${event.status})`;
case "middleware":
const middlewareName = event.data.middleware;
return event.phase === "start" ? `Middleware started: ${middlewareName}` : `Middleware ended: ${middlewareName} (${event.status})`;
default:
return `${event.type} ${event.phase}`;
}
}
};
__name(_TraceAnalyzer, "TraceAnalyzer");
exports.TraceAnalyzer = _TraceAnalyzer;
}
});
// src/helpers/utilities.ts
function getMethodsFromClassOrInstance(target) {
const isClass = /^\s*class\s+/.test(target.toString());
const isInstance = typeof target === "object" && !isClass ? true : false;
const staticMethods = [];
const instanceMethods = [];
if (isInstance) {
const prototype = Object.getPrototypeOf(target);
const instancePropertyNames = Object.getOwnPropertyNames(prototype);
const constructor = prototype.constructor;
const staticPropertyNames = Object.getOwnPropertyNames(constructor);
staticMethods.push(...staticPropertyNames.map((name) => constructor[name]));
instanceMethods.push(...instancePropertyNames.map((name) => prototype[name]));
} else {
const staticPropertyNames = Object.getOwnPropertyNames(target);
staticMethods.push(...staticPropertyNames.map((name) => target[name]));
}
return {
staticMethods,
instanceMethods,
isInstance: !isClass
};
}
function loadUtilities(target) {
const tools = loadTools(target);
const hooks = loadHooks(target);
const jobs = loadJobs(target);
const middleware = loadMiddleware(target);
return {
tools,
hooks,
jobs,
middleware
};
}
function loadTools(target) {
var _a, _b, _c, _d, _e, _f, _g, _h, _i;
const tools = [];
const { staticMethods, instanceMethods } = getMethodsFromClassOrInstance(target);
const methods = [
...staticMethods,
...instanceMethods
];
for (const method of methods) {
if (typeof method === "function" && ("_toolInfo" in method || "_parameterInfo" in method)) {
const params = (_a = method["_parameterInfo"]) != null ? _a : [];
tools.push({
target: method.bind(target),
name: (_c = (_b = method["_toolInfo"]) == null ? void 0 : _b.name) != null ? _c : method["_methodName"],
description: (_e = (_d = method["_toolInfo"]) == null ? void 0 : _d.description) != null ? _e : void 0,
params,
enabled: (_g = (_f = method["_toolInfo"]) == null ? void 0 : _f.enabled) != null ? _g : () => true,
cache: (_i = (_h = method["_toolInfo"]) == null ? void 0 : _h.cache) != null ? _i : false
});
}
}
return tools;
}
function loadHooks(target) {
const hooks = [];
const { staticMethods, instanceMethods, isInstance } = getMethodsFromClassOrInstance(target);
const methods = isInstance ? instanceMethods : staticMethods;
for (const method of methods) {
if (typeof method === "function" && "_hookName" in method) {
hooks.push({
name: method["_hookName"],
handler: method.bind(target),
session: method["_session"],
setup: method["_setup"],
description: method["_description"]
});
}
}
return hooks;
}
function loadJobs(target) {
const jobs = [];
const { staticMethods, instanceMethods, isInstance } = getMethodsFromClassOrInstance(target);
const methods = isInstance ? instanceMethods : staticMethods;
for (const method of methods) {
if (typeof method === "function" && "_schedule" in method) {
jobs.push({
handler: method.bind(target),
schedule: method["_schedule"],
options: method["_options"],
name: method["_methodName"] || method["name"]
});
}
}
return jobs;
}
function loadMiddleware(target) {
var _a;
const middleware = [];
const { staticMethods, instanceMethods } = getMethodsFromClassOrInstance(target);
const methods = [
...staticMethods,
...instanceMethods
];
for (const method of methods) {
if (typeof method === "function" && "_middlewareTrigger" in method) {
middleware.push({
trigger: method["_middlewareTrigger"],
action: method.bind(target),
name: method["_methodName"] || method["name"],
critical: (_a = method["_critical"]) != null ? _a : false,
order: method["_order"],
id: method["_id"]
});
}
}
return middleware;
}
var init_utilities = __esm({
"src/helpers/utilities.ts"() {
__name(getMethodsFromClassOrInstance, "getMethodsFromClassOrInstance");
__name(loadUtilities, "loadUtilities");
__name(loadTools, "loadTools");
__name(loadHooks, "loadHooks");
__name(loadJobs, "loadJobs");
__name(loadMiddleware, "loadMiddleware");
}
});
// src/helpers/index.ts
function sleep(ms) {
return __async(this, null, function* () {
yield new Promise((resolve) => setTimeout(resolve, ms));
});
}
function sanitizeMessages(messages) {
for (let i = 0; i < messages.length; i++) {
if (messages[i].role === "assistant" && messages[i].getToolCalls().length > 0) {
if (i === messages.length - 1) {
messages.pop();
} else {
if (messages[i + 1].role === "user" && messages[i + 1].getToolResults().length > 0) {
continue;
} else {
messages.splice(i, 1);
i--;
}
}
} else if (messages[i].role === "user" && messages[i].getToolResults().length > 0) {
if (i === 0) {
messages.shift();
i--;
} else {
if (messages[i - 1].role === "assistant" && messages[i - 1].getToolCalls().length > 0) {
continue;
} else {
messages.splice(i, 1);
i--;
}
}
}
}
}
function parseErrorToString(error) {
return parseErrorToError(error).message;
}
function parseErrorToError(error) {
if (error instanceof Error) {
return error;
} else if (typeof error === "string") {
return new Error(error);
} else {
return new Error(JSON.stringify(error));
}
}
var cleanParam;
var init_helpers = __esm({
"src/helpers/index.ts"() {
init_trace();
init_utilities();
cleanParam = /* @__PURE__ */ __name((param, requiredList) => {
param.required && param.key && (requiredList == null ? void 0 : requiredList.push(param.key));
const objectRequiredParams = [];
switch (param.type) {
case "array":
if (!param.items) throw new Error(`Array parameters must have items defined - ${JSON.stringify(param)}`);
return {
type: "array",
description: param.description,
items: cleanParam(param.items)
};
case "object":
if (!param.properties) throw new Error(`Object parameters must have properties defined - ${JSON.stringify(param)}`);
return {
type: "object",
description: param.description,
properties: Object.fromEntries(param.properties.map((property) => {
if (!property.key) throw new Error(`Object properties must have keys defined - ${JSON.stringify(property)}`);
return [
property.key,
cleanParam(property, objectRequiredParams)
];
})),
required: objectRequiredParams
};
case "string":
return {
type: "string",
description: param.description,
enum: param.enum
};
case "number":
return {
type: "number",
description: param.description,
enum: param.enum
};
case "boolean":
return {
type: "boolean",
description: param.description
};
}
}, "cleanParam");
__name(sleep, "sleep");
__name(sanitizeMessages, "sanitizeMessages");
__name(parseErrorToString, "parseErrorToString");
__name(parseErrorToError, "parseErrorToError");
}
});
// src/types/agent.ts
var init_agent = __esm({
"src/types/agent.ts"() {
}
});
// src/types/messages.ts
var _MagmaMessage, MagmaMessage, _MagmaUserMessage, MagmaUserMessage, _MagmaAssistantMessage, MagmaAssistantMessage, _MagmaSystemMessage, MagmaSystemMessage;
var init_messages = __esm({
"src/types/messages.ts"() {
_MagmaMessage = class _MagmaMessage {
constructor({ role, content, blocks, id }) {
__publicField(this, "id");
__publicField(this, "role");
__publicField(this, "blocks", []);
this.id = id;
this.role = role;
if (blocks) {
this.blocks = blocks;
} else if (content !== void 0 && content !== null) {
this.blocks = [
{
type: "text",
text: content
}
];
}
}
getText() {
return this.blocks.filter((block) => block.type === "text").map((block) => block.text).join("\n");
}
getToolCalls() {
return this.blocks.filter((block) => block.type === "tool_call").map((block) => block.tool_call);
}
getToolResults() {
return this.blocks.filter((block) => block.type === "tool_result").map((block) => block.tool_result);
}
getReasoning() {
return this.blocks.filter((block) => block.type === "reasoning").filter((block) => !block.redacted).map((block) => block.reasoning).join("\n");
}
getImages() {
return this.blocks.filter((block) => block.type === "image").map((block) => block.image);
}
get content() {
return this.getText();
}
};
__name(_MagmaMessage, "MagmaMessage");
MagmaMessage = _MagmaMessage;
_MagmaUserMessage = class _MagmaUserMessage extends MagmaMessage {
constructor(magmaUserMessage) {
super(magmaUserMessage);
__publicField(this, "role", "user");
}
};
__name(_MagmaUserMessage, "MagmaUserMessage");
MagmaUserMessage = _MagmaUserMessage;
_MagmaAssistantMessage = class _MagmaAssistantMessage extends MagmaMessage {
constructor(magmaAssistantMessage) {
super(magmaAssistantMessage);
__publicField(this, "role", "assistant");
}
};
__name(_MagmaAssistantMessage, "MagmaAssistantMessage");
MagmaAssistantMessage = _MagmaAssistantMessage;
_MagmaSystemMessage = class _MagmaSystemMessage extends MagmaMessage {
constructor(magmaSystemMessage) {
super(magmaSystemMessage);
__publicField(this, "role", "system");
this.blocks.forEach((block) => {
var _a;
block.cache = (_a = block.cache) != null ? _a : magmaSystemMessage.cache;
});
}
};
__name(_MagmaSystemMessage, "MagmaSystemMessage");
MagmaSystemMessage = _MagmaSystemMessage;
}
});
// src/types/providers.ts
var init_providers = __esm({
"src/types/providers.ts"() {
}
});
// src/types/utilities/hooks.ts
var init_hooks = __esm({
"src/types/utilities/hooks.ts"() {
}
});
// src/types/utilities/jobs.ts
var init_jobs = __esm({
"src/types/utilities/jobs.ts"() {
}
});
// src/types/utilities/middleware.ts
var init_middleware = __esm({
"src/types/utilities/middleware.ts"() {
}
});
// src/types/utilities/tools.ts
var init_tools = __esm({
"src/types/utilities/tools.ts"() {
}
});
// src/types/utilities/index.ts
var init_utilities2 = __esm({
"src/types/utilities/index.ts"() {
init_hooks();
init_jobs();
init_middleware();
init_tools();
}
});
// src/types/trace.ts
var init_trace2 = __esm({
"src/types/trace.ts"() {
}
});
// src/types/index.ts
var init_types = __esm({
"src/types/index.ts"() {
init_agent();
init_messages();
init_providers();
init_utilities2();
init_trace2();
}
});
// src/providers/anthropic.ts
var anthropic_exports = {};
__export(anthropic_exports, {
AnthropicProvider: () => AnthropicProvider
});
var _AnthropicProvider, AnthropicProvider;
var init_anthropic = __esm({
"src/providers/anthropic.ts"() {
init_providers2();
init_types();
init_helpers();
_AnthropicProvider = class _AnthropicProvider extends Provider {
static convertConfig(config) {
var _a;
const { model, settings } = config.providerConfig;
const anthropicConfig = __spreadValues({
stream: config.stream,
model,
messages: this.convertMessages(config.messages),
max_tokens: (_a = settings == null ? void 0 : settings.max_tokens) != null ? _a : model.includes("claude-3-5") ? 8192 : 4096,
tools: this.convertTools(config.tools),
system: config.messages.filter((m) => m.role === "system").flatMap((m) => m.blocks.filter((b) => b.type === "text").map((b) => ({
type: "text",
text: b.text,
cache_control: b.cache ? {
type: "ephemeral"
} : void 0
})))
}, settings);
return anthropicConfig;
}
static convertMessages(messages) {
const anthropicMessages = [];
for (let i = 0; i < messages.length; i++) {
const message = messages[i];
if ("id" in message) delete message.id;
switch (message.role) {
case "system":
continue;
case "assistant":
let assistantContent = [];
for (const block of message.blocks) {
switch (block.type) {
case "reasoning":
if (block.redacted) {
assistantContent.push({
type: "redacted_thinking",
data: block.reasoning
});
} else {
if (!block.signature) {
assistantContent.push({
type: "text",
text: `<thinking>${block.reasoning}</thinking>`
});
} else {
assistantContent.push({
type: "thinking",
thinking: block.reasoning,
signature: block.signature
});
}
}
break;
case "tool_call":
assistantContent.push({
type: "tool_use",
id: block.tool_call.id,
name: block.tool_call.fn_name,
input: block.tool_call.fn_args
});
break;
case "text":
assistantContent.push({
type: "text",
text: block.text
});
break;
default:
throw new Error(`Unsupported block type for assistant messages: ${block.type}`);
}
}
anthropicMessages.push({
role: "assistant",
content: assistantContent
});
if (i + 1 < messages.length && messages[i + 1].role === "assistant" && messages[i].getToolCalls().length === 0) {
anthropicMessages.push({
role: "user",
content: "Continue."
});
}
break;
case "user":
let userContent = [];
for (const block of message.blocks) {
switch (block.type) {
case "text":
userContent.push({
type: "text",
text: block.text
});
break;
case "image":
if (block.image.type === "image/url") {
userContent.push({
type: "image",
source: {
type: "url",
url: block.image.data
}
});
} else {
userContent.push({
type: "image",
source: {
type: "base64",
data: block.image.data,
media_type: block.image.type
}
});
}
break;
case "tool_result":
userContent.push({
type: "tool_result",
tool_use_id: block.tool_result.id,
content: typeof block.tool_result.result !== "string" ? JSON.stringify(block.tool_result.result) : block.tool_result.result
});
break;
default:
throw new Error(`Unsupported block type for user messages: ${block.type}`);
}
}
anthropicMessages.push({
role: "user",
content: userContent
});
break;
}
}
if (anthropicMessages.length === 0 || anthropicMessages[0].role != "user") anthropicMessages.unshift({
role: "user",
content: "begin"
});
return anthropicMessages;
}
static makeCompletionRequest(_0) {
return __async(this, arguments, function* ({ config, onStreamChunk, attempt = 0, signal, agent, trace, requestId }) {
var _a, _b, _c, _d, _e, _f, _g, _h;
try {
const anthropic = config.providerConfig.client;
if (!anthropic) throw new Error("Anthropic instance not configured");
const anthropicConfig = this.convertConfig(config);
trace.push({
type: "completion",
phase: "start",
requestId,
timestamp: Date.now(),
data: {
message: config.messages.at(-1)
}
});
if (config.stream) {
const stream = yield anthropic.messages.create(__spreadProps(__spreadValues({}, anthropicConfig), {
stream: true
}), {
signal
});
let blockBuffer = [];
const usage = {
input_tokens: 0,
output_tokens: 0,
cache_write_tokens: 0,
cache_read_tokens: 0
};
let id = (_a = stream._request_id) != null ? _a : "gen-" + Math.random().toString(36).substring(2, 15);
let stopReason = "unknown";
try {
for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
const chunk = temp.value;
let magmaStreamChunk = {
id,
provider: "anthropic",
model: anthropicConfig.model,
delta: new MagmaAssistantMessage({
role: "assistant",
blocks: []
}),
buffer: new MagmaAssistantMessage({
role: "assistant",
blocks: []
}),
usage: {
input_tokens: null,
output_tokens: null,
cache_write_tokens: null,
cache_read_tokens: null
},
stop_reason: void 0
};
switch (chunk.type) {
case "message_start":
id = chunk.message.id;
magmaStreamChunk.id = id;
usage.input_tokens += chunk.message.usage.input_tokens;
usage.output_tokens += chunk.message.usage.output_tokens;
usage.cache_write_tokens += (_b = chunk.message.usage.cache_creation_input_tokens) != null ? _b : 0;
usage.cache_read_tokens += (_c = chunk.message.usage.cache_read_input_tokens) != null ? _c : 0;
magmaStreamChunk.usage.input_tokens = chunk.message.usage.input_tokens;
magmaStreamChunk.usage.output_tokens = chunk.message.usage.output_tokens;
magmaStreamChunk.usage.cache_write_tokens = chunk.message.usage.cache_creation_input_tokens;
magmaStreamChunk.usage.cache_read_tokens = chunk.message.usage.cache_read_input_tokens;
break;
case "message_delta":
usage.output_tokens += chunk.usage.output_tokens;
magmaStreamChunk.usage.output_tokens = chunk.usage.output_tokens;
if (chunk.delta.stop_reason) {
stopReason = this.convertStopReason(chunk.delta.stop_reason);
magmaStreamChunk.stop_reason = stopReason;
}
break;
case "content_block_start":
let blockStart;
switch (chunk.content_block.type) {
case "text":
blockStart = {
type: "text",
text: chunk.content_block.text
};
break;
case "thinking":
blockStart = {
type: "reasoning",
reasoning: chunk.content_block.thinking,
signature: chunk.content_block.signature
};
break;
case "redacted_thinking":
blockStart = {
type: "reasoning",
reasoning: chunk.content_block.data,
redacted: true
};
break;
case "tool_use":
blockStart = {
type: "tool_call",
tool_call: {
id: chunk.content_block.id,
fn_name: chunk.content_block.name,
fn_args: {},
fn_args_buffer: ""
}
};
break;
}
blockBuffer[chunk.index] = blockStart;
magmaStreamChunk.delta.blocks.push(blockStart);
break;
case "content_block_delta":
let blockToChange = blockBuffer[chunk.index];
switch (chunk.delta.type) {
case "text_delta":
blockToChange = blockBuffer[chunk.index];
blockToChange.text += chunk.delta.text;
magmaStreamChunk.delta.blocks.push({
type: "text",
text: chunk.delta.text
});
break;
case "input_json_delta":
blockToChange = blockBuffer[chunk.index];
blockToChange.tool_call.fn_args_buffer += chunk.delta.partial_json;
magmaStreamChunk.delta.blocks.push({
type: "tool_call",
tool_call: {
id: blockToChange.tool_call.id,
fn_name: blockToChange.tool_call.fn_name,
fn_args: (_d = core.safeJSON(chunk.delta.partial_json)) != null ? _d : {},
fn_args_buffer: chunk.delta.partial_json
}
});
break;
case "thinking_delta":
blockToChange = blockBuffer[chunk.index];
blockToChange.reasoning += chunk.delta.thinking;
magmaStreamChunk.delta.blocks.push({
type: "reasoning",
reasoning: chunk.delta.thinking
});
break;
case "signature_delta":
blockToChange = blockBuffer[chunk.index];
blockToChange.signature += chunk.delta.signature;
magmaStreamChunk.delta.blocks.push({
type: "reasoning",
reasoning: "",
signature: chunk.delta.signature
});
break;
default:
throw new Error(`Unsupported delta type: ${chunk.delta.type}`);
}
break;
case "message_stop": {
let magmaMessage = new MagmaAssistantMessage({
role: "assistant",
blocks: blockBuffer.map((b) => {
var _a2, _b2;
return b.type === "tool_call" ? {
type: "tool_call",
tool_call: __spreadProps(__spreadValues({}, b.tool_call), {
fn_args: (_b2 = core.safeJSON((_a2 = b.tool_call.fn_args_buffer) != null ? _a2 : "")) != null ? _b2 : {},
fn_args_buffer: b.tool_call.fn_args_buffer
})
} : b;
})
});
const magmaCompletion = {
provider: "anthropic",
model: anthropicConfig.model,
message: magmaMessage,
usage,
stop_reason: stopReason != null ? stopReason : "unknown"
};
onStreamChunk == null ? void 0 : onStreamChunk(null);
trace.push({
type: "completion",
phase: "end",
status: "success",
requestId,
timestamp: Date.now(),
data: {
completion: magmaCompletion
}
});
return magmaCompletion;
}
}
magmaStreamChunk.buffer.blocks = blockBuffer.map((b) => {
var _a2, _b2;
return b.type === "tool_call" ? {
type: "tool_call",
tool_call: __spreadProps(__spreadValues({}, b.tool_call), {
fn_args: (_b2 = core.safeJSON((_a2 = b.tool_call.fn_args_buffer) != null ? _a2 : "")) != null ? _b2 : {},
fn_args_buffer: b.tool_call.fn_args_buffer
})
} : b;
});
onStreamChunk == null ? void 0 : onStreamChunk(magmaStreamChunk);
}
} catch (temp) {
error = [temp];
} finally {
try {
more && (temp = iter.return) && (yield temp.call(iter));
} finally {
if (error)
throw error[0];
}
}
return null;
} else {
const anthropicCompletion = yield anthropic.messages.create(anthropicConfig, {
signal
});
const blocks = anthropicCompletion.content;
let magmaMessage = new MagmaAssistantMessage({
role: "assistant",
blocks: []
});
for (const block of blocks) {
switch (block.type) {
case "text":
magmaMessage.blocks.push({
type: "text",
text: block.text
});
break;
case "tool_use":
magmaMessage.blocks.push({
type: "tool_call",
tool_call: {
id: block.id,
fn_name: block.name,
fn_args: (_e = block.input) != null ? _e : {}
}
});
break;
case "thinking":
magmaMessage.blocks.push({
type: "reasoning",
reasoning: block.thinking,
signature: block.signature
});
break;
case "redacted_thinking":
magmaMessage.blocks.push({
type: "reasoning",
reasoning: block.data,
redacted: true
});
break;
default:
throw new Error(`Unsupported block type for assistant messages: ${block}`);
}
}
if (magmaMessage.blocks.length === 0) {
return null;
}
const magmaCompletion = {
provider: "anthropic",
model: anthropicCompletion.model,
message: magmaMessage,
usage: {
input_tokens: anthropicCompletion.usage.input_tokens,
output_tokens: anthropicCompletion.usage.output_tokens,
cache_write_tokens: (_f = anthropicCompletion.usage.cache_creation_input_tokens) != null ? _f : 0,
cache_read_tokens: (_g = anthropicCompletion.usage.cache_read_input_tokens) != null ? _g : 0
},
stop_reason: this.convertStopReason(anthropicCompletion.stop_reason)
};
trace.push({
type: "completion",
phase: "end",
status: "success",
requestId,
timestamp: Date.now(),
data: {
completion: magmaCompletion
}
});
return magmaCompletion;
}
} catch (error2) {
if (signal == null ? void 0 : signal.aborted) {
trace.push({
type: "completion",
phase: "end",
status: "abort",
requestId,
timestamp: Date.now(),
data: {
error: parseErrorToString(error2)
}
});
return null;
}
if (((_h = error2.error) == null ? void 0 : _h.type) === "rate_limit_error") {
trace.push({
type: "completion",
phase: "end",
status: "error",
requestId,
timestamp: Date.now(),
data: {
error: parseErrorToString(error2)
}
});
if (attempt >= MAX_RETRIES) {
throw new Error(`Rate limited after ${MAX_RETRIES} attempts`);
}
const delay = Math.min(Math.pow(2, attempt) * 1e3, 6e4);
agent.log(`Rate limited. Retrying after ${delay}ms.`);
yield sleep(delay);
return this.makeCompletionRequest({
config,
onStreamChunk,
attempt: attempt + 1,
signal,
agent,
trace,
requestId
});
} else {
trace.push({
type: "completion",
phase: "end",
status: "error",
requestId,
timestamp: Date.now(),
data: {
error: parseErrorToString(error2)
}
});
throw error2;
}
}
});
}
// Tool schema to LLM function call converter
static convertTools(tools) {
const anthropicTools = [];
for (const tool of tools) {
const baseObject = {
type: "object",
properties: tool.params
};
anthropicTools.push({
name: tool.name,
description: tool.description,
input_schema: tool.params.length === 0 ? {
type: "object"
} : cleanParam(baseObject, []),
cache_control: tool.cache ? {
type: "ephemeral"
} : void 0
});
}
return anthropicTools;
}
static convertStopReason(stop_reason) {
switch (stop_reason) {
case "end_turn":
return "natural";
case "max_tokens":
return "max_tokens";
case "tool_use":
return "tool_call";
default:
return "unknown";
}
}
};
__name(_AnthropicProvider, "AnthropicProvider");
AnthropicProvider = _AnthropicProvider;
}
});
// src/providers/groq.ts
var groq_exports = {};
__export(groq_exports, {
GroqProvider: () => GroqProvider
});
var _GroqProvider, GroqProvider;
var init_groq = __esm({
"src/providers/groq.ts"() {
init_providers2();
init_types();
init_helpers();
_GroqProvider = class _GroqProvider extends Provider {
static convertConfig(config) {
const { model, settings } = config.providerConfig;
const groqConfig = __spreadValues({
stream: config.stream,
model,
messages: this.convertMessages(config.messages),
tools: this.convertTools(config.tools)
}, settings);
return groqConfig;
}
static makeCompletionRequest(_0) {
return __async(this, arguments, function* ({ config, onStreamChunk, attempt = 0, signal, agent, trace, requestId }) {
var _a, _b, _c, _d, _e, _f, _g, _h;
try {
const groq = config.providerConfig.client;
if (!groq) throw new Error("Groq instance not configured");
const groqConfig = this.convertConfig(config);
trace.push({
type: "completion",
phase: "start",
requestId,
timestamp: Date.now(),
data: {
message: config.messages.at(-1)
}
});
if (config.stream) {
const stream = yield groq.chat.completions.create(__spreadProps(__spreadValues({}, groqConfig), {
stream: true
}), {
signal
});
let contentBuffer = "";
const usage = {
input_tokens: 0,
output_tokens: 0,
cache_write_tokens: 0,
cache_read_tokens: 0
};
let streamedToolCalls = {};
let stopReason = "unknown";
try {
for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield iter.next()).done; more = false) {
const chunk = temp.value;
let magmaStreamChunk = {
id: chunk.id,
provider: "groq",
model: chunk.model,
delta: new MagmaAssistantMessage({
role: "assistant",
blocks: []
}),
buffer: new MagmaAssistantMessage({
role: "assistant",
blocks: []
}),
usage: {
input_tokens: null,
output_tokens: null,
cache_write_tokens: null,
cache_read_tokens: null
},
stop_reason: void 0
};
const choice = chunk.choices[0];
const delta = choice == null ? void 0 : choice.delta;
if (choice == null ? void 0 : choice.finish_reason) {
stopReason = this.convertStopReason(choice.finish_reason);
magmaStreamChunk.stop_reason = stopReason;
}
for (const toolCall of (_a = delta == null ? void 0 : delta.tool_calls) != null ? _a : []) {
const { index } = toolCall;
if (!streamedToolCalls[index]) {
streamedToolCalls[index] = toolCall;
} else {
if (streamedToolCalls[index].function) {
streamedToolCalls[index].function.arguments += (_c = (_b = toolCall.function) == null ? void 0 : _b.arguments) != null ? _c : "";
} else {
streamedToolCalls[index].function = toolCall.function;
}
}
}
if ((_d = chunk.x_groq) == null ? void 0 : _d.usage) {
usage.input_tokens = chunk.x_groq.usage.prompt_tokens;
usage.output_tokens = chunk.x_groq.usage.completion_tokens;
usage.cache_write_tokens = 0;
usage.cache_read_tokens = 0;
magmaStreamChunk.usage = {
input_tokens: chunk.x_groq.usage.prompt_tokens,
output_tokens: chunk.x_groq.usage.completion_tokens,
cache_write_tokens: 0,
cache_read_tokens: 0
};
}
if (delta == null ? void 0 : delta.tool_calls) {
const toolCallBlocks = delta.tool_calls.map((toolCall) => {
var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
return {
type: "tool_call",
tool_call: {
id: (_a2 = streamedToolCalls[toolCall.index].id) != null ? _a2 : "gen-" + Math.random().toString(36).substring(2, 15),
fn_name: (_c2 = (_b2 = toolCall.function) == null ? void 0 : _b2.name) != null ? _c2 : "",
fn_args: (_f2 = core$1.safeJSON((_e2 = (_d2 = toolCall.function) == null ? void 0 : _d2.arguments) != null ? _e2 : "")) != null ? _f2 : {},
fn_args_buffer: (_h2 = (_g2 = toolCall.function) == null ? void 0 : _g2.arguments) != null ? _h2 : ""
}
};
});
magmaStreamChunk.delta.blocks.push(...toolCallBlocks);
}
if (delta == null ? void 0 : delta.content) {
const textBlock = {
type: "text",
text: delta.content
};
magmaStreamChunk.delta.blocks.push(textBlock);
contentBuffer += delta.content;
}
if (contentBuffer.length > 0) {
const bufferTextBlock = {
type: "text",
text: contentBuffer
};
magmaStreamChunk.buffer.blocks.push(bufferTextBlock);
}
if (Object.keys(streamedToolCalls).length > 0) {
const bufferToolCallBlocks = Object.values(streamedToolCalls).map((toolCall) => {
var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
return {
type: "tool_call",
tool_call: {
id: (_a2 = toolCall.id) != null ? _a2 : "gen-" + Math.random().toString(36).substring(2, 15),
fn_name: (_c2 = (_b2 = toolCall.function) == null ? void 0 : _b2.name) != null ? _c2 : "",
fn_args: (_f2 = core$1.safeJSON((_e2 = (_d2 = toolCall.function) == null ? void 0 : _d2.arguments) != null ? _e2 : "")) != null ? _f2 : {},
fn_args_buffer: (_h2 = (_g2 = toolCall.function) == null ? void 0 : _g2.arguments) != null ? _h2 : ""
}
};
});
magmaStreamChunk.buffer.blocks.push(...bufferToolCallBlocks);
}
onStreamChunk == null ? void 0 : onStreamChunk(magmaStreamChunk);
}
} catch (temp) {
error = [temp];
} finally {
try {
more && (temp = iter.return) && (yield temp.call(iter));
} finally {
if (error)
throw error[0];
}
}
let magmaMessage = new MagmaAssistantMessage({
role: "assistant",
blocks: []
});
if (contentBuffer.length > 0) {
magmaMessage.blocks.push({
type: "text",
text: contentBuffer
});
}
const toolCalls = Object.values(streamedToolCalls);
if (toolCalls.length > 0) {
const toolCallBlocks = toolCalls.map((toolCall) => {
var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2;
return {
type: "tool_call",
tool_call: {
id: (_a2 = toolCall.id) != null ? _a2 : "gen-" + Math.random().toString(36).substring(2, 15),
fn_name: (_c2 = (_b2 = toolCall.function) == null ? void 0 : _b2.name) != null ? _c2 : "",
fn_args: (_f2 = core$1.safeJSON((_e2 = (_d2 = toolCall.function) == null ? void 0 : _d2.arguments) != null ? _e2 : "")) != null ? _f2 : {},
fn_args_buffer: (_h2 = (_g2 = toolCall.function) == null ? void 0 : _g2.argumen