@oneuptime/common 11.3.24 → 11.3.26

package/Server/Services/AIService.ts

@@ -9,6 +9,8 @@ import LLMService, {
   LLMProviderConfig,
   LLMCompletionResponse,
   LLMMessage,
+  LLMToolCall,
+  LLMToolDefinition,
 } from "../Utils/LLM/LLMService";
 import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
 import LlmLog from "../../Models/DatabaseModels/LlmLog";
@@ -20,18 +22,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 +62,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 +86,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,6 +125,9 @@ export class Service extends BaseService {
     if (request.scheduledMaintenanceId) {
       logEntry.scheduledMaintenanceId = request.scheduledMaintenanceId;
     }
+    if (request.aiRunId) {
+      logEntry.aiRunId = request.aiRunId;
+    }
 
     // Check if billing should apply
     const shouldBill: boolean =
@@ -153,6 +181,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 +190,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 +208,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) => {
@@ -221,6 +242,7 @@ export class Service extends BaseService {
 
       return {
         content: response.content,
+        toolCalls: response.toolCalls,
         llmLog: savedLog,
       };
     } catch (error) {

package/Server/Services/DatabaseService.ts

@@ -2106,6 +2106,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/LlmProviderService.ts

@@ -6,6 +6,7 @@ import ObjectID from "../../Types/ObjectID";
 import UpdateBy from "../Types/Database/UpdateBy";
 import QueryHelper from "../Types/Database/QueryHelper";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 
 export class Service extends DatabaseService<Model> {
@@ -153,6 +154,115 @@ export class Service extends DatabaseService<Model> {
 
     return null;
   }
+
+  /*
+   * Resolve the provider to use for a chat turn. When the user has explicitly
+   * chosen a provider (llmProviderId), use it — but only if it is actually
+   * usable by this project: either a global provider, or one owned by the
+   * project. Otherwise fall back to the project default / global provider.
+   * A stale id (e.g. the chosen provider was deleted) also falls back, so a
+   * conversation never breaks because its provider went away.
+   */
+  @CaptureSpan()
+  public async getProviderForChat(data: {
+    projectId: ObjectID;
+    llmProviderId?: ObjectID | undefined;
+  }): Promise<Model | null> {
+    if (data.llmProviderId) {
+      const provider: Model | null = await this.findOneBy({
+        query: {
+          _id: data.llmProviderId.toString(),
+        },
+        select: {
+          _id: true,
+          name: true,
+          llmType: true,
+          apiKey: true,
+          baseUrl: true,
+          modelName: true,
+          isGlobalLlm: true,
+          projectId: true,
+          costPerMillionTokensInUSDCents: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (provider) {
+        const isGlobal: boolean = provider.isGlobalLlm === true;
+        const belongsToProject: boolean =
+          provider.projectId?.toString() === data.projectId.toString();
+
+        if (isGlobal || belongsToProject) {
+          return provider;
+        }
+      }
+      // Fall through to default resolution when the id is invalid/inaccessible.
+    }
+
+    return this.getLLMProviderForProject(data.projectId);
+  }
+
+  /*
+   * The providers a project member can pick from in the chat provider switcher:
+   * every provider configured for the project plus every global provider.
+   * Secrets (apiKey) are never selected here — this only feeds the picker UI.
+   */
+  @CaptureSpan()
+  public async getSelectableProvidersForProject(
+    projectId: ObjectID,
+  ): Promise<Array<Model>> {
+    const [projectProviders, globalProviders]: [Array<Model>, Array<Model>] =
+      await Promise.all([
+        this.findBy({
+          query: {
+            projectId: projectId,
+          },
+          select: {
+            _id: true,
+            name: true,
+            llmType: true,
+            modelName: true,
+            isDefault: true,
+            isGlobalLlm: true,
+          },
+          sort: {
+            isDefault: SortOrder.Descending,
+            name: SortOrder.Ascending,
+          },
+          skip: 0,
+          limit: LIMIT_MAX,
+          props: {
+            isRoot: true,
+          },
+        }),
+        this.findBy({
+          query: {
+            projectId: QueryHelper.isNull(),
+            isGlobalLlm: true,
+          },
+          select: {
+            _id: true,
+            name: true,
+            llmType: true,
+            modelName: true,
+            isDefault: true,
+            isGlobalLlm: true,
+          },
+          sort: {
+            name: SortOrder.Ascending,
+          },
+          skip: 0,
+          limit: LIMIT_MAX,
+          props: {
+            isRoot: true,
+          },
+        }),
+      ]);
+
+    return [...projectProviders, ...globalProviders];
+  }
 }
 
 export default new Service();

package/Server/Services/ProjectService.ts

@@ -1915,6 +1915,30 @@ export class ProjectService extends DatabaseService<Model> {
     );
   }
 
+  @CaptureSpan()
+  /*
+   * Atomically deduct AI spend from the project's balance. A single
+   * SET aiCurrentBalanceInUSDCents = aiCurrentBalanceInUSDCents - amount
+   * so concurrent AI runs (many LLM calls per turn, several turns per
+   * project) can't clobber each other's deductions the way a
+   * read-then-write would. No-op for non-positive amounts.
+   */
+  @CaptureSpan()
+  public async deductAiBalanceInUSDCents(data: {
+    projectId: ObjectID;
+    amountInUSDCents: number;
+  }): Promise<void> {
+    if (!data.amountInUSDCents || data.amountInUSDCents <= 0) {
+      return;
+    }
+
+    await this.atomicDecrementColumnValueBy({
+      id: data.projectId,
+      columnName: "aiCurrentBalanceInUSDCents",
+      value: data.amountInUSDCents,
+    });
+  }
+
   @CaptureSpan()
   public async incrementAndGetIncidentCounter(
     projectId: ObjectID,

package/Server/Types/AnalyticsDatabase/ModelPermission.ts

@@ -703,18 +703,31 @@ export default class ModelPermission {
    * scale to telemetry volume; one Postgres roundtrip + one indexed
    * predicate does. See Internal/Docs/PermissionsSimplification.md.
    */
-  private static async addOwnedScopeToQuery<TBaseModel extends BaseModel>(
+  /*
+   * Resolves the owned-scope decision for an analytics model without touching
+   * a query. Returns `null` when no ownership filter applies (root/master,
+   * creates, models without @OwnedThrough, no applicable permission rows, or
+   * an unrestricted grant) — i.e. the caller has full access. Otherwise
+   * returns the FK column plus the exact set of parent resource IDs the user
+   * may read (possibly empty, meaning "access to nothing").
+   *
+   * This is the single source of truth for owned-scope resolution:
+   * addOwnedScopeToQuery injects it into a ClickHouse query, and
+   * getAccessibleServiceIdsForAnalyticsModel exposes it to callers that build
+   * their own aggregation SQL (e.g. the AI toolbox), so the two can never
+   * drift apart.
+   */
+  private static async resolveOwnedScope<TBaseModel extends BaseModel>(
     modelType: { new (): TBaseModel },
-    query: Query<TBaseModel>,
     props: DatabaseCommonInteractionProps,
     type: DatabaseRequestType,
-  ): Promise<Query<TBaseModel>> {
+  ): Promise<{ fkColumn: string; allowedResourceIds: Set<string> } | null> {
     if (props.isRoot || props.isMasterAdmin) {
-      return query;
+      return null;
     }
 
     if (type === DatabaseRequestType.Create) {
-      return query;
+      return null;
     }
 
     /*
@@ -725,7 +738,7 @@ export default class ModelPermission {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const model: any = new modelType();
     if (!model.ownedThrough) {
-      return query;
+      return null;
     }
 
     const modelPermissions: Array<Permission> = this.getModelPermissions(
@@ -748,7 +761,7 @@ export default class ModelPermission {
     );
 
     if (applicableRows.length === 0) {
-      return query;
+      return null;
     }
 
     /*
@@ -771,7 +784,7 @@ export default class ModelPermission {
       },
     );
     if (hasUnrestrictedGrant) {
-      return query;
+      return null;
     }
 
     const allowedResourceIds: Set<string> = new Set<string>();
@@ -831,7 +844,59 @@ export default class ModelPermission {
       allowedResourceIds.add(props.tenantId.toString());
     }
 
-    const fkColumn: string = model.ownedThrough.fkColumn;
+    return { fkColumn: model.ownedThrough.fkColumn, allowedResourceIds };
+  }
+
+  /*
+   * The set of parent resource (Service) IDs the user may read for an analytics
+   * model, for callers that bypass findBy() and build aggregation SQL directly
+   * (e.g. the AI toolbox's log_histogram / query_traces, which call the
+   * aggregation services with a raw projectId). Pass the result as the
+   * aggregation's `serviceIds` filter.
+   *
+   * `null` means no ownership restriction applies — do NOT constrain (the user
+   * has project-wide access). A returned array (even empty) means the user is
+   * label/owned-restricted: constrain to exactly these IDs, and treat an empty
+   * array as "no accessible services" (match nothing), NEVER as "no filter".
+   */
+  public static async getAccessibleServiceIdsForAnalyticsModel<
+    TBaseModel extends BaseModel,
+  >(
+    modelType: { new (): TBaseModel },
+    props: DatabaseCommonInteractionProps,
+    type: DatabaseRequestType,
+  ): Promise<Array<ObjectID> | null> {
+    const scope: {
+      fkColumn: string;
+      allowedResourceIds: Set<string>;
+    } | null = await this.resolveOwnedScope(modelType, props, type);
+
+    if (!scope) {
+      return null;
+    }
+
+    return Array.from(scope.allowedResourceIds).map((id: string) => {
+      return new ObjectID(id);
+    });
+  }
+
+  private static async addOwnedScopeToQuery<TBaseModel extends BaseModel>(
+    modelType: { new (): TBaseModel },
+    query: Query<TBaseModel>,
+    props: DatabaseCommonInteractionProps,
+    type: DatabaseRequestType,
+  ): Promise<Query<TBaseModel>> {
+    const scope: {
+      fkColumn: string;
+      allowedResourceIds: Set<string>;
+    } | null = await this.resolveOwnedScope(modelType, props, type);
+
+    if (!scope) {
+      return query;
+    }
+
+    const fkColumn: string = scope.fkColumn;
+    const allowedResourceIds: Set<string> = scope.allowedResourceIds;
     const sentinelNoMatch: Array<string> = [
       ObjectID.getZeroObjectID().toString(),
     ];

package/Server/Utils/AI/AIChatPrivacyFilter.ts

@@ -0,0 +1,28 @@
+import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import NotAuthorizedException from "../../../Types/Exception/NotAuthorizedException";
+
+/*
+ * AI conversations (and their messages, runs and run events) are personal to
+ * the user who created them. This filter pins every non-root query to the
+ * requesting user so one project member can never read another member's
+ * conversations — including through the auto-generated list/count endpoints.
+ */
+export function pinQueryToRequestingUser<TQuery>(
+  query: TQuery,
+  props: DatabaseCommonInteractionProps,
+  userColumnName: string,
+): TQuery {
+  if (props.isRoot || props.isMasterAdmin) {
+    return query;
+  }
+
+  if (!props.userId) {
+    throw new NotAuthorizedException(
+      "AI conversations are personal and can only be accessed by the user who created them.",
+    );
+  }
+
+  (query as Record<string, unknown>)[userColumnName] = props.userId;
+
+  return query;
+}