Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
15.6 KB
Raw Blame
import type { DbClient } from '../../db.js'
import type {
  GovernedToolKindRead,
  GovernedTraceOrigin,
  GovernedTraceSessionApprovalV1,
  GovernedTraceSessionInteractionV1,
  GovernedTraceSessionRunV1,
  GovernedTraceSessionTokenUsageV1,
  GovernedTraceSessionToolV1,
} from './contracts.js'
import { projectTraceSafeFields } from './traceSafeFieldProjection.js'

function toolKind(value: unknown): GovernedToolKindRead {
  return value === 'internal_tool' || value === 'mcp_server_tool' || value === 'workflow'
    ? value
    : 'unclassified'
}

export class PostgresGovernedSessionDetailRepository {
  constructor(private readonly db: DbClient) {}

  async readRuns(
    hostRef: string,
    sessionId: string,
    highWatermark: string
  ): Promise<GovernedTraceSessionRunV1[]> {
    const result = await this.db.query(
      `SELECT a.run_id::text AS run_id, MIN(a.occurred_at) AS started_at,
              MAX(a.occurred_at) FILTER (WHERE a.event_type = 'run_end') AS ended_at,
              COALESCE(
                (array_agg(a.outcome ORDER BY a.occurred_at DESC, a.ingest_sequence DESC)
                  FILTER (WHERE a.event_type='run_end'))[1],
                (array_agg(a.outcome ORDER BY a.occurred_at DESC, a.ingest_sequence DESC)
                  FILTER (WHERE a.event_type='run_start'))[1],
                'unknown'
              ) AS outcome,
              (array_agg(a.origin ORDER BY a.occurred_at))[1] AS origin,
              COUNT(*)::int AS event_count
         FROM governed_event_stream s
         JOIN agent_run_events a
           ON s.event_family='agent_run' AND s.event_id=a.event_id
        WHERE s.stream_sequence <= $3::bigint AND a.host_ref=$1 AND a.session_id=$2
        GROUP BY a.run_id ORDER BY MIN(a.occurred_at) DESC LIMIT 200`,
      [hostRef, sessionId, highWatermark]
    )
    return (result.rows as Array<Record<string, unknown>>).map(row => ({
      runId: String(row.run_id),
      startedAt: new Date(String(row.started_at)).toISOString(),
      endedAt: row.ended_at ? new Date(String(row.ended_at)).toISOString() : null,
      outcome: String(row.outcome),
      origin: String(row.origin) as GovernedTraceOrigin,
      eventCount: Number(row.event_count),
    }))
  }

  async readTools(
    hostRef: string,
    sessionId: string,
    highWatermark: string
  ): Promise<GovernedTraceSessionToolV1[]> {
    const result = await this.db.query(
      `SELECT a.payload_metadata->>'tool_name' AS tool_name,
              a.payload_metadata->>'tool_kind' AS tool_kind,
              a.payload_metadata->>'tool_source_ref' AS tool_source_ref,
              COUNT(*)::int AS total_calls,
              COUNT(*) FILTER (WHERE a.outcome='succeeded')::int AS succeeded,
              COUNT(*) FILTER (WHERE a.outcome='failed')::int AS failed,
              MIN(a.occurred_at) AS first_at, MAX(a.occurred_at) AS last_at
         FROM governed_event_stream s
         JOIN agent_run_events a
           ON s.event_family='agent_run' AND s.event_id=a.event_id
        WHERE s.stream_sequence <= $3::bigint AND a.host_ref=$1 AND a.session_id=$2
          AND a.event_type='tool_call' AND a.payload_metadata ? 'tool_name'
        GROUP BY a.payload_metadata->>'tool_name', a.payload_metadata->>'tool_kind',
                 a.payload_metadata->>'tool_source_ref'
        ORDER BY MAX(a.occurred_at) DESC LIMIT 200`,
      [hostRef, sessionId, highWatermark]
    )
    return (result.rows as Array<Record<string, unknown>>).map(row => ({
      toolName: String(row.tool_name),
      toolKind: toolKind(row.tool_kind),
      toolSourceRef: row.tool_source_ref ? String(row.tool_source_ref) : null,
      totalCalls: Number(row.total_calls),
      succeeded: Number(row.succeeded),
      failed: Number(row.failed),
      firstOccurredAt: new Date(String(row.first_at)).toISOString(),
      lastOccurredAt: new Date(String(row.last_at)).toISOString(),
    }))
  }

