@opengeni/core 1.3.0 → 1.4.0

package/dist/transcription.d.ts

@@ -1,4 +1,6 @@
+import type { VoiceInputPricing, VoiceInputUsage } from "@opengeni/config";
 import type { TranscribeAudioResponse, VoiceInputErrorCode } from "@opengeni/contracts";
+import type { CreditDebitAttribution } from "@opengeni/db";
 /**
  * Server-owned upstream budget for one provider attempt. Resumable recording
  * claims remain fenced for longer than this budget before another worker may
@@ -31,21 +33,112 @@ export type TranscriptionRequest = {
     preferredProvider?: string | null | undefined;
     fallbackEnabled?: boolean | undefined;
     excludedProviders?: readonly string[] | undefined;
+    /**
+     * Credit settlement facts for a deployment-funded provider. Required when
+     * the selected provider is deployment-funded and credit billing is active;
+     * the service fails closed without it.
+     */
+    billing?: TranscriptionBillingContext | undefined;
+    /**
+     * Internal: return `settleBilling` instead of settling before returning, so
+     * a resumable segment's transcript commits before any billing write.
+     */
+    deferBillingSettlement?: boolean;
+};
+/**
+ * Trusted, server-built settlement identity for one transcription unit. The
+ * usage receipt and debit idempotency keys derive from `workspaceId` +
+ * `sourceId` (see `voiceInputSettlementKeys`), so a retry or a later
+ * reconciliation settles the same unit exactly once.
+ */
+export type TranscriptionBillingContext = {
+    /**
+     * Server-derived unit identity. Never a client-chosen value: a reused id
+     * settles once, so a client-controlled id would make later calls free.
+     */
+    sourceId: string;
+    /** Trusted payer facts from the authenticated request boundary. */
+    attribution: CreditDebitAttribution;
+    /**
+     * Audio duration measured by the server from WAV bytes it produced (the
+     * resumable segment, or the normalized one-shot upload). Bills whenever the
+     * provider reports no usage this deployment has a price for.
+     */
+    trustedDurationSeconds?: number | undefined;
 };
 export type TranscriptionResult = TranscribeAudioResponse & {
     /** Server-private provider id for operational metrics only. Never returned to clients. */
     providerId: string;
     audioSeconds: number;
     latencyMs: number;
+    /** Opengeni credits charged for this call (0 for subscription/free providers). */
+    creditCostMicros?: number | undefined;
+    /**
+     * Server-only settlement callback; never serialized into a public response.
+     * Never rejects: a settlement failure after provider success is logged and
+     * retried, and the transcript is still delivered.
+     */
+    settleBilling?: () => Promise<void>;
+};
+export type TranscriptionBillingRefusalCode = "insufficient_credits" | "allowance_exhausted" | "monthly_model_cost_limit";
+/**
+ * Pre-use refusal for deployment-funded transcription: 402 for credits and
+ * allowances (same codes as session admission), 429 for a static monthly cap.
+ */
+export declare class TranscriptionBillingRefusedError extends Error {
+    readonly status: 402 | 429;
+    readonly code: TranscriptionBillingRefusalCode;
+    readonly details: {
+        scope?: string;
+        resetsAt?: string | null;
+        subjectId?: string;
+    };
+    constructor(input: {
+        code: TranscriptionBillingRefusalCode;
+        message: string;
+        details?: {
+            scope?: string;
+            resetsAt?: string | null;
+            subjectId?: string;
+        };
+    });
+}
+/**
+ * Credit admission and settlement for deployment-funded transcription.
+ * Subscription providers (Codex, SuperGrok) never reach this port.
+ */
+export type TranscriptionBilling = {
+    /** Refuse before any audio is sent when the payer cannot fund the call. */
+    admit(input: {
+        accountId: string;
+        workspaceId: string;
+        attribution: CreditDebitAttribution;
+    }): Promise<void>;
+    /**
+     * Record usage and debit credits once per unit, after use. The usage receipt
+     * commits before the debit, so a failed debit leaves a durable receipt that
+     * `admit` reconciles on the workspace's next voice request.
+     */
+    settle(input: {
+        accountId: string;
+        workspaceId: string;
+        providerId: string;
+        model: string;
+        pricing: VoiceInputPricing;
+        usage: VoiceInputUsage | null;
+        billing: TranscriptionBillingContext;
+    }): Promise<{
+        creditCostMicros: number;
+    }>;
 };
 export declare class TranscriptionServiceError extends Error {
-    readonly code: VoiceInputErrorCode;
+    readonly code: Exclude<VoiceInputErrorCode, TranscriptionBillingRefusalCode>;
     readonly status: number;
     readonly retryable: boolean;
     /** Explicit rejection before any transcription result; safe to try another provider. */
     readonly fallbackSafe: boolean;
     constructor(input: {
-        code: VoiceInputErrorCode;
+        code: Exclude<VoiceInputErrorCode, TranscriptionBillingRefusalCode>;
         message: string;
         status?: number;
         retryable?: boolean;
@@ -73,6 +166,15 @@ export type TranscriptionProvider = {
     /** The adapter guarantees that its upstream transport honors AbortSignal. */
     readonly supportsServerDeadline: true;
     readonly experimental?: boolean | undefined;
+    /**
+     * Present when the deployment pays the upstream provider (OpenAI/Azure):
+     * the call is admitted against and settled in Opengeni credits. Absent for
+     * the workspace's own subscriptions, which are never charged.
+     */
+    readonly deploymentFunded?: {
+        readonly model: string;
+        readonly pricing: VoiceInputPricing | null;
+    } | undefined;
     /**
      * Deployment readiness when called without a workspace. When `workspaceId` is
      * provided, providers may require a workspace-attached credential (e.g. Codex).
@@ -90,14 +192,27 @@ export type TranscriptionProvider = {
     }): Promise<{
         text: string;
         languages: string[];
+        usage?: VoiceInputUsage | null | undefined;
     }>;
 };
 export type TranscriptionService = {
     limits(): TranscriptionLimits;
     /** True when at least one ready provider can serve requests. */
     available(context?: TranscriptionAvailabilityContext): boolean | Promise<boolean>;
+    availableProviderIds?(context: TranscriptionAvailabilityContext): Promise<string[]>;
     /** Select one provider before a durable segment attempt; retries pin this id. */
     selectProvider?(context: TranscriptionAvailabilityContext): string | null | Promise<string | null>;
+    /**
+     * Credit admission for an exact provider before durable work is claimed.
+     * Resolves for subscription providers; throws TranscriptionBillingRefusedError
+     * when a deployment-funded provider cannot be paid for.
+     */
+    admit?(input: {
+        providerId: string;
+        accountId: string;
+        workspaceId: string;
+        attribution: CreditDebitAttribution;
+    }): Promise<void>;
     transcribe(request: TranscriptionRequest): Promise<TranscriptionResult>;
 };
 export type PreparedTranscriptionSegment = {
@@ -113,6 +228,8 @@ export type TranscriptionSegmenter = {
         sourceMimeType: string;
         totalDurationMilliseconds: number;
         providerSegmentSeconds: number;
+        /** Hard decode ceiling (`ffmpeg -t`); audio past it is never decoded. */
+        maxDecodeSeconds?: number | undefined;
         chunks: AsyncIterable<Uint8Array>;
         signal?: AbortSignal | undefined;
     }): AsyncIterable<PreparedTranscriptionSegment>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -50,17 +50,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/capabilities": "1.3.0",
-    "@opengeni/codex": "1.3.0",
-    "@opengeni/config": "1.3.0",
-    "@opengeni/contracts": "1.3.0",
-    "@opengeni/db": "1.3.0",
-    "@opengeni/documents": "1.3.0",
-    "@opengeni/events": "1.3.0",
-    "@opengeni/network": "1.3.0",
-    "@opengeni/observability": "1.3.0",
-    "@opengeni/runtime": "1.3.0",
-    "@opengeni/storage": "1.3.0",
+    "@opengeni/capabilities": "1.4.0",
+    "@opengeni/codex": "1.4.0",
+    "@opengeni/config": "1.4.0",
+    "@opengeni/contracts": "1.4.0",
+    "@opengeni/db": "1.4.0",
+    "@opengeni/documents": "1.4.0",
+    "@opengeni/events": "1.4.0",
+    "@opengeni/network": "1.4.0",
+    "@opengeni/observability": "1.4.0",
+    "@opengeni/runtime": "1.4.0",
+    "@opengeni/storage": "1.4.0",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/domain/connector-tool-permissions.ts

@@ -23,7 +23,6 @@ import type {
 import {
   buildConnectionTokenResolver,
   getConnectionMetadata,
-  listConnectionsMetadata,
   listEnabledMcpCapabilityServers,
   listConnectorToolPermissionPolicies,
   listChangedConnectorToolPermissions,
@@ -37,11 +36,16 @@ import {
 import { HTTPException } from "hono/http-exception";
 import {
   GMAIL_REST_MCP_TOOLS,
+  gmailToolAvailableOnDeployment,
   gmailToolSupportsScopes,
   isOfficialGmailMcpConfig,
   isOfficialSlackMcpConfig,
 } from "@opengeni/runtime";
 import { hasPermission } from "../access";
+import {
+  personalConnectionDelegationSourceForGrant,
+  visibleMcpAccountConnections,
+} from "./personal-connection-delegations";
 import {
   buildCapabilityCatalog,
   settingsWithMcpCapabilityServers,
@@ -195,12 +199,14 @@ async function resolveTarget(input: Input) {
     throw new HTTPException(403, {
       message: "Only the authenticated connection owner may manage personal tool permissions",
     });
+  const source = personalConnectionDelegationSourceForGrant(input.grant);
   const visible = ref
-    ? await listConnectionsMetadata(
-        input.db,
-        input.workspaceId,
-        input.personalOwnerVerified ? input.grant.subjectId : null,
-      )
+    ? await visibleMcpAccountConnections(input.db, {
+        accountId: input.grant.accountId,
+        workspaceId: input.workspaceId,
+        source:
+          input.personalOwnerVerified && source.kind === "subject" ? source : { kind: "none" },
+      })
     : [];
   const bindings = mcpAccountBindingsFromVisibleConnections({
     accountId: input.grant.accountId,
@@ -256,9 +262,16 @@ async function resolveTarget(input: Input) {
 export function reviewedConnectorToolCatalog(
   server: Pick<Settings["mcpServers"][number], "url" | "connectionRef" | "allowedTools">,
   grantedScopes: readonly string[],
+  deployment: Pick<Settings, "gmailWatchTopicName">,
 ): ListedTool[] | null {
   const tools = isOfficialGmailMcpConfig(server.url, server.connectionRef)
-    ? GMAIL_REST_MCP_TOOLS.filter((tool) => gmailToolSupportsScopes(tool.name, grantedScopes))
+    ? GMAIL_REST_MCP_TOOLS.filter(
+        (tool) =>
+          gmailToolSupportsScopes(tool.name, grantedScopes) &&
+          gmailToolAvailableOnDeployment(tool.name, {
+            watchTopicName: deployment.gmailWatchTopicName,
+          }),
+      )
     : isOfficialSlackMcpConfig(server.url, server.connectionRef)
       ? slackRestMcpToolsForScopes(grantedScopes)
       : null;
@@ -275,6 +288,7 @@ async function listTools(
   const reviewed = reviewedConnectorToolCatalog(
     target.server,
     target.connection?.grantedScopes ?? [],
+    input.settings,
   );
   if (reviewed !== null) return reviewed;
   let headers = { ...target.server.headers };
@@ -283,7 +297,9 @@ async function listTools(
       input.db,
       input.settings,
     )({
-      workspaceId: input.workspaceId,
+      // The selected account's credentials remain in its origin workspace;
+      // approval preferences remain scoped to the workspace being configured.
+      workspaceId: target.connection?.workspaceId ?? input.workspaceId,
       ...(target.connection?.subjectId ? { subjectId: input.grant.subjectId } : {}),
       serverId: target.server.id,
       toolName: "tools/list",

package/src/domain/realtime-voice-billing.ts

@@ -0,0 +1,330 @@
+import {
+  AI_GATEWAY_REALTIME_MODELS,
+  AZURE_LIVE_REALTIME_MODEL_ID,
+  configuredStaticUsageLimits,
+  parseRealtimeVoicePricingJson,
+  parseRealtimeVoicePricingTableJson,
+  realtimeVoiceMinuteCreditMicros,
+  realtimeVoiceStartedMinutes,
+  voiceInputCreditBillingActive,
+  type RealtimeVoicePricing,
+  type Settings,
+} from "@opengeni/config";
+import type { SessionRealtimeModel } from "@opengeni/contracts";
+import {
+  applyCreditDebitAfterUse,
+  checkWorkspaceAllowance,
+  creditDebitAttributionMetadata,
+  existingUsageEventIdempotencyKeys,
+  getSpendableCreditBalance,
+  loadSessionRealtimeBillingFacts,
+  recordUsageEvent,
+  sumUsageQuantity,
+  withRlsContext,
+  type CreditDebitAttribution,
+  type Database,
+} from "@opengeni/db";
+import { TranscriptionBillingRefusedError } from "../transcription";
+
+/** Credit debit type and usage source for deployment-funded live voice. */
+export const REALTIME_VOICE_DEBIT_TYPE = "voice_realtime_debit";
+export const REALTIME_VOICE_SOURCE_TYPE = "voice_realtime";
+
+export type DeploymentRealtimeVoice = {
+  provider: "azure-live" | "ai-gateway";
+  /** Credentials exist and this deployment offers the model. */
+  configured: boolean;
+  pricing: RealtimeVoicePricing | null;
+};
+
+/**
+ * Live-voice models the deployment pays the provider for. Connected Codex,
+ * SuperGrok, and a workspace's own Gateway key are paid by the workspace and
+ * return null. (The catalog lists hosted GPT Live instead of the managed
+ * Gateway choices when both are configured; both remain priced and gated.)
+ */
+export function deploymentRealtimeVoice(
+  settings: Settings,
+  model: SessionRealtimeModel | string,
+): DeploymentRealtimeVoice | null {
+  const azureConfigured = Boolean(settings.azureLiveEndpoint && settings.azureLiveApiKey?.trim());
+  if (model === AZURE_LIVE_REALTIME_MODEL_ID) {
+    return {
+      provider: "azure-live",
+      configured: azureConfigured,
+      pricing: parseRealtimeVoicePricingJson(settings.azureLivePricingJson),
+    };
+  }
+  for (const gateway of Object.values(AI_GATEWAY_REALTIME_MODELS)) {
+    if (gateway.managedModelId !== model) continue;
+    return {
+      provider: "ai-gateway",
+      configured: Boolean(settings.vercelAiGatewayApiKey),
+      pricing:
+        parseRealtimeVoicePricingTableJson(settings.aiGatewayRealtimePricingJson)[
+          gateway.upstreamModelId
+        ] ?? null,
+    };
+  }
+  return null;
+}
+
+export type RealtimeVoiceUnavailableCode = "not_configured" | "pricing_unconfigured";
+
+/** The deployment cannot offer this live-voice model at all (not a credit refusal). */
+export class RealtimeVoiceUnavailableError extends Error {
+  readonly name = "RealtimeVoiceUnavailableError";
+  constructor(
+    readonly code: RealtimeVoiceUnavailableCode,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+/** Static offer check: configured, and priced whenever credits are enforced. */
+export function realtimeVoiceOfferProblem(
+  settings: Settings,
+  voice: DeploymentRealtimeVoice,
+): RealtimeVoiceUnavailableError | null {
+  if (!voice.configured) {
+    return new RealtimeVoiceUnavailableError(
+      "not_configured",
+      "Opengeni live voice is not configured on this deployment.",
+    );
+  }
+  if (voiceInputCreditBillingActive(settings) && !voice.pricing) {
+    return new RealtimeVoiceUnavailableError(
+      "pricing_unconfigured",
+      "Opengeni live voice is not available on this deployment yet.",
+    );
+  }
+  return null;
+}
+
+export const REALTIME_VOICE_INSUFFICIENT_CREDITS_MESSAGE =
+  "Live voice needs Opengeni credits. Add credits to continue.";
+
+function startOfUtcMonth(now: Date): Date {
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+
+function initiatingHuman(attribution: CreditDebitAttribution): string | null {
+  return attribution.kind === "human" || attribution.kind === "turn"
+    ? attribution.initiatingHumanSubjectId
+    : null;
+}
+
+export type RealtimeVoiceSettlement = {
+  /** Credits debited by this settlement call (0 on replay). */
+  debitedMicros: number;
+  /** Why the live call must stop now, when it must. */
+  stop: TranscriptionBillingRefusedError | RealtimeVoiceUnavailableError | null;
+};
+
+/**
+ * Credit admission and time metering for deployment-funded live voice.
+ *
+ * Admission mirrors voice-input admission (same refusal codes and HTTP
+ * shape): spendable general credits must be positive, the workspace/member
+ * allowance must not be exhausted, and the static monthly cost cap applies.
+ * Metering bills every started minute of each issued provider connection,
+ * measured only from server-observed facts (connection claim time, owner
+ * heartbeats, owner-proven end). Each (connection, minute) is one idempotent
+ * usage receipt plus one post-use debit.
+ */
+export function createRealtimeVoiceBilling(deps: { db: Database; settings: Settings }) {
+  const billingActive = () => voiceInputCreditBillingActive(deps.settings);
+
+  async function refusal(input: {
+    accountId: string;
+    workspaceId: string;
+    attribution: CreditDebitAttribution;
+    now: Date;
+  }): Promise<TranscriptionBillingRefusedError | null> {
+    const balance = await getSpendableCreditBalance(deps.db, input.accountId);
+    if (balance.balanceMicros <= 0) {
+      return new TranscriptionBillingRefusedError({
+        code: "insufficient_credits",
+        message: REALTIME_VOICE_INSUFFICIENT_CREDITS_MESSAGE,
+      });
+    }
+    const allowance = await checkWorkspaceAllowance(deps.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: initiatingHuman(input.attribution),
+    });
+    if (allowance) {
+      return new TranscriptionBillingRefusedError({
+        code: allowance.code,
+        message: allowance.message,
+        details: {
+          scope: allowance.scope,
+          resetsAt: allowance.resetsAt,
+          ...(allowance.subjectId ? { subjectId: allowance.subjectId } : {}),
+        },
+      });
+    }
+    if (deps.settings.usageLimitsMode === "static" || deps.settings.usageLimitsMode === "managed") {
+      const cap = configuredStaticUsageLimits(deps.settings).maxMonthlyCostMicrosPerAccount;
+      if (cap) {
+        const used = await sumUsageQuantity(deps.db, {
+          accountId: input.accountId,
+          eventType: "model.cost",
+          since: startOfUtcMonth(input.now),
+        });
+        if (used >= cap) {
+          return new TranscriptionBillingRefusedError({
+            code: "monthly_model_cost_limit",
+            message: "The monthly model cost limit has been reached.",
+          });
+        }
+      }
+    }
+    return null;
+  }
+
+  return {
+    /**
+     * Throws RealtimeVoiceUnavailableError when the deployment cannot offer
+     * the model and TranscriptionBillingRefusedError for a credit refusal.
+     * Workspace-funded models are always admitted here.
+     */
+    async admit(input: {
+      accountId: string;
+      workspaceId: string;
+      model: SessionRealtimeModel;
+      attribution: CreditDebitAttribution;
+      now?: Date;
+    }): Promise<void> {
+      const voice = deploymentRealtimeVoice(deps.settings, input.model);
+      if (!voice) return;
+      const problem = realtimeVoiceOfferProblem(deps.settings, voice);
+      if (problem) throw problem;
+      if (!billingActive()) return;
+      const refused = await refusal({ ...input, now: input.now ?? new Date() });
+      if (refused) throw refused;
+    },
+
+    /** Spendable credits are positive (always true when credits are not enforced). */
+    async hasSpendableCredits(accountId: string): Promise<boolean> {
+      if (!billingActive()) return true;
+      const balance = await getSpendableCreditBalance(deps.db, accountId);
+      return balance.balanceMicros > 0;
+    },
+
+    /**
+     * Settle every started minute observed so far for one live-voice mode and
+     * report whether the call must stop. Safe to call repeatedly and
+     * concurrently: receipts and debits are idempotent per (connection, minute).
+     */
+    async settle(input: {
+      workspaceId: string;
+      sessionId: string;
+      realtimeId: string;
+      /** Authenticated caller; its attribution applies only when it owns the call. */
+      callerSubjectId: string;
+      attribution: CreditDebitAttribution;
+      now?: Date;
+    }): Promise<RealtimeVoiceSettlement> {
+      const now = input.now ?? new Date();
+      if (!billingActive()) return { debitedMicros: 0, stop: null };
+      const facts = await loadSessionRealtimeBillingFacts(deps.db, { ...input, now });
+      if (!facts) return { debitedMicros: 0, stop: null };
+      const voice = deploymentRealtimeVoice(deps.settings, facts.model);
+      if (!voice) return { debitedMicros: 0, stop: null };
+      if (!voice.pricing) {
+        // Pricing was removed after admission: nothing to bill against, so the
+        // call must end rather than continue unpriced.
+        return {
+          debitedMicros: 0,
+          stop: new RealtimeVoiceUnavailableError(
+            "pricing_unconfigured",
+            "Opengeni live voice is no longer available on this deployment.",
+          ),
+        };
+      }
+      const attribution: CreditDebitAttribution =
+        input.callerSubjectId === facts.ownerSubjectId ? input.attribution : { kind: "unknown" };
+      const cost = realtimeVoiceMinuteCreditMicros(voice.pricing);
+      const minutes = facts.connections.flatMap((connection) =>
+        Array.from(
+          { length: realtimeVoiceStartedMinutes(connection.startedAt, connection.observedUntil) },
+          (_, index) => ({
+            connectionId: connection.id,
+            minute: index + 1,
+            startsAt: new Date(connection.startedAt.getTime() + index * 60_000),
+            key: `voice.realtime_cost:${connection.id}:${index + 1}`,
+          }),
+        ),
+      );
+      const recorded = await existingUsageEventIdempotencyKeys(deps.db, {
+        accountId: facts.accountId,
+        workspaceId: facts.workspaceId,
+        keys: minutes.map((minute) => minute.key),
+      });
+      let debitedMicros = 0;
+      for (const minute of minutes) {
+        if (recorded.has(minute.key)) continue;
+        debitedMicros += await withRlsContext(
+          deps.db,
+          { accountId: facts.accountId, workspaceId: facts.workspaceId },
+          async (tx) => {
+            const sourceId = `${minute.connectionId}:${minute.minute}`;
+            const receipt = await recordUsageEvent(tx, {
+              accountId: facts.accountId,
+              workspaceId: facts.workspaceId,
+              sessionId: facts.sessionId,
+              eventType: "model.cost",
+              quantity: cost.creditCostMicros,
+              unit: "usd_micros",
+              sourceResourceType: REALTIME_VOICE_SOURCE_TYPE,
+              sourceResourceId: sourceId,
+              idempotencyKey: minute.key,
+              occurredAt: minute.startsAt,
+              initiator: { kind: "service", subjectId: "api:voice-realtime" },
+              initiatorContext: { creditDebitAttribution: attribution },
+            });
+            const amount = Number(receipt.quantity);
+            if (amount <= 0) return 0;
+            const debit = await applyCreditDebitAfterUse(tx, {
+              accountId: facts.accountId,
+              workspaceId: facts.workspaceId,
+              type: REALTIME_VOICE_DEBIT_TYPE,
+              amountMicros: amount,
+              sourceType: REALTIME_VOICE_SOURCE_TYPE,
+              sourceId,
+              idempotencyKey: `credit:${REALTIME_VOICE_DEBIT_TYPE}:${sourceId}`,
+              occurredAt: minute.startsAt,
+              metadata: {
+                provider: voice.provider,
+                model: facts.model,
+                realtimeId: facts.realtimeId,
+                connectionId: minute.connectionId,
+                minute: minute.minute,
+                basis: "server_observed_started_minute",
+                providerCostMicros: cost.providerCostMicros,
+                ...(attribution.kind === "unknown"
+                  ? {}
+                  : creditDebitAttributionMetadata(attribution)),
+              },
+            });
+            return debit.debitedMicros;
+          },
+        );
+      }
+      const stop =
+        facts.state === "active"
+          ? await refusal({
+              accountId: facts.accountId,
+              workspaceId: facts.workspaceId,
+              attribution,
+              now,
+            })
+          : null;
+      return { debitedMicros, stop };
+    },
+  };
+}
+
+export type RealtimeVoiceBilling = ReturnType<typeof createRealtimeVoiceBilling>;

package/src/domain/scheduled-task-access.ts

@@ -14,6 +14,7 @@ import {
   allowedFirstPartyMcpToolsForSession,
   resolveFirstPartyMcpToolPolicy,
   type Settings,
+  type FirstPartyMcpToolPolicySettings,
 } from "@opengeni/config";
 import {
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
@@ -256,7 +257,7 @@ export function planScheduledTaskOpenGeniTools(input: {
     ScheduledTaskCreatorPolicy,
     "firstPartyMcpTools" | "firstPartyMcpPermissions"
   > | null;
-  settings: Pick<Settings, "defaultFirstPartyMcpTools" | "allowedFirstPartyMcpTools">;
+  settings: FirstPartyMcpToolPolicySettings;
   grantPermissions: readonly Permission[];
   grantPermissionMode?: AccessGrant["permissionMode"];
   permissionsRequiredByTools: FirstPartyToolPermissionRequirements;

package/src/domain/scheduled-tasks.ts

@@ -15,6 +15,7 @@ import {
 import {
   allowedFirstPartyMcpToolsForSession,
   resolveFirstPartyMcpToolPolicy,
+  type FirstPartyMcpToolPolicySettings,
   type Settings,
 } from "@opengeni/config";
 import {
@@ -232,7 +233,7 @@ export function scheduledConnectionSurfaceEligibility(
   settings: Settings,
   target: Pick<Session, "firstPartyMcpTools" | "firstPartyMcpPermissions"> | null,
 ): { googleDrivePublicationEnabled: boolean; atlassianEnabled: boolean } {
-  const tools = target?.firstPartyMcpTools ?? resolveFirstPartyMcpToolPolicy(settings).default;
+  const tools = allowedFirstPartyMcpToolsForSession(settings, target?.firstPartyMcpTools);
   const permissions = target?.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
   return {
     googleDrivePublicationEnabled:
@@ -2502,7 +2503,7 @@ async function validateScheduledTaskAgentConfig(input: {
  * Mutable rig/variable-set metadata is revalidated again at dispatch.
  */
 export function validateIncidentTelemetryPreflightSelection(
-  settings: Pick<Settings, "allowedFirstPartyMcpTools" | "defaultFirstPartyMcpTools">,
+  settings: FirstPartyMcpToolPolicySettings,
   agentConfig: ScheduledTaskAgentConfig,
 ): void {
   const executionClass = agentConfig.executionClass;