@oneuptime/common 11.3.25 → 11.3.28

package/Server/Infrastructure/PostgresDatabase.ts

@@ -1,5 +1,6 @@
 import logger from "../Utils/Logger";
 import DatabaseDataSourceOptions from "./Postgres/DataSourceOptions";
+import { recordSchemaMigrationFailureBestEffort } from "../Utils/Database/MigrationFailureLog";
 import Sleep from "../../Types/Sleep";
 import { DataSource, DataSourceOptions, QueryRunner } from "typeorm";
 import { createDatabase, dropDatabase } from "typeorm-extension";
@@ -95,6 +96,16 @@ export default class Database {
     } catch (err) {
       logger.error("Postgres Database Connection Failed");
       logger.error(err);
+
+      /*
+       * When this process runs schema migrations on boot (migrationsRun=true),
+       * connect() also fails if a migration threw. Record which migration
+       * failed and why — on a throwaway connection, since the DataSource above
+       * is unusable — so the admin health page can explain the pending schema.
+       * Best-effort and self-contained: it never throws and never masks `err`.
+       */
+      await recordSchemaMigrationFailureBestEffort(dataSourceOptions, err);
+
       throw err;
     }
   }

package/Server/Services/AIConversationMessageService.ts

@@ -0,0 +1,39 @@
+import PositiveNumber from "../../Types/PositiveNumber";
+import CountBy from "../Types/Database/CountBy";
+import FindBy from "../Types/Database/FindBy";
+import { OnFind } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIConversationMessage";
+import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeFind(
+    findBy: FindBy<Model>,
+  ): Promise<OnFind<Model>> {
+    findBy.query = pinQueryToRequestingUser(
+      findBy.query,
+      findBy.props,
+      "userId",
+    );
+    return { findBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public override async countBy(
+    countBy: CountBy<Model>,
+  ): Promise<PositiveNumber> {
+    countBy.query = pinQueryToRequestingUser(
+      countBy.query,
+      countBy.props,
+      "userId",
+    );
+    return super.countBy(countBy);
+  }
+}
+
+export default new Service();

package/Server/Services/AIConversationService.ts

@@ -0,0 +1,63 @@
+import PositiveNumber from "../../Types/PositiveNumber";
+import CountBy from "../Types/Database/CountBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import FindBy from "../Types/Database/FindBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnDelete, OnFind, OnUpdate } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIConversation";
+import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeFind(
+    findBy: FindBy<Model>,
+  ): Promise<OnFind<Model>> {
+    findBy.query = pinQueryToRequestingUser(
+      findBy.query,
+      findBy.props,
+      "createdByUserId",
+    );
+    return { findBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public override async countBy(
+    countBy: CountBy<Model>,
+  ): Promise<PositiveNumber> {
+    countBy.query = pinQueryToRequestingUser(
+      countBy.query,
+      countBy.props,
+      "createdByUserId",
+    );
+    return super.countBy(countBy);
+  }
+
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    updateBy.query = pinQueryToRequestingUser(
+      updateBy.query,
+      updateBy.props,
+      "createdByUserId",
+    );
+    return { updateBy, carryForward: null };
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    deleteBy.query = pinQueryToRequestingUser(
+      deleteBy.query,
+      deleteBy.props,
+      "createdByUserId",
+    );
+    return { deleteBy, carryForward: null };
+  }
+}
+
+export default new Service();

package/Server/Services/AIRunEventService.ts

@@ -0,0 +1,39 @@
+import PositiveNumber from "../../Types/PositiveNumber";
+import CountBy from "../Types/Database/CountBy";
+import FindBy from "../Types/Database/FindBy";
+import { OnFind } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIRunEvent";
+import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeFind(
+    findBy: FindBy<Model>,
+  ): Promise<OnFind<Model>> {
+    findBy.query = pinQueryToRequestingUser(
+      findBy.query,
+      findBy.props,
+      "userId",
+    );
+    return { findBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public override async countBy(
+    countBy: CountBy<Model>,
+  ): Promise<PositiveNumber> {
+    countBy.query = pinQueryToRequestingUser(
+      countBy.query,
+      countBy.props,
+      "userId",
+    );
+    return super.countBy(countBy);
+  }
+}
+
+export default new Service();

package/Server/Services/AIRunService.ts

@@ -0,0 +1,39 @@
+import PositiveNumber from "../../Types/PositiveNumber";
+import CountBy from "../Types/Database/CountBy";
+import FindBy from "../Types/Database/FindBy";
+import { OnFind } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIRun";
+import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  protected override async onBeforeFind(
+    findBy: FindBy<Model>,
+  ): Promise<OnFind<Model>> {
+    findBy.query = pinQueryToRequestingUser(
+      findBy.query,
+      findBy.props,
+      "userId",
+    );
+    return { findBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public override async countBy(
+    countBy: CountBy<Model>,
+  ): Promise<PositiveNumber> {
+    countBy.query = pinQueryToRequestingUser(
+      countBy.query,
+      countBy.props,
+      "userId",
+    );
+    return super.countBy(countBy);
+  }
+}
+
+export default new Service();

package/Server/Services/AIService.ts

@@ -9,7 +9,12 @@ import LLMService, {
   LLMProviderConfig,
   LLMCompletionResponse,
   LLMMessage,
+  LLMToolCall,
+  LLMToolDefinition,
+  LLMUsage,
 } from "../Utils/LLM/LLMService";
+import LlmType from "../../Types/LLM/LlmType";
+import { Span, trace } from "@opentelemetry/api";
 import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
 import LlmLog from "../../Models/DatabaseModels/LlmLog";
 import LlmLogStatus from "../../Types/LlmLogStatus";
@@ -20,18 +25,32 @@ import logger, { LogAttributes } from "../Utils/Logger";
 
 export interface AILogRequest {
   projectId: ObjectID;
-  userId?: ObjectID;
+  userId?: ObjectID | undefined;
   feature: string; // e.g., "IncidentPostmortem", "IncidentNote"
   incidentId?: ObjectID;
   alertId?: ObjectID;
   scheduledMaintenanceId?: ObjectID;
+  aiRunId?: ObjectID;
+  /*
+   * When set, use this specific provider (validated against the project) rather
+   * than the project default. Powers the in-chat provider/model switcher.
+   */
+  llmProviderId?: ObjectID | undefined;
   messages: Array<LLMMessage>;
-  maxTokens?: number;
-  temperature?: number;
+  tools?: Array<LLMToolDefinition> | undefined;
+  maxTokens?: number | undefined;
+  temperature?: number | undefined;
+  /*
+   * When false, prompt/response previews are NOT persisted to LlmLog.
+   * Use for features whose content is private to a single user (e.g. AI
+   * chat) — LlmLog is readable by all project members.
+   */
+  storeContentPreviews?: boolean | undefined;
 }
 
 export interface AILogResponse {
   content: string;
+  toolCalls?: Array<LLMToolCall> | undefined;
   llmLog: LlmLog;
 }
 
@@ -46,9 +65,12 @@ export class Service extends BaseService {
   ): Promise<AILogResponse> {
     const startTime: Date = new Date();
 
-    // Get LLM provider for the project
+    // Get LLM provider for the project (honoring an explicit per-chat choice).
     const llmProvider: LlmProvider | null =
-      await LlmProviderService.getLLMProviderForProject(request.projectId);
+      await LlmProviderService.getProviderForChat({
+        projectId: request.projectId,
+        llmProviderId: request.llmProviderId,
+      });
 
     if (!llmProvider) {
       throw new BadDataException(
@@ -67,12 +89,18 @@ export class Service extends BaseService {
     logEntry.projectId = request.projectId;
     logEntry.isGlobalProvider = llmProvider.isGlobalLlm || false;
     logEntry.feature = request.feature;
-    logEntry.requestPrompt = request.messages
-      .map((m: LLMMessage) => {
-        return m.content;
-      })
-      .join("\n")
-      .substring(0, 5000); // Store first 5000 chars
+
+    const storeContentPreviews: boolean =
+      request.storeContentPreviews !== false;
+
+    logEntry.requestPrompt = storeContentPreviews
+      ? request.messages
+          .map((m: LLMMessage) => {
+            return m.content;
+          })
+          .join("\n")
+          .substring(0, 5000) // Store first 5000 chars
+      : "[Redacted — this content is private to the requesting user]";
     logEntry.requestStartedAt = startTime;
 
     // Set optional fields only if they have values
@@ -100,10 +128,21 @@ export class Service extends BaseService {
     if (request.scheduledMaintenanceId) {
       logEntry.scheduledMaintenanceId = request.scheduledMaintenanceId;
     }
+    if (request.aiRunId) {
+      logEntry.aiRunId = request.aiRunId;
+    }
 
-    // Check if billing should apply
+    /*
+     * Check if billing should apply. Only bill for the global (OneUptime-hosted)
+     * provider, and only when it actually has a per-token cost. A free global
+     * provider (costPerMillionTokensInUSDCents = 0, the default) consumes no
+     * balance, so it must not require or block on one either — otherwise a $0
+     * provider would still fail with "Insufficient AI balance".
+     */
     const shouldBill: boolean =
-      IsBillingEnabled && (llmProvider.isGlobalLlm || false);
+      IsBillingEnabled &&
+      (llmProvider.isGlobalLlm || false) &&
+      (llmProvider.costPerMillionTokensInUSDCents || 0) > 0;
 
     // Check balance if billing enabled and using global provider
     if (shouldBill) {
@@ -153,6 +192,8 @@ export class Service extends BaseService {
         llmProviderConfig: llmConfig,
         messages: request.messages,
         temperature: request.temperature ?? 0.7,
+        maxTokens: request.maxTokens,
+        tools: request.tools,
       });
 
       const endTime: Date = new Date();
@@ -160,7 +201,9 @@ export class Service extends BaseService {
       // Update log with success info
       logEntry.status = LlmLogStatus.Success;
       logEntry.totalTokens = response.usage?.totalTokens || 0;
-      logEntry.responsePreview = response.content.substring(0, 2000); // Store first 2000 chars
+      logEntry.responsePreview = storeContentPreviews
+        ? response.content.substring(0, 2000) // Store first 2000 chars
+        : "[Redacted — this content is private to the requesting user]";
       logEntry.requestCompletedAt = endTime;
       logEntry.durationMs = endTime.getTime() - startTime.getTime();
 
@@ -176,27 +219,16 @@ export class Service extends BaseService {
 
         // Deduct from project balance
         if (totalCost > 0) {
-          const project: Project | null = await ProjectService.findOneById({
-            id: request.projectId,
-            select: { aiCurrentBalanceInUSDCents: true },
-            props: { isRoot: true },
+          /*
+           * Atomic decrement — concurrent LLM calls within and across chat
+           * turns must not lose each other's deductions (a read-modify-write
+           * here silently forgave overlapping spend).
+           */
+          await ProjectService.deductAiBalanceInUSDCents({
+            projectId: request.projectId,
+            amountInUSDCents: totalCost,
           });
 
-          if (project) {
-            const newBalance: number = Math.max(
-              0,
-              (project.aiCurrentBalanceInUSDCents || 0) - totalCost,
-            );
-
-            await ProjectService.updateOneById({
-              id: request.projectId,
-              data: {
-                aiCurrentBalanceInUSDCents: newBalance,
-              },
-              props: { isRoot: true },
-            });
-          }
-
           // Check if auto-recharge is needed (do this async, don't wait)
           AIBillingService.rechargeIfBalanceIsLow(request.projectId).catch(
             (err: Error) => {
@@ -213,6 +245,18 @@ export class Service extends BaseService {
         }
       }
 
+      /*
+       * Emit gen_ai.* semantic-convention attributes on the active span so
+       * OneUptime's own AI usage is a first-class LLM span in OneUptime's own
+       * telemetry (dogfooding — LlmSpanUtil detects these). Never fails the call.
+       */
+      this.setGenAiSpanAttributes({
+        llmType: llmProvider.llmType,
+        modelName: llmConfig.modelName,
+        usage: response.usage,
+        costInUSDCents: logEntry.costInUSDCents,
+      });
+
       // Save log entry
       const savedLog: LlmLog = await LlmLogService.create({
         data: logEntry,
@@ -221,6 +265,7 @@ export class Service extends BaseService {
 
       return {
         content: response.content,
+        toolCalls: response.toolCalls,
         llmLog: savedLog,
       };
     } catch (error) {
@@ -239,6 +284,55 @@ export class Service extends BaseService {
       throw error;
     }
   }
+
+  /*
+   * Set gen_ai.* attributes (OpenTelemetry GenAI semantic conventions) on the
+   * currently-active span. The @CaptureSpan()-wrapped caller owns that span, so
+   * LlmSpanUtil recognizes these calls as first-class LLM spans.
+   */
+  private setGenAiSpanAttributes(data: {
+    llmType: LlmType;
+    modelName?: string | undefined;
+    usage?: LLMUsage | undefined;
+    costInUSDCents?: number | undefined;
+  }): void {
+    try {
+      const span: Span | undefined = trace.getActiveSpan();
+      if (!span) {
+        return;
+      }
+
+      span.setAttribute("gen_ai.system", data.llmType.toString());
+      span.setAttribute("gen_ai.provider.name", data.llmType.toString());
+      span.setAttribute("gen_ai.operation.name", "chat");
+
+      if (data.modelName) {
+        span.setAttribute("gen_ai.request.model", data.modelName);
+        span.setAttribute("gen_ai.response.model", data.modelName);
+      }
+
+      if (data.usage) {
+        span.setAttribute(
+          "gen_ai.usage.input_tokens",
+          data.usage.promptTokens || 0,
+        );
+        span.setAttribute(
+          "gen_ai.usage.output_tokens",
+          data.usage.completionTokens || 0,
+        );
+        span.setAttribute(
+          "gen_ai.usage.total_tokens",
+          data.usage.totalTokens || 0,
+        );
+      }
+
+      if (data.costInUSDCents) {
+        span.setAttribute("gen_ai.usage.cost_usd", data.costInUSDCents / 100);
+      }
+    } catch {
+      // Telemetry must never fail the LLM call.
+    }
+  }
 }
 
 export default new Service();

package/Server/Services/AnalyticsDatabaseService.ts

@@ -1899,7 +1899,16 @@ export default class AnalyticsDatabaseService<
     return data;
   }
 
-  protected async getException(error: Exception): Promise<void> {
+  /*
+   * Rethrow hook for the catch blocks below. MUST stay synchronous and
+   * `never`-returning: the call sites use `throw this.getException(error)`,
+   * so if this were `async` it would return a Promise that `throw` then
+   * throws verbatim (never awaited) — the real exception is lost, callers up
+   * the stack catch a bare Promise (surfacing as "[object Promise]"), and the
+   * un-awaited rejection becomes an unhandled rejection. Throwing directly
+   * propagates the original exception on the synchronous throw path.
+   */
+  protected getException(error: Exception): never {
     throw error;
   }
 

package/Server/Services/DatabaseService.ts

@@ -443,7 +443,16 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     return Promise.resolve(error);
   }
 
-  protected async getException(error: Exception): Promise<void> {
+  /*
+   * Rethrow hook for the catch blocks below. MUST stay synchronous and
+   * `never`-returning: the call sites use `throw this.getException(error)`,
+   * so if this were `async` it would return a Promise that `throw` then
+   * throws verbatim (never awaited) — the real exception is lost, callers up
+   * the stack catch a bare Promise (surfacing as "[object Promise]"), and the
+   * un-awaited rejection becomes an unhandled rejection. Throwing directly
+   * propagates the original exception on the synchronous throw path.
+   */
+  protected getException(error: Exception): never {
     throw error;
   }
 
@@ -2106,6 +2115,25 @@ class DatabaseService<TBaseModel extends BaseModel> extends BaseService {
     );
   }
 
+  /*
+   * Atomically subtract `value` from a numeric column in a single UPDATE
+   * (SET col = col - value) so concurrent callers never lose each other's
+   * writes the way a read-modify-write would. The column can go negative;
+   * callers that gate on a non-negative balance simply reject the next
+   * request rather than silently forgiving the overage.
+   */
+  protected async atomicDecrementColumnValueBy(data: {
+    id: ObjectID;
+    columnName: keyof TBaseModel;
+    value: number;
+  }): Promise<void> {
+    await this.getRepository().decrement(
+      { _id: data.id.toString() } as any,
+      data.columnName as string,
+      data.value,
+    );
+  }
+
   @CaptureSpan()
   public async searchBy({
     skip,

package/Server/Services/IncidentService.ts

@@ -3479,7 +3479,7 @@ ${incidentSeverity.name}
     const response: LLMCompletionResponse = await LLMService.getCompletion({
       llmProviderConfig: llmConfig,
       messages: aiContext.messages,
-      temperature: 0.7,
+      temperature: 0.2,
     });
 
     return response.content;

package/Server/Services/IncomingCallPolicyEscalationRuleService.ts

@@ -135,6 +135,79 @@ export class Service extends DatabaseService<IncomingCallPolicyEscalationRule> {
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<IncomingCallPolicyEscalationRule>,
   ): Promise<OnUpdate<IncomingCallPolicyEscalationRule>> {
+    /*
+     * Enforce user/schedule mutual exclusivity on update (parity with onBeforeCreate).
+     * Only runs when the update actually touches one of the routing-target fields, so
+     * internal updates (status/order via isRoot) are unaffected.
+     */
+    const data: UpdateBy<IncomingCallPolicyEscalationRule>["data"] =
+      updateBy.data;
+    const isTouchingTarget: boolean =
+      data.userId !== undefined ||
+      data.onCallDutyPolicyScheduleId !== undefined;
+
+    if (isTouchingTarget && updateBy.query._id) {
+      const settingUser: boolean = Boolean(data.userId);
+      const settingSchedule: boolean = Boolean(data.onCallDutyPolicyScheduleId);
+
+      if (settingUser && settingSchedule) {
+        throw new BadDataException(
+          "Only one of User or On-Call Schedule can be specified, not both",
+        );
+      }
+
+      // Setting one target clears the other so a rule can never hold both.
+      const nullableData: {
+        userId?: ObjectID | null;
+        onCallDutyPolicyScheduleId?: ObjectID | null;
+      } = data as {
+        userId?: ObjectID | null;
+        onCallDutyPolicyScheduleId?: ObjectID | null;
+      };
+      if (settingUser) {
+        nullableData.onCallDutyPolicyScheduleId = null;
+      }
+      if (settingSchedule) {
+        nullableData.userId = null;
+      }
+
+      const existing: IncomingCallPolicyEscalationRule | null =
+        await this.findOneBy({
+          query: {
+            _id: updateBy.query._id!,
+          },
+          select: {
+            userId: true,
+            onCallDutyPolicyScheduleId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      /*
+       * Whether each target will be present AFTER this update, accounting for
+       * fields left untouched (keep existing) and the opposite-field clearing
+       * done above.
+       */
+      const willHaveUser: boolean = settingUser
+        ? true
+        : data.userId === undefined
+          ? Boolean(existing?.userId)
+          : false;
+      const willHaveSchedule: boolean = settingSchedule
+        ? true
+        : data.onCallDutyPolicyScheduleId === undefined
+          ? Boolean(existing?.onCallDutyPolicyScheduleId)
+          : false;
+
+      if (!willHaveUser && !willHaveSchedule) {
+        throw new BadDataException(
+          "Either a User or an On-Call Schedule must be specified for the escalation rule",
+        );
+      }
+    }
+
     if (updateBy.data.order && !updateBy.props.isRoot && updateBy.query._id) {
       const resource: IncomingCallPolicyEscalationRule | null =
         await this.findOneBy({
@@ -194,8 +267,8 @@ export class Service extends DatabaseService<IncomingCallPolicyEscalationRule> {
       if (newOrder > currentOrder) {
         // moving down.
         for (const resource of resources) {
-          if (resource.order! <= newOrder) {
-            // increment order.
+          if (resource.order! > currentOrder && resource.order! <= newOrder) {
+            // decrement order to fill the gap left by the moved rule.
             await this.updateOneBy({
               query: {
                 _id: resource._id!,

package/Server/Services/IncomingCallPolicyService.ts

@@ -2,7 +2,10 @@ import DatabaseService from "./DatabaseService";
 import IncomingCallPolicy from "../../Models/DatabaseModels/IncomingCallPolicy";
 import IncomingCallPolicyLabelRuleEngineService from "./IncomingCallPolicyLabelRuleEngineService";
 import IncomingCallPolicyOwnerRuleEngineService from "./IncomingCallPolicyOwnerRuleEngineService";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DeleteBy from "../Types/Database/DeleteBy";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import releaseIncomingCallPhoneNumber from "../Utils/IncomingCallPhoneNumber";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger, { LogAttributes } from "../Utils/Logger";
 
@@ -11,6 +14,44 @@ export class Service extends DatabaseService<IncomingCallPolicy> {
     super(IncomingCallPolicy);
   }
 
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<IncomingCallPolicy>,
+  ): Promise<OnDelete<IncomingCallPolicy>> {
+    /*
+     * Release any provisioned numbers before the policy rows are removed so we
+     * don't leave paid, orphaned numbers on the provider that can never be
+     * released again (the policy — and its SID — would be gone).
+     */
+    const policies: Array<IncomingCallPolicy> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        callProviderPhoneNumberId: true,
+        projectCallSMSConfigId: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const policy of policies) {
+      if (policy.callProviderPhoneNumberId && policy.projectCallSMSConfigId) {
+        await releaseIncomingCallPhoneNumber({
+          projectCallSMSConfigId: policy.projectCallSMSConfigId,
+          callProviderPhoneNumberId: policy.callProviderPhoneNumberId,
+        });
+      }
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<IncomingCallPolicy>,