Skip to content

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

feat(ai): observe what a managed AI call costs, at the worker seam (#15492)

Abdulafcfe95fce15
diff --git a/packages/core/execution/src/lib/workers/worker-contract.ts b/packages/core/execution/src/lib/workers/worker-contract.ts
index c30c71ceddd..18de920ab47 100644
--- a/packages/core/execution/src/lib/workers/worker-contract.ts
+++ b/packages/core/execution/src/lib/workers/worker-contract.ts
@@ -1,4 +1,4 @@
-import { AIProviderName } from '@activepieces/core-utils'
+import { ActivepiecesAiBilling, AIProviderName } from '@activepieces/core-utils'
import { AgentPieceToolMetadata, PiecePackage } from '@activepieces/core-piece-types'
import { StreamStepProgress } from '../engine/engine-operation'
import { GetFlowVersionForWorkerRequest, UploadRunLogsRequest } from '../engine/requests'
@@ -98,6 +98,7 @@ export type WorkerToApiContract = {
resolveAiProvider(input: ResolveAiProviderRequest): Promise<ResolveAiProviderResponse>
saveFlowStepFile(input: SaveFlowStepFileRequest): Promise<SaveFlowStepFileResponse>
readFlowStepFile(input: ReadFlowStepFileRequest): Promise<ReadFlowStepFileResponse>
+ reportAiUsage(input: ReportAiUsageRequest): Promise<void>
resumeAiStep(input: ResumeAiStepRequest): Promise<void>
updateFlowStepProgress(input: UpdateFlowStepProgressRequest): Promise<void>
executePieceTool(input: ExecutePieceToolRequest): Promise<ExecutePieceToolResponse>
@@ -437,6 +438,35 @@ export type SaveFlowStepFileRequest = {
fileName: string
}
+export type ReportAiUsageRequest = {
+ billing: ActivepiecesAiBilling
+ provider: AIProviderName
+ modelId: string
+ idempotencyKey: string
+ usage: AiUsageCharge
+ toolCalls?: number
+ generationId?: string
+ requestId?: string
+ flowRun?: AiUsageFlowRunContext
+ chat?: AiUsageChatContext
+}
+
+export type AiUsageFlowRunContext = {
+ flowId: string
+ flowRunId: string
+ environment: string
+}
+
+export type AiUsageChatContext = {
+ userId: string
+ turnIndex: number
+ tier: string
+}
+
+export type AiUsageCharge =
+ | { type: 'observed-cost', costUsd: number }
+ | { type: 'flat-credits', credits: number }
+
export type ReadFlowStepFileRequest = {
projectId: string
platformId: string
diff --git a/packages/core/utils/src/index.ts b/packages/core/utils/src/index.ts
index bf1ec62ef75..60ad2d7bca5 100644
--- a/packages/core/utils/src/index.ts
+++ b/packages/core/utils/src/index.ts
@@ -9,6 +9,7 @@ export * from './lib/metadata'
export * from './lib/seek-page'
export * from './lib/locale'
export * from './lib/permission'
+export * from './lib/activepieces-ai-billing'
export * from './lib/mustache-utils'
export * from './lib/friendly-piece-error'
export * from './lib/color'
diff --git a/packages/core/utils/src/lib/activepieces-ai-billing.ts b/packages/core/utils/src/lib/activepieces-ai-billing.ts
new file mode 100644
index 00000000000..5c28f995e6c
--- /dev/null
+++ b/packages/core/utils/src/lib/activepieces-ai-billing.ts
@@ -0,0 +1,28 @@
+import { AIProviderName } from './permission'
+
+export enum ActivepiecesAiBillingScope {
+ PLATFORM = 'platform',
+ PROJECT = 'project',
+ CONVERSATION = 'conversation',
+}
+
+export type ActivepiecesAiBilling =
+ | { scope: ActivepiecesAiBillingScope.PLATFORM, platformId: string }
+ | { scope: ActivepiecesAiBillingScope.PROJECT, platformId: string, projectId: string }
+ | { scope: ActivepiecesAiBillingScope.CONVERSATION, platformId: string, projectId: string | null, conversationId: string }
+
+export type ActivepiecesAiCall = {
+ generationId: string
+ costUsd: number
+ inputTokens?: number
+ outputTokens?: number
+}
+
+export type ActivepiecesAiCostEvent = {
+ billing: ActivepiecesAiBilling
+ provider: AIProviderName
+ modelId: string
+ call: ActivepiecesAiCall
+}
+
+export type ActivepiecesAiCostReporter = (event: ActivepiecesAiCostEvent) => void
diff --git a/packages/server/api/src/app/ai/ai-credits.ts b/packages/server/api/src/app/ai/ai-credits.ts
new file mode 100644
index 00000000000..9dc526695a0
--- /dev/null
+++ b/packages/server/api/src/app/ai/ai-credits.ts
@@ -0,0 +1,24 @@
+import { AiUsageCharge } from '@activepieces/shared'
+import { system } from '../helper/system/system'
+import { AppSystemProp } from '../helper/system/system-props'
+
+export function chargeFor({ usage, toolCalls = 0 }: { usage: AiUsageCharge, toolCalls?: number }): number {
+ return creditsForModelCall(usage) + toolCalls * CREDITS_PER_TOOL_CALL
+}
+
+function creditsForModelCall(usage: AiUsageCharge): number {
+ if (usage.type === 'flat-credits') {
+ return usage.credits
+ }
+ return usage.costUsd / dollarsPerCredit()
+}
+
+function dollarsPerCredit(): number {
+ const value = system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)
+ if (value <= 0) {
+ throw new Error(`AP_${AppSystemProp.AI_CREDIT_USD_VALUE} must be greater than zero, so a call cannot bill an unbounded number of credits`)
+ }
+ return value
+}
+
+const CREDITS_PER_TOOL_CALL = 1
diff --git a/packages/server/api/src/app/ai/ai-rpc-handlers.ts b/packages/server/api/src/app/ai/ai-rpc-handlers.ts
index 7dfd3b8fda7..139a0cc9493 100644
--- a/packages/server/api/src/app/ai/ai-rpc-handlers.ts
+++ b/packages/server/api/src/app/ai/ai-rpc-handlers.ts
@@ -1,5 +1,5 @@
import { ActivepiecesError, ErrorCode, isNil, sanitizeObjectForPostgresql, tryCatch } from '@activepieces/core-utils'
-import { FileCompression, FileSizeError, FileType, ReadFlowStepFileRequest, ReadFlowStepFileResponse, ResolveAiProviderRequest, ResolveAiProviderResponse, ResumeAiStepRequest, SaveFlowStepFileRequest, SaveFlowStepFileResponse, spreadIfDefined } from '@activepieces/shared'
+import { FileCompression, FileSizeError, FileType, ReadFlowStepFileRequest, ReadFlowStepFileResponse, ReportAiUsageRequest, ResolveAiProviderRequest, ResolveAiProviderResponse, ResumeAiStepRequest, SaveFlowStepFileRequest, SaveFlowStepFileResponse, spreadIfDefined } from '@activepieces/shared'
import { FastifyBaseLogger } from 'fastify'
import { fileService } from '../file/file.service'
import { filesService } from '../file/files-service'
@@ -9,6 +9,7 @@ import { AppSystemProp } from '../helper/system/system-props'
import { projectService } from '../project/project-service'
import { resumeService } from '../waitpoints/resume-service'
import { aiProviderService } from './ai-provider-service'
+import { aiUsageService } from './ai-usage-service'
export const aiRpcHandlers = (log: FastifyBaseLogger) => ({
async resolveAiProvider(input: ResolveAiProviderRequest): Promise<ResolveAiProviderResponse> {
@@ -65,6 +66,10 @@ export const aiRpcHandlers = (log: FastifyBaseLogger) => ({
}
},
+ async reportAiUsage(input: ReportAiUsageRequest): Promise<void> {
+ await aiUsageService(log).report(input)
+ },
+
async resumeAiStep(input: ResumeAiStepRequest): Promise<void> {
const resumeFields = { flowRun: { id: input.flowRunId }, waitpoint: { id: input.waitpointId } }
const flowRun = await flowRunService(log).getOne({ id: input.flowRunId, projectId: input.projectId })
diff --git a/packages/server/api/src/app/ai/ai-usage-service.ts b/packages/server/api/src/app/ai/ai-usage-service.ts
new file mode 100644
index 00000000000..81353ea228f
--- /dev/null
+++ b/packages/server/api/src/app/ai/ai-usage-service.ts
@@ -0,0 +1,87 @@
+import { ActivepiecesAiBillingScope, isNil } from '@activepieces/core-utils'
+import { isAppSumoCreditedPlan, ReportAiUsageRequest } from '@activepieces/shared'
+import { FastifyBaseLogger } from 'fastify'
+import { platformPlanService } from '../ee/platform/platform-plan/platform-plan.service'
+import { trackBillingAndSendTelemetry } from '../platform/billing-and-telemetry'
+import { AiCreditConsumptionProperties, ChatAppSumoConsumptionProperties, ChatCreditConsumptionProperties, CreditUsageSource } from '../platform/billing-provider'
+import { chargeFor } from './ai-credits'
+
+export const aiUsageService = (log: FastifyBaseLogger) => ({
+ async report(input: ReportAiUsageRequest): Promise<void> {
+ const toolCalls = input.toolCalls ?? 0
+ const credits = chargeFor({ usage: input.usage, toolCalls })
+ const platformId = input.billing.platformId
+ const platformPlan = await platformPlanService(log).getOrCreateForPlatform(platformId)
+ const appSumo = isAppSumoCreditedPlan(platformPlan.plan)
+ const chat = chatEventOf(input, toolCalls)
+ if (!isNil(chat)) {
+ await trackBillingAndSendTelemetry({
+ log,
+ licenseKey: platformPlan.licenseKey,
+ credits: { platformId, value: credits, source: CreditUsageSource.CHAT, idempotencyKey: input.idempotencyKey, properties: chat.credits },
+ appSumo: appSumo ? { platformId, value: credits, source: CreditUsageSource.CHAT, idempotencyKey: `${input.idempotencyKey}:appSumo`, properties: chat.appSumo } : undefined,
+ })
+ return
+ }
+ const properties = billingProperties(input, toolCalls)
+ await trackBillingAndSendTelemetry({
+ log,
+ licenseKey: platformPlan.licenseKey,
+ credits: { platformId, value: credits, source: CreditUsageSource.AI, idempotencyKey: input.idempotencyKey, properties },
+ appSumo: appSumo ? { platformId, value: credits, source: CreditUsageSource.AI, idempotencyKey: `${input.idempotencyKey}:appSumo`, properties } : undefined,
+ })
+ },
+})
+
+function chatEventOf(input: ReportAiUsageRequest, toolCalls: number): { credits: ChatCreditConsumptionProperties, appSumo: ChatAppSumoConsumptionProperties } | undefined {
+ if (input.billing.scope !== ActivepiecesAiBillingScope.CONVERSATION || isNil(input.chat)) {
+ return undefined
+ }
+ const { conversationId } = input.billing
+ const { userId, turnIndex, tier } = input.chat
+ const projectId = input.billing.projectId ?? PROJECTLESS_CHAT
+ return {
+ credits: {
+ platformId: input.billing.platformId,
+ projectId,
+ userId,
+ conversationId,
+ turnIndex,
+ messages: MESSAGES_PER_MODEL_CALL,
+ toolCalls,
+ provider: input.provider,
+ model: input.modelId,
+ tier,
+ },
+ appSumo: { platformId: input.billing.platformId, projectId, conversationId, turnIndex, tier },
+ }
+}
+
+function billingProperties(input: ReportAiUsageRequest, toolCalls: number): AiCreditConsumptionProperties {
+ return {
+ platformId: input.billing.platformId,
+ projectId: projectIdOf(input),
+ flowId: input.flowRun?.flowId ?? OUTSIDE_A_FLOW,
+ flowRunId: input.flowRun?.flowRunId ?? input.requestId ?? OUTSIDE_A_FLOW,
+ environment: input.flowRun?.environment ?? OUTSIDE_A_FLOW,
+ messages: MESSAGES_PER_MODEL_CALL,
+ toolCalls,
+ breakdown: [{
+ provider: input.provider,
+ model: input.modelId,
+ messages: MESSAGES_PER_MODEL_CALL,
+ toolCalls,
+ }],
+ }
+}
+
+function projectIdOf(input: ReportAiUsageRequest): string {
+ if (input.billing.scope === ActivepiecesAiBillingScope.PLATFORM) {
+ return PROJECTLESS_CHAT
+ }
+ return input.billing.projectId ?? PROJECTLESS_CHAT
+}
+
+const MESSAGES_PER_MODEL_CALL = 1
+const PROJECTLESS_CHAT = 'chat'
+const OUTSIDE_A_FLOW = 'none'
diff --git a/packages/server/api/src/app/helper/system-validator.ts b/packages/server/api/src/app/helper/system-validator.ts
index f10afd7d663..6b0c97bc583 100644
--- a/packages/server/api/src/app/helper/system-validator.ts
+++ b/packages/server/api/src/app/helper/system-validator.ts
@@ -33,6 +33,12 @@ function positiveIntegerValidator(value: string | undefined) {
return Number.isInteger(parsed) && parsed > 0 ? true : 'Value must be a positive integer'
}
+function positiveFiniteNumberValidator(value: string | undefined) {
+ const parsed = isNil(value) ? Number.NaN : Number(value)
+ const isValid = Number.isFinite(parsed) && parsed > 0
+ return isValid ? true : 'Value must be a finite number greater than zero'
+}
+
function stringValidator(value: string) {
const isValid = typeof value === 'string' && value.length > 0
return isValid ? true : 'Value must be a non-empty string'
@@ -70,6 +76,7 @@ const systemPropValidators: {
[AppSystemProp.PAUSED_FLOW_TIMEOUT_DAYS]: numberValidator,
[AppSystemProp.APP_WEBHOOK_SECRETS]: stringValidator,
[AppSystemProp.MAX_FILE_SIZE_MB]: numberValidator,
+ [AppSystemProp.AI_CREDIT_USD_VALUE]: positiveFiniteNumberValidator,
[AppSystemProp.MAX_FLOW_RUN_LOG_SIZE_MB]: numberValidator,
[AppSystemProp.FLOW_RUN_LOG_INPUT_TRUNCATE_THRESHOLD_KB]: positiveIntegerValidator,
[AppSystemProp.FLOW_RUN_LOG_SLICE_THRESHOLD_KB]: positiveIntegerValidator,
diff --git a/packages/server/api/src/app/helper/system/system-props.ts b/packages/server/api/src/app/helper/system/system-props.ts
index 995831815c3..23978e21483 100644
--- a/packages/server/api/src/app/helper/system/system-props.ts
+++ b/packages/server/api/src/app/helper/system/system-props.ts
@@ -59,6 +59,7 @@ export enum AppSystemProp {
LOKI_USERNAME = 'LOKI_USERNAME',
MAX_FIELDS_PER_TABLE = 'MAX_FIELDS_PER_TABLE',
MAX_FILE_SIZE_MB = 'MAX_FILE_SIZE_MB',
+ AI_CREDIT_USD_VALUE = 'AI_CREDIT_USD_VALUE',
MAX_FLOW_RUN_LOG_SIZE_MB = 'MAX_FLOW_RUN_LOG_SIZE_MB',
FLOW_RUN_LOG_INPUT_TRUNCATE_THRESHOLD_KB = 'FLOW_RUN_LOG_INPUT_TRUNCATE_THRESHOLD_KB',
FLOW_RUN_LOG_SLICE_THRESHOLD_KB = 'FLOW_RUN_LOG_SLICE_THRESHOLD_KB',
diff --git a/packages/server/api/src/app/helper/system/system.ts b/packages/server/api/src/app/helper/system/system.ts
index e15c21564f4..45ae8d697c2 100644
--- a/packages/server/api/src/app/helper/system/system.ts
+++ b/packages/server/api/src/app/helper/system/system.ts
@@ -37,6 +37,7 @@ const systemPropDefaultValues: Partial<Record<SystemProp, string>> = {
[AppSystemProp.LOG_PRETTY]: 'false',
[AppSystemProp.S3_USE_SIGNED_URLS]: 'false',
[AppSystemProp.MAX_FILE_SIZE_MB]: '25',
+ [AppSystemProp.AI_CREDIT_USD_VALUE]: '0.0005',
[AppSystemProp.MAX_FLOW_RUN_LOG_SIZE_MB]: '50',
[AppSystemProp.FLOW_RUN_LOG_INPUT_TRUNCATE_THRESHOLD_KB]: '2',
[AppSystemProp.FLOW_RUN_LOG_SLICE_THRESHOLD_KB]: '32',
@@ -97,6 +98,23 @@ export const system = {
return value
},
+ getDecimalOrThrow(prop: SystemProp): number {
+ const stringNumber = getEnvVarOrReturnDefaultValue(prop)
+ const parsedNumber = isNil(stringNumber) || stringNumber === '' ? Number.NaN : Number(stringNumber)
+
+ if (!Number.isFinite(parsedNumber)) {
+ throw new ActivepiecesError(
+ {
+ code: ErrorCode.SYSTEM_PROP_NOT_DEFINED,
+ params: {
+ prop,
+ },
+ },
+ `System property AP_${prop} is not a finite number, please check the documentation`,
+ )
+ }
+ return parsedNumber
+ },
getNumber(prop: SystemProp): number | null {
const stringNumber = getEnvVarOrReturnDefaultValue(prop)
diff --git a/packages/server/api/src/app/mcp/mcp-server-builder.ts b/packages/server/api/src/app/mcp/mcp-server-builder.ts
index a6389dc6519..cc51bc441c0 100644
--- a/packages/server/api/src/app/mcp/mcp-server-builder.ts
+++ b/packages/server/api/src/app/mcp/mcp-server-builder.ts
@@ -12,6 +12,7 @@ import { McpActivityContext, withActivityRecording } from './activity/mcp-activi
import { ALLOW_ALL, PermissionChecker, resolvePermissionChecker } from './mcp-permissions'
import { mcpProjectSelection, ProjectSelectionScope } from './mcp-project-selection'
import { mcpToolInput } from './mcp-tool-input'
+import { McpCallBilling, mcpUsageTracker } from './mcp-usage-tracker'
import { activepiecesTools, ALL_CONTROLLABLE_TOOL_NAMES, LOCKED_TOOL_NAMES, PLATFORM_LEVEL_TOOL_NAMES } from './tools'
import { apSetProjectContextTool } from './tools/ap-set-project-context'
@@ -67,16 +68,18 @@ export async function buildMcpServer({ mcp, userId, platformId, clientKey, clien
instructions: MCP_SERVER_INSTRUCTIONS,
})
+ const billing = await mcpUsageTracker(log).resolveCallBilling({ mcp, clientId })
+
if (projectId) {
const permissionChecker = userId
? await resolvePermissionChecker({ userId, projectId, log })
: ALLOW_ALL
const activityContext: McpActivityContext | null = isNil(platformId) || isNil(userId) ? null : { platformId, projectId, userId, clientKey }
- registerFlowTools({ server, mcp, projectId, permissionChecker, log })
- registerStaticTools({ server, mcp, projectId, userId, permissionChecker, activityContext, log })
+ registerFlowTools({ server, mcp, projectId, permissionChecker, billing, log })
+ registerStaticTools({ server, mcp, projectId, userId, permissionChecker, activityContext, billing, log })
}
else if (!isNil(mcp.platformId) && !isNil(userId) && !isNil(resolveProjectMcp)) {
- registerPlatformTools({ server, mcp, userId, clientKey, selectionScope: { platformId: mcp.platformId, userId, clientId }, resolveProjectMcp, log })
+ registerPlatformTools({ server, mcp, userId, clientKey, selectionScope: { platformId: mcp.platformId, userId, clientId }, resolveProjectMcp, billing, log })
}
else {
registerPlaceholderTools(server)
@@ -86,18 +89,19 @@ export async function buildMcpServer({ mcp, userId, platformId, clientKey, clien
return server
}
-function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope, resolveProjectMcp, log }: {
+function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope, resolveProjectMcp, billing, log }: {
server: McpServer
mcp: PopulatedMcpServer
userId: string
clientKey: McpOAuthClientKey | null
selectionScope: ProjectSelectionScope
resolveProjectMcp: (projectId: string) => Promise<PopulatedMcpServer>
+ billing: McpCallBilling
log: FastifyBaseLogger
}): void {
const platformId = mcp.platformId!
const contextTool = apSetProjectContextTool({ platformId, userId, selectionScope, log })
- server.registerTool(contextTool.title, buildToolConfig(contextTool), (args: Record<string, unknown>) => contextTool.execute(args))
+ server.registerTool(contextTool.title, buildToolConfig(contextTool), (args: Record<string, unknown>) => charged({ execute: contextTool.execute, toolName: contextTool.title, projectId: null, billing })(args))
const templateMcp: ProjectScopedMcpServer = { ...mcp, projectId: platformId }
const allTools = activepiecesTools(templateMcp, userId, log)
@@ -106,7 +110,7 @@ function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope,
tools.forEach((tool) => {
if (PLATFORM_LEVEL_TOOL_SET.has(tool.title)) {
- server.registerTool(tool.title, buildToolConfig(tool), (args: Record<string, unknown>) => tool.execute(args))
+ server.registerTool(tool.title, buildToolConfig(tool), (args: Record<string, unknown>) => charged({ execute: tool.execute, toolName: tool.title, projectId: null, billing })(args))
return
}
@@ -117,7 +121,7 @@ function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope,
}
const activityContext: McpActivityContext = { platformId, projectId: selectedProjectId, userId, clientKey }
const recordedExecute = withActivityRecording({
- execute: (toolArgs: Record<string, unknown>) => executeInSelectedProject({ toolTitle: tool.title, args: toolArgs, projectId: selectedProjectId, userId, resolveProjectMcp, log }),
+ execute: (toolArgs: Record<string, unknown>) => executeInSelectedProject({ toolTitle: tool.title, args: toolArgs, projectId: selectedProjectId, userId, resolveProjectMcp, billing, log }),
tool,
resolveContext: () => Promise.resolve(activityContext),
log,
@@ -127,12 +131,13 @@ function registerPlatformTools({ server, mcp, userId, clientKey, selectionScope,
})
}
-async function executeInSelectedProject({ toolTitle, args, projectId, userId, resolveProjectMcp, log }: {
+async function executeInSelectedProject({ toolTitle, args, projectId, userId, resolveProjectMcp, billing, log }: {
toolTitle: string
args: Record<string, unknown>
projectId: string
userId: string
resolveProjectMcp: (projectId: string) => Promise<PopulatedMcpServer>
+ billing: McpCallBilling
log: FastifyBaseLogger
}): Promise<McpToolResult> {
const projectMcp = await resolveProjectMcp(projectId)
@@ -146,7 +151,11 @@ async function executeInSelectedProject({ toolTitle, args, projectId, userId, re
isError: true,
}
}
- const execute = permissionChecker.wrapExecute({ execute: realTool.execute, permission: realTool.permission, toolTitle: realTool.title })
+ const execute = permissionChecker.wrapExecute({
+ execute: charged({ execute: realTool.execute, toolName: realTool.title, projectId, billing }),
+ permission: realTool.permission,
+ toolTitle: realTool.title,
+ })
return execute(args)
}
@@ -160,7 +169,7 @@ function noProjectSelectedResult(): McpToolResult {
}
}
-function registerFlowTools({ server, mcp, projectId, permissionChecker, log }: RegisterToolsParams): void {
+function registerFlowTools({ server, mcp, projectId, permissionChecker, billing, log }: RegisterToolsParams): void {
const enabledFlows = mcp.flows.filter((flow) => flow.status === FlowStatus.ENABLED)
for (const flow of enabledFlows) {
const { toolName: mcpToolNameInput, toolDescription, mcpInputs, returnsResponse } = extractMcpTriggerInput(flow)
@@ -174,6 +183,11 @@ function registerFlowTools({ server, mcp, projectId, permissionChecker, log }: R
if (flowPermissionError) {
return flowPermissionError
}
+ const refusal = await billing.refusalWhenOutOfCredits({ toolName })
+ if (!isNil(refusal)) {
+ return refusal
+ }
+ billing.charge({ toolName, projectId })
const result = await runFlowAsTool({ flow, properties: mcpInputs, payload: args, returnsResponse, log })
@@ -246,18 +260,38 @@ export async function runFlowAsTool({ flow, properties, payload, returnsResponse
return { content: [{ type: 'text', text }], ...(isOkay ? {} : { isError: true }) }
}
-function registerStaticTools({ server, mcp, projectId, userId, permissionChecker, activityContext, log }: RegisterStaticToolsParams): void {
+function registerStaticTools({ server, mcp, projectId, userId, permissionChecker, activityContext, billing, log }: RegisterStaticToolsParams): void {
const allTools = activepiecesTools({ ...mcp, projectId }, userId, log)
const disabledToolSet = new Set(mcp.disabledTools ?? [])
const tools = allTools.filter(t => LOCKED_TOOL_NAMES.includes(t.title) || !disabledToolSet.has(t.title))
tools.forEach((tool) => {
- const execute = permissionChecker.wrapExecute({ execute: tool.execute, permission: tool.permission, toolTitle: tool.title })
+ const execute = permissionChecker.wrapExecute({
+ execute: charged({ execute: tool.execute, toolName: tool.title, projectId, billing }),
+ permission: tool.permission,
+ toolTitle: tool.title,
+ })
const recordedExecute = withActivityRecording({ execute, tool, resolveContext: () => Promise.resolve(activityContext), log })
server.registerTool(tool.title, buildToolConfig(tool), (args: Record<string, unknown>) => recordedExecute(args))
})
}
+function charged({ execute, toolName, projectId, billing }: {
+ execute: McpToolDefinition['execute']
+ toolName: string
+ projectId: string | null
+ billing: McpCallBilling
+}): McpToolDefinition['execute'] {
+ return async (args) => {
+ const refusal = await billing.refusalWhenOutOfCredits({ toolName })
+ if (!isNil(refusal)) {
+ return refusal
+ }
+ billing.charge({ toolName, projectId })
+ return execute(args)
+ }
+}
+
function registerPlaceholderTools(server: McpServer): void {
const lockedToolSet = new Set<string>(LOCKED_TOOL_NAMES)
const allToolNames = [...LOCKED_TOOL_NAMES, ...ALL_CONTROLLABLE_TOOL_NAMES]
@@ -302,6 +336,7 @@ type RegisterToolsParams = {
mcp: PopulatedMcpServer
projectId: string
permissionChecker: PermissionChecker
+ billing: McpCallBilling
log: FastifyBaseLogger
}
diff --git a/packages/server/api/src/app/mcp/mcp-usage-tracker.ts b/packages/server/api/src/app/mcp/mcp-usage-tracker.ts
new file mode 100644
index 00000000000..85067ae42ee
--- /dev/null
+++ b/packages/server/api/src/app/mcp/mcp-usage-tracker.ts
@@ -0,0 +1,112 @@
+import { ActivepiecesError, apId, ErrorCode, isNil, tryCatch } from '@activepieces/core-utils'
+import { isAppSumoCreditedPlan, McpToolResult, PopulatedMcpServer } from '@activepieces/shared'
+import { FastifyBaseLogger } from 'fastify'
+import { platformPlanService } from '../ee/platform/platform-plan/platform-plan.service'
+import { rejectedPromiseHandler } from '../helper/promise-handler'
+import { trackBillingAndSendTelemetry } from '../platform/billing-and-telemetry'
+import { assertCreditsAndAppSumoNotExceeded, CreditUsageSource, McpCallCreditConsumptionProperties } from '../platform/billing-provider'
+import { projectService } from '../project/project-service'
+import { INTERNAL_CHAT_CLIENT_ID } from './oauth/token/mcp-oauth-token.service'
+
+export const mcpUsageTracker = (log: FastifyBaseLogger) => ({
+ async resolveCallBilling({ mcp, clientId }: ResolveCallBillingParams): Promise<McpCallBilling> {
+ if (clientId === INTERNAL_CHAT_CLIENT_ID) {
+ return EXEMPT_FROM_BILLING
+ }
+ const platformId = await resolvePlatformId({ mcp, log })
+ if (isNil(platformId)) {
+ log.warn({ mcp: { id: mcp.id } }, '[mcpUsageTracker] Could not tell which platform an MCP server belongs to, so its calls are neither gated nor billed')
+ return EXEMPT_FROM_BILLING
+ }
+ return {
+ refusalWhenOutOfCredits: ({ toolName }) => refusalWhenOutOfCredits({ platformId, toolName, log }),
+ charge: ({ toolName, projectId }) => {
+ rejectedPromiseHandler(chargeCall({ platformId, projectId, toolName, clientId, log }), log)
+ },
+ }
+ },
+})
+
+async function resolvePlatformId({ mcp, log }: { mcp: PopulatedMcpServer, log: FastifyBaseLogger }): Promise<string | null> {
+ if (!isNil(mcp.platformId)) {
+ return mcp.platformId
+ }
+ const { projectId } = mcp
+ if (isNil(projectId)) {
+ return null
+ }
+ const { data: project } = await tryCatch(() => projectService(log).getOneOrThrow(projectId))
+ return project?.platformId ?? null
+}
+
+// A credits lookup that fails for its own reasons must not take the tool down with it, so anything
+// that is not a definite "out of credits" lets the call through, as the chat personalization path does.
+async function refusalWhenOutOfCredits({ platformId, toolName, log }: RefusalParams): Promise<McpToolResult | null> {
+ const { error } = await tryCatch(() => assertCreditsAndAppSumoNotExceeded({ platformId, log }))
+ if (isNil(error)) {
+ return null
+ }
+ const exhausted = error instanceof ActivepiecesError && error.error.code === ErrorCode.QUOTA_EXCEEDED
+ if (!exhausted) {
+ log.warn({ error, platform: { id: platformId }, tool: { name: toolName } }, '[mcpUsageTracker] Credits check failed, allowing the call')
+ return null
+ }
+ return {
+ content: [{ type: 'text', text: `❌ Out of credits: this platform has used all of its Activepieces credits, so "${toolName}" cannot run. Add credits or upgrade the plan, then try again.` }],
+ isError: true,
+ }
+}
+
+async function chargeCall({ platformId, projectId, toolName, clientId, log }: ChargeCallParams): Promise<void> {
+ const { error } = await tryCatch(async () => {
+ const platformPlan = await platformPlanService(log).getOrCreateForPlatform(platformId)
+ const properties: McpCallCreditConsumptionProperties = { platformId, projectId, toolName, clientId }
+ const usage = {
+ platformId,
+ value: MCP_CALL_CREDITS,
+ source: CreditUsageSource.MCP as const,
+ idempotencyKey: `mcp:${apId()}`,
+ properties,
+ }
+ await trackBillingAndSendTelemetry({
+ log,
+ licenseKey: platformPlan.licenseKey,
+ credits: usage,
+ ...(isAppSumoCreditedPlan(platformPlan.plan) ? { appSumo: { ...usage, idempotencyKey: `mcpAppSumo:${apId()}` } } : {}),
+ })
+ })
+ if (!isNil(error)) {
+ log.warn({ error, platform: { id: platformId }, tool: { name: toolName } }, '[mcpUsageTracker] An MCP call was not billed')
+ }
+}
+
+const EXEMPT_FROM_BILLING: McpCallBilling = {
+ refusalWhenOutOfCredits: async () => null,
+ charge: () => undefined,
+}
+
+export const MCP_CALL_CREDITS = 1
+
+export type McpCallBilling = {
+ refusalWhenOutOfCredits: (params: { toolName: string }) => Promise<McpToolResult | null>
+ charge: (params: { toolName: string, projectId: string | null }) => void
+}
+
+type ResolveCallBillingParams = {
+ mcp: PopulatedMcpServer
+ clientId: string
+}
+
+type RefusalParams = {
+ platformId: string
+ toolName: string
+ log: FastifyBaseLogger
+}
+
+type ChargeCallParams = {
+ platformId: string
+ projectId: string | null
+ toolName: string
+ clientId: string
+ log: FastifyBaseLogger
+}
diff --git a/packages/server/api/src/app/mcp/oauth/token/mcp-oauth-token.service.ts b/packages/server/api/src/app/mcp/oauth/token/mcp-oauth-token.service.ts
index 59611008665..647c35c5820 100644
--- a/packages/server/api/src/app/mcp/oauth/token/mcp-oauth-token.service.ts
+++ b/packages/server/api/src/app/mcp/oauth/token/mcp-oauth-token.service.ts
@@ -18,7 +18,6 @@ import { McpOAuthTokenEntity } from './mcp-oauth-token.entity'
const repo = repoFactory(McpOAuthTokenEntity)
const clientRepo = repoFactory(McpOAuthClientEntity)
-const INTERNAL_CHAT_CLIENT_ID = 'internal-chat'
const DEFAULT_GRANT_PAGE_SIZE = 20
const TOKEN_ALIAS = 'mcp_oauth_token'
const UNKNOWN_CLIENT_KEY: McpOAuthClientKey = 'unknown'
@@ -302,6 +301,8 @@ type TokenResponse = {
refresh_token?: string
}
+export const INTERNAL_CHAT_CLIENT_ID = 'internal-chat'
+
export type McpOAuthAccessTokenPayload = {
sub: string
projectId: string | null
diff --git a/packages/server/api/src/app/platform/billing-provider.ts b/packages/server/api/src/app/platform/billing-provider.ts
index e5f57786c05..75c284c6bd5 100644
--- a/packages/server/api/src/app/platform/billing-provider.ts
+++ b/packages/server/api/src/app/platform/billing-provider.ts
@@ -144,6 +144,7 @@ export enum CreditUsageSource {
AI = 'ai',
CHAT = 'chat',
AGENT_DRAFT = 'agent_draft',
+ MCP = 'mcp',
}
type ToFlowRunCreditPropertiesParams = {
@@ -191,6 +192,13 @@ export type AiCreditConsumptionProperties = FlowRunCreditConsumptionProperties &
breakdown: CreditEventBreakdownEntry[]
}
+export type McpCallCreditConsumptionProperties = {
+ platformId: string
+ projectId: string | null
+ toolName: string
+ clientId: string
+}
+
export type ChatCreditConsumptionProperties = CreditConsumptionPropertiesBase & {
userId: string
conversationId: string
@@ -219,11 +227,13 @@ export type TrackCreditsParams =
| (TrackUsageParamsBase & { source: CreditUsageSource.AI, properties: AiCreditConsumptionProperties })
| (TrackUsageParamsBase & { source: CreditUsageSource.CHAT, properties: ChatCreditConsumptionProperties })
| (TrackUsageParamsBase & { source: CreditUsageSource.AGENT_DRAFT, properties: AgentDraftCreditConsumptionProperties })
+ | (TrackUsageParamsBase & { source: CreditUsageSource.MCP, properties: McpCallCreditConsumptionProperties })
export type TrackAppSumoAiUsageParams = TrackUsageParamsBase & (
{ source: CreditUsageSource.AGENT_DRAFT, properties: AgentDraftCreditConsumptionProperties } |
{ source: CreditUsageSource.AI, properties: AiCreditConsumptionProperties } |
- { source: CreditUsageSource.CHAT, properties: ChatAppSumoConsumptionProperties }
+ { source: CreditUsageSource.CHAT, properties: ChatAppSumoConsumptionProperties } |
+ { source: CreditUsageSource.MCP, properties: McpCallCreditConsumptionProperties }
)
export type TrackFeatureParams =
diff --git a/packages/server/api/src/app/workers/rpc/worker-rpc-service.ts b/packages/server/api/src/app/workers/rpc/worker-rpc-service.ts
index 4ebe7d1f753..efe0f5cd2b9 100644
--- a/packages/server/api/src/app/workers/rpc/worker-rpc-service.ts
+++ b/packages/server/api/src/app/workers/rpc/worker-rpc-service.ts
@@ -403,6 +403,9 @@ export function createHandlers(log: FastifyBaseLogger, assignment: WorkerGroupAs
async readFlowStepFile(input) {
return aiRpcHandlers(log).readFlowStepFile(input)
},
+ async reportAiUsage(input) {
+ return aiRpcHandlers(log).reportAiUsage(input)
+ },
async resumeAiStep(input) {
return aiRpcHandlers(log).resumeAiStep(input)
},
diff --git a/packages/server/api/test/unit/app/ai/ai-credits.test.ts b/packages/server/api/test/unit/app/ai/ai-credits.test.ts
new file mode 100644
index 00000000000..cc652d38e30
--- /dev/null
+++ b/packages/server/api/test/unit/app/ai/ai-credits.test.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from 'vitest'
+
+const rate = { value: 0.0005 }
+
+vi.mock('../../../../src/app/helper/system/system', () => ({
+ system: { getDecimalOrThrow: () => rate.value },
+}))
+
+const { chargeFor } = await import('../../../../src/app/ai/ai-credits')
+
+describe('chargeFor', () => {
+ it('converts an observed dollar cost at the configured rate', () => {
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0.0005 } })).toBe(1)
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0.005 } })).toBe(10)
+ })
+
+ it('keeps a small call fractional rather than rounding it up to a whole credit', () => {
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0.00037 } })).toBeCloseTo(0.74, 6)
+ })
+
+ it('charges nothing for a genuinely free model, which reports a real cost of zero', () => {
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0 } })).toBe(0)
+ })
+
+ it('scales with the size of the call, which is the whole point of billing on cost', () => {
+ const small = chargeFor({ usage: { type: 'observed-cost', costUsd: 0.0004 } })
+ const large = chargeFor({ usage: { type: 'observed-cost', costUsd: 0.004 } })
+ expect(large).toBeCloseTo(small * 10, 6)
+ })
+
+ it('passes flat credits straight through, which is how a BYOK call bills one per model call', () => {
+ expect(chargeFor({ usage: { type: 'flat-credits', credits: 1 } })).toBe(1)
+ })
+
+ it('passes a flat charge of several credits through unchanged', () => {
+ expect(chargeFor({ usage: { type: 'flat-credits', credits: 4 } })).toBe(4)
+ })
+
+ it('adds one credit per tool call on top of what the model call cost', () => {
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0.0005 }, toolCalls: 3 })).toBe(4)
+ })
+
+ it('charges the tool calls a BYOK turn made alongside its flat credit', () => {
+ expect(chargeFor({ usage: { type: 'flat-credits', credits: 1 }, toolCalls: 2 })).toBe(3)
+ })
+
+ it('charges for tool calls even when the model call itself cost nothing', () => {
+ expect(chargeFor({ usage: { type: 'observed-cost', costUsd: 0 }, toolCalls: 2 })).toBe(2)
+ })
+
+ it('refuses a rate of zero rather than billing an unbounded number of credits', () => {
+ rate.value = 0
+ expect(() => chargeFor({ usage: { type: 'observed-cost', costUsd: 0.0042 } })).toThrow(/greater than zero/)
+ rate.value = 0.0005
+ })
+})
diff --git a/packages/server/api/test/unit/app/helper/system-decimal.test.ts b/packages/server/api/test/unit/app/helper/system-decimal.test.ts
new file mode 100644
index 00000000000..86f3b0d1164
--- /dev/null
+++ b/packages/server/api/test/unit/app/helper/system-decimal.test.ts
@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { system } from '../../../../src/app/helper/system/system'
+import { AppSystemProp } from '../../../../src/app/helper/system/system-props'
+
+const ENV_KEY = `AP_${AppSystemProp.AI_CREDIT_USD_VALUE}`
+
+afterEach(() => {
+ delete process.env[ENV_KEY]
+})
+
+describe('system.getDecimalOrThrow', () => {
+ it('reads the shipped default as the fraction it is, not zero', () => {
+ expect(system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toBeCloseTo(0.0005, 10)
+ })
+
+ it('reads a fractional value a self-hoster set, which getNumber would truncate to zero', () => {
+ process.env[ENV_KEY] = '0.002'
+
+ expect(system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toBeCloseTo(0.002, 10)
+ expect(system.getNumber(AppSystemProp.AI_CREDIT_USD_VALUE)).toBe(0)
+ })
+
+ it('still reads a whole number', () => {
+ process.env[ENV_KEY] = '2'
+
+ expect(system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toBe(2)
+ })
+
+ it('throws on a value that is not a number at all, instead of silently reading zero', () => {
+ process.env[ENV_KEY] = 'cheap'
+
+ expect(() => system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toThrow()
+ })
+
+ it('throws on an infinite rate, which would divide every observed cost down to a free call', () => {
+ process.env[ENV_KEY] = 'Infinity'
+
+ expect(() => system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toThrow()
+ })
+
+ it('throws on a value that overflows to infinity rather than reading as the huge number it looks like', () => {
+ process.env[ENV_KEY] = '1e999'
+
+ expect(() => system.getDecimalOrThrow(AppSystemProp.AI_CREDIT_USD_VALUE)).toThrow()
+ })
+})
diff --git a/packages/server/api/test/unit/app/mcp/mcp-usage-tracker.test.ts b/packages/server/api/test/unit/app/mcp/mcp-usage-tracker.test.ts
new file mode 100644
index 00000000000..f74070dedc0
--- /dev/null
+++ b/packages/server/api/test/unit/app/mcp/mcp-usage-tracker.test.ts
@@ -0,0 +1,195 @@
+import { ActivepiecesError, ErrorCode, PlatformUsageMetric } from '@activepieces/core-utils'
+import { McpServerType, PopulatedMcpServer } from '@activepieces/shared'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { INTERNAL_CHAT_CLIENT_ID } from '../../../../src/app/mcp/oauth/token/mcp-oauth-token.service'
+import { MCP_CALL_CREDITS, mcpUsageTracker } from '../../../../src/app/mcp/mcp-usage-tracker'
+
+const { mockTrackBillingAndSendTelemetry, mockGetOrCreateForPlatform, mockGetProject, mockAssertCredits } = vi.hoisted(() => ({
+ mockTrackBillingAndSendTelemetry: vi.fn().mockResolvedValue(undefined),
+ mockGetOrCreateForPlatform: vi.fn(),
+ mockGetProject: vi.fn(),
+ mockAssertCredits: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock('../../../../src/app/platform/billing-provider', () => ({
+ CreditUsageSource: { MCP: 'mcp' },
+ assertCreditsAndAppSumoNotExceeded: mockAssertCredits,
+}))
+
+vi.mock('../../../../src/app/platform/billing-and-telemetry', () => ({
+ trackBillingAndSendTelemetry: mockTrackBillingAndSendTelemetry,
+}))
+
+vi.mock('../../../../src/app/ee/platform/platform-plan/platform-plan.service', () => ({
+ platformPlanService: () => ({ getOrCreateForPlatform: mockGetOrCreateForPlatform }),
+}))
+
+vi.mock('../../../../src/app/project/project-service', () => ({
+ projectService: () => ({ getOneOrThrow: mockGetProject }),
+}))
+
+const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+
+const EXTERNAL_CLIENT_ID = 'claude-desktop'
+
+function mcpServer(overrides: Partial<PopulatedMcpServer>): PopulatedMcpServer {
+ const base: PopulatedMcpServer = {
+ id: 'mcp-1',
+ created: '2026-09-01T00:00:00.000Z',
+ updated: '2026-09-01T00:00:00.000Z',
+ platformId: null,
+ projectId: null,
+ type: McpServerType.PROJECT,
+ token: 'token-1',
+ disabledTools: [],
+ flows: [],
+ }
+ return { ...base, ...overrides }
+}
+
+async function chargeOnce({ mcp, clientId, projectId }: { mcp: PopulatedMcpServer, clientId: string, projectId: string | null }): Promise<void> {
+ const billing = await mcpUsageTracker(log as never).resolveCallBilling({ mcp, clientId })
+ billing.charge({ toolName: 'ap_run_action', projectId })
+ await flushPendingCharges()
+}
+
+function flushPendingCharges(): Promise<void> {
+ return new Promise((resolve) => setImmediate(resolve))
+}
+
+describe('mcpUsageTracker.resolveCallBilling — charging', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockGetOrCreateForPlatform.mockResolvedValue({ plan: 'plus', licenseKey: null })
+ mockGetProject.mockResolvedValue({ platformId: 'platform-1' })
+ mockAssertCredits.mockResolvedValue(undefined)
+ })
+
+ it('charges one credit for an external client such as Claude or Cursor', async () => {
+ await chargeOnce({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID, projectId: 'project-1' })
+
+ const { credits } = mockTrackBillingAndSendTelemetry.mock.calls[0][0]
+ expect(credits.value).toBe(MCP_CALL_CREDITS)
+ expect(credits.source).toBe('mcp')
+ })
+
+ it('charges nothing for the internal chat client, the id the agent MCP token is issued with, which already pays per tool call', async () => {
+ await chargeOnce({ mcp: mcpServer({ projectId: 'project-1' }), clientId: INTERNAL_CHAT_CLIENT_ID, projectId: 'project-1' })
+
+ expect(mockTrackBillingAndSendTelemetry).not.toHaveBeenCalled()
+ })
+
+ it('resolves the platform from the project, since a project-scoped server stores no platform', async () => {
+ await chargeOnce({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID, projectId: 'project-1' })
+
+ expect(mockGetProject).toHaveBeenCalledWith('project-1')
+ const { credits } = mockTrackBillingAndSendTelemetry.mock.calls[0][0]
+ expect(credits.properties).toMatchObject({ platformId: 'platform-1', projectId: 'project-1', toolName: 'ap_run_action', clientId: EXTERNAL_CLIENT_ID })
+ })
+
+ it('bills a platform-scoped server without asking the project service', async () => {
+ await chargeOnce({ mcp: mcpServer({ platformId: 'platform-2', type: McpServerType.PLATFORM }), clientId: EXTERNAL_CLIENT_ID, projectId: null })
+
+ expect(mockGetProject).not.toHaveBeenCalled()
+ const { credits } = mockTrackBillingAndSendTelemetry.mock.calls[0][0]
+ expect(credits.properties).toMatchObject({ platformId: 'platform-2', projectId: null })
+ })
+
+ it('charges nothing when neither a platform nor a project names an owner to bill', async () => {
+ await chargeOnce({ mcp: mcpServer({}), clientId: EXTERNAL_CLIENT_ID, projectId: null })
+
+ expect(mockTrackBillingAndSendTelemetry).not.toHaveBeenCalled()
+ expect(log.warn).toHaveBeenCalled()
+ })
+
+ it('gives every call its own key, so a client calling the same tool twice pays twice', async () => {
+ const billing = await mcpUsageTracker(log as never).resolveCallBilling({ mcp: mcpServer({ platformId: 'platform-2', type: McpServerType.PLATFORM }), clientId: EXTERNAL_CLIENT_ID })
+ billing.charge({ toolName: 'ap_run_action', projectId: null })
+ billing.charge({ toolName: 'ap_run_action', projectId: null })
+ await flushPendingCharges()
+ expect(mockTrackBillingAndSendTelemetry).toHaveBeenCalledTimes(2)
+
+ const [first, second] = mockTrackBillingAndSendTelemetry.mock.calls
+ expect(first[0].credits.idempotencyKey).not.toBe(second[0].credits.idempotencyKey)
+ })
+
+ it('charges AppSumo credits alongside the platform balance on a credited plan', async () => {
+ mockGetOrCreateForPlatform.mockResolvedValue({ plan: 'appsumo_activepieces_tier1', licenseKey: null })
+
+ await chargeOnce({ mcp: mcpServer({ platformId: 'platform-2', type: McpServerType.PLATFORM }), clientId: EXTERNAL_CLIENT_ID, projectId: null })
+
+ const { appSumo } = mockTrackBillingAndSendTelemetry.mock.calls[0][0]
+ expect(appSumo?.value).toBe(MCP_CALL_CREDITS)
+ })
+
+ it('lets the call through when billing fails, rather than failing the tool', async () => {
+ mockTrackBillingAndSendTelemetry.mockRejectedValueOnce(new Error('autumn is down'))
+
+ await chargeOnce({ mcp: mcpServer({ platformId: 'platform-2', type: McpServerType.PLATFORM }), clientId: EXTERNAL_CLIENT_ID, projectId: null })
+
+ expect(log.warn).toHaveBeenCalled()
+ })
+})
+
+async function refusalFor({ mcp, clientId }: { mcp: PopulatedMcpServer, clientId: string }) {
+ const billing = await mcpUsageTracker(log as never).resolveCallBilling({ mcp, clientId })
+ return billing.refusalWhenOutOfCredits({ toolName: 'ap_run_action' })
+}
+
+const OUT_OF_CREDITS = new ActivepiecesError({ code: ErrorCode.QUOTA_EXCEEDED, params: { metric: PlatformUsageMetric.CREDITS } })
+
+describe('mcpUsageTracker.resolveCallBilling — refusing a client with no credits left', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockGetOrCreateForPlatform.mockResolvedValue({ plan: 'plus', licenseKey: null })
+ mockGetProject.mockResolvedValue({ platformId: 'platform-1' })
+ mockAssertCredits.mockResolvedValue(undefined)
+ })
+
+ it('lets the call through while the platform still has credits', async () => {
+ const refusal = await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID })
+
+ expect(refusal).toBeNull()
+ })
+
+ it('refuses an external client once the platform is out of credits, as chat already does', async () => {
+ mockAssertCredits.mockRejectedValue(OUT_OF_CREDITS)
+
+ const refusal = await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID })
+
+ expect(refusal?.isError).toBe(true)
+ expect(refusal?.content[0].text).toContain('Out of credits')
+ })
+
+ it('names the tool in the refusal, so the client can report what it could not run', async () => {
+ mockAssertCredits.mockRejectedValue(OUT_OF_CREDITS)
+
+ const refusal = await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID })
+
+ expect(refusal?.content[0].text).toContain('ap_run_action')
+ })
+
+ it('never refuses our own chat, which the conversation endpoint has already gated', async () => {
+ mockAssertCredits.mockRejectedValue(OUT_OF_CREDITS)
+
+ const refusal = await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: INTERNAL_CHAT_CLIENT_ID })
+
+ expect(refusal).toBeNull()
+ expect(mockAssertCredits).not.toHaveBeenCalled()
+ })
+
+ it('lets the call through when the credits lookup itself fails, rather than taking the tool down', async () => {
+ mockAssertCredits.mockRejectedValue(new Error('autumn is down'))
+
+ const refusal = await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID })
+
+ expect(refusal).toBeNull()
+ expect(log.warn).toHaveBeenCalled()
+ })
+
+ it('checks credits against the platform the project belongs to', async () => {
+ await refusalFor({ mcp: mcpServer({ projectId: 'project-1' }), clientId: EXTERNAL_CLIENT_ID })
+
+ expect(mockAssertCredits).toHaveBeenCalledWith(expect.objectContaining({ platformId: 'platform-1' }))
+ })
+})
diff --git a/packages/server/utils/src/activepieces-ai-cost.ts b/packages/server/utils/src/activepieces-ai-cost.ts
new file mode 100644
index 00000000000..91e9487dfea
--- /dev/null
+++ b/packages/server/utils/src/activepieces-ai-cost.ts
@@ -0,0 +1,172 @@
+import { AIProviderName, isNil, ActivepiecesAiBilling, ActivepiecesAiCall, ActivepiecesAiCostReporter } from '@activepieces/core-utils'
+import { isJSONObject, LanguageModelV4GenerateResult, LanguageModelV4StreamPart, SharedV4ProviderMetadata } from '@ai-sdk/provider'
+import { LanguageModel, wrapLanguageModel } from 'ai'
+import { z } from 'zod'
+
+export function wrapActivepiecesLanguageModel({ model, provider, modelId, billing }: WrapActivepiecesLanguageModelParams): LanguageModel {
+ if (provider !== AIProviderName.ACTIVEPIECES || typeof model === 'string') {
+ return model
+ }
+ return wrapLanguageModel({
+ model,
+ middleware: {
+ wrapGenerate: async ({ doGenerate }) => {
+ const result = await doGenerate()
+ reportUsage({ billing, provider, modelId, call: toGeneratedCall(result) })
+ return result
+ },
+ wrapStream: async ({ doStream }) => {
+ const { stream, ...rest } = await doStream()
+ return { ...rest, stream: stream.pipeThrough(streamCostObserver({ billing, provider, modelId })) }
+ },
+ },
+ })
+}
+
+export function observedEmbeddingFetch({ provider, modelId, billing, wrapped }: ObservedEmbeddingFetchParams): typeof globalThis.fetch | undefined {
+ if (provider !== AIProviderName.ACTIVEPIECES) {
+ return wrapped
+ }
+ const send = wrapped ?? fetch
+ return async (input, init) => {
+ const response = await send(input, init)
+ void readEmbeddingCall(response)
+ .then((call) => reportUsage({ billing, provider, modelId, call }))
+ .catch(() => undefined)
+ return response
+ }
+}
+
+function toGeneratedCall(result: LanguageModelV4GenerateResult): ActivepiecesAiCall | undefined {
+ return toCall({ generationId: result.response?.id, providerMetadata: result.providerMetadata })
+}
+
+function streamCostObserver({ billing, provider, modelId }: ObserverParams): TransformStream<LanguageModelV4StreamPart, LanguageModelV4StreamPart> {
+ let generationId: string | undefined
+ return new TransformStream({
+ transform: (chunk, controller) => {
+ if (chunk.type === 'response-metadata') {
+ generationId = chunk.id ?? generationId
+ }
+ if (chunk.type === 'finish') {
+ reportUsage({ billing, provider, modelId, call: toCall({ generationId, providerMetadata: chunk.providerMetadata }) })
+ }
+ controller.enqueue(chunk)
+ },
+ })
+}
+
+function toCall({ generationId, providerMetadata }: { generationId: string | undefined, providerMetadata: SharedV4ProviderMetadata | undefined }): ActivepiecesAiCall | undefined {
+ const usage = openRouterUsageOf(providerMetadata)
+ if (isNil(generationId) || isNil(usage) || isNil(usage.cost)) {
+ return undefined
+ }
+ return {
+ generationId,
+ costUsd: usage.cost,
+ ...(isNil(usage.promptTokens) ? {} : { inputTokens: usage.promptTokens }),
+ ...(isNil(usage.completionTokens) ? {} : { outputTokens: usage.completionTokens }),
+ }
+}
+
+function openRouterUsageOf(providerMetadata: SharedV4ProviderMetadata | undefined): OpenRouterUsage | undefined {
+ const openRouter = providerMetadata?.['openrouter']
+ if (isNil(openRouter)) {
+ return undefined
+ }
+ const usage = openRouter['usage']
+ if (!isJSONObject(usage)) {
+ return undefined
+ }
+ return parseOrUndefined(OpenRouterUsage, usage)
+}
+
+async function readEmbeddingCall(response: Response): Promise<ActivepiecesAiCall | undefined> {
+ if (!response.ok) {
+ return undefined
+ }
+ const body = parseOrUndefined(EmbeddingCostResponse, await response.clone().json())
+ if (isNil(body) || isNil(body.usage.cost)) {
+ return undefined
+ }
+ return {
+ generationId: body.id,
+ costUsd: body.usage.cost,
+ ...(isNil(body.usage.prompt_tokens) ? {} : { inputTokens: body.usage.prompt_tokens }),
+ }
+}
+
+function parseOrUndefined<T extends z.ZodType>(schema: T, value: unknown): z.infer<T> | undefined {
+ const parsed = schema.safeParse(value)
+ return parsed.success ? parsed.data : undefined
+}
+
+function reportUsage({ billing, provider, modelId, call }: ReportUsageParams): void {
+ if (isNil(call)) {
+ return
+ }
+ if (isNil(reporter)) {
+ unreportedCalls += 1
+ return
+ }
+ reporter({ billing, provider, modelId, call })
+}
+
+const OpenRouterUsage = z.object({
+ cost: z.number().optional(),
+ promptTokens: z.number().optional(),
+ completionTokens: z.number().optional(),
+})
+
+const EmbeddingCostResponse = z.object({
+ id: z.string().min(1),
+ usage: z.object({
+ cost: z.number().optional(),
+ prompt_tokens: z.number().optional(),
+ }),
+})
+
+let reporter: ActivepiecesAiCostReporter | undefined
+let unreportedCalls = 0
+
+export const activepiecesAiCost = {
+ setReporter: (next: ActivepiecesAiCostReporter): void => {
+ reporter = next
+ },
+ hasReporter: (): boolean => !isNil(reporter),
+ assertReporterInstalled: (): void => {
+ if (isNil(reporter)) {
+ throw new Error('No Activepieces AI cost reporter was installed, so every call on the Activepieces AI provider would run unbilled')
+ }
+ },
+ unreportedCallCount: (): number => unreportedCalls,
+ wrapActivepiecesLanguageModel,
+ observedEmbeddingFetch,
+}
+
+type OpenRouterUsage = z.infer<typeof OpenRouterUsage>
+
+type WrapActivepiecesLanguageModelParams = {
+ model: LanguageModel
+ provider: AIProviderName
+ modelId: string
+ billing: ActivepiecesAiBilling
+}
+
+type ObservedEmbeddingFetchParams = {
+ provider: AIProviderName
+ modelId: string
+ billing: ActivepiecesAiBilling
+ wrapped: typeof globalThis.fetch | undefined
+}
+
+type ObserverParams = {
+ billing: ActivepiecesAiBilling
+ provider: AIProviderName
+ modelId: string
+}
+
+type ReportUsageParams = ObserverParams & {
+ call: ActivepiecesAiCall | undefined
+}
+
diff --git a/packages/server/utils/src/index.ts b/packages/server/utils/src/index.ts
index 1dcd855e7f2..1e2a6701d4a 100644
--- a/packages/server/utils/src/index.ts
+++ b/packages/server/utils/src/index.ts
@@ -27,6 +27,7 @@ export { safeHttp } from './safe-http'
export type { SsrfAgents } from './safe-http'
export { DEFAULT_MCP_MAX_RESPONSE_BYTES, DEFAULT_MCP_TIMEOUT_MS, mcpTransport } from './mcp-transport'
export { systemUsage } from './system-usage'
+export { activepiecesAiCost } from './activepieces-ai-cost'
export { agentAiUtils } from './agent-ai-utils'
export type { ContentPartLike } from './agent-ai-utils'
export { aiUtils, EMBEDDING_DIMENSIONS } from './ai-utils'
diff --git a/packages/server/worker/src/lib/execute/jobs/ai/ai-cost-reporter.ts b/packages/server/worker/src/lib/execute/jobs/ai/ai-cost-reporter.ts
new file mode 100644
index 00000000000..55616eb1f54
--- /dev/null
+++ b/packages/server/worker/src/lib/execute/jobs/ai/ai-cost-reporter.ts
@@ -0,0 +1,25 @@
+import { apId, isNil, tryCatch } from '@activepieces/core-utils'
+import { activepiecesAiCost } from '@activepieces/server-utils'
+import { WorkerToApiContract } from '@activepieces/shared'
+import { FastifyBaseLogger } from 'fastify'
+
+export function installAiCostReporter({ apiClient, log }: {
+ apiClient: WorkerToApiContract
+ log: FastifyBaseLogger
+}): void {
+ activepiecesAiCost.setReporter(({ billing, provider, modelId, call }) => {
+ void tryCatch(() => apiClient.reportAiUsage({
+ billing,
+ provider,
+ modelId,
+ idempotencyKey: `ai:${apId()}`,
+ usage: { type: 'observed-cost', costUsd: call.costUsd },
+ generationId: call.generationId,
+ })).then(({ error }) => {
+ if (isNil(error)) {
+ return
+ }
+ log.error({ error, provider, model: modelId, generationId: call.generationId }, '[aiCostReporter] A managed AI call went unbilled')
+ })
+ })
+}
diff --git a/packages/server/worker/src/lib/worker.ts b/packages/server/worker/src/lib/worker.ts
index 6360a3a5c7e..e4d190d7ab5 100644
--- a/packages/server/worker/src/lib/worker.ts
+++ b/packages/server/worker/src/lib/worker.ts
@@ -11,6 +11,7 @@ import { getApiUrl, system, WorkerSystemProp } from './config/configs'
import { logger } from './config/logger'
import { workerSettings } from './config/worker-settings'
import { getHandler } from './execute/job-registry'
+import { installAiCostReporter } from './execute/jobs/ai/ai-cost-reporter'
import { JobContext, JobResult, JobResultKind } from './execute/types'
import { sandboxConfig } from './runtime/sandbox-config'
import { VERSION_MISMATCH_POLL_PAUSE_MS, versionChecker } from './utils/version-checker'
@@ -71,6 +72,7 @@ export const worker = {
})
const apiClient = createRpcClient<WorkerToApiContract>(socket, rpcTimeoutMsFor)
+ installAiCostReporter({ apiClient, log: logger })
socket.on('connect', async () => {
logger.info('Connected to API server via Socket.IO')