@scoutqa/mastra-core 0.24.6-fork.1

package/dist/agent/workflows/prepare-stream/schema.d.ts

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+import type { MastraBase } from '../../../base.js';
+import type { MastraLLMVNext } from '../../../llm/model/model.loop.js';
+import type { Mastra } from '../../../mastra/index.js';
+import type { OutputProcessor } from '../../../processors/index.js';
+import type { Telemetry } from '../../../telemetry/index.js';
+import type { DynamicArgument } from '../../../types/index.js';
+import type { Agent } from '../../agent.js';
+import { MessageList } from '../../message-list/index.js';
+import type { AgentExecuteOnFinishOptions } from '../../types.js';
+export type AgentCapabilities = {
+    agentName: string;
+    logger: MastraBase['logger'];
+    getMemory: Agent['getMemory'];
+    getModel: Agent['getModel'];
+    generateMessageId: Mastra['generateId'];
+    _agentNetworkAppend?: boolean;
+    saveStepMessages: Agent['saveStepMessages'];
+    convertTools: Agent['convertTools'];
+    getMemoryMessages: Agent['getMemoryMessages'];
+    runInputProcessors: Agent['__runInputProcessors'];
+    executeOnFinish: (args: AgentExecuteOnFinishOptions) => Promise<void>;
+    outputProcessors?: DynamicArgument<OutputProcessor[]>;
+    llm: MastraLLMVNext;
+    getTelemetry?: () => Telemetry | undefined;
+};
+declare const coreToolSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodAny]>;
+    outputSchema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodAny]>>;
+    execute: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodAny], null>, z.ZodPromise<z.ZodAny>>>;
+    type: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"function">, z.ZodLiteral<"provider-defined">, z.ZodUndefined]>>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+    outputSchema?: any;
+    type?: "function" | "provider-defined" | undefined;
+    id?: string | undefined;
+    description?: string | undefined;
+    args?: Record<string, any> | undefined;
+    parameters?: any;
+}, {
+    execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+    outputSchema?: any;
+    type?: "function" | "provider-defined" | undefined;
+    id?: string | undefined;
+    description?: string | undefined;
+    args?: Record<string, any> | undefined;
+    parameters?: any;
+}>;
+export type CoreTool = z.infer<typeof coreToolSchema>;
+export declare const storageThreadSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    resourceId: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    resourceId: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    title?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}, {
+    resourceId: string;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    title?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+}>;
+export declare const prepareToolsStepOutputSchema: z.ZodObject<{
+    convertedTools: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodAny]>;
+        outputSchema: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodAny]>>;
+        execute: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny, z.ZodAny], null>, z.ZodPromise<z.ZodAny>>>;
+        type: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"function">, z.ZodLiteral<"provider-defined">, z.ZodUndefined]>>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+        outputSchema?: any;
+        type?: "function" | "provider-defined" | undefined;
+        id?: string | undefined;
+        description?: string | undefined;
+        args?: Record<string, any> | undefined;
+        parameters?: any;
+    }, {
+        execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+        outputSchema?: any;
+        type?: "function" | "provider-defined" | undefined;
+        id?: string | undefined;
+        description?: string | undefined;
+        args?: Record<string, any> | undefined;
+        parameters?: any;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    convertedTools: Record<string, {
+        execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+        outputSchema?: any;
+        type?: "function" | "provider-defined" | undefined;
+        id?: string | undefined;
+        description?: string | undefined;
+        args?: Record<string, any> | undefined;
+        parameters?: any;
+    }>;
+}, {
+    convertedTools: Record<string, {
+        execute?: ((args_0: any, args_1: any) => Promise<any>) | undefined;
+        outputSchema?: any;
+        type?: "function" | "provider-defined" | undefined;
+        id?: string | undefined;
+        description?: string | undefined;
+        args?: Record<string, any> | undefined;
+        parameters?: any;
+    }>;
+}>;
+export declare const prepareMemoryStepOutputSchema: z.ZodObject<{
+    threadExists: z.ZodBoolean;
+    thread: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        resourceId: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        resourceId: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    }>>;
+    messageList: z.ZodType<MessageList, z.ZodTypeDef, MessageList>;
+    tripwire: z.ZodOptional<z.ZodBoolean>;
+    tripwireReason: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    messageList: MessageList;
+    threadExists: boolean;
+    thread?: {
+        resourceId: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    } | undefined;
+    tripwireReason?: string | undefined;
+    tripwire?: boolean | undefined;
+}, {
+    messageList: MessageList;
+    threadExists: boolean;
+    thread?: {
+        resourceId: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        title?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+    } | undefined;
+    tripwireReason?: string | undefined;
+    tripwire?: boolean | undefined;
+}>;
+export type PrepareMemoryStepOutput = z.infer<typeof prepareMemoryStepOutputSchema>;
+export type PrepareToolsStepOutput = z.infer<typeof prepareToolsStepOutputSchema>;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/agent/workflows/prepare-stream/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/agent/workflows/prepare-stream/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC;IAC7B,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC9B,QAAQ,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;IACxC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IAC5C,YAAY,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACpC,iBAAiB,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IAC9C,kBAAkB,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAClD,eAAe,EAAE,CAAC,IAAI,EAAE,2BAA2B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtE,gBAAgB,CAAC,EAAE,eAAe,CAAC,eAAe,EAAE,CAAC,CAAC;IACtD,GAAG,EAAE,cAAc,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,SAAS,GAAG,SAAS,CAAC;CAC5C,CAAC;AAEF,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAWlB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/agent/workflows/prepare-stream/stream-step.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { MastraMemory } from '../../../memory/memory.js';
+import type { MemoryConfig } from '../../../memory/types.js';
+import { AISDKV5OutputStream, MastraModelOutput } from '../../../stream/index.js';
+import type { OutputSchema } from '../../../stream/base/schema.js';
+import type { SaveQueueManager } from '../../save-queue/index.js';
+import type { AgentMethodType } from '../../types.js';
+import type { AgentCapabilities } from './schema.js';
+interface StreamStepOptions<FORMAT extends 'aisdk' | 'mastra' | undefined = undefined> {
+    capabilities: AgentCapabilities;
+    runId: string;
+    returnScorerData?: boolean;
+    /**
+     * @deprecated When using format: 'aisdk', use the `@mastra/ai-sdk` package instead. See https://mastra.ai/en/docs/frameworks/agentic-uis/ai-sdk#streaming
+     */
+    format?: FORMAT;
+    requireToolApproval?: boolean;
+    resumeContext?: {
+        resumeData: any;
+        snapshot: any;
+    };
+    agentId: string;
+    toolCallId?: string;
+    methodType: AgentMethodType;
+    saveQueueManager?: SaveQueueManager;
+    memoryConfig?: MemoryConfig;
+    memory?: MastraMemory;
+    resourceId?: string;
+}
+export declare function createStreamStep<OUTPUT extends OutputSchema | undefined = undefined, FORMAT extends 'aisdk' | 'mastra' | undefined = undefined>({ capabilities, runId, returnScorerData, format, requireToolApproval, resumeContext, agentId, toolCallId, methodType, saveQueueManager, memoryConfig, memory, resourceId, }: StreamStepOptions<FORMAT>): import("../../..").Step<"stream-text-step", z.ZodObject<any, z.UnknownKeysParam, z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, z.ZodAny, z.ZodUnion<[z.ZodType<MastraModelOutput<OUTPUT | undefined>, z.ZodTypeDef, MastraModelOutput<OUTPUT | undefined>>, z.ZodType<AISDKV5OutputStream<OUTPUT | undefined>, z.ZodTypeDef, AISDKV5OutputStream<OUTPUT | undefined>>]>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, import("../../..").DefaultEngineType>;
+export {};
+//# sourceMappingURL=stream-step.d.ts.map