  async readApprovals(
    hostRef: string,
    sessionId: string,
    highWatermark: string,
    promptState: 'enabled' | 'disabled' | 'unavailable'
  ): Promise<GovernedTraceSessionApprovalV1[]> {
    const toolResult = await this.db.query(
      `SELECT a.approval_request_id::text, a.run_id::text,
              a.payload_metadata->>'tool_name' AS tool_name,
              a.payload_metadata->>'tool_kind' AS tool_kind,
              a.payload_metadata->>'tool_source_ref' AS tool_source_ref,
              MIN(a.occurred_at) FILTER (WHERE a.decision='require_approval') AS requested_at,
              MAX(a.occurred_at) FILTER (WHERE a.outcome IN ('approved','denied')) AS decided_at,
              (array_remove(array_agg(a.outcome ORDER BY a.occurred_at DESC, a.ingest_sequence DESC), NULL))[1] AS state,
              (array_remove(array_agg(a.decision_actor_sub ORDER BY a.occurred_at DESC, a.ingest_sequence DESC), NULL))[1] AS decision_actor_sub,
              bool_or(ph.approval_request_id IS NOT NULL AND ph.expires_at > clock_timestamp()) AS has_prompt,
              bool_or(ph.approval_request_id IS NOT NULL) AS has_prompt_record,
              bool_or(tc.outcome='succeeded') AS executed_succeeded,
              bool_or(tc.outcome='failed') AS executed_failed
         FROM governed_event_stream s
         JOIN agent_run_events a
           ON s.event_family='agent_run' AND s.event_id=a.event_id
    LEFT JOIN governed_approval_prompt_history ph
           ON ph.approval_request_id=a.approval_request_id
    LEFT JOIN (
              SELECT tc.*
                FROM governed_event_stream tcs
                JOIN agent_run_events tc
                  ON tcs.event_family='agent_run' AND tcs.event_id=tc.event_id
               WHERE tcs.stream_sequence <= $3::bigint
             ) tc ON tc.run_id=a.run_id
                  AND tc.host_ref=a.host_ref
                  AND tc.session_id=a.session_id
                  AND tc.event_type='tool_call'
                  AND tc.approval_request_id=a.approval_request_id
        WHERE s.stream_sequence <= $3::bigint
          AND a.host_ref=$1 AND a.session_id=$2 AND a.event_type='approval'
        GROUP BY a.approval_request_id, a.run_id, a.payload_metadata->>'tool_name',
                 a.payload_metadata->>'tool_kind', a.payload_metadata->>'tool_source_ref'
        ORDER BY MIN(a.occurred_at) DESC LIMIT 200`,
      [hostRef, sessionId, highWatermark]
    )
    const toolApprovals = (toolResult.rows as Array<Record<string, unknown>>).map(row => {
      const state =
        row.state === 'approved' || row.state === 'denied'
          ? row.state
          : row.requested_at
            ? 'requested'
            : 'unavailable'
      return {
        approvalRequestId: row.approval_request_id ? String(row.approval_request_id) : null,
        runId: String(row.run_id),
        source: 'tool',
        toolName: row.tool_name ? String(row.tool_name) : null,
        toolKind: toolKind(row.tool_kind),
        toolSourceRef: row.tool_source_ref ? String(row.tool_source_ref) : null,
        state,
        requestedAt: row.requested_at ? new Date(String(row.requested_at)).toISOString() : null,
        decidedAt: row.decided_at ? new Date(String(row.decided_at)).toISOString() : null,
        decisionActorSub: row.decision_actor_sub ? String(row.decision_actor_sub) : null,
        observedExecution: row.executed_failed
          ? 'failed'
          : row.executed_succeeded
            ? 'succeeded'
            : 'not_observed',
        promptHistory:
          promptState === 'disabled'
            ? 'disabled'
            : promptState === 'unavailable'
              ? 'unavailable'
              : row.has_prompt
                ? 'available'
                : row.has_prompt_record
                  ? 'expired'
                  : 'none',
      } as GovernedTraceSessionApprovalV1
    })
    const workflowResult = await this.db.query(
      `WITH session_runs AS MATERIALIZED (
         SELECT DISTINCT a.run_id
           FROM governed_event_stream s
           JOIN agent_run_events a
             ON s.event_family='agent_run' AND s.event_id=a.event_id
          WHERE s.stream_sequence <= $3::bigint
            AND a.host_ref=$1 AND a.session_id=$2
       )
       SELECT war.id::text AS approval_request_id, session_runs.run_id::text,
              war.requested_at, war.decided_at,
              war.decided_by_user_id AS decision_actor_sub, war.status,
              ph.approval_request_id IS NOT NULL AS has_prompt_record,
              ph.expires_at > clock_timestamp() AS has_prompt,
              wr.phase AS run_phase
         FROM session_runs
         JOIN workflow_approval_requests war
           ON war.bound_workflow_run_id=session_runs.run_id
           OR EXISTS (
                SELECT 1 FROM workflow_runs linked_run
                 WHERE linked_run.run_id=session_runs.run_id
                   AND linked_run.approval_request_id=war.id
              )
    LEFT JOIN workflow_runs wr
           ON wr.run_id=session_runs.run_id AND wr.approval_request_id=war.id
    LEFT JOIN governed_approval_prompt_history ph ON ph.approval_request_id=war.id
        ORDER BY war.requested_at DESC
        LIMIT 200`,
      [hostRef, sessionId, highWatermark]
    )
    const workflowApprovals = (workflowResult.rows as Array<Record<string, unknown>>).map(row => ({
      approvalRequestId: String(row.approval_request_id),
      runId: String(row.run_id),
      source: 'workflow' as const,
      toolName: null,
      toolKind: 'workflow' as const,
      toolSourceRef: 'workflow-control',
      state:
        row.status === 'approved' || row.status === 'consumed'
          ? ('approved' as const)
          : row.status === 'denied'
            ? ('denied' as const)
            : row.status === 'pending'
              ? ('requested' as const)
              : ('unavailable' as const),
      requestedAt: row.requested_at ? new Date(String(row.requested_at)).toISOString() : null,
      decidedAt: row.decided_at ? new Date(String(row.decided_at)).toISOString() : null,
      decisionActorSub: row.decision_actor_sub ? String(row.decision_actor_sub) : null,
      observedExecution:
        row.run_phase === 'Succeeded'
          ? ('succeeded' as const)
          : row.run_phase === 'Failed'
            ? ('failed' as const)
            : ('not_observed' as const),
      promptHistory:
        promptState === 'disabled'
          ? ('disabled' as const)
          : promptState === 'unavailable'
            ? ('unavailable' as const)
            : row.has_prompt
              ? ('available' as const)
              : row.has_prompt_record
                ? ('expired' as const)
                : ('none' as const),
    }))
    return [...toolApprovals, ...workflowApprovals]
      .sort((left, right) =>
        String(right.requestedAt ?? '').localeCompare(String(left.requestedAt ?? ''))
      )
      .slice(0, 200)
  }

