chore: import upstream snapshot with attribution

apps/sim/lib/api/contracts/logs.ts

@@ -0,0 +1,403 @@
+import { z } from 'zod'
+import { userFileSchema } from '@/lib/api/contracts/primitives'
+import { defineRouteContract } from '@/lib/api/contracts/types'
+
+const comparisonOperatorSchema = z.enum(['=', '>', '<', '>=', '<=', '!='])
+
+export const logIdParamsSchema = z.object({
+  id: z.string().min(1),
+})
+
+export const executionIdParamsSchema = z.object({
+  executionId: z.string().min(1),
+})
+
+export const cancelWorkflowExecutionParamsSchema = z.object({
+  id: z.string().min(1, 'Invalid workflow ID'),
+  executionId: z.string().min(1, 'Invalid execution ID'),
+})
+
+const logFilterQuerySchema = z.object({
+  workspaceId: z.string(),
+  level: z.string().optional(),
+  workflowIds: z.string().optional(),
+  folderIds: z.string().optional(),
+  triggers: z.string().optional(),
+  startDate: z.string().optional(),
+  endDate: z.string().optional(),
+  search: z.string().optional(),
+  workflowName: z.string().optional(),
+  folderName: z.string().optional(),
+  executionId: z.string().optional(),
+  costOperator: comparisonOperatorSchema.optional(),
+  costValue: z.coerce.number().optional(),
+  durationOperator: comparisonOperatorSchema.optional(),
+  durationValue: z.coerce.number().optional(),
+})
+
+export const logSortBySchema = z.enum(['date', 'duration', 'cost', 'status']).default('date')
+export const logSortOrderSchema = z.enum(['asc', 'desc']).default('desc')
+
+export const listLogsQuerySchema = logFilterQuerySchema.extend({
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(200).optional().default(100),
+  sortBy: logSortBySchema,
+  sortOrder: logSortOrderSchema,
+})
+
+export const logDetailQuerySchema = z.object({
+  workspaceId: z.string().min(1),
+})
+
+export const statsQueryParamsSchema = logFilterQuerySchema.extend({
+  segmentCount: z.coerce.number().optional().default(72),
+})
+
+const workflowSummarySchema = z
+  .object({
+    id: z.string(),
+    name: z.string().nullable(),
+    description: z.string().nullable(),
+    folderId: z.string().nullable(),
+    userId: z.string().nullable(),
+    workspaceId: z.string().nullable(),
+    createdAt: z.string().nullable(),
+    updatedAt: z.string().nullable(),
+  })
+  .partial()
+
+const tokenBreakdownSchema = z
+  .object({
+    total: z.number().optional(),
+    input: z.number().optional(),
+    output: z.number().optional(),
+    prompt: z.number().optional(),
+    completion: z.number().optional(),
+  })
+  .partial()
+
+const modelCostSchema = z
+  .object({
+    input: z.number().optional(),
+    output: z.number().optional(),
+    total: z.number().optional(),
+    tokens: tokenBreakdownSchema.optional(),
+  })
+  .partial()
+
+const costSummarySchema = z
+  .object({
+    total: z.number().optional(),
+    input: z.number().optional(),
+    output: z.number().optional(),
+    tokens: tokenBreakdownSchema.optional(),
+    models: z.record(z.string(), modelCostSchema).optional(),
+    pricing: z
+      .object({
+        input: z.number(),
+        output: z.number(),
+        cachedInput: z.number().optional(),
+        updatedAt: z.string(),
+      })
+      .optional(),
+  })
+  .partial()
+
+/**
+ * Itemized cost breakdown derived from the usage_log ledger (the single source
+ * of truth) for the detail view. Each item is one billed line (base fee, a
+ * model, or a tool/integration); the items reconcile to `total`.
+ */
+const costLedgerItemSchema = z.object({
+  category: z.enum(['fixed', 'model', 'tool']),
+  description: z.string(),
+  cost: z.number(),
+  inputTokens: z.number().optional(),
+  outputTokens: z.number().optional(),
+})
+
+export const costLedgerSchema = z.object({
+  total: z.number(),
+  items: z.array(costLedgerItemSchema),
+})
+
+export type CostLedger = z.output<typeof costLedgerSchema>
+export type CostLedgerItem = z.output<typeof costLedgerItemSchema>
+
+const pauseSummarySchema = z.object({
+  status: z.string().nullable(),
+  total: z.number(),
+  resumed: z.number(),
+})
+
+const blockExecutionSchema = z.object({
+  id: z.string(),
+  blockId: z.string(),
+  blockName: z.string(),
+  blockType: z.string(),
+  startedAt: z.string(),
+  endedAt: z.string(),
+  durationMs: z.number(),
+  status: z.enum(['success', 'error', 'skipped']),
+  errorMessage: z.string().optional(),
+  errorStackTrace: z.string().optional(),
+  inputData: z.unknown(),
+  outputData: z.unknown(),
+  cost: costSummarySchema.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+})
+
+const toolCallSchema = z
+  .object({
+    id: z.string().optional(),
+    name: z.string().optional(),
+    arguments: z.unknown().optional(),
+    result: z.unknown().optional(),
+    error: z.string().optional(),
+    startTime: z.string().optional(),
+    endTime: z.string().optional(),
+    duration: z.number().optional(),
+  })
+  .passthrough()
+
+type TraceSpan = {
+  id: string
+  name: string
+  type: string
+  duration?: number
+  durationMs?: number
+  startTime?: string
+  endTime?: string
+  status?: string
+  blockId?: string
+  input?: unknown
+  output?: unknown
+  tokens?: number | { total?: number; input?: number; output?: number }
+  relativeStartMs?: number
+  toolCalls?: Array<z.output<typeof toolCallSchema>>
+  children?: TraceSpan[]
+}
+
+const traceSpanSchema: z.ZodType<TraceSpan> = z.lazy(() =>
+  z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      type: z.string(),
+      duration: z.number().optional(),
+      durationMs: z.number().optional(),
+      startTime: z.string().optional(),
+      endTime: z.string().optional(),
+      status: z.string().optional(),
+      blockId: z.string().optional(),
+      input: z.unknown().optional(),
+      output: z.unknown().optional(),
+      tokens: z
+        .union([
+          z.number(),
+          z
+            .object({
+              total: z.number().optional(),
+              input: z.number().optional(),
+              output: z.number().optional(),
+            })
+            .partial(),
+        ])
+        .optional(),
+      relativeStartMs: z.number().optional(),
+      toolCalls: z.array(toolCallSchema).optional(),
+      children: z.array(traceSpanSchema).optional(),
+    })
+    .passthrough()
+)
+
+const executionDataDetailSchema = z
+  .object({
+    totalDuration: z.number().nullable().optional(),
+    enhanced: z.literal(true).optional(),
+    traceSpans: z.array(traceSpanSchema).optional(),
+    blockExecutions: z.array(blockExecutionSchema).optional(),
+    finalOutput: z.unknown().optional(),
+    workflowInput: z.unknown().optional(),
+    blockInput: z.record(z.string(), z.unknown()).optional(),
+    trigger: z.unknown().optional(),
+  })
+  .passthrough()
+
+export const workflowLogSummarySchema = z.object({
+  id: z.string(),
+  workflowId: z.string().nullable(),
+  executionId: z.string().nullable(),
+  deploymentVersionId: z.string().nullable(),
+  deploymentVersion: z.number().nullable(),
+  deploymentVersionName: z.string().nullable(),
+  level: z.string(),
+  status: z.string().nullable(),
+  duration: z.string().nullable(),
+  trigger: z.string().nullable(),
+  createdAt: z.string(),
+  workflow: workflowSummarySchema.nullable(),
+  jobTitle: z.string().nullable(),
+  // Top-level run cost is the cost_total projection of the usage_log ledger,
+  // rendered as { total } (dollars). The itemized breakdown lives in costLedger
+  // (detail only); per-block costs use the richer costSummarySchema elsewhere.
+  cost: z.object({ total: z.number() }).nullable(),
+  pauseSummary: pauseSummarySchema,
+  hasPendingPause: z.boolean(),
+})
+
+export const workflowLogDetailSchema = workflowLogSummarySchema.extend({
+  executionData: executionDataDetailSchema,
+  files: z.array(userFileSchema).nullable(),
+  // Itemized, ledger-sourced cost breakdown. Null for legacy/pre-ledger runs,
+  // where the UI falls back to the (reconciling) cost jsonb.
+  costLedger: costLedgerSchema.nullable().optional(),
+})
+
+export type WorkflowLogSummary = z.output<typeof workflowLogSummarySchema>
+export type WorkflowLogDetail = z.output<typeof workflowLogDetailSchema>
+
+/**
+ * A row that may be either a list-view summary or a fully loaded detail. Used by
+ * UI surfaces that render the same log before and after its detail query resolves.
+ */
+export type WorkflowLogRow = WorkflowLogSummary &
+  Partial<Pick<WorkflowLogDetail, 'executionData' | 'files' | 'costLedger'>>
+
+export const listLogsResponseSchema = z.object({
+  data: z.array(workflowLogSummarySchema),
+  nextCursor: z.string().nullable(),
+})
+
+export type ListLogsResponse = z.output<typeof listLogsResponseSchema>
+
+export const segmentStatsSchema = z.object({
+  timestamp: z.string(),
+  totalExecutions: z.number(),
+  successfulExecutions: z.number(),
+  avgDurationMs: z.number(),
+})
+
+export const workflowStatsSchema = z.object({
+  workflowId: z.string(),
+  workflowName: z.string(),
+  segments: z.array(segmentStatsSchema),
+  overallSuccessRate: z.number(),
+  totalExecutions: z.number(),
+  totalSuccessful: z.number(),
+})
+
+export const dashboardStatsResponseSchema = z.object({
+  workflows: z.array(workflowStatsSchema),
+  aggregateSegments: z.array(segmentStatsSchema),
+  totalRuns: z.number(),
+  totalErrors: z.number(),
+  avgLatency: z.number(),
+  timeBounds: z.object({
+    start: z.string(),
+    end: z.string(),
+  }),
+  segmentMs: z.number(),
+})
+
+export const executionSnapshotDataSchema = z.object({
+  executionId: z.string(),
+  workflowId: z.string().nullable(),
+  workflowState: z.record(z.string(), z.unknown()).nullable(),
+  childWorkflowSnapshots: z.record(z.string(), z.unknown()).optional(),
+  executionMetadata: z.object({
+    trigger: z.string().nullable(),
+    startedAt: z.string(),
+    endedAt: z.string().optional(),
+    totalDurationMs: z.number().nullable().optional(),
+    cost: z.unknown().nullable(),
+    totalTokens: z.number().nullable().optional(),
+  }),
+})
+
+export const triggersQuerySchema = z.object({
+  workspaceId: z.string(),
+})
+export type TriggersQuery = z.output<typeof triggersQuerySchema>
+
+export const cancelWorkflowExecutionResponseSchema = z.object({
+  success: z.boolean(),
+  executionId: z.string(),
+  redisAvailable: z.boolean(),
+  durablyRecorded: z.boolean(),
+  locallyAborted: z.boolean(),
+  pausedCancelled: z.boolean(),
+  reason: z.enum(['recorded', 'redis_unavailable', 'redis_write_failed']),
+})
+
+export type SegmentStats = z.output<typeof segmentStatsSchema>
+export type WorkflowStats = z.output<typeof workflowStatsSchema>
+export type DashboardStatsResponse = z.output<typeof dashboardStatsResponseSchema>
+export type ExecutionSnapshotData = z.output<typeof executionSnapshotDataSchema>
+export type CancelWorkflowExecutionResponse = z.output<typeof cancelWorkflowExecutionResponseSchema>
+
+export const listLogsContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/logs',
+  query: listLogsQuerySchema,
+  response: {
+    mode: 'json',
+    schema: listLogsResponseSchema,
+  },
+})
+
+export const getLogDetailContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/logs/[id]',
+  params: logIdParamsSchema,
+  query: logDetailQuerySchema,
+  response: {
+    mode: 'json',
+    schema: z.object({
+      data: workflowLogDetailSchema,
+    }),
+  },
+})
+
+export const getLogByExecutionIdContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/logs/by-execution/[executionId]',
+  params: executionIdParamsSchema,
+  query: logDetailQuerySchema,
+  response: {
+    mode: 'json',
+    schema: z.object({
+      data: workflowLogDetailSchema,
+    }),
+  },
+})
+
+export const getDashboardStatsContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/logs/stats',
+  query: statsQueryParamsSchema,
+  response: {
+    mode: 'json',
+    schema: dashboardStatsResponseSchema,
+  },
+})
+
+export const getExecutionSnapshotContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/logs/execution/[executionId]',
+  params: executionIdParamsSchema,
+  response: {
+    mode: 'json',
+    schema: executionSnapshotDataSchema,
+  },
+})
+
+export const cancelWorkflowExecutionContract = defineRouteContract({
+  method: 'POST',
+  path: '/api/workflows/[id]/executions/[executionId]/cancel',
+  params: cancelWorkflowExecutionParamsSchema,
+  response: {
+    mode: 'json',
+    schema: cancelWorkflowExecutionResponseSchema,
+  },
+})