@mastra/core
Version:
255 lines (254 loc) • 10.1 kB
JavaScript
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const require_observability = require("../../observability-BzV5axz0.cjs");
const require_agent = require("../../agent-DCD4MApC.cjs");
const require_create_durable_agent = require("../../create-durable-agent-CB4JGA_3.cjs");
//#region src/agent/durable/workflows/shared/execute-tool-calls.ts
/**
* Execute tool calls durably with optional hooks for observability and streaming.
*
* This is the shared implementation used by:
* - Core DurableAgent workflow
* - Inngest durable agent workflow (with observability hooks)
* - Evented durable agent workflow
*
* @param ctx - Tool execution context with tool calls, resolved tools, and optional hooks
* @returns Array of tool call outputs with results or errors
*/
async function executeDurableToolCalls(ctx) {
const toolResults = [];
for (const toolCall of ctx.toolCalls) {
if (toolCall.providerExecuted && toolCall.output !== void 0) {
toolResults.push({
...toolCall,
result: toolCall.output
});
continue;
}
const tool = ctx.tools[toolCall.toolName];
if (!tool) {
const error = {
name: "ToolNotFoundError",
message: `Tool ${toolCall.toolName} not found`
};
await ctx.onToolError?.(toolCall, error);
toolResults.push({
...toolCall,
error
});
continue;
}
await ctx.onToolStart?.(toolCall);
try {
if (tool.execute) {
const result = await tool.execute(toolCall.args, {
toolCallId: toolCall.toolCallId,
messages: [],
workspace: ctx.workspace,
requestContext: ctx.requestContext
});
await ctx.onToolResult?.(toolCall, result);
toolResults.push({
...toolCall,
result
});
} else {
await ctx.onToolResult?.(toolCall, void 0);
toolResults.push({
...toolCall,
result: void 0
});
}
} catch (error) {
const toolError = {
name: "ToolExecutionError",
message: error instanceof Error ? error.message : String(error),
stack: error instanceof Error ? error.stack : void 0
};
await ctx.onToolError?.(toolCall, toolError);
toolResults.push({
...toolCall,
error: toolError
});
}
}
return toolResults;
}
//#endregion
//#region src/agent/durable/evented-agent.ts
/**
* EventedAgent - A durable agent that uses fire-and-forget execution.
*
* EventedAgent extends DurableAgent and overrides the execution strategy to use
* fire-and-forget execution via the workflow engine's startAsync() method.
*
* Unlike DurableAgent which runs the workflow synchronously, EventedAgent:
* 1. Uses startAsync() for non-blocking execution
* 2. Fire-and-forget pattern - execution starts and returns immediately
* 3. Events are streamed via pubsub as the workflow executes
*/
/**
* EventedAgent extends DurableAgent to use fire-and-forget execution.
*
* This agent type uses the built-in evented workflow engine, which is useful when:
* - You don't need an external execution engine (like Inngest)
* - You want fire-and-forget execution with pubsub streaming
* - You need resumable streams with event caching
*
* The key difference from DurableAgent is the execution strategy:
* - DurableAgent: Runs the workflow synchronously via createRun + start
* - EventedAgent: Uses run.startAsync() for fire-and-forget execution
*
* @example
* ```typescript
* import { Agent } from '@mastra/core/agent';
* import { EventedAgent } from '@mastra/core/agent/durable';
*
* const agent = new Agent({
* id: 'my-agent',
* instructions: 'You are a helpful assistant',
* model: openai('gpt-4'),
* });
*
* const eventedAgent = new EventedAgent({ agent });
*
* const { output, runId, cleanup } = await eventedAgent.stream('Hello!');
* const text = await output.text;
* cleanup();
* ```
*/
var EventedAgent = class extends require_create_durable_agent.DurableAgent {
/**
* Create a new EventedAgent that wraps an existing Agent
*/
constructor(config) {
super(config);
}
/**
* Execute the durable workflow using fire-and-forget pattern.
*
* Unlike DurableAgent which runs the workflow synchronously, EventedAgent uses
* the workflow's startAsync() method for non-blocking execution.
*
* @param runId - The unique run ID
* @param workflowInput - The serialized workflow input
* @internal
*/
async executeWorkflow(runId, workflowInput) {
try {
const run = await this.getWorkflow().createRun({
runId,
pubsub: this.pubsubInternal
});
const entry = require_create_durable_agent.globalRunRegistry.get(runId);
await run.startAsync({
inputData: workflowInput,
requestContext: entry?.requestContext,
actor: workflowInput.options?.actor,
...require_observability.createObservabilityContext({ currentSpan: entry?.agentSpan })
});
} catch (error) {
await this.emitError(runId, error instanceof Error ? error : new Error(String(error)));
}
}
};
/**
* Check if an object is an EventedAgent class instance
*/
function isEventedAgentClass(obj) {
return obj instanceof EventedAgent;
}
//#endregion
//#region src/agent/durable/create-evented-agent.ts
/**
* Create an EventedAgent that wraps an existing Agent.
*
* This factory function creates an EventedAgent instance with fire-and-forget
* execution via the built-in workflow engine.
*
* @param options - Configuration options
* @returns An EventedAgent instance
*
* @example
* ```typescript
* const agent = new Agent({
* id: 'my-agent',
* instructions: 'You are helpful',
* model: openai('gpt-4'),
* });
*
* const eventedAgent = createEventedAgent({ agent });
*
* const mastra = new Mastra({
* agents: { myAgent: eventedAgent },
* });
* ```
*/
function createEventedAgent(options) {
const { agent, pubsub, cache, maxSteps } = options;
return new EventedAgent({
agent,
pubsub,
cache,
maxSteps
});
}
/**
* Check if an object is an EventedAgent
*/
function isEventedAgent(obj) {
return obj instanceof EventedAgent;
}
//#endregion
exports.AGENT_STREAM_TOPIC = require_agent.AGENT_STREAM_TOPIC;
exports.AgentStreamEventTypes = require_agent.AgentStreamEventTypes;
exports.DurableAgent = require_create_durable_agent.DurableAgent;
exports.DurableAgentDefaults = require_agent.DurableAgentDefaults;
exports.DurableStepIds = require_agent.DurableStepIds;
exports.EventedAgent = EventedAgent;
exports.ExtendedRunRegistry = require_create_durable_agent.ExtendedRunRegistry;
exports.RunRegistry = require_create_durable_agent.RunRegistry;
exports.accumulatedUsageSchema = require_create_durable_agent.accumulatedUsageSchema;
exports.baseDurableAgenticInputSchema = require_create_durable_agent.baseDurableAgenticInputSchema;
exports.baseIterationStateSchema = require_create_durable_agent.baseIterationStateSchema;
exports.buildStepRecord = require_create_durable_agent.buildStepRecord;
exports.calculateAccumulatedUsage = require_create_durable_agent.calculateAccumulatedUsage;
exports.createBaseIterationStateUpdate = require_create_durable_agent.createBaseIterationStateUpdate;
exports.createDurableAgent = require_create_durable_agent.createDurableAgent;
exports.createDurableAgentStream = require_create_durable_agent.createDurableAgentStream;
exports.createDurableAgenticWorkflow = require_create_durable_agent.createDurableAgenticWorkflow;
exports.createDurableBackgroundTaskCheckStep = require_create_durable_agent.createDurableBackgroundTaskCheckStep;
exports.createDurableLLMExecutionStep = require_create_durable_agent.createDurableLLMExecutionStep;
exports.createDurableLLMMappingStep = require_create_durable_agent.createDurableLLMMappingStep;
exports.createDurableToolCallStep = require_create_durable_agent.createDurableToolCallStep;
exports.createEventedAgent = createEventedAgent;
exports.createWorkflowInput = require_create_durable_agent.createWorkflowInput;
exports.durableAgenticOutputSchema = require_create_durable_agent.durableAgenticOutputSchema;
exports.emitChunkEvent = require_create_durable_agent.emitChunkEvent;
exports.emitErrorEvent = require_create_durable_agent.emitErrorEvent;
exports.emitFinishEvent = require_create_durable_agent.emitFinishEvent;
exports.emitStepFinishEvent = require_create_durable_agent.emitStepFinishEvent;
exports.emitStepStartEvent = require_create_durable_agent.emitStepStartEvent;
exports.emitSuspendedEvent = require_create_durable_agent.emitSuspendedEvent;
exports.executeDurableToolCalls = executeDurableToolCalls;
exports.globalRunRegistry = require_create_durable_agent.globalRunRegistry;
exports.isDurableAgent = require_create_durable_agent.isDurableAgent;
exports.isEventedAgent = isEventedAgent;
exports.isEventedAgentClass = isEventedAgentClass;
exports.isLocalDurableAgent = require_create_durable_agent.isLocalDurableAgent;
exports.modelConfigSchema = require_create_durable_agent.modelConfigSchema;
exports.modelListEntrySchema = require_create_durable_agent.modelListEntrySchema;
exports.prepareForDurableExecution = require_create_durable_agent.prepareForDurableExecution;
exports.rebuildRunToolsFromMastra = require_create_durable_agent.rebuildRunToolsFromMastra;
exports.resolveDurableToolCallConcurrency = require_create_durable_agent.resolveDurableToolCallConcurrency;
exports.resolveInternalState = require_create_durable_agent.resolveInternalState;
exports.resolveModel = require_create_durable_agent.resolveModel;
exports.resolveRuntimeDependencies = require_create_durable_agent.resolveRuntimeDependencies;
exports.resolveTool = require_create_durable_agent.resolveTool;
exports.runDurableStreamUntilIdle = require_create_durable_agent.runDurableStreamUntilIdle;
exports.runResumeDurableStreamUntilIdle = require_create_durable_agent.runResumeDurableStreamUntilIdle;
exports.serializeDurableOptions = require_create_durable_agent.serializeDurableOptions;
exports.serializeDurableState = require_create_durable_agent.serializeDurableState;
exports.serializeModelConfig = require_create_durable_agent.serializeModelConfig;
exports.serializeToolsMetadata = require_create_durable_agent.serializeToolsMetadata;
exports.toolRequiresApproval = require_create_durable_agent.toolRequiresApproval;
//# sourceMappingURL=index.cjs.map