@powerhousedao/pieces-framework 6.2.3-dev.11

package/dist/index.js

@@ -0,0 +1,1569 @@
+import { _ as ErrorHandlingOptionsParam, a as ObjectProperty, c as DynamicProp, d as ArrayProperty, f as ArraySubProps, g as MultiSelectDropdownProperty, h as DropdownProperty, i as RichTextProperty, l as DynamicProperties, m as JsonProperty, n as Property, o as assertNotNullOrUndefined, p as DateTimeProperty, r as CustomProperty, s as isNotUndefined, t as InputProperty, u as DynamicPropsValue, v as IAction, y as createAction } from "./input-COuhC1I-.js";
+import { A as PropertyType, C as CheckboxProperty, D as DropdownState, E as DropdownOption, O as LongTextProperty, S as NumberProperty, T as StaticMultiSelectDropdownProperty, _ as DateRangeProperty, a as chunk, b as ApFile, c as isNil, f as pickBy, g as DateRangePreset, h as MarkdownVariant, i as camelCase, j as BasePropertySchema, k as ShortTextProperty, l as isString, m as unique, n as tryCatch, p as startCase, s as isEmpty, u as kebabCase, v as DateRangeValue, w as StaticDropdownProperty, x as FileProperty, y as dateRangeUtils } from "./markdown-property-Df2l6_y_.js";
+import { _ as TriggerStrategy, a as OAuth2AuthorizationMethod, b as AppConnectionType, c as OAuth2Props, d as SecretTextProperty, f as BasicAuthProperty, g as AUTHENTICATION_PROPERTY_NAME, h as spreadIfDefined, i as getAuthPropertyForValue, l as OIDCProperty, n as PieceAuth, o as OAuth2Property, p as BasicAuthPropertyValue, r as PieceAuthProperty, s as OAuth2PropertyValue, t as DEFAULT_CONNECTION_DISPLAY_NAME, u as CustomAuthProperty, v as TriggerTestStrategy, x as OAuth2GrantType, y as WebhookHandshakeStrategy } from "./authentication-B7brX_It.js";
+import * as z from "zod/mini";
+import { customAlphabet } from "nanoid";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+//#region upstream/core-piece-types/lib/piece.ts
+let PackageType = /* @__PURE__ */ function(PackageType) {
+	PackageType["ARCHIVE"] = "ARCHIVE";
+	PackageType["REGISTRY"] = "REGISTRY";
+	return PackageType;
+}({});
+let PieceType = /* @__PURE__ */ function(PieceType) {
+	PieceType["CUSTOM"] = "CUSTOM";
+	PieceType["OFFICIAL"] = "OFFICIAL";
+	return PieceType;
+}({});
+let PieceCategory = /* @__PURE__ */ function(PieceCategory) {
+	PieceCategory["ARTIFICIAL_INTELLIGENCE"] = "ARTIFICIAL_INTELLIGENCE";
+	PieceCategory["COMMUNICATION"] = "COMMUNICATION";
+	PieceCategory["COMMERCE"] = "COMMERCE";
+	PieceCategory["CORE"] = "CORE";
+	PieceCategory["UNIVERSAL_AI"] = "UNIVERSAL_AI";
+	PieceCategory["FLOW_CONTROL"] = "FLOW_CONTROL";
+	PieceCategory["BUSINESS_INTELLIGENCE"] = "BUSINESS_INTELLIGENCE";
+	PieceCategory["ACCOUNTING"] = "ACCOUNTING";
+	PieceCategory["PRODUCTIVITY"] = "PRODUCTIVITY";
+	PieceCategory["CONTENT_AND_FILES"] = "CONTENT_AND_FILES";
+	PieceCategory["DEVELOPER_TOOLS"] = "DEVELOPER_TOOLS";
+	PieceCategory["CUSTOMER_SUPPORT"] = "CUSTOMER_SUPPORT";
+	PieceCategory["FORMS_AND_SURVEYS"] = "FORMS_AND_SURVEYS";
+	PieceCategory["HUMAN_RESOURCES"] = "HUMAN_RESOURCES";
+	PieceCategory["PAYMENT_PROCESSING"] = "PAYMENT_PROCESSING";
+	PieceCategory["MARKETING"] = "MARKETING";
+	PieceCategory["SALES_AND_CRM"] = "SALES_AND_CRM";
+	return PieceCategory;
+}({});
+
+//#endregion
+//#region upstream/core-piece-types/lib/execution.ts
+let ExecutionType = /* @__PURE__ */ function(ExecutionType) {
+	ExecutionType["BEGIN"] = "BEGIN";
+	ExecutionType["RESUME"] = "RESUME";
+	return ExecutionType;
+}({});
+let PauseType = /* @__PURE__ */ function(PauseType) {
+	PauseType["DELAY"] = "DELAY";
+	PauseType["WEBHOOK"] = "WEBHOOK";
+	return PauseType;
+}({});
+let StreamStepProgress = /* @__PURE__ */ function(StreamStepProgress) {
+	StreamStepProgress["WEBSOCKET"] = "WEBSOCKET";
+	StreamStepProgress["NONE"] = "NONE";
+	return StreamStepProgress;
+}({});
+const RespondResponse = z.object({
+	status: z.optional(z.number()),
+	body: z.optional(z.unknown()),
+	headers: z.optional(z.record(z.string(), z.string()))
+});
+const DelayPauseMetadata = z.object({
+	type: z.literal(PauseType.DELAY),
+	resumeDateTime: z.string(),
+	requestIdToReply: z.optional(z.string()),
+	handlerId: z.optional(z.string()),
+	streamStepProgress: z.optional(z.enum(StreamStepProgress))
+});
+const WebhookPauseMetadata = z.object({
+	type: z.literal(PauseType.WEBHOOK),
+	requestId: z.string(),
+	requestIdToReply: z.optional(z.string()),
+	response: RespondResponse,
+	handlerId: z.optional(z.string()),
+	streamStepProgress: z.optional(z.enum(StreamStepProgress))
+});
+const PauseMetadata = z.union([DelayPauseMetadata, WebhookPauseMetadata]);
+
+//#endregion
+//#region upstream/core-utils/lib/id-generator.ts
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ID_LENGTH = 21;
+const ApId = z.string().check(z.regex(new RegExp(`^[0-9a-zA-Z]{${ID_LENGTH}}$`)));
+const apId = customAlphabet(ALPHABET, ID_LENGTH);
+
+//#endregion
+//#region upstream/core-utils/lib/base-model.ts
+const DateOrString = z.pipe(z.transform((val) => val instanceof Date ? val.toISOString() : val), z.string());
+const BaseModelSchema = {
+	id: z.string(),
+	created: DateOrString,
+	updated: DateOrString
+};
+const Nullable = (schema) => z.optional(z.nullable(schema));
+function NullableEnum(enumObj) {
+	return z.optional(z.nullable(z.enum(enumObj)));
+}
+const OptionalBooleanFromQuery = z.pipe(z.transform((val) => val === "true" || val === true ? true : val === "false" || val === false ? false : void 0), z.optional(z.boolean()));
+const OptionalArrayFromQuery = (schema) => z.pipe(z.transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : void 0), z.optional(z.array(schema)));
+
+//#endregion
+//#region upstream/core-utils/lib/seek-page.ts
+const SeekPage = (t) => z.object({
+	data: z.array(t),
+	next: Nullable(z.string()),
+	previous: Nullable(z.string())
+});
+
+//#endregion
+//#region upstream/core-utils/lib/locale.ts
+let LocalesEnum = /* @__PURE__ */ function(LocalesEnum) {
+	LocalesEnum["DUTCH"] = "nl";
+	LocalesEnum["ENGLISH"] = "en";
+	LocalesEnum["GERMAN"] = "de";
+	LocalesEnum["FRENCH"] = "fr";
+	LocalesEnum["SPANISH"] = "es";
+	LocalesEnum["JAPANESE"] = "ja";
+	LocalesEnum["CHINESE_SIMPLIFIED"] = "zh";
+	LocalesEnum["PORTUGUESE"] = "pt";
+	LocalesEnum["ARABIC"] = "ar";
+	LocalesEnum["CHINESE_TRADITIONAL"] = "zh-TW";
+	return LocalesEnum;
+}({});
+
+//#endregion
+//#region upstream/core-utils/lib/permission.ts
+let AIProviderName = /* @__PURE__ */ function(AIProviderName) {
+	AIProviderName["OPENAI"] = "openai";
+	AIProviderName["OPENROUTER"] = "openrouter";
+	AIProviderName["ANTHROPIC"] = "anthropic";
+	AIProviderName["AZURE"] = "azure";
+	AIProviderName["GOOGLE"] = "google";
+	AIProviderName["ACTIVEPIECES"] = "activepieces";
+	AIProviderName["CLOUDFLARE_GATEWAY"] = "cloudflare-gateway";
+	AIProviderName["CUSTOM"] = "custom";
+	AIProviderName["BEDROCK"] = "bedrock";
+	AIProviderName["VERTEX"] = "vertex";
+	AIProviderName["MISTRAL"] = "mistral";
+	AIProviderName["XAI"] = "xai";
+	AIProviderName["DEEPSEEK"] = "deepseek";
+	AIProviderName["ZAI"] = "zai";
+	AIProviderName["QWEN"] = "qwen";
+	AIProviderName["MINIMAX"] = "minimax";
+	AIProviderName["MOONSHOT"] = "moonshot";
+	return AIProviderName;
+}({});
+
+//#endregion
+//#region upstream/core-piece-types/lib/agents.ts
+const TASK_COMPLETION_TOOL_NAME = "updateTaskStatus";
+let AgentToolType = /* @__PURE__ */ function(AgentToolType) {
+	AgentToolType["PIECE"] = "PIECE";
+	AgentToolType["FLOW"] = "FLOW";
+	AgentToolType["MCP"] = "MCP";
+	AgentToolType["KNOWLEDGE_BASE"] = "KNOWLEDGE_BASE";
+	return AgentToolType;
+}({});
+let FieldControlMode = /* @__PURE__ */ function(FieldControlMode) {
+	FieldControlMode["AGENT_DECIDE"] = "agent-decide";
+	FieldControlMode["CHOOSE_YOURSELF"] = "choose-yourself";
+	FieldControlMode["LEAVE_EMPTY"] = "leave-empty";
+	return FieldControlMode;
+}({});
+let KnowledgeBaseSourceType = /* @__PURE__ */ function(KnowledgeBaseSourceType) {
+	KnowledgeBaseSourceType["FILE"] = "FILE";
+	KnowledgeBaseSourceType["TABLE"] = "TABLE";
+	return KnowledgeBaseSourceType;
+}({});
+let McpProtocol = /* @__PURE__ */ function(McpProtocol) {
+	McpProtocol["SSE"] = "sse";
+	McpProtocol["STREAMABLE_HTTP"] = "streamable-http";
+	McpProtocol["SIMPLE_HTTP"] = "http";
+	return McpProtocol;
+}({});
+let McpAuthType = /* @__PURE__ */ function(McpAuthType) {
+	McpAuthType["NONE"] = "none";
+	McpAuthType["ACCESS_TOKEN"] = "access_token";
+	McpAuthType["API_KEY"] = "api_key";
+	McpAuthType["HEADERS"] = "headers";
+	return McpAuthType;
+}({});
+let AgentOutputFieldType = /* @__PURE__ */ function(AgentOutputFieldType) {
+	AgentOutputFieldType["TEXT"] = "text";
+	AgentOutputFieldType["NUMBER"] = "number";
+	AgentOutputFieldType["BOOLEAN"] = "boolean";
+	return AgentOutputFieldType;
+}({});
+let AgentTaskStatus = /* @__PURE__ */ function(AgentTaskStatus) {
+	AgentTaskStatus["COMPLETED"] = "COMPLETED";
+	AgentTaskStatus["FAILED"] = "FAILED";
+	AgentTaskStatus["IN_PROGRESS"] = "IN_PROGRESS";
+	return AgentTaskStatus;
+}({});
+let ContentBlockType = /* @__PURE__ */ function(ContentBlockType) {
+	ContentBlockType["MARKDOWN"] = "MARKDOWN";
+	ContentBlockType["TOOL_CALL"] = "TOOL_CALL";
+	return ContentBlockType;
+}({});
+let ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
+	ToolCallStatus["IN_PROGRESS"] = "in-progress";
+	ToolCallStatus["COMPLETED"] = "completed";
+	return ToolCallStatus;
+}({});
+let ExecutionToolStatus = /* @__PURE__ */ function(ExecutionToolStatus) {
+	ExecutionToolStatus["SUCCESS"] = "SUCCESS";
+	ExecutionToolStatus["FAILED"] = "FAILED";
+	return ExecutionToolStatus;
+}({});
+let ToolCallType = /* @__PURE__ */ function(ToolCallType) {
+	ToolCallType["PIECE"] = "PIECE";
+	ToolCallType["FLOW"] = "FLOW";
+	ToolCallType["MCP"] = "MCP";
+	ToolCallType["KNOWLEDGE_BASE"] = "KNOWLEDGE_BASE";
+	ToolCallType["UNKNOWN"] = "UNKNOWN";
+	return ToolCallType;
+}({});
+let AgentPieceProps = /* @__PURE__ */ function(AgentPieceProps) {
+	AgentPieceProps["AGENT_ID"] = "agentId";
+	AgentPieceProps["AGENT_TOOLS"] = "agentTools";
+	AgentPieceProps["STRUCTURED_OUTPUT"] = "structuredOutput";
+	AgentPieceProps["PROMPT"] = "prompt";
+	AgentPieceProps["MAX_STEPS"] = "maxSteps";
+	AgentPieceProps["AI_PROVIDER_MODEL"] = "aiProviderModel";
+	AgentPieceProps["WEB_SEARCH"] = "webSearch";
+	AgentPieceProps["WEB_SEARCH_OPTIONS"] = "webSearchOptions";
+	return AgentPieceProps;
+}({});
+const PredefinedInputField = z.object({
+	mode: z.enum(FieldControlMode),
+	value: z.unknown()
+});
+const PredefinedInputsStructure = z.object({
+	auth: z.optional(z.string()),
+	fields: z.record(z.string(), PredefinedInputField)
+});
+const AgentPieceToolMetadata = z.object({
+	pieceName: z.string(),
+	pieceVersion: z.string(),
+	actionName: z.string(),
+	predefinedInput: z.optional(PredefinedInputsStructure)
+});
+const AgentPieceTool = z.object({
+	type: z.literal(AgentToolType.PIECE),
+	toolName: z.string().check(z.minLength(1)),
+	pieceMetadata: AgentPieceToolMetadata
+});
+const McpAuthNone = z.object({ type: z.literal(McpAuthType.NONE) });
+const McpAuthAccessToken = z.object({
+	type: z.literal(McpAuthType.ACCESS_TOKEN),
+	accessToken: z.string()
+});
+const McpAuthApiKey = z.object({
+	type: z.literal(McpAuthType.API_KEY),
+	apiKey: z.string(),
+	apiKeyHeader: z.string()
+});
+const McpAuthHeaders = z.object({
+	type: z.literal(McpAuthType.HEADERS),
+	headers: z.record(z.string(), z.string())
+});
+const McpAuthConfig = z.discriminatedUnion("type", [
+	McpAuthNone,
+	McpAuthAccessToken,
+	McpAuthApiKey,
+	McpAuthHeaders
+]);
+const AgentFlowTool = z.object({
+	type: z.literal(AgentToolType.FLOW),
+	toolName: z.string().check(z.minLength(1)),
+	externalFlowId: z.string(),
+	flowDisplayName: z.optional(z.string())
+});
+const AgentMcpTool = z.object({
+	type: z.literal(AgentToolType.MCP),
+	toolName: z.string().check(z.minLength(1)),
+	serverUrl: z.url(),
+	protocol: z.enum(McpProtocol),
+	auth: McpAuthConfig
+});
+const AgentKnowledgeBaseTool = z.object({
+	type: z.literal(AgentToolType.KNOWLEDGE_BASE),
+	toolName: z.string().check(z.minLength(1)),
+	sourceType: z.enum(KnowledgeBaseSourceType),
+	sourceId: z.string(),
+	sourceName: z.string()
+});
+const AgentTool = z.discriminatedUnion("type", [
+	AgentPieceTool,
+	AgentFlowTool,
+	AgentMcpTool,
+	AgentKnowledgeBaseTool
+]);
+const AgentOutputField = z.object({
+	displayName: z.string(),
+	description: z.optional(z.string()),
+	type: z.enum(AgentOutputFieldType)
+});
+const MarkdownContentBlock = z.object({
+	type: z.literal(ContentBlockType.MARKDOWN),
+	markdown: z.string()
+});
+const toolCallBaseShape = {
+	type: z.literal(ContentBlockType.TOOL_CALL),
+	input: Nullable(z.record(z.string(), z.unknown())),
+	output: z.optional(z.unknown()),
+	toolName: z.string(),
+	status: z.enum(ToolCallStatus),
+	toolCallId: z.string(),
+	startTime: z.string(),
+	endTime: z.optional(z.string())
+};
+z.object(toolCallBaseShape);
+const ToolCallContentBlock = z.discriminatedUnion("toolCallType", [
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.PIECE),
+		pieceName: z.string(),
+		pieceVersion: z.string(),
+		actionName: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.FLOW),
+		displayName: z.string(),
+		externalFlowId: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.MCP),
+		displayName: z.string(),
+		serverUrl: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.KNOWLEDGE_BASE),
+		displayName: z.string(),
+		sourceType: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.UNKNOWN),
+		displayName: z.string()
+	})
+]);
+const AgentStepBlock = z.union([MarkdownContentBlock, ToolCallContentBlock]);
+function buildAuthHeaders(authConfig) {
+	let headers = {};
+	switch (authConfig.type) {
+		case McpAuthType.NONE: break;
+		case McpAuthType.HEADERS:
+			headers = authConfig.headers;
+			break;
+		case McpAuthType.ACCESS_TOKEN:
+			headers["Authorization"] = `Bearer ${authConfig.accessToken}`;
+			break;
+		case McpAuthType.API_KEY: {
+			const headerName = authConfig.apiKeyHeader;
+			headers[headerName] = authConfig.apiKey;
+			break;
+		}
+	}
+	return headers;
+}
+function shortHash(str) {
+	let h = 5381;
+	for (let i = 0; i < str.length; i++) h = (Math.imul(h, 33) ^ str.charCodeAt(i)) >>> 0;
+	return h.toString(36).padStart(6, "0").slice(-6);
+}
+function sanitizeToolName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function createToolName(name) {
+	const sanitized = sanitizeToolName(name);
+	return `${sanitized.slice(0, MAX_PREFIX_LENGTH)}_${shortHash(sanitized.length > 0 ? sanitized : name)}_mcp`;
+}
+function toValidToolName(name) {
+	if (PROVIDER_TOOL_NAME_PATTERN.test(name)) return name;
+	const generated = createToolName(name);
+	return PROVIDER_TOOL_NAME_PATTERN.test(generated) ? generated : createToolName(`tool_${name}`);
+}
+function suggestToolName(sourceName) {
+	return toValidToolName(sanitizeToolName(sourceName));
+}
+function isProviderSafeIdentifier(name) {
+	return PROVIDER_TOOL_NAME_PATTERN.test(name);
+}
+function toProviderSafeIdentifier({ name, fallback }) {
+	if (isProviderSafeIdentifier(name)) return name;
+	const sanitized = sanitizeToolName(name).slice(0, MAX_IDENTIFIER_LENGTH);
+	if (sanitized.length === 0) return fallback;
+	const seeded = /^[a-z_]/.test(sanitized) ? sanitized : `_${sanitized}`;
+	return isProviderSafeIdentifier(seeded) ? seeded : fallback;
+}
+function createPieceToolName(pieceName, actionName) {
+	const idx = pieceName.indexOf("piece-");
+	return createToolName(`${idx >= 0 ? pieceName.substring(idx + 6) : pieceName}-${actionName}`);
+}
+const MAX_PREFIX_LENGTH = 53;
+const MAX_IDENTIFIER_LENGTH = 64;
+const PROVIDER_TOOL_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_-]{0,63}$/;
+const mcpToolNameUtils = {
+	createToolName,
+	createPieceToolName,
+	toValidToolName,
+	suggestToolName,
+	isProviderSafeIdentifier,
+	toProviderSafeIdentifier
+};
+const AGENT_STEP_TIMEOUT_MS = 10800 * 1e3;
+const AGENT_STEP_TEST_TIMEOUT_MS = 900 * 1e3;
+
+//#endregion
+//#region upstream/core-piece-types/lib/ai-providers.ts
+let AIProviderModelType = /* @__PURE__ */ function(AIProviderModelType) {
+	AIProviderModelType["IMAGE"] = "image";
+	AIProviderModelType["TEXT"] = "text";
+	return AIProviderModelType;
+}({});
+const BaseAIProviderAuthConfig = z.object({ apiKey: z.string() });
+const AnthropicProviderAuthConfig = BaseAIProviderAuthConfig;
+const ActivePiecesProviderAuthConfig = z.object({
+	apiKey: z.string(),
+	apiKeyHash: z.string()
+});
+const OpenAICompatibleProviderAuthConfig = BaseAIProviderAuthConfig;
+const CloudflareGatewayProviderAuthConfig = BaseAIProviderAuthConfig;
+const AzureProviderAuthConfig = BaseAIProviderAuthConfig;
+const GoogleProviderAuthConfig = BaseAIProviderAuthConfig;
+const OpenAIProviderAuthConfig = BaseAIProviderAuthConfig;
+const OpenRouterProviderAuthConfig = BaseAIProviderAuthConfig;
+const MistralProviderAuthConfig = BaseAIProviderAuthConfig;
+const VertexProviderAuthConfig = z.object({ serviceAccountJson: z.string().check(z.minLength(1)) });
+const BedrockProviderAuthConfig = z.object({
+	accessKeyId: z.string().check(z.minLength(1)),
+	secretAccessKey: z.string().check(z.minLength(1))
+});
+const AnthropicProviderConfig = z.object({});
+const ActivePiecesProviderConfig = z.object({});
+const GoogleProviderConfig = z.object({});
+const OpenAIProviderConfig = z.object({});
+const OpenRouterProviderConfig = z.object({});
+const MistralProviderConfig = z.object({});
+const ProviderModelConfig = z.object({
+	modelId: z.string(),
+	modelName: z.string(),
+	modelType: z.enum(AIProviderModelType)
+});
+const OpenAICompatibleProviderConfig = z.object({
+	apiKeyHeader: z.string(),
+	baseUrl: z.string(),
+	models: z.array(ProviderModelConfig),
+	defaultHeaders: z.optional(z.record(z.string(), z.string())),
+	apiStyle: z.optional(z.enum(["chat", "responses"]))
+});
+const CloudflareGatewayProviderConfig = z.object({
+	accountId: z.string(),
+	gatewayId: z.string(),
+	models: z.array(ProviderModelConfig),
+	vertexProject: z.optional(z.string()),
+	vertexRegion: z.optional(z.string())
+});
+const AzureProviderConfig = z.object({
+	resourceName: z.string(),
+	apiVersion: z.pipe(z.transform((v) => typeof v === "string" && v.trim().length === 0 ? void 0 : v), z.optional(z.string()))
+});
+const BedrockProviderConfig = z.object({ region: z.string().check(z.minLength(1)) });
+const VertexProviderConfig = z.object({
+	project: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
+	region: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
+	models: z.array(ProviderModelConfig)
+});
+const OpenAiCompatibleVendorConfig = z.object({});
+const AIProviderAuthConfig = z.union([
+	AnthropicProviderAuthConfig,
+	AzureProviderAuthConfig,
+	GoogleProviderAuthConfig,
+	OpenAIProviderAuthConfig,
+	OpenRouterProviderAuthConfig,
+	CloudflareGatewayProviderAuthConfig,
+	OpenAICompatibleProviderAuthConfig,
+	ActivePiecesProviderAuthConfig,
+	BedrockProviderAuthConfig,
+	VertexProviderAuthConfig,
+	MistralProviderAuthConfig
+]);
+const AIProviderConfig = z.union([
+	OpenAICompatibleProviderConfig,
+	CloudflareGatewayProviderConfig,
+	AzureProviderConfig,
+	VertexProviderConfig,
+	BedrockProviderConfig,
+	AnthropicProviderConfig,
+	GoogleProviderConfig,
+	OpenAIProviderConfig,
+	OpenRouterProviderConfig,
+	ActivePiecesProviderConfig,
+	MistralProviderConfig,
+	OpenAiCompatibleVendorConfig
+]);
+const AIProviderModel = z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.enum(AIProviderModelType)
+});
+const AIProviderWithoutSensitiveData = z.object({
+	id: z.string(),
+	name: z.string(),
+	provider: z.enum(AIProviderName),
+	config: AIProviderConfig,
+	enabledForChat: z.boolean()
+});
+const ProjectAIProvider = z.object({
+	provider: z.enum(AIProviderName),
+	name: z.string(),
+	enabledForChat: z.boolean(),
+	keys: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	}))
+});
+const GetProviderConfigResponse = z.object({
+	provider: z.enum(AIProviderName),
+	configId: z.string(),
+	config: AIProviderConfig,
+	auth: AIProviderAuthConfig,
+	platformId: z.string()
+});
+function splitCloudflareGatewayModelId(modelId) {
+	const slashIndex = modelId.indexOf("/");
+	if (slashIndex === -1) return {
+		provider: void 0,
+		model: modelId,
+		publisher: void 0
+	};
+	const provider = modelId.substring(0, slashIndex).trim().toLowerCase();
+	const rest = modelId.substring(slashIndex + 1);
+	if (provider === "google-vertex-ai") {
+		const secondSlashIndex = rest.indexOf("/");
+		if (secondSlashIndex === -1) return {
+			provider: void 0,
+			model: modelId,
+			publisher: void 0
+		};
+		return {
+			provider: "google-vertex-ai",
+			publisher: rest.substring(0, secondSlashIndex),
+			model: rest.substring(secondSlashIndex + 1)
+		};
+	}
+	return {
+		provider,
+		model: rest,
+		publisher: void 0
+	};
+}
+function getEffectiveProviderAndModel({ provider, model }) {
+	if (provider !== AIProviderName.CLOUDFLARE_GATEWAY || !model) return {
+		provider,
+		model
+	};
+	const split = splitCloudflareGatewayModelId(model);
+	const mapped = CF_GATEWAY_SUBMODEL_TO_PROVIDER[(split.provider ?? "").trim().toLowerCase()];
+	if (!mapped) return {
+		provider,
+		model
+	};
+	return {
+		provider: mapped,
+		model: split.model
+	};
+}
+const CF_GATEWAY_SUBMODEL_TO_PROVIDER = {
+	openai: AIProviderName.OPENAI,
+	anthropic: AIProviderName.ANTHROPIC,
+	"google-ai-studio": AIProviderName.GOOGLE,
+	"google-vertex-ai": AIProviderName.GOOGLE
+};
+const OPENAI_CHAT_MODELS = [
+	"gpt-5.5",
+	"gpt-5.4-mini",
+	"gpt-5.4-nano",
+	"gpt-4.1",
+	"gpt-4.1-mini"
+];
+const ANTHROPIC_CHAT_MODELS = [
+	"claude-sonnet-4-6",
+	"claude-opus-4-7",
+	"claude-haiku-4-5"
+];
+const ANTHROPIC_OPENROUTER_CHAT_MODELS = [
+	"claude-sonnet-4.6",
+	"claude-opus-4.7",
+	"claude-opus-4.8",
+	"claude-haiku-4.5"
+];
+const GOOGLE_CHAT_MODELS = [
+	"gemini-2.5-pro",
+	"gemini-2.5-flash",
+	"gemini-3.7-flash",
+	"gemini-3.1-pro-preview",
+	"gemini-3-flash-preview"
+];
+const X_AI_OPENROUTER_CHAT_MODELS = ["grok-4.20"];
+const REASONING_OPTIONAL_CHAT_MODELS = ANTHROPIC_OPENROUTER_CHAT_MODELS.map((model) => `${AIProviderName.ANTHROPIC}/${model}`);
+const ALLOWED_CHAT_MODELS_BY_PROVIDER = {
+	[AIProviderName.OPENAI]: OPENAI_CHAT_MODELS,
+	[AIProviderName.ANTHROPIC]: ANTHROPIC_CHAT_MODELS,
+	[AIProviderName.GOOGLE]: GOOGLE_CHAT_MODELS,
+	[AIProviderName.VERTEX]: GOOGLE_CHAT_MODELS,
+	[AIProviderName.ACTIVEPIECES]: [
+		...ANTHROPIC_OPENROUTER_CHAT_MODELS.map((m) => `${AIProviderName.ANTHROPIC}/${m}`),
+		...OPENAI_CHAT_MODELS.map((m) => `${AIProviderName.OPENAI}/${m}`),
+		...GOOGLE_CHAT_MODELS.map((m) => `${AIProviderName.GOOGLE}/${m}`),
+		...X_AI_OPENROUTER_CHAT_MODELS.map((m) => `x-ai/${m}`)
+	]
+};
+const DEFAULT_MAX_CONTEXT_TOKENS = 128e3;
+const PROVIDER_MAX_CONTEXT_TOKENS = {
+	[AIProviderName.OPENAI]: 128e3,
+	[AIProviderName.ANTHROPIC]: 2e5,
+	[AIProviderName.GOOGLE]: 1048576,
+	[AIProviderName.BEDROCK]: 2e5,
+	[AIProviderName.VERTEX]: 1048576,
+	[AIProviderName.AZURE]: 128e3,
+	[AIProviderName.OPENROUTER]: 128e3,
+	[AIProviderName.ACTIVEPIECES]: 2e5,
+	[AIProviderName.MISTRAL]: 128e3
+};
+function getMaxContextTokens({ provider }) {
+	if (!provider) return DEFAULT_MAX_CONTEXT_TOKENS;
+	return PROVIDER_MAX_CONTEXT_TOKENS[provider] ?? DEFAULT_MAX_CONTEXT_TOKENS;
+}
+const DEFAULT_EMBEDDING_MODELS = {
+	[AIProviderName.OPENAI]: "text-embedding-3-small",
+	[AIProviderName.GOOGLE]: "text-embedding-004",
+	[AIProviderName.AZURE]: "text-embedding-3-small",
+	[AIProviderName.ACTIVEPIECES]: "text-embedding-3-small",
+	[AIProviderName.OPENROUTER]: "openai/text-embedding-3-small"
+};
+const WEB_SEARCH_MODE_BY_PROVIDER = {
+	[AIProviderName.ANTHROPIC]: "native",
+	[AIProviderName.GOOGLE]: "native",
+	[AIProviderName.OPENROUTER]: "plugin",
+	[AIProviderName.ACTIVEPIECES]: "plugin"
+};
+const NO_IMAGE_GENERATION_PROVIDERS = new Set([
+	AIProviderName.ANTHROPIC,
+	AIProviderName.MISTRAL,
+	AIProviderName.XAI,
+	AIProviderName.DEEPSEEK,
+	AIProviderName.ZAI,
+	AIProviderName.QWEN,
+	AIProviderName.MINIMAX,
+	AIProviderName.MOONSHOT
+]);
+const OPENAI_COMPATIBLE_VENDOR_BASE_URLS = {
+	[AIProviderName.XAI]: "https://api.x.ai/v1",
+	[AIProviderName.DEEPSEEK]: "https://api.deepseek.com/v1",
+	[AIProviderName.ZAI]: "https://api.z.ai/api/paas/v4",
+	[AIProviderName.QWEN]: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+	[AIProviderName.MINIMAX]: "https://api.minimax.io/v1",
+	[AIProviderName.MOONSHOT]: "https://api.moonshot.ai/v1"
+};
+function buildProviderCapabilities(provider) {
+	return {
+		chatModels: ALLOWED_CHAT_MODELS_BY_PROVIDER[provider],
+		maxContextTokens: getMaxContextTokens({ provider }),
+		defaultEmbeddingModel: DEFAULT_EMBEDDING_MODELS[provider],
+		supportsEmbedding: DEFAULT_EMBEDDING_MODELS[provider] !== void 0,
+		supportsImageGeneration: !NO_IMAGE_GENERATION_PROVIDERS.has(provider),
+		webSearch: WEB_SEARCH_MODE_BY_PROVIDER[provider]
+	};
+}
+const ACTIVEPIECES_CHAT_TIERS = [
+	{
+		id: "fast",
+		label: "Fast",
+		modelId: "anthropic/claude-haiku-4.5",
+		nativeModelId: "claude-haiku-4-5",
+		thinkingBudget: 5e3,
+		creditWeight: 2
+	},
+	{
+		id: "smart",
+		label: "Expert",
+		modelId: "anthropic/claude-sonnet-4.6",
+		nativeModelId: "claude-sonnet-4-6",
+		thinkingBudget: 1e4,
+		creditWeight: 10
+	},
+	{
+		id: "premium",
+		label: "Heavy",
+		modelId: "anthropic/claude-opus-4.8",
+		nativeModelId: "claude-opus-4-7",
+		thinkingBudget: 2e4,
+		creditWeight: 20
+	}
+];
+const DEFAULT_CHAT_TIER_ID = "smart";
+const AI_PROVIDER_CAPABILITIES = {
+	[AIProviderName.OPENAI]: buildProviderCapabilities(AIProviderName.OPENAI),
+	[AIProviderName.ANTHROPIC]: buildProviderCapabilities(AIProviderName.ANTHROPIC),
+	[AIProviderName.OPENROUTER]: buildProviderCapabilities(AIProviderName.OPENROUTER),
+	[AIProviderName.AZURE]: buildProviderCapabilities(AIProviderName.AZURE),
+	[AIProviderName.GOOGLE]: buildProviderCapabilities(AIProviderName.GOOGLE),
+	[AIProviderName.CLOUDFLARE_GATEWAY]: buildProviderCapabilities(AIProviderName.CLOUDFLARE_GATEWAY),
+	[AIProviderName.CUSTOM]: buildProviderCapabilities(AIProviderName.CUSTOM),
+	[AIProviderName.BEDROCK]: buildProviderCapabilities(AIProviderName.BEDROCK),
+	[AIProviderName.VERTEX]: buildProviderCapabilities(AIProviderName.VERTEX),
+	[AIProviderName.MISTRAL]: buildProviderCapabilities(AIProviderName.MISTRAL),
+	[AIProviderName.ACTIVEPIECES]: buildProviderCapabilities(AIProviderName.ACTIVEPIECES),
+	[AIProviderName.XAI]: buildProviderCapabilities(AIProviderName.XAI),
+	[AIProviderName.DEEPSEEK]: buildProviderCapabilities(AIProviderName.DEEPSEEK),
+	[AIProviderName.ZAI]: buildProviderCapabilities(AIProviderName.ZAI),
+	[AIProviderName.QWEN]: buildProviderCapabilities(AIProviderName.QWEN),
+	[AIProviderName.MINIMAX]: buildProviderCapabilities(AIProviderName.MINIMAX),
+	[AIProviderName.MOONSHOT]: buildProviderCapabilities(AIProviderName.MOONSHOT)
+};
+
+//#endregion
+//#region upstream/core-piece-types/lib/forms.ts
+const FileResponseInterfaceV1 = z.object({
+	base64Url: z.string(),
+	fileName: z.string(),
+	extension: z.optional(z.string())
+});
+const FileResponseInterfaceV2 = z.object({
+	mimeType: z.string(),
+	url: z.string(),
+	fileName: z.optional(z.string())
+});
+const FileResponseInterface = z.union([FileResponseInterfaceV1, FileResponseInterfaceV2]);
+let HumanInputFormResultTypes = /* @__PURE__ */ function(HumanInputFormResultTypes) {
+	HumanInputFormResultTypes["FILE"] = "file";
+	HumanInputFormResultTypes["MARKDOWN"] = "markdown";
+	return HumanInputFormResultTypes;
+}({});
+function createKeyForFormInput(displayName) {
+	/**We do this because react form inputs must not contain quotes */
+	return displayName.toLowerCase().replace(/\s+(\w)/g, (_, letter) => letter.toUpperCase()).replace(/^(.)/, (letter) => letter.toLowerCase()).replaceAll(/[\\"''\n\r\t]/g, "");
+}
+const HumanInputFormResult = z.union([z.object({
+	type: z.literal(HumanInputFormResultTypes.FILE),
+	value: FileResponseInterface
+}), z.object({
+	type: z.literal(HumanInputFormResultTypes.MARKDOWN),
+	value: z.string(),
+	files: z.optional(z.array(FileResponseInterface))
+})]);
+const ChatFormResponse = z.object({
+	sessionId: z.string(),
+	message: z.string(),
+	files: z.optional(z.array(z.string()))
+});
+
+//#endregion
+//#region upstream/core-piece-types/lib/tables.ts
+let FieldType = /* @__PURE__ */ function(FieldType) {
+	FieldType["TEXT"] = "TEXT";
+	FieldType["NUMBER"] = "NUMBER";
+	FieldType["DATE"] = "DATE";
+	FieldType["DATETIME"] = "DATETIME";
+	FieldType["STATIC_DROPDOWN"] = "STATIC_DROPDOWN";
+	return FieldType;
+}({});
+let TableAutomationTrigger = /* @__PURE__ */ function(TableAutomationTrigger) {
+	TableAutomationTrigger["ON_NEW_RECORD"] = "ON_NEW_RECORD";
+	TableAutomationTrigger["ON_UPDATE_RECORD"] = "ON_UPDATE_RECORD";
+	return TableAutomationTrigger;
+}({});
+let TableAutomationStatus = /* @__PURE__ */ function(TableAutomationStatus) {
+	TableAutomationStatus["ENABLED"] = "ENABLED";
+	TableAutomationStatus["DISABLED"] = "DISABLED";
+	return TableAutomationStatus;
+}({});
+let TableWebhookEventType = /* @__PURE__ */ function(TableWebhookEventType) {
+	TableWebhookEventType["RECORD_CREATED"] = "RECORD_CREATED";
+	TableWebhookEventType["RECORD_UPDATED"] = "RECORD_UPDATED";
+	TableWebhookEventType["RECORD_DELETED"] = "RECORD_DELETED";
+	return TableWebhookEventType;
+}({});
+let FilterOperator = /* @__PURE__ */ function(FilterOperator) {
+	FilterOperator["EQ"] = "eq";
+	FilterOperator["NEQ"] = "neq";
+	FilterOperator["GT"] = "gt";
+	FilterOperator["GTE"] = "gte";
+	FilterOperator["LT"] = "lt";
+	FilterOperator["LTE"] = "lte";
+	FilterOperator["CO"] = "co";
+	FilterOperator["EXISTS"] = "exists";
+	FilterOperator["NOT_EXISTS"] = "not_exists";
+	return FilterOperator;
+}({});
+const Field = z.union([z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	externalId: z.string(),
+	type: z.literal(FieldType.STATIC_DROPDOWN),
+	tableId: z.string(),
+	projectId: z.string(),
+	data: z.object({ options: z.array(z.object({ value: z.string() })) })
+}), z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	externalId: z.string(),
+	type: z.union([
+		z.literal(FieldType.TEXT),
+		z.literal(FieldType.NUMBER),
+		z.literal(FieldType.DATE),
+		z.literal(FieldType.DATETIME)
+	]),
+	tableId: z.string(),
+	projectId: z.string()
+})]);
+const Table = z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	folderId: Nullable(z.string()),
+	projectId: z.string(),
+	externalId: z.string(),
+	status: NullableEnum(TableAutomationStatus),
+	trigger: NullableEnum(TableAutomationTrigger)
+});
+const PopulatedRecord = z.object({
+	...BaseModelSchema,
+	tableId: z.string(),
+	projectId: z.string(),
+	cells: z.record(z.string(), z.object({
+		updated: z.string(),
+		created: z.string(),
+		value: z.unknown(),
+		fieldName: z.string()
+	}))
+});
+const CreateTableWebhookRequest = z.object({
+	events: z.array(z.enum(TableWebhookEventType)),
+	webhookUrl: z.string(),
+	flowId: z.string()
+});
+const ExportTableResponse = z.object({
+	fields: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	})),
+	rows: z.array(z.record(z.string(), z.string())),
+	name: z.string()
+});
+const ListTablesRequest = z.object({
+	projectId: z.string(),
+	limit: z.optional(z.coerce.number()),
+	cursor: z.optional(z.string()),
+	name: z.optional(z.string()),
+	externalIds: OptionalArrayFromQuery(z.string()),
+	folderId: z.optional(z.string()),
+	folderIds: OptionalArrayFromQuery(z.string())
+});
+const CreateRecordsRequest = z.object({
+	records: z.array(z.array(z.object({
+		fieldId: z.string(),
+		value: coerceToString()
+	}))),
+	tableId: z.string()
+});
+const UpdateRecordRequest = z.object({
+	cells: z.optional(z.array(z.object({
+		fieldId: z.string(),
+		value: coerceToString()
+	}))),
+	tableId: z.string(),
+	agentUpdate: z.optional(z.boolean())
+});
+const Filter = z.discriminatedUnion("operator", [
+	valueFilter(FilterOperator.EQ),
+	valueFilter(FilterOperator.NEQ),
+	valueFilter(FilterOperator.GT),
+	valueFilter(FilterOperator.GTE),
+	valueFilter(FilterOperator.LT),
+	valueFilter(FilterOperator.LTE),
+	valueFilter(FilterOperator.CO),
+	existenceFilter(FilterOperator.EXISTS),
+	existenceFilter(FilterOperator.NOT_EXISTS)
+]);
+const ListRecordsRequest = z.object({
+	tableId: z.string(),
+	limit: z.optional(z.coerce.number()),
+	cursor: z.optional(z.string()),
+	filters: OptionalArrayFromQuery(Filter)
+});
+const StaticDropdownEmptyOption = {
+	label: "",
+	value: ""
+};
+function coerceToString() {
+	return z.pipe(z.transform((v) => v === null || v === void 0 ? v : String(v)), z.nullable(z.string()));
+}
+function valueFilter(op) {
+	return z.object({
+		fieldId: z.string(),
+		operator: z.literal(op),
+		value: z.string()
+	});
+}
+function existenceFilter(op) {
+	return z.object({
+		fieldId: z.string(),
+		operator: z.literal(op)
+	});
+}
+
+//#endregion
+//#region upstream/core-piece-types/lib/flow-contracts.ts
+let FlowStatus = /* @__PURE__ */ function(FlowStatus) {
+	FlowStatus["ENABLED"] = "ENABLED";
+	FlowStatus["DISABLED"] = "DISABLED";
+	return FlowStatus;
+}({});
+let FlowTriggerType = /* @__PURE__ */ function(FlowTriggerType) {
+	FlowTriggerType["EMPTY"] = "EMPTY";
+	FlowTriggerType["PIECE"] = "PIECE_TRIGGER";
+	return FlowTriggerType;
+}({});
+const StopResponse = z.object({
+	status: z.optional(z.number()),
+	body: z.optional(z.unknown()),
+	headers: z.optional(z.record(z.string(), z.string()))
+});
+const Project = z.object({
+	...BaseModelSchema,
+	deleted: Nullable(DateOrString),
+	ownerId: z.string(),
+	displayName: z.string(),
+	platformId: z.string(),
+	externalId: Nullable(z.string())
+});
+const USE_DRAFT_QUERY_PARAM_NAME = "useDraft";
+const PARENT_RUN_ID_HEADER = "ap-parent-run-id";
+const FAIL_PARENT_ON_FAILURE_HEADER = "ap-fail-parent-on-failure";
+const RAW_PAYLOAD_HEADER = "ap-raw-payload";
+
+//#endregion
+//#region upstream/core-piece-types/lib/mcp-piece.ts
+let McpPropertyType = /* @__PURE__ */ function(McpPropertyType) {
+	McpPropertyType["TEXT"] = "Text";
+	McpPropertyType["BOOLEAN"] = "Boolean";
+	McpPropertyType["DATE"] = "Date";
+	McpPropertyType["NUMBER"] = "Number";
+	McpPropertyType["ARRAY"] = "Array";
+	McpPropertyType["OBJECT"] = "Object";
+	return McpPropertyType;
+}({});
+const McpProperty = z.object({
+	name: z.string(),
+	description: z.optional(z.string()),
+	type: z.string(),
+	required: z.boolean()
+});
+const McpTrigger = z.object({
+	pieceName: z.string(),
+	triggerName: z.string(),
+	input: z.object({
+		toolName: z.string(),
+		toolDescription: z.string(),
+		inputSchema: z.array(McpProperty),
+		returnsResponse: z.boolean()
+	})
+});
+
+//#endregion
+//#region upstream/core-piece-types/lib/engine-tools.ts
+function normalizeToolOutputToExecuteResponse(raw) {
+	if (raw === null || typeof raw !== "object") return {
+		status: ExecutionToolStatus.FAILED,
+		output: raw,
+		resolvedInput: {},
+		errorMessage: "Invalid tool output"
+	};
+	const o = raw;
+	if (o["status"] === ExecutionToolStatus.SUCCESS || o["status"] === ExecutionToolStatus.FAILED) return {
+		status: o["status"],
+		output: o["output"],
+		resolvedInput: o["resolvedInput"] ?? {},
+		errorMessage: o["errorMessage"]
+	};
+	const isError = o["isError"] === true;
+	let output = o["structuredContent"];
+	if (output === void 0 && Array.isArray(o["content"])) {
+		const parts = o["content"].map((c) => c?.text).filter(Boolean);
+		output = parts.length === 1 ? parts[0] : parts.length ? { text: parts.join("") } : o["content"];
+	}
+	if (output === void 0) output = o;
+	return {
+		status: isError ? ExecutionToolStatus.FAILED : ExecutionToolStatus.SUCCESS,
+		output,
+		resolvedInput: {},
+		errorMessage: isError ? o["content"]?.[0]?.text ?? o["message"] ?? "Tool failed" : void 0
+	};
+}
+
+//#endregion
+//#region upstream/framework/lib/property/util.ts
+function buildSchema(props, auth, requireAuth = true) {
+	const entries = Object.entries(props);
+	const propsSchema = {};
+	for (const [name, property] of entries) {
+		switch (property.type) {
+			case PropertyType.MARKDOWN:
+				propsSchema[name] = z.optional(z.union([
+					z.null(),
+					z.undefined(),
+					z.never(),
+					z.unknown()
+				]));
+				break;
+			case PropertyType.DATE_TIME:
+			case PropertyType.SHORT_TEXT:
+			case PropertyType.LONG_TEXT:
+			case PropertyType.RICH_TEXT:
+			case PropertyType.COLOR:
+			case PropertyType.FILE:
+				propsSchema[name] = property.required ? z.string().check(z.minLength(1)) : z.string();
+				break;
+			case PropertyType.CHECKBOX:
+				propsSchema[name] = z.union([z.boolean(), z.string()]);
+				break;
+			case PropertyType.NUMBER:
+				propsSchema[name] = z.union([property.required ? z.string().check(z.minLength(1)) : z.string(), z.number()]);
+				break;
+			case PropertyType.STATIC_DROPDOWN:
+			case PropertyType.DROPDOWN:
+				propsSchema[name] = z.unknown().check(z.refine((val) => val !== null && val !== void 0, { error: "Value must not be null or undefined" }));
+				break;
+			case PropertyType.SECRET_TEXT:
+				propsSchema[name] = property.required ? z.string().check(z.minLength(1)) : z.string();
+				break;
+			case PropertyType.BASIC_AUTH:
+			case PropertyType.CUSTOM_AUTH:
+			case PropertyType.OAUTH2: break;
+			case PropertyType.ARRAY: {
+				const arrayItemSchema = isNil(property.properties) ? property.required ? z.string().check(z.minLength(1)) : z.string() : buildSchema(property.properties, void 0);
+				propsSchema[name] = z.union([
+					property.required ? z.array(arrayItemSchema).check(z.minLength(1)) : z.array(arrayItemSchema),
+					z.record(z.string(), z.unknown()),
+					property.required ? z.string().check(z.minLength(1)) : z.string()
+				]);
+				break;
+			}
+			case PropertyType.OBJECT:
+				propsSchema[name] = z.union([z.record(z.string(), z.any()), property.required ? z.string().check(z.minLength(1)) : z.string()]);
+				break;
+			case PropertyType.DATE_RANGE:
+				propsSchema[name] = z.union([z.record(z.string(), z.any()), z.string()]);
+				break;
+			case PropertyType.JSON:
+				propsSchema[name] = z.union([
+					z.record(z.string(), z.any()),
+					z.array(z.any()),
+					property.required ? z.string().check(z.minLength(1)) : z.string()
+				]);
+				break;
+			case PropertyType.MULTI_SELECT_DROPDOWN:
+			case PropertyType.STATIC_MULTI_SELECT_DROPDOWN:
+				propsSchema[name] = z.union([property.required ? z.array(z.any()).check(z.minLength(1)) : z.array(z.any()), property.required ? z.string().check(z.minLength(1)) : z.string()]);
+				break;
+			case PropertyType.DYNAMIC:
+				propsSchema[name] = z.record(z.string(), z.any());
+				break;
+			case PropertyType.CUSTOM:
+				propsSchema[name] = z.unknown();
+				break;
+		}
+		if (!property.required && property.type !== PropertyType.ARRAY) propsSchema[name] = z.optional(z.union(isEmpty(propsSchema[name]) ? [
+			z.any(),
+			z.null(),
+			z.undefined()
+		] : [
+			propsSchema[name],
+			z.null(),
+			z.undefined()
+		]));
+	}
+	if (auth && requireAuth) propsSchema[AUTHENTICATION_PROPERTY_NAME] = z.string().check(z.minLength(1));
+	return z.object(propsSchema);
+}
+const piecePropertiesUtils = { buildSchema };
+
+//#endregion
+//#region upstream/framework/lib/property/index.ts
+const PieceProperty = z.union([InputProperty, PieceAuthProperty]);
+const PiecePropertyMap = z.record(z.string(), PieceProperty);
+const InputPropertyMap = z.record(z.string(), InputProperty);
+
+//#endregion
+//#region upstream/framework/lib/trigger/trigger.ts
+const DEDUPE_KEY_PROPERTY = "_dedupe_key";
+let WebhookRenewStrategy = /* @__PURE__ */ function(WebhookRenewStrategy) {
+	WebhookRenewStrategy["CRON"] = "CRON";
+	WebhookRenewStrategy["NONE"] = "NONE";
+	return WebhookRenewStrategy;
+}({});
+const WebhookRenewConfiguration = z.union([z.object({
+	strategy: z.literal(WebhookRenewStrategy.CRON),
+	cronExpression: z.string()
+}), z.object({ strategy: z.literal(WebhookRenewStrategy.NONE) })]);
+var ITrigger = class {
+	constructor(name, displayName, description, requireAuth, props, type, handshakeConfiguration, onHandshake, renewConfiguration, onRenew, onEnable, onDisable, onStart, run, test, sampleData, testStrategy, outputSchema, aiMetadata, classification, propertyGroups) {
+		this.name = name;
+		this.displayName = displayName;
+		this.description = description;
+		this.requireAuth = requireAuth;
+		this.props = props;
+		this.type = type;
+		this.handshakeConfiguration = handshakeConfiguration;
+		this.onHandshake = onHandshake;
+		this.renewConfiguration = renewConfiguration;
+		this.onRenew = onRenew;
+		this.onEnable = onEnable;
+		this.onDisable = onDisable;
+		this.onStart = onStart;
+		this.run = run;
+		this.test = test;
+		this.sampleData = sampleData;
+		this.testStrategy = testStrategy;
+		this.outputSchema = outputSchema;
+		this.aiMetadata = aiMetadata;
+		this.classification = classification;
+		this.propertyGroups = propertyGroups;
+	}
+};
+const createTrigger = (params) => {
+	switch (params.type) {
+		case TriggerStrategy.WEBHOOK: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, params.handshakeConfiguration ?? { strategy: WebhookHandshakeStrategy.NONE }, params.onHandshake ?? (async () => ({ status: 200 })), params.renewConfiguration ?? { strategy: WebhookRenewStrategy.NONE }, params.onRenew ?? (async () => Promise.resolve()), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, params.test ? TriggerTestStrategy.TEST_FUNCTION : TriggerTestStrategy.SIMULATION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.POLLING: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.MANUAL: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.APP_WEBHOOK: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, isNil(params.sampleData) && isNil(params.test) ? TriggerTestStrategy.SIMULATION : TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+	}
+};
+
+//#endregion
+//#region upstream/framework/lib/context/index.ts
+var PieceServerContextError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PieceServerContextError";
+	}
+};
+function isPieceServerContextError(error) {
+	return error instanceof Error && error.name === "PieceServerContextError";
+}
+let StoreScope = /* @__PURE__ */ function(StoreScope) {
+	StoreScope["PROJECT"] = "COLLECTION";
+	StoreScope["FLOW"] = "FLOW";
+	return StoreScope;
+}({});
+
+//#endregion
+//#region upstream/framework/lib/context/versioning.ts
+let ContextVersion = /* @__PURE__ */ function(ContextVersion) {
+	ContextVersion["V1"] = "1";
+	ContextVersion["V2"] = "2";
+	return ContextVersion;
+}({});
+const LATEST_CONTEXT_VERSION = ContextVersion.V2;
+const MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION = "0.82.0";
+const backwardCompatabilityContextUtils = { makeActionContextBackwardCompatible({ context, contextVersion }) {
+	switch (contextVersion) {
+		case ContextVersion.V2: return context;
+		case ContextVersion.V1: return addLegacyMethods({ context });
+		case void 0: return addLegacyMethodsAndServerUrl({ context });
+	}
+} };
+function addLegacyMethods({ context }) {
+	return {
+		...context,
+		generateResumeUrl: buildLegacyGenerateResumeUrl({ context }),
+		run: {
+			...context.run,
+			pause: buildLegacyPauseHook({ context })
+		}
+	};
+}
+function addLegacyMethodsAndServerUrl({ context }) {
+	return {
+		...addLegacyMethods({ context }),
+		serverUrl: context.server.publicUrl
+	};
+}
+/**
+* @deprecated Since 2026-04-12. Remove after 2026-10-12 once all pieces migrate to createWaitpoint/waitForWaitpoint.
+*/
+function buildLegacyPauseHook({ context }) {
+	return (req) => {
+		const type = req.pauseMetadata.type === PauseType.DELAY ? "DELAY" : "WEBHOOK";
+		const responseToSend = req.pauseMetadata.type === PauseType.WEBHOOK ? req.pauseMetadata.response : void 0;
+		const resumeDateTime = req.pauseMetadata.type === PauseType.DELAY ? req.pauseMetadata.resumeDateTime : void 0;
+		context.run.createWaitpoint({
+			type,
+			version: "V0",
+			resumeDateTime,
+			responseToSend
+		}).catch((e) => {
+			console.error("[buildLegacyPauseHook] Failed to create waitpoint", e);
+			process.exit(1);
+		});
+		context.run.waitForWaitpoint("");
+	};
+}
+/**
+* @deprecated Since 2026-04-12. Remove after 2026-10-12 once all pieces migrate to createWaitpoint/waitForWaitpoint.
+*/
+function buildLegacyGenerateResumeUrl({ context }) {
+	return (params) => {
+		const randomId = Math.random().toString(36).substring(2);
+		const url = new URL(`${context.server.publicUrl}v1/flow-runs/${context.run.id}/requests/${randomId}${params.sync ? "/sync" : ""}`);
+		url.search = new URLSearchParams(params.queryParams).toString();
+		return url.toString();
+	};
+}
+
+//#endregion
+//#region upstream/framework/lib/piece.ts
+var Piece = class {
+	_actions = {};
+	_triggers = {};
+	getContextInfo = () => ({ version: LATEST_CONTEXT_VERSION });
+	constructor(displayName, logoUrl, authors, events, actions, triggers, categories, auth, minimumSupportedRelease = MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION, maximumSupportedRelease, description = "", deprecated) {
+		this.displayName = displayName;
+		this.logoUrl = logoUrl;
+		this.authors = authors;
+		this.events = events;
+		this.categories = categories;
+		this.auth = auth;
+		this.minimumSupportedRelease = minimumSupportedRelease;
+		this.maximumSupportedRelease = maximumSupportedRelease;
+		this.description = description;
+		this.deprecated = deprecated;
+		if (!isValidSimpleSemver(minimumSupportedRelease) || isSemverLessThan(minimumSupportedRelease, "0.82.0")) this.minimumSupportedRelease = MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION;
+		actions.forEach((action) => this._actions[action.name] = action);
+		triggers.forEach((trigger) => this._triggers[trigger.name] = trigger);
+	}
+	metadata() {
+		return {
+			displayName: this.displayName,
+			logoUrl: this.logoUrl,
+			actions: this._actions,
+			triggers: this._triggers,
+			categories: this.categories,
+			description: this.description,
+			authors: this.authors,
+			auth: withConnectionIdentifierFlag(this.auth),
+			minimumSupportedRelease: this.minimumSupportedRelease,
+			maximumSupportedRelease: this.maximumSupportedRelease,
+			deprecated: this.deprecated,
+			contextInfo: this.getContextInfo?.()
+		};
+	}
+	getAction(actionName) {
+		return this._actions[actionName];
+	}
+	getTrigger(triggerName) {
+		return this._triggers[triggerName];
+	}
+	actions() {
+		return this._actions;
+	}
+	triggers() {
+		return this._triggers;
+	}
+};
+const createPiece = (params) => {
+	if (params.auth && Array.isArray(params.auth)) {
+		if (!params.auth.every((auth, index, self) => index === self.findIndex((t) => t.type === auth.type))) throw new Error("Auth properties must be unique by type");
+	}
+	return new Piece(params.displayName, params.logoUrl, params.authors ?? [], params.events, params.actions, params.triggers, params.categories ?? [], params.auth, params.minimumSupportedRelease, params.maximumSupportedRelease, params.description, params.deprecated);
+};
+function withConnectionIdentifierFlag(auth) {
+	if (auth === void 0) return;
+	return Array.isArray(auth) ? auth.map(flagConnectionIdentifier) : flagConnectionIdentifier(auth);
+}
+function flagConnectionIdentifier(auth) {
+	return {
+		...auth,
+		hasConnectionIdentifier: auth.getConnectionIdentifier !== void 0
+	};
+}
+function isValidSimpleSemver(version) {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+function isSemverLessThan(a, b) {
+	const [a1, a2, a3] = a.split(".").map(Number);
+	const [b1, b2, b3] = b.split(".").map(Number);
+	if (a1 !== b1) return a1 < b1;
+	if (a2 !== b2) return a2 < b2;
+	return a3 < b3;
+}
+
+//#endregion
+//#region upstream/framework/lib/piece-metadata.ts
+const I18nForPiece = z.optional(z.record(z.string(), z.record(z.string(), z.string())));
+const PieceBase = z.object({
+	id: z.optional(z.string()),
+	name: z.string(),
+	displayName: z.string(),
+	logoUrl: z.string(),
+	description: z.string(),
+	authors: z.array(z.string()),
+	platformId: z.optional(z.string()),
+	directoryPath: z.optional(z.string()),
+	auth: z.optional(z.union([PieceAuthProperty, z.array(PieceAuthProperty)])),
+	version: z.string(),
+	categories: z.optional(z.array(z.enum(PieceCategory))),
+	minimumSupportedRelease: z.optional(z.string()),
+	maximumSupportedRelease: z.optional(z.string()),
+	deprecated: z.optional(z.boolean()),
+	i18n: I18nForPiece
+});
+const Audience = z.enum([
+	"human",
+	"ai",
+	"both"
+]);
+const AiMetadata = z.object({
+	description: z.optional(z.string()),
+	idempotent: z.optional(z.boolean())
+});
+const ActionClassification = z.enum([
+	"READ",
+	"SEARCH",
+	"WRITE",
+	"DESTRUCTIVE"
+]);
+const READ_ONLY_CLASSIFICATIONS = ["READ", "SEARCH"];
+const isReadOnlyClassification = (classification) => classification !== void 0 && READ_ONLY_CLASSIFICATIONS.includes(classification);
+const PropertyGroupDisplay = z.enum([
+	"tabs",
+	"section",
+	"summary",
+	"builder",
+	"footer"
+]);
+const PropertyGroup = z.object({
+	key: z.string(),
+	display: PropertyGroupDisplay,
+	label: z.optional(z.string()),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	props: z.array(z.string())
+});
+const ActionBase = z.object({
+	name: z.string(),
+	displayName: z.string(),
+	description: z.string(),
+	props: PiecePropertyMap,
+	propertyGroups: z.optional(z.array(PropertyGroup)),
+	requireAuth: z.boolean(),
+	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
+	outputSchema: z.optional(z.custom()),
+	audience: z.optional(Audience),
+	aiMetadata: z.optional(AiMetadata),
+	classification: z.optional(ActionClassification)
+});
+const TriggerBase = z.object({
+	name: z.string(),
+	displayName: z.string(),
+	description: z.string(),
+	props: PiecePropertyMap,
+	propertyGroups: z.optional(z.array(PropertyGroup)),
+	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
+	type: z.enum(TriggerStrategy),
+	sampleData: z.unknown(),
+	handshakeConfiguration: z.optional(z.custom()),
+	renewConfiguration: z.optional(WebhookRenewConfiguration),
+	testStrategy: z.enum(TriggerTestStrategy),
+	outputSchema: z.optional(z.custom()),
+	aiMetadata: z.optional(AiMetadata),
+	classification: z.optional(ActionClassification)
+});
+const PieceMetadata = z.object({
+	...PieceBase.shape,
+	actions: z.record(z.string(), ActionBase),
+	triggers: z.record(z.string(), TriggerBase)
+});
+const PieceMetadataSummary = z.object({
+	...PieceBase.shape,
+	actions: z.number(),
+	triggers: z.number(),
+	suggestedActions: z.optional(z.array(ActionBase)),
+	suggestedTriggers: z.optional(z.array(TriggerBase))
+});
+const PiecePackageMetadata = z.object({
+	projectUsage: z.number(),
+	pieceType: z.enum(PieceType),
+	packageType: z.enum(PackageType),
+	platformId: z.optional(z.string()),
+	archiveId: z.optional(z.string())
+});
+const PieceMetadataModel = z.object({
+	...PieceMetadata.shape,
+	...PiecePackageMetadata.shape
+});
+const PieceMetadataModelSummary = z.object({
+	...PieceMetadataSummary.shape,
+	...PiecePackageMetadata.shape
+});
+const PiecePackageInformation = z.object({
+	name: z.string(),
+	version: z.string()
+});
+
+//#endregion
+//#region upstream/framework/lib/i18n.ts
+const pieceTranslation = {
+	translatePiece: (params) => {
+		const { piece, locale, mutate = false } = params;
+		if (!locale) return piece;
+		try {
+			const target = piece.i18n?.[locale];
+			if (!target) return piece;
+			const translatedPiece = mutate ? piece : JSON.parse(JSON.stringify(piece));
+			pieceTranslation.pathsToValuesToTranslate.forEach((key) => {
+				translateProperty(translatedPiece, key, target);
+			});
+			return translatedPiece;
+		} catch (err) {
+			console.error(`error translating piece ${piece.name}:`, err);
+			return piece;
+		}
+	},
+	initializeI18n: async (pieceOutputPath) => {
+		try {
+			const locales = Object.values(LocalesEnum);
+			const i18n = {};
+			for (const locale of locales) {
+				const translations = await readLocaleFile(locale, pieceOutputPath);
+				if (translations) i18n[locale] = translations;
+			}
+			return Object.keys(i18n).length > 0 ? i18n : void 0;
+		} catch (err) {
+			console.log(`Error initializing i18n for ${pieceOutputPath}:`, err);
+			return;
+		}
+	},
+	pathsToValuesToTranslate: [
+		"description",
+		"auth.username.displayName",
+		"auth.username.description",
+		"auth.password.displayName",
+		"auth.password.description",
+		"auth.props.*.displayName",
+		"auth.props.*.description",
+		"auth.props.*.options.options.*.label",
+		"auth.description",
+		"actions.*.displayName",
+		"actions.*.description",
+		"actions.*.props.*.displayName",
+		"actions.*.props.*.description",
+		"actions.*.props.*.options.options.*.label",
+		"triggers.*.displayName",
+		"triggers.*.description",
+		"triggers.*.props.*.displayName",
+		"triggers.*.props.*.description",
+		"triggers.*.props.*.options.options.*.label"
+	]
+};
+/**This function translates a property inside a piece, i.e description, displayName, etc...
+*
+* @param pieceModelOrProperty - The piece model or property to translate
+* @param path - The path to the property to translate, i.e auth.username.displayName
+* @param i18n - The i18n object
+*/
+function translateProperty(pieceModelOrProperty, path, i18n) {
+	const parsedKeys = path.split(".");
+	if (parsedKeys[0] === "*") return Object.values(pieceModelOrProperty).forEach((item) => translateProperty(item, parsedKeys.slice(1).join("."), i18n));
+	const nextObject = pieceModelOrProperty[parsedKeys[0]];
+	if (!nextObject) return;
+	if (parsedKeys.length > 1) return translateProperty(nextObject, parsedKeys.slice(1).join("."), i18n);
+	const valueInI18n = i18n[pieceModelOrProperty[parsedKeys[0]].slice(0, 512)];
+	if (valueInI18n) pieceModelOrProperty[parsedKeys[0]] = valueInI18n;
+}
+async function fileExists(filePath) {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const readLocaleFile = async (locale, pieceOutputPath) => {
+	const filePath = path.join(pieceOutputPath, "src", "i18n", `${locale}.json`);
+	if (!await fileExists(filePath)) return null;
+	try {
+		const fileContent = await fs.readFile(filePath, "utf8");
+		const translations = JSON.parse(fileContent);
+		if (typeof translations === "object" && translations !== null) return translations;
+		throw new Error(`Invalid i18n file format for ${locale} in piece ${pieceOutputPath}`);
+	} catch (error) {
+		console.error(`Error reading i18n file for ${locale} in piece ${pieceOutputPath}:`, error);
+		return null;
+	}
+};
+
+//#endregion
+//#region upstream/framework/lib/test/index.ts
+function createMockActionContext(params) {
+	return {
+		executionType: ExecutionType.BEGIN,
+		auth: void 0,
+		propsValue: params.propsValue,
+		store: {
+			put: async (key, value) => value,
+			get: async () => null,
+			delete: async () => {}
+		},
+		connections: { get: async () => null },
+		tags: { add: async () => {} },
+		server: {
+			apiUrl: "http://localhost:3000",
+			publicUrl: "http://localhost:4200",
+			token: "test-token"
+		},
+		files: { write: async () => "test-file-url" },
+		output: { update: async () => {} },
+		agent: { tools: async () => ({}) },
+		run: {
+			id: "test-run-id",
+			stop: () => {},
+			pause: () => {},
+			respond: () => {}
+		},
+		project: {
+			id: "test-project-id",
+			externalId: async () => void 0
+		},
+		flows: {
+			list: async () => ({
+				data: [],
+				next: null,
+				previous: null
+			}),
+			current: {
+				id: "test-flow-id",
+				version: { id: "test-flow-version-id" }
+			}
+		},
+		step: { name: "test-step" },
+		generateResumeUrl: () => "http://localhost:3000/resume"
+	};
+}
+function createMockPollingTriggerContext(params) {
+	return {
+		...createMockActionContext({ propsValue: params.propsValue }),
+		setSchedule: (schedule) => {
+			params.onSetSchedule?.(schedule);
+		}
+	};
+}
+
+//#endregion
+//#region src/powerhouse/context.ts
+function reactorOf(ctx) {
+	const reactor = ctx !== null && typeof ctx === "object" ? ctx.reactor : void 0;
+	if (!reactor) throw new Error("ctx.reactor is not available: this piece is not running on a Powerhouse reactor");
+	return reactor;
+}
+
+//#endregion
+export { ACTIVEPIECES_CHAT_TIERS, AGENT_STEP_TEST_TIMEOUT_MS, AGENT_STEP_TIMEOUT_MS, AIProviderModel, AIProviderName, AIProviderWithoutSensitiveData, AI_PROVIDER_CAPABILITIES, ActionBase, ActionClassification, AgentFlowTool, AgentKnowledgeBaseTool, AgentMcpTool, AgentOutputField, AgentOutputFieldType, AgentPieceProps, AgentStepBlock, AgentTaskStatus, AgentTool, AgentToolType, AiMetadata, ApFile, AppConnectionType, ArrayProperty, ArraySubProps, Audience, AzureProviderConfig, BaseAIProviderAuthConfig, BasePropertySchema, BasicAuthProperty, BasicAuthPropertyValue, BedrockProviderAuthConfig, BedrockProviderConfig, ChatFormResponse, CheckboxProperty, CloudflareGatewayProviderConfig, ContentBlockType, ContextVersion, CreateRecordsRequest, CreateTableWebhookRequest, CustomAuthProperty, CustomProperty, DEDUPE_KEY_PROPERTY, DEFAULT_CHAT_TIER_ID, DEFAULT_CONNECTION_DISPLAY_NAME, DateRangePreset, DateRangeProperty, DateRangeValue, DateTimeProperty, DropdownOption, DropdownProperty, DropdownState, DynamicProp, DynamicProperties, DynamicPropsValue, ErrorHandlingOptionsParam, ExecutionToolStatus, ExecutionType, ExportTableResponse, FAIL_PARENT_ON_FAILURE_HEADER, Field, FieldType, FileProperty, FileResponseInterface, Filter, FilterOperator, FlowStatus, FlowTriggerType, GetProviderConfigResponse, HumanInputFormResult, HumanInputFormResultTypes, IAction, ITrigger, InputProperty, InputPropertyMap, JsonProperty, KnowledgeBaseSourceType, LATEST_CONTEXT_VERSION, ListRecordsRequest, ListTablesRequest, LongTextProperty, MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION, MarkdownContentBlock, MarkdownVariant, McpAuthConfig, McpAuthType, McpProperty, McpPropertyType, McpProtocol, McpTrigger, MultiSelectDropdownProperty, NumberProperty, OAuth2AuthorizationMethod, OAuth2GrantType, OAuth2Property, OAuth2PropertyValue, OAuth2Props, OIDCProperty, OPENAI_COMPATIBLE_VENDOR_BASE_URLS, ObjectProperty, OpenAICompatibleProviderConfig, OpenAiCompatibleVendorConfig, PARENT_RUN_ID_HEADER, Piece, PieceAuth, PieceAuthProperty, PieceBase, PieceCategory, PieceMetadata, PieceMetadataModel, PieceMetadataModelSummary, PieceMetadataSummary, PiecePackageInformation, PieceProperty, PiecePropertyMap, PieceServerContextError, PopulatedRecord, Project, ProjectAIProvider, Property, PropertyGroup, PropertyGroupDisplay, PropertyType, RAW_PAYLOAD_HEADER, READ_ONLY_CLASSIFICATIONS, RichTextProperty, SecretTextProperty, SeekPage, ShortTextProperty, StaticDropdownEmptyOption, StaticDropdownProperty, StaticMultiSelectDropdownProperty, StopResponse, StoreScope, TASK_COMPLETION_TOOL_NAME, Table, TableWebhookEventType, ToolCallContentBlock, ToolCallStatus, ToolCallType, TriggerBase, TriggerStrategy, USE_DRAFT_QUERY_PARAM_NAME, UpdateRecordRequest, VertexProviderAuthConfig, VertexProviderConfig, WebhookHandshakeStrategy, WebhookRenewConfiguration, WebhookRenewStrategy, apId, assertNotNullOrUndefined, backwardCompatabilityContextUtils, buildAuthHeaders, camelCase, chunk, createAction, createKeyForFormInput, createMockActionContext, createMockPollingTriggerContext, createPiece, createTrigger, dateRangeUtils, getAuthPropertyForValue, getEffectiveProviderAndModel, isEmpty, isNil, isNotUndefined, isPieceServerContextError, isReadOnlyClassification, isString, kebabCase, mcpToolNameUtils, normalizeToolOutputToExecuteResponse, pickBy, piecePropertiesUtils, pieceTranslation, reactorOf, splitCloudflareGatewayModelId, spreadIfDefined, startCase, tryCatch, unique };
+//# sourceMappingURL=index.js.map