  async readInteractions(params: {
    hostRef: string
    sessionId: string
    highWatermark: string
    after: string
    limit: number
  }): Promise<GovernedTraceSessionInteractionV1[]> {
    const result = await this.db.query(
      `SELECT s.stream_sequence::text, a.event_id::text, a.run_id::text, a.event_type,
              a.occurred_at, a.outcome, a.payload_metadata->>'tool_name' AS tool_name,
              a.payload_metadata->>'tool_kind' AS tool_kind,
              a.payload_metadata->>'tool_source_ref' AS tool_source_ref,
              a.approval_request_id::text, a.decision, a.decision_actor_sub,
              jsonb_strip_nulls(jsonb_build_object(
                'reason_code', a.payload_metadata->'reason_code',
                'error_class', a.payload_metadata->'error_class',
                'phase', a.payload_metadata->'phase',
                'state', a.payload_metadata->'state',
                'status', a.payload_metadata->'status',
                'transition', a.payload_metadata->'transition',
                'resource_class', a.payload_metadata->'resource_class',
                'unit', a.payload_metadata->'unit',
                'tool_name', a.payload_metadata->'tool_name',
                'tool_kind', a.payload_metadata->'tool_kind',
                'tool_source_ref', a.payload_metadata->'tool_source_ref',
                'model', a.payload_metadata->'model',
                'attempt', a.payload_metadata->'attempt',
                'count', a.payload_metadata->'count',
                'config_hash', a.payload_metadata->'config_hash'
              )) AS safe_fields
         FROM governed_event_stream s
         JOIN agent_run_events a
           ON s.event_family='agent_run' AND s.event_id=a.event_id
        WHERE s.stream_sequence > $3::bigint AND s.stream_sequence <= $4::bigint
          AND a.host_ref=$1 AND a.session_id=$2
        ORDER BY s.stream_sequence ASC LIMIT $5`,
      [params.hostRef, params.sessionId, params.after, params.highWatermark, params.limit]
    )
    return (result.rows as Array<Record<string, unknown>>).map(row => ({
      streamSequence: String(row.stream_sequence),
      eventId: String(row.event_id),
      runId: String(row.run_id),
      eventType: row.event_type as GovernedTraceSessionInteractionV1['eventType'],
      occurredAt: new Date(String(row.occurred_at)).toISOString(),
      outcome: String(row.outcome),
      toolName: row.tool_name ? String(row.tool_name) : null,
      toolKind: row.tool_name ? toolKind(row.tool_kind) : null,
      toolSourceRef: row.tool_source_ref ? String(row.tool_source_ref) : null,
      approvalRequestId: row.approval_request_id ? String(row.approval_request_id) : null,
      decision: String(row.decision),
      decisionActorSub: row.decision_actor_sub ? String(row.decision_actor_sub) : null,
      safeFields: projectTraceSafeFields(row.safe_fields, 'session'),
    }))
  }

