@sixb/pg 0.1.1 → 0.1.2

package/src/agents/runs.ts

@@ -1,9 +1,14 @@
+import { assertAgentRunExecution } from "@sixb/core/internal/agent-run-storage-provider"
+import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth"
+import { serializeSixbFailure } from "@sixb/core/internal/errors"
 import {
+  AGENT_RUN_FAILURE_CODES,
   type AgentRunRecord,
   type AgentRunStore,
   AgentStorageError,
   type ConfirmAgentRunExecutionOwnershipInput,
   type CreateAgentRunInput,
+  type ExecutionStorage,
   type FinishAgentRunInput,
   type FinishQueuedAgentRunInput,
   type ListAgentRunsInput,
@@ -20,10 +25,20 @@ import { type AgentRunRow, rowToRunRecord } from "./rows"
 const PG_RUN_ID_BATCH_SIZE = 10_000
 
 export class PgAgentRunStore implements AgentRunStore {
-  constructor(private readonly sql: PgStoreClient) {}
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly executions: ExecutionStorage
+  ) {}
 
   async create(input: CreateAgentRunInput): Promise<AgentRunRecord> {
     const createdAt = input.createdAt ?? new Date()
+    await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      agentId: input.agentId,
+    })
 
     try {
       return await runPgTransaction(this.sql, async (tx) => {
@@ -51,22 +66,22 @@ export class PgAgentRunStore implements AgentRunStore {
           INSERT INTO agent_runs (
             project_id,
             id,
+            execution_id,
             thread_id,
             agent_id,
             trigger_message_id,
-            requested_by_principal_type,
-            requested_by_principal_id,
+            requester_group_ids,
             status,
             attempt,
             created_at
           ) VALUES (
             ${input.projectId},
             ${input.id},
+            ${input.executionId},
             ${input.threadId},
             ${input.agentId},
             ${input.triggerMessageId},
-            ${input.requestedByPrincipal.type},
-            ${input.requestedByPrincipal.id},
+            ${JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds))}::text::jsonb,
             ${"queued"},
             ${0},
             ${createdAt}
@@ -101,8 +116,6 @@ export class PgAgentRunStore implements AgentRunStore {
         UPDATE agent_runs
         SET
           status = ${"running"},
-          execution_principal_type = ${input.executionPrincipal?.type ?? null},
-          execution_principal_id = ${input.executionPrincipal?.id ?? null},
           model_id = ${input.modelId ?? null},
           attempt = ${1},
           execution_token = ${input.execution.token},
@@ -121,7 +134,10 @@ export class PgAgentRunStore implements AgentRunStore {
       const run = await this.lockStatus(tx, input.projectId, input.id, "queued")
       const [row] = await tx<AgentRunRow[]>`
         UPDATE agent_runs
-        SET status = ${input.status}, error = ${input.error ?? null}, completed_at = ${completedAt}
+        SET
+          status = ${input.status},
+          error = ${input.error === undefined ? null : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)}::text::jsonb,
+          completed_at = ${completedAt}
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         RETURNING *
       `
@@ -174,7 +190,10 @@ export class PgAgentRunStore implements AgentRunStore {
 
   async finish(input: FinishAgentRunInput): Promise<AgentRunRecord> {
     const completedAt = input.completedAt ?? new Date()
-    const errorValue = input.status === "succeeded" ? null : (input.error ?? null)
+    const errorValue =
+      input.status === "succeeded" || input.error === undefined
+        ? null
+        : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)
 
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id)
@@ -192,12 +211,7 @@ export class PgAgentRunStore implements AgentRunStore {
           status = ${input.status},
           model_id = COALESCE(${input.modelId ?? null}, model_id),
           finish_reason = ${input.finishReason ?? null},
-          usage_input_tokens = ${input.usage?.inputTokens ?? null},
-          usage_output_tokens = ${input.usage?.outputTokens ?? null},
-          usage_total_tokens = ${input.usage?.totalTokens ?? null},
-          usage_reasoning_tokens = ${input.usage?.reasoningTokens ?? null},
-          usage_cached_input_tokens = ${input.usage?.cachedInputTokens ?? null},
-          error = ${errorValue},
+          error = ${errorValue}::text::jsonb,
           diagnostics = ${input.diagnostics === undefined ? null : JSON.stringify(input.diagnostics)}::text::jsonb,
           execution_token = ${null},
           execution_queue_lease_expires_at = ${null},

package/src/auth-storage/service-accounts.ts

@@ -85,28 +85,27 @@ export class PgAuthServiceAccountStore implements AuthServiceAccountStore {
   }
 
   async update(input: UpdateAuthServiceAccountInput): Promise<ServiceAccountRecord> {
-    const existing = await this.getById(input)
-    if (!existing) {
-      throw new AuthStorageError(
-        "missing_service_account",
-        `[Sixb] Service account '${input.id}' not found for project '${input.projectId}'.`
-      )
-    }
-
+    const id = assertNonEmpty(input.id, "Service account id")
+    const projectId = assertNonEmpty(input.projectId, "Project id")
     const updatedAt = dateOrNow(input.updatedAt)
     const name =
-      input.name === undefined ? existing.name : assertNonEmpty(input.name, "Service account name")
-    const description = input.description === undefined ? existing.description : input.description
+      input.name === undefined ? null : assertNonEmpty(input.name, "Service account name")
     const [row] = await this.sql<PgAuthServiceAccountRow[]>`
       UPDATE auth_service_accounts
-      SET name = ${name},
-          description = ${description ?? null},
-          status = ${input.status ?? existing.status},
+      SET name = COALESCE(${name}, name),
+          description = COALESCE(${input.description ?? null}, description),
+          status = COALESCE(${input.status ?? null}, status),
           updated_at = ${updatedAt}
-      WHERE project_id = ${input.projectId}
-        AND id = ${input.id}
+      WHERE project_id = ${projectId}
+        AND id = ${id}
       RETURNING *
     `
+    if (!row) {
+      throw new AuthStorageError(
+        "missing_service_account",
+        `[Sixb] Service account '${id}' not found for project '${projectId}'.`
+      )
+    }
 
     return rowToServiceAccountRecord(row)
   }

package/src/auth-storage/shared.ts

@@ -128,14 +128,6 @@ export async function getUserRowByEmail(
   return row ?? null
 }
 
-export async function getUserByEmail(
-  sql: SQLClient,
-  params: { readonly projectId: string; readonly email: string }
-): Promise<UserRecord | null> {
-  const row = await getUserRowByEmail(sql, params)
-  return row ? rowToUserRecord(row) : null
-}
-
 export async function requireUserById(
   sql: SQLClient,
   params: { readonly projectId: string; readonly id: string }