package/dist/agent/workflows/prepare-stream/stream-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-step.d.ts","sourceRoot":"","sources":["../../../../src/agent/workflows/prepare-stream/stream-step.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,UAAU,iBAAiB,CAAC,MAAM,SAAS,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS;IACnF,YAAY,EAAE,iBAAiB,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,aAAa,CAAC,EAAE;QACd,UAAU,EAAE,GAAG,CAAC;QAChB,QAAQ,EAAE,GAAG,CAAC;KACf,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,eAAe,CAAC;IAC5B,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,MAAM,SAAS,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,EACzD,EACA,YAAY,EACZ,KAAK,EACL,gBAAgB,EAChB,MAA2B,EAC3B,mBAAmB,EACnB,aAAa,EACb,OAAO,EACP,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,MAAM,EACN,UAAU,GACX,EAAE,iBAAiB,CAAC,MAAM,CAAC;;;;0VAuD3B"}

package/dist/ai-tracing/context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AI Tracing Context Integration
+ *
+ * This module provides automatic AI tracing context propagation throughout Mastra's execution contexts.
+ * It uses JavaScript Proxies to transparently wrap Mastra, Agent, and Workflow instances so that
+ * tracing context is automatically injected without requiring manual passing by users.
+ */
+import type { MastraPrimitives } from '../action/index.js';
+import type { Mastra } from '../mastra/index.js';
+import type { TracingContext } from './types.js';
+/**
+ * Checks to see if a passed object is an actual instance of Mastra
+ * (for the purposes of wrapping it for AI Tracing)
+ */
+export declare function isMastra<T extends Mastra | (Mastra & MastraPrimitives) | MastraPrimitives>(mastra: T): boolean;
+/**
+ * Creates a tracing-aware Mastra proxy that automatically injects
+ * AI tracing context into agent and workflow method calls
+ */
+export declare function wrapMastra<T extends Mastra | (Mastra & MastraPrimitives) | MastraPrimitives>(mastra: T, tracingContext: TracingContext): T;
+//# sourceMappingURL=context.d.ts.map

package/dist/ai-tracing/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/ai-tracing/context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAElD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,KAAK,EAAE,cAAc,EAAa,MAAM,SAAS,CAAC;AAgBzD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,CAAC,MAAM,GAAG,gBAAgB,CAAC,GAAG,gBAAgB,EAAE,MAAM,EAAE,CAAC,GAAG,OAAO,CAK9G;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,CAAC,MAAM,GAAG,gBAAgB,CAAC,GAAG,gBAAgB,EAC1F,MAAM,EAAE,CAAC,EACT,cAAc,EAAE,cAAc,GAC7B,CAAC,CA4CH"}

package/dist/ai-tracing/exporters/base.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Base Exporter for AI Tracing
+ *
+ * Provides common functionality shared by all AI tracing exporters:
+ * - Logger initialization with proper Mastra logger support
+ * - Disabled state management
+ * - Graceful shutdown lifecycle
+ */
+import { LogLevel } from '../../logger/index.js';
+import type { IMastraLogger } from '../../logger/index.js';
+import type { AITracingEvent, AITracingExporter } from '../types.js';
+/**
+ * Base configuration that all exporters should support
+ */
+export interface BaseExporterConfig {
+    /** Optional Mastra logger instance */
+    logger?: IMastraLogger;
+    /** Log level for the exporter (defaults to INFO) - accepts both enum and string */
+    logLevel?: LogLevel | 'debug' | 'info' | 'warn' | 'error';
+}
+/**
+ * Abstract base class for AI tracing exporters
+ *
+ * Handles common concerns:
+ * - Logger setup with proper Mastra logger
+ * - Disabled state management
+ * - Basic lifecycle methods
+ *
+ * @example
+ * ```typescript
+ * class MyExporter extends BaseExporter {
+ *   name = 'my-exporter';
+ *
+ *   constructor(config: MyExporterConfig) {
+ *     super(config);
+ *
+ *     if (!config.apiKey) {
+ *       this.setDisabled('Missing API key');
+ *       return;
+ *     }
+ *
+ *     // Initialize exporter-specific logic
+ *   }
+ *
+ *   async _exportEvent(event: AITracingEvent): Promise<void> {
+ *     // Export logic
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseExporter implements AITracingExporter {
+    /** Exporter name - must be implemented by subclasses */
+    abstract name: string;
+    /** Mastra logger instance */
+    protected logger: IMastraLogger;
+    /** Whether this exporter is disabled */
+    protected isDisabled: boolean;
+    /**
+     * Initialize the base exporter with logger
+     */
+    constructor(config?: BaseExporterConfig);
+    /**
+     * Set the logger for the exporter (called by Mastra/AITracing during initialization)
+     */
+    __setLogger(logger: IMastraLogger): void;
+    /**
+     * Convert string log level to LogLevel enum
+     */
+    private resolveLogLevel;
+    /**
+     * Mark the exporter as disabled and log a message
+     *
+     * @param reason - Reason why the exporter is disabled
+     */
+    protected setDisabled(reason: string): void;
+    /**
+     * Export a tracing event
+     *
+     * This method checks if the exporter is disabled before calling _exportEvent.
+     * Subclasses should implement _exportEvent instead of overriding this method.
+     */
+    exportEvent(event: AITracingEvent): Promise<void>;
+    /**
+     * Export a tracing event - must be implemented by subclasses
+     *
+     * This method is called by exportEvent after checking if the exporter is disabled.
+     */
+    protected abstract _exportEvent(event: AITracingEvent): Promise<void>;
+    /**
+     * Optional initialization hook called after Mastra is fully configured
+     */
+    init?(_config?: any): void;
+    /**
+     * Optional method to add scores to traces
+     */
+    addScoreToTrace?(_args: {
+        traceId: string;
+        spanId?: string;
+        score: number;
+        reason?: string;
+        scorerName: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /**
+     * Shutdown the exporter and clean up resources
+     *
+     * Default implementation just logs. Override to add custom cleanup.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/ai-tracing/exporters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/exporters/base.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAiB,QAAQ,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8BAAsB,YAAa,YAAW,iBAAiB;IAC7D,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,6BAA6B;IAC7B,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC;IAEhC,wCAAwC;IACxC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAS;IAEtC;;OAEG;gBACS,MAAM,GAAE,kBAAuB;IAO3C;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMxC;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;OAIG;IACH,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK3C;;;;;OAKG;IACG,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvD;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAErE;;OAEG;IACH,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAE1B;;OAEG;IACH,eAAe,CAAC,CAAC,KAAK,EAAE;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,GAAG,OAAO,CAAC,IAAI,CAAC;IAEjB;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/ai-tracing/exporters/cloud.d.ts

@@ -0,0 +1,30 @@
+import type { AITracingEvent } from '../types.js';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export interface CloudExporterConfig extends BaseExporterConfig {
+    maxBatchSize?: number;
+    maxBatchWaitMs?: number;
+    maxRetries?: number;
+    accessToken?: string;
+    endpoint?: string;
+}
+export declare class CloudExporter extends BaseExporter {
+    name: string;
+    private config;
+    private buffer;
+    private flushTimer;
+    constructor(config?: CloudExporterConfig);
+    protected _exportEvent(event: AITracingEvent): Promise<void>;
+    private addToBuffer;
+    private formatSpan;
+    private shouldFlush;
+    private scheduleFlush;
+    private flush;
+    /**
+     * Uploads spans to cloud API using fetchWithRetry for all retry logic
+     */
+    private batchUpload;
+    private resetBuffer;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=cloud.d.ts.map

package/dist/ai-tracing/exporters/cloud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/exporters/cloud.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,UAAU,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA0BD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,IAAI,SAAsC;IAE1C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAA+B;gBAErC,MAAM,GAAE,mBAAwB;cA8B5B,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBlE,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,aAAa;YAoBP,KAAK;IA8CnB;;OAEG;YACW,WAAW;IAezB,OAAO,CAAC,WAAW;IAMb,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuChC"}

package/dist/ai-tracing/exporters/console.d.ts

@@ -0,0 +1,10 @@
+import type { AITracingEvent } from '../types.js';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export declare class ConsoleExporter extends BaseExporter {
+    name: string;
+    constructor(config?: BaseExporterConfig);
+    protected _exportEvent(event: AITracingEvent): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=console.d.ts.map

package/dist/ai-tracing/exporters/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/exporters/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,IAAI,SAA8B;gBAEtB,MAAM,GAAE,kBAAuB;cAI3B,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA+E5D,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/ai-tracing/exporters/default.d.ts

@@ -0,0 +1,98 @@
+import type { IMastraLogger } from '../../logger/index.js';
+import type { Mastra } from '../../mastra/index.js';
+import type { AITracingEvent, AITracingExporter, TracingConfig, TracingStrategy } from '../types.js';
+interface BatchingConfig {
+    maxBatchSize?: number;
+    maxBufferSize?: number;
+    maxBatchWaitMs?: number;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    strategy?: TracingStrategy | 'auto';
+}
+export declare class DefaultExporter implements AITracingExporter {
+    name: string;
+    private logger;
+    private mastra;
+    private config;
+    private resolvedStrategy;
+    private buffer;
+    private flushTimer;
+    private allCreatedSpans;
+    constructor(config?: BatchingConfig, logger?: IMastraLogger);
+    private strategyInitialized;
+    /**
+     * Register the Mastra instance (called after Mastra construction is complete)
+     */
+    __registerMastra(mastra: Mastra): void;
+    /**
+     * Initialize the exporter (called after all dependencies are ready)
+     */
+    init(_config?: TracingConfig): void;
+    /**
+     * Initialize the resolved strategy once storage is available
+     */
+    private initializeStrategy;
+    /**
+     * Builds a unique span key for tracking
+     */
+    private buildSpanKey;
+    /**
+     * Gets the next sequence number for a span
+     */
+    private getNextSequence;
+    /**
+     * Handles out-of-order span updates by logging and skipping
+     */
+    private handleOutOfOrderUpdate;
+    /**
+     * Adds an event to the appropriate buffer based on strategy
+     */
+    private addToBuffer;
+    /**
+     * Checks if buffer should be flushed based on size or time triggers
+     */
+    private shouldFlush;
+    /**
+     * Resets the buffer after successful flush
+     */
+    private resetBuffer;
+    /**
+     * Schedules a flush using setTimeout
+     */
+    private scheduleFlush;
+    /**
+     * Serializes span attributes to storage record format
+     * Handles all AI span types and their specific attributes
+     */
+    private serializeAttributes;
+    private buildCreateRecord;
+    private buildUpdateRecord;
+    /**
+     * Handles realtime strategy - processes each event immediately
+     */
+    private handleRealtimeEvent;
+    /**
+     * Handles batch-with-updates strategy - buffers events and processes in batches
+     */
+    private handleBatchWithUpdatesEvent;
+    /**
+     * Handles insert-only strategy - only processes SPAN_ENDED events in batches
+     */
+    private handleInsertOnlyEvent;
+    /**
+     * Calculates retry delay using exponential backoff
+     */
+    private calculateRetryDelay;
+    /**
+     * Flushes the current buffer to storage with retry logic
+     */
+    private flush;
+    /**
+     * Attempts to flush with exponential backoff retry logic
+     */
+    private flushWithRetries;
+    exportEvent(event: AITracingEvent): Promise<void>;
+    shutdown(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=default.d.ts.map

package/dist/ai-tracing/exporters/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/exporters/default.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAI3C,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAqB,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAErH,UAAU,cAAc;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,QAAQ,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;CACrC;AAoDD,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,IAAI,SAA8B;IAClC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,UAAU,CAA+B;IAGjD,OAAO,CAAC,eAAe,CAA0B;gBAErC,MAAM,GAAE,cAAmB,EAAE,MAAM,CAAC,EAAE,aAAa;IAkC/D,OAAO,CAAC,mBAAmB,CAAS;IAEpC;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAItC;;OAEG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI;IAcnC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;OAEG;IACH,OAAO,CAAC,WAAW;IAgFnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAsBnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAiBnB;;OAEG;IACH,OAAO,CAAC,aAAa;IAarB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,iBAAiB;IAczB;;OAEG;YACW,mBAAmB;IAyCjC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAgBnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAoB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;YACW,KAAK;IA4DnB;;OAEG;YACW,gBAAgB;IA2DxB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IA+BjD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuBhC"}

package/dist/ai-tracing/exporters/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Mastra AI Tracing Exporters
+ */
+export * from './base.js';
+export { CloudExporter } from './cloud.js';
+export type { CloudExporterConfig } from './cloud.js';
+export * from './console.js';
+export * from './default.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ai-tracing/exporters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ai-tracing/exporters/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,QAAQ,CAAC;AAGvB,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,YAAY,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}