  async readTokenUsagePoints(
    hostRef: string,
    sessionId: string,
    highWatermark: string
  ): Promise<Pick<GovernedTraceSessionTokenUsageV1, 'points' | 'pointsTruncated'>> {
    const result = await this.db.query(
      `SELECT s.stream_sequence::text, a.event_id::text, a.run_id::text,
              a.occurred_at, a.payload_metadata->>'provider' AS provider,
              a.payload_metadata->>'model' AS model,
              a.payload_metadata->>'source_kind' AS source_kind,
              a.payload_metadata->>'iteration' AS iteration,
              a.payload_metadata->>'input_tokens' AS input_tokens,
              a.payload_metadata->>'output_tokens' AS output_tokens,
              a.payload_metadata->>'cache_read_tokens' AS cache_read_tokens,
              a.payload_metadata->>'cache_write_tokens' AS cache_write_tokens,
              a.payload_metadata->>'cache_tokens_reported' AS cache_tokens_reported
         FROM governed_event_stream s
         JOIN agent_run_events a
           ON s.event_family='agent_run' AND s.event_id=a.event_id
        WHERE s.stream_sequence <= $3::bigint
          AND a.host_ref=$1 AND a.session_id=$2 AND a.event_type='token_usage'
        ORDER BY a.occurred_at DESC, a.ingest_sequence DESC
        LIMIT 201`,
      [hostRef, sessionId, highWatermark]
    )
    const pointsTruncated = result.rows.length > 200
    const points = (result.rows as Array<Record<string, unknown>>)
      .slice(0, 200)
      .map(row => ({
        streamSequence: String(row.stream_sequence),
        eventId: String(row.event_id),
        runId: String(row.run_id),
        occurredAt: new Date(String(row.occurred_at)).toISOString(),
        provider: String(row.provider),
        model: String(row.model),
        sourceKind: String(row.source_kind),
        iteration: row.iteration === null ? null : Number(row.iteration),
        inputTokens: Number(row.input_tokens),
        outputTokens: Number(row.output_tokens),
        cacheReadTokens: Number(row.cache_read_tokens),
        cacheWriteTokens: Number(row.cache_write_tokens),
        cacheTokensReported: row.cache_tokens_reported === 'true',
      }))
      .reverse()
    return { points, pointsTruncated }
  }
}