@mastra/core/dist/chunk-GNP47JBD.js

Mastra is a framework for building AI-powered applications and agents with a modern TypeScript stack.

// src/tools/payload-transform.ts
function normalizeToolPayloadTransformPolicy(policy) {
  if (!policy) {
    return void 0;
  }
  if ("transformToolPayload" in policy) {
    return policy;
  }
  if ("projectToolPayload" in policy && policy.projectToolPayload) {
    return {
      transformToolPayload: policy.projectToolPayload,
      targets: policy.targets
    };
  }
  return void 0;
}
var PHASE_TO_TOOL_TRANSFORMER = {
  "input-delta": "inputDelta",
  "input-available": "input",
  "output-available": "output",
  error: "error",
  approval: "approval",
  suspend: "suspend",
  resume: "resume"
};
function isPolicyConfiguredForTarget(policy, target) {
  return Boolean(policy?.transformToolPayload && (!policy.targets || policy.targets.includes(target)));
}
function isTransformConfigured(source, target) {
  return Boolean(isPolicyConfiguredForTarget(source?.policy, target) || source?.toolTransform?.[target]);
}
function getToolTransformer(source, target, phase) {
  return source?.toolTransform?.[target]?.[PHASE_TO_TOOL_TRANSFORMER[phase]];
}
function safePlaceholder(context) {
  return {
    message: `Tool ${context.phase} payload unavailable`
  };
}
async function transformOneTarget(context, source, logger) {
  const configured = isTransformConfigured(source, context.target);
  if (!configured) {
    return void 0;
  }
  const transformers = [
    isPolicyConfiguredForTarget(source?.policy, context.target) ? source?.policy?.transformToolPayload : void 0,
    getToolTransformer(source, context.target, context.phase)
  ].filter(Boolean);
  if (transformers.length === 0) {
    return context.phase === "input-delta" ? { suppress: true } : { transformed: safePlaceholder(context) };
  }
  for (const transformer of transformers) {
    try {
      const transformed = await transformer(context);
      if (transformed !== void 0) {
        return { transformed };
      }
    } catch (error) {
      logger?.warn?.("Tool payload transform failed", {
        toolName: context.toolName,
        toolCallId: context.toolCallId,
        target: context.target,
        phase: context.phase,
        error
      });
      return context.phase === "input-delta" ? { suppress: true, failed: true } : { transformed: safePlaceholder(context), failed: true };
    }
  }
  return context.phase === "input-delta" ? { suppress: true } : { transformed: safePlaceholder(context) };
}
async function transformToolPayloadForTargets(context, source, logger) {
  const display = await transformOneTarget({ ...context, target: "display" }, source, logger);
  const transcript = await transformOneTarget({ ...context, target: "transcript" }, source, logger);
  if (!display && !transcript) {
    return void 0;
  }
  return {
    ...display ? { display: { [context.phase]: display } } : {},
    ...transcript ? { transcript: { [context.phase]: transcript } } : {}
  };
}
function getTransformedToolPayload(metadata, target, phase) {
  const mastraMetadata = metadata?.mastra;
  const state = mastraMetadata?.toolPayloadTransform?.[target]?.[phase] ?? mastraMetadata?.toolPayloadProjection?.[target]?.[phase];
  if (state && Object.prototype.hasOwnProperty.call(state, "projected") && !Object.prototype.hasOwnProperty.call(state, "transformed")) {
    const { projected, ...rest } = state;
    return { ...rest, transformed: projected };
  }
  return state;
}
function hasTransformedToolPayload(transform) {
  return Boolean(transform && Object.prototype.hasOwnProperty.call(transform, "transformed"));
}
function mergeTransformMetadata(existing, next) {
  if (!existing) {
    return next;
  }
  if (!next) {
    return existing;
  }
  return {
    display: {
      ...existing.display ?? {},
      ...next.display ?? {}
    },
    transcript: {
      ...existing.transcript ?? {},
      ...next.transcript ?? {}
    }
  };
}
function withToolPayloadTransformProviderMetadata(providerMetadata, transformMetadata) {
  const transform = transformMetadata?.mastra?.toolPayloadTransform;
  if (!transform) {
    return providerMetadata;
  }
  return {
    ...providerMetadata ?? {},
    mastra: {
      ...providerMetadata?.mastra ?? {},
      toolPayloadTransform: mergeTransformMetadata(providerMetadata?.mastra?.toolPayloadTransform, transform)
    }
  };
}
function withToolPayloadTransformMetadata(chunk, transform) {
  if (!transform) {
    return chunk;
  }
  return {
    ...chunk,
    metadata: {
      ...chunk.metadata ?? {},
      mastra: {
        ...chunk.metadata?.mastra ?? {},
        toolPayloadTransform: mergeTransformMetadata(chunk.metadata?.mastra?.toolPayloadTransform, transform)
      }
    }
  };
}

export { getTransformedToolPayload, hasTransformedToolPayload, normalizeToolPayloadTransformPolicy, transformToolPayloadForTargets, withToolPayloadTransformMetadata, withToolPayloadTransformProviderMetadata };
//# sourceMappingURL=chunk-GNP47JBD.js.map
//# sourceMappingURL=chunk-GNP47JBD.js.map