@mastra/core/dist/payload-transform-DJzDdfpE.cjs

//#region src/tools/payload-transform.ts
function normalizeToolPayloadTransformPolicy(policy) {
	if (!policy) return;
	if ("transformToolPayload" in policy) return policy;
	if ("projectToolPayload" in policy && policy.projectToolPayload) return {
		transformToolPayload: policy.projectToolPayload,
		targets: policy.targets
	};
}
const 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) {
	if (!isTransformConfigured(source, context.target)) return;
	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;
	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)
			}
		}
	};
}
//#endregion
Object.defineProperty(exports, "getTransformedToolPayload", {
	enumerable: true,
	get: function() {
		return getTransformedToolPayload;
	}
});
Object.defineProperty(exports, "hasTransformedToolPayload", {
	enumerable: true,
	get: function() {
		return hasTransformedToolPayload;
	}
});
Object.defineProperty(exports, "normalizeToolPayloadTransformPolicy", {
	enumerable: true,
	get: function() {
		return normalizeToolPayloadTransformPolicy;
	}
});
Object.defineProperty(exports, "transformToolPayloadForTargets", {
	enumerable: true,
	get: function() {
		return transformToolPayloadForTargets;
	}
});
Object.defineProperty(exports, "withToolPayloadTransformMetadata", {
	enumerable: true,
	get: function() {
		return withToolPayloadTransformMetadata;
	}
});
Object.defineProperty(exports, "withToolPayloadTransformProviderMetadata", {
	enumerable: true,
	get: function() {
		return withToolPayloadTransformProviderMetadata;
	}
});

//# sourceMappingURL=payload-transform-DJzDdfpE.cjs.map