@mastra/core 0.23.1 → 0.23.2-alpha.0

package/dist/{chunk-PDST7KX7.cjs → chunk-P35FNLTQ.cjs}

@@ -507,7 +507,7 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
       error: `${prefix} - Failed ${toolType} execution`
     };
   }
-  createExecute(tool, options, logType) {
+  createExecute(tool, options, logType, processedSchema) {
     const { logger, mastra: _mastra, memory: _memory, runtimeContext, model, ...rest } = options;
     const logModelObject = {
       modelId: model?.modelId,
@@ -572,7 +572,7 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
       let logger2 = options.logger || this.logger;
       try {
         logger2.debug(start, { ...rest, model: logModelObject, args });
-        const parameters = this.getParameters();
+        const parameters = processedSchema || this.getParameters();
         const { data, error: error2 } = chunkVF676YCO_cjs.validateToolInput(parameters, args, options.name);
         if (error2) {
           logger2.warn(`Tool input validation failed for '${options.name}'`, {
@@ -643,18 +643,6 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
     if (providerTool) {
       return providerTool;
     }
-    const definition = {
-      type: "function",
-      description: this.originalTool.description,
-      parameters: this.getParameters(),
-      outputSchema: this.getOutputSchema(),
-      requireApproval: this.options.requireApproval,
-      execute: this.originalTool.execute ? this.createExecute(
-        this.originalTool,
-        { ...this.options, description: this.originalTool.description },
-        this.logType
-      ) : void 0
-    };
     const model = this.options.model;
     const schemaCompatLayers = [];
     if (model) {
@@ -673,11 +661,25 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
         new schemaCompat.MetaSchemaCompatLayer(modelInfo)
       );
     }
-    const processedSchema = schemaCompat.applyCompatLayer({
-      schema: this.getParameters(),
-      compatLayers: schemaCompatLayers,
-      mode: "aiSdkSchema"
-    });
+    let processedZodSchema;
+    let processedSchema;
+    const originalSchema = this.getParameters();
+    const applicableLayer = schemaCompatLayers.find((layer) => layer.shouldApply());
+    if (applicableLayer && originalSchema) {
+      processedZodSchema = applicableLayer.processZodType(originalSchema);
+      processedSchema = schemaCompat.applyCompatLayer({
+        schema: originalSchema,
+        compatLayers: schemaCompatLayers,
+        mode: "aiSdkSchema"
+      });
+    } else {
+      processedZodSchema = originalSchema;
+      processedSchema = schemaCompat.applyCompatLayer({
+        schema: originalSchema,
+        compatLayers: schemaCompatLayers,
+        mode: "aiSdkSchema"
+      });
+    }
     let processedOutputSchema;
     if (this.getOutputSchema()) {
       processedOutputSchema = schemaCompat.applyCompatLayer({
@@ -686,6 +688,20 @@ var CoreToolBuilder = class extends chunk6VOPKVYH_cjs.MastraBase {
         mode: "aiSdkSchema"
       });
     }
+    const definition = {
+      type: "function",
+      description: this.originalTool.description,
+      parameters: this.getParameters(),
+      outputSchema: this.getOutputSchema(),
+      requireApproval: this.options.requireApproval,
+      execute: this.originalTool.execute ? this.createExecute(
+        this.originalTool,
+        { ...this.options, description: this.originalTool.description },
+        this.logType,
+        processedZodSchema
+        // Pass the processed Zod schema for validation
+      ) : void 0
+    };
     return {
       ...definition,
       id: "id" in this.originalTool ? this.originalTool.id : void 0,
@@ -2568,36 +2584,63 @@ function wrapRun(run, tracingContext) {
   }
 }
 var ModelSpanTracker = class {
-  modelSpan;
-  currentStepSpan;
-  currentChunkSpan;
-  accumulator = {};
-  stepIndex = 0;
-  chunkSequence = 0;
+  #modelSpan;
+  #currentStepSpan;
+  #currentChunkSpan;
+  #accumulator = {};
+  #stepIndex = 0;
+  #chunkSequence = 0;
   constructor(modelSpan) {
-    this.modelSpan = modelSpan;
+    this.#modelSpan = modelSpan;
+  }
+  /**
+   * Get the tracing context for creating child spans.
+   * Returns the current step span if active, otherwise the model span.
+   */
+  getTracingContext() {
+    return {
+      currentSpan: this.#currentStepSpan ?? this.#modelSpan
+    };
+  }
+  /**
+   * Report an error on the generation span
+   */
+  reportGenerationError(options) {
+    this.#modelSpan?.error(options);
+  }
+  /**
+   * End the generation span
+   */
+  endGeneration(options) {
+    this.#modelSpan?.end(options);
+  }
+  /**
+   * Update the generation span
+   */
+  updateGeneration(options) {
+    this.#modelSpan?.update(options);
   }
   /**
    * Start a new Model execution step
    */
-  startStepSpan(payload) {
-    this.currentStepSpan = this.modelSpan?.createChildSpan({
-      name: `step: ${this.stepIndex}`,
+  #startStepSpan(payload) {
+    this.#currentStepSpan = this.#modelSpan?.createChildSpan({
+      name: `step: ${this.#stepIndex}`,
       type: "model_step" /* MODEL_STEP */,
       attributes: {
-        stepIndex: this.stepIndex,
+        stepIndex: this.#stepIndex,
         ...payload?.messageId ? { messageId: payload.messageId } : {},
         ...payload?.warnings?.length ? { warnings: payload.warnings } : {}
       },
       input: payload?.request
     });
-    this.chunkSequence = 0;
+    this.#chunkSequence = 0;
   }
   /**
    * End the current Model execution step with token usage, finish reason, output, and metadata
    */
-  endStepSpan(payload) {
-    if (!this.currentStepSpan) return;
+  #endStepSpan(payload) {
+    if (!this.#currentStepSpan) return;
     const output = payload.output;
     const { usage, ...otherOutput } = output;
     const stepResult = payload.stepResult;
@@ -2606,7 +2649,7 @@ var ModelSpanTracker = class {
     if (cleanMetadata?.request) {
       delete cleanMetadata.request;
     }
-    this.currentStepSpan.end({
+    this.#currentStepSpan.end({
       output: otherOutput,
       attributes: {
         usage,
@@ -2618,86 +2661,161 @@ var ModelSpanTracker = class {
         ...cleanMetadata
       }
     });
-    this.currentStepSpan = void 0;
-    this.stepIndex++;
+    this.#currentStepSpan = void 0;
+    this.#stepIndex++;
   }
   /**
    * Create a new chunk span (for multi-part chunks like text-start/delta/end)
    */
-  startChunkSpan(chunkType, initialData) {
-    if (!this.currentStepSpan) {
-      this.startStepSpan();
+  #startChunkSpan(chunkType, initialData) {
+    if (!this.#currentStepSpan) {
+      this.#startStepSpan();
     }
-    this.currentChunkSpan = this.currentStepSpan?.createChildSpan({
+    this.#currentChunkSpan = this.#currentStepSpan?.createChildSpan({
       name: `chunk: '${chunkType}'`,
       type: "model_chunk" /* MODEL_CHUNK */,
       attributes: {
         chunkType,
-        sequenceNumber: this.chunkSequence
+        sequenceNumber: this.#chunkSequence
       }
     });
-    this.accumulator = initialData || {};
+    this.#accumulator = initialData || {};
   }
   /**
    * Append string content to a specific field in the accumulator
    */
-  appendToAccumulator(field, text) {
-    if (this.accumulator[field] === void 0) {
-      this.accumulator[field] = text;
+  #appendToAccumulator(field, text) {
+    if (this.#accumulator[field] === void 0) {
+      this.#accumulator[field] = text;
     } else {
-      this.accumulator[field] += text;
+      this.#accumulator[field] += text;
     }
   }
   /**
    * End the current chunk span.
    * Safe to call multiple times - will no-op if span already ended.
    */
-  endChunkSpan(output) {
-    if (!this.currentChunkSpan) return;
-    this.currentChunkSpan.end({
-      output: output !== void 0 ? output : this.accumulator
+  #endChunkSpan(output) {
+    if (!this.#currentChunkSpan) return;
+    this.#currentChunkSpan.end({
+      output: output !== void 0 ? output : this.#accumulator
     });
-    this.currentChunkSpan = void 0;
-    this.accumulator = {};
-    this.chunkSequence++;
+    this.#currentChunkSpan = void 0;
+    this.#accumulator = {};
+    this.#chunkSequence++;
   }
   /**
    * Create an event span (for single chunks like tool-call)
    */
-  createEventSpan(chunkType, output) {
-    if (!this.currentStepSpan) {
-      this.startStepSpan();
+  #createEventSpan(chunkType, output) {
+    if (!this.#currentStepSpan) {
+      this.#startStepSpan();
     }
-    const span = this.currentStepSpan?.createEventSpan({
+    const span = this.#currentStepSpan?.createEventSpan({
       name: `chunk: '${chunkType}'`,
       type: "model_chunk" /* MODEL_CHUNK */,
       attributes: {
         chunkType,
-        sequenceNumber: this.chunkSequence
+        sequenceNumber: this.#chunkSequence
       },
       output
     });
     if (span) {
-      this.chunkSequence++;
+      this.#chunkSequence++;
     }
   }
   /**
    * Check if there is currently an active chunk span
    */
-  hasActiveChunkSpan() {
-    return !!this.currentChunkSpan;
+  #hasActiveChunkSpan() {
+    return !!this.#currentChunkSpan;
   }
   /**
    * Get the current accumulator value
    */
-  getAccumulator() {
-    return this.accumulator;
+  #getAccumulator() {
+    return this.#accumulator;
   }
   /**
-   * Get the current step span (for making tool calls children of steps)
+   * Handle text chunk spans (text-start/delta/end)
    */
-  getCurrentStepSpan() {
-    return this.currentStepSpan;
+  #handleTextChunk(chunk) {
+    switch (chunk.type) {
+      case "text-start":
+        this.#startChunkSpan("text");
+        break;
+      case "text-delta":
+        this.#appendToAccumulator("text", chunk.payload.text);
+        break;
+      case "text-end": {
+        this.#endChunkSpan();
+        break;
+      }
+    }
+  }
+  /**
+   * Handle reasoning chunk spans (reasoning-start/delta/end)
+   */
+  #handleReasoningChunk(chunk) {
+    switch (chunk.type) {
+      case "reasoning-start":
+        this.#startChunkSpan("reasoning");
+        break;
+      case "reasoning-delta":
+        this.#appendToAccumulator("text", chunk.payload.text);
+        break;
+      case "reasoning-end": {
+        this.#endChunkSpan();
+        break;
+      }
+    }
+  }
+  /**
+   * Handle tool call chunk spans (tool-call-input-streaming-start/delta/end, tool-call)
+   */
+  #handleToolCallChunk(chunk) {
+    switch (chunk.type) {
+      case "tool-call-input-streaming-start":
+        this.#startChunkSpan("tool-call", {
+          toolName: chunk.payload.toolName,
+          toolCallId: chunk.payload.toolCallId
+        });
+        break;
+      case "tool-call-delta":
+        this.#appendToAccumulator("toolInput", chunk.payload.argsTextDelta);
+        break;
+      case "tool-call-input-streaming-end":
+      case "tool-call": {
+        const acc = this.#getAccumulator();
+        let toolInput;
+        try {
+          toolInput = acc.toolInput ? JSON.parse(acc.toolInput) : {};
+        } catch {
+          toolInput = acc.toolInput;
+        }
+        this.#endChunkSpan({
+          toolName: acc.toolName,
+          toolCallId: acc.toolCallId,
+          toolInput
+        });
+        break;
+      }
+    }
+  }
+  /**
+   * Handle object chunk spans (object, object-result)
+   */
+  #handleObjectChunk(chunk) {
+    switch (chunk.type) {
+      case "object":
+        if (!this.#hasActiveChunkSpan()) {
+          this.#startChunkSpan("object");
+        }
+        break;
+      case "object-result":
+        this.#endChunkSpan(chunk.object);
+        break;
+    }
   }
   /**
    * Wraps a stream with model tracing transform to track MODEL_STEP and MODEL_CHUNK spans.
@@ -2706,37 +2824,36 @@ var ModelSpanTracker = class {
    * create MODEL_STEP and MODEL_CHUNK spans for each semantic unit in the stream.
    */
   wrapStream(stream) {
-    const tracker = this;
     return stream.pipeThrough(
       new web.TransformStream({
-        transform(chunk, controller) {
+        transform: (chunk, controller) => {
           controller.enqueue(chunk);
           switch (chunk.type) {
             case "text-start":
             case "text-delta":
             case "text-end":
-              handleTextChunk(chunk, tracker);
+              this.#handleTextChunk(chunk);
               break;
             case "tool-call-input-streaming-start":
             case "tool-call-delta":
             case "tool-call-input-streaming-end":
             case "tool-call":
-              handleToolCallChunk(chunk, tracker);
+              this.#handleToolCallChunk(chunk);
               break;
             case "reasoning-start":
             case "reasoning-delta":
             case "reasoning-end":
-              handleReasoningChunk(chunk, tracker);
+              this.#handleReasoningChunk(chunk);
               break;
             case "object":
             case "object-result":
-              handleObjectChunk(chunk, tracker);
+              this.#handleObjectChunk(chunk);
               break;
             case "step-start":
-              tracker.startStepSpan(chunk.payload);
+              this.#startStepSpan(chunk.payload);
               break;
             case "step-finish":
-              tracker.endStepSpan(chunk.payload);
+              this.#endStepSpan(chunk.payload);
               break;
             case "raw":
             // Skip raw chunks as they're redundant
@@ -2754,7 +2871,7 @@ var ModelSpanTracker = class {
                   delete outputPayload.data;
                 }
               }
-              tracker.createEventSpan(chunk.type, outputPayload);
+              this.#createEventSpan(chunk.type, outputPayload);
               break;
             }
           }
@@ -2763,75 +2880,6 @@ var ModelSpanTracker = class {
     );
   }
 };
-function handleTextChunk(chunk, tracker) {
-  switch (chunk.type) {
-    case "text-start":
-      tracker.startChunkSpan("text");
-      break;
-    case "text-delta":
-      tracker.appendToAccumulator("text", chunk.payload.text);
-      break;
-    case "text-end": {
-      tracker.endChunkSpan();
-      break;
-    }
-  }
-}
-function handleReasoningChunk(chunk, tracker) {
-  switch (chunk.type) {
-    case "reasoning-start":
-      tracker.startChunkSpan("reasoning");
-      break;
-    case "reasoning-delta":
-      tracker.appendToAccumulator("text", chunk.payload.text);
-      break;
-    case "reasoning-end": {
-      tracker.endChunkSpan();
-      break;
-    }
-  }
-}
-function handleToolCallChunk(chunk, tracker) {
-  switch (chunk.type) {
-    case "tool-call-input-streaming-start":
-      tracker.startChunkSpan("tool-call", {
-        toolName: chunk.payload.toolName,
-        toolCallId: chunk.payload.toolCallId
-      });
-      break;
-    case "tool-call-delta":
-      tracker.appendToAccumulator("toolInput", chunk.payload.argsTextDelta);
-      break;
-    case "tool-call-input-streaming-end":
-    case "tool-call": {
-      const acc = tracker.getAccumulator();
-      let toolInput;
-      try {
-        toolInput = acc.toolInput ? JSON.parse(acc.toolInput) : {};
-      } catch {
-        toolInput = acc.toolInput;
-      }
-      tracker.endChunkSpan({
-        toolName: acc.toolName,
-        toolCallId: acc.toolCallId,
-        toolInput
-      });
-      break;
-    }
-  }
-}
-function handleObjectChunk(chunk, tracker) {
-  switch (chunk.type) {
-    case "object":
-      if (!tracker.hasActiveChunkSpan()) {
-        tracker.startChunkSpan("object");
-      }
-      break;
-    case "object-result":
-      tracker.endChunkSpan(chunk.object);
-      break;
-  }
-}
 
 exports.AISpanType = AISpanType;
 exports.AITracingEventType = AITracingEventType;
@@ -2884,5 +2932,5 @@ exports.setupAITracing = setupAITracing;
 exports.shutdownAITracingRegistry = shutdownAITracingRegistry;
 exports.unregisterAITracing = unregisterAITracing;
 exports.wrapMastra = wrapMastra;
-//# sourceMappingURL=chunk-PDST7KX7.cjs.map
-//# sourceMappingURL=chunk-PDST7KX7.cjs.map
+//# sourceMappingURL=chunk-P35FNLTQ.cjs.map
+//# sourceMappingURL=chunk-P35FNLTQ.cjs.map