@magemetrics/core 0.12.1 → 0.13.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { sha256 } from '@noble/hashes/sha2.js';
-import z8, { z } from 'zod';
+import z9, { z } from 'zod';
 import { GoTrueClient } from '@supabase/auth-js';
 import createApiClient2 from 'openapi-fetch';
 import dayjs from 'dayjs';
@@ -58,7 +58,7 @@ var addApiKeyHeader = (apiKey) => {
 
 // package.json
 var package_default = {
-  version: "0.12.1"};
+  version: "0.13.0"};
 
 // src/core/MageMetricsEventEmitter.ts
 var MageMetricsEventEmitter = class {
@@ -482,7 +482,7 @@ function getOpenApiConfiguration(refOrOpenapi, metadataOrOptions, options) {
   };
 }
 
-// ../../node_modules/.pnpm/hono@4.12.14/node_modules/hono/dist/router/reg-exp-router/node.js
+// ../../node_modules/.pnpm/hono@4.12.15/node_modules/hono/dist/router/reg-exp-router/node.js
 new Set(".\\+*[^]$()");
 var createRoute = (routeConfig) => {
   const route = {
@@ -494,6 +494,7 @@ var createRoute = (routeConfig) => {
   return Object.defineProperty(route, "getRoutingPath", { enumerable: false });
 };
 extendZodWithOpenApi(z);
+var ExternalUserIdSchema = z.string().min(1, "external_user_id must not be empty").max(58, "external_user_id must be at most 58 characters").regex(/^[a-z0-9._+-]+$/, "external_user_id must contain only lowercase alphanumeric characters, dots, hyphens, underscores, and plus signs").refine((s) => !s.startsWith(".") && !s.endsWith("."), "external_user_id must not start or end with a dot").refine((s) => !s.includes(".."), "external_user_id must not contain consecutive dots");
 
 // ../shared/dist/src/endpoints/auth.routes.js
 var GetApiInformationInputSchema = z.object({
@@ -626,6 +627,73 @@ var ExchangeExternalToken = createRoute({
     }
   }
 });
+var MintEmbedTokenInputSchema = z.object({
+  uid: ExternalUserIdSchema,
+  attributes: z.record(z.string(), z.unknown()),
+  applicationName: z.string().trim().min(1).optional()
+});
+var MintEmbedTokenOutputSchema = z.object({
+  token: z.string(),
+  expires_at: z.iso.datetime()
+});
+createRoute({
+  method: "post",
+  path: "/api/v1/auth/mintEmbedToken",
+  operationId: "mintEmbedToken",
+  tags: ["internal"],
+  request: {
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: MintEmbedTokenInputSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      content: {
+        "application/json": {
+          schema: MintEmbedTokenOutputSchema
+        }
+      },
+      description: "Mint a short-lived Magemetrics embed assertion"
+    },
+    400: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Invalid input"
+    },
+    401: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Authentication required"
+    },
+    403: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Service account required"
+    },
+    500: {
+      content: {
+        "application/json": {
+          schema: z.object({ error: z.string() })
+        }
+      },
+      description: "Unable to mint an embed token"
+    }
+  }
+});
 
 // src/core/types.ts
 var TOKEN_STORAGE_KEY = "mm-ai-sp-token";
@@ -848,6 +916,9 @@ var ExternalAuthProvider = class {
 var SupabaseHeaderSchema = z.object({
   [HEADER_SP_TOKEN]: z.string().optional()
 });
+var SupabaseScopedHeaderSchema = SupabaseHeaderSchema.extend({
+  [HEADER_APPLICATION_NAME]: z.string().optional()
+});
 var FEEDBACK_OPTIONS = [
   { label: "Helpful", value: "helpful" },
   { label: "Partially helpful", value: "partially helpful" },
@@ -968,7 +1039,7 @@ var MaterializationFieldsSchema = z.object({
 });
 var ReportSchema = z.object({
   created_at: z.string(),
-  flow_id: z.string(),
+  flow_id: z.string().nullable(),
   id: z.number().openapi({
     description: "Deprecated: use uuid.",
     deprecated: true
@@ -988,7 +1059,9 @@ var ReportSchema = z.object({
   is_removed: z.boolean(),
   ...MaterializationFieldsSchema.shape
 });
+ReportSchema.omit({ flow_id: true });
 var FrontendReportSchema = ReportSchema.omit({
+  flow_id: true,
   sql: true,
   table: true,
   data_sample: true,
@@ -1091,6 +1164,7 @@ var DataTableSchema = z.object({
   id: z.number(),
   dataset: z.string(),
   table_name: z.string(),
+  database: z.string().nullable(),
   description: z.string().nullable(),
   primary_key_names: z.string().array(),
   row_count: z.number().nullable(),
@@ -2084,20 +2158,20 @@ var CreateSpeechToken = createRoute({
     }
   }
 });
-z8.discriminatedUnion("status", [
-  z8.object({
-    status: z8.literal("error"),
-    error: z8.string()
+z9.discriminatedUnion("status", [
+  z9.object({
+    status: z9.literal("error"),
+    error: z9.string()
   }),
-  z8.object({
-    status: z8.literal("success"),
-    flowId: z8.string()
+  z9.object({
+    status: z9.literal("success"),
+    flowId: z9.string()
   })
 ]);
-var TriggerFlowBody = z8.object({
-  triggerId: z8.string(),
-  variables: z8.record(z8.string(), z8.string()),
-  applicationName: z8.string().optional()
+var TriggerFlowBody = z9.object({
+  triggerId: z9.string(),
+  variables: z9.record(z9.string(), z9.string()),
+  applicationName: z9.string().optional()
 });
 var TriggerFlow = createRoute({
   method: "post",
@@ -2121,9 +2195,9 @@ var TriggerFlow = createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z8.object({
-            status: z8.literal("success"),
-            flowId: z8.string()
+          schema: z9.object({
+            status: z9.literal("success"),
+            flowId: z9.string()
           })
         }
       }
@@ -2131,8 +2205,8 @@ var TriggerFlow = createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z9.object({
+            error: z9.string()
           })
         }
       },
@@ -2141,7 +2215,7 @@ var TriggerFlow = createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z8.object({ error: z8.string() })
+          schema: z9.object({ error: z9.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2150,8 +2224,8 @@ var TriggerFlow = createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z9.object({
+            error: z9.string()
           })
         }
       }
@@ -2181,9 +2255,9 @@ createRoute({
       description: "Flow id",
       content: {
         "application/json": {
-          schema: z8.object({
-            status: z8.literal("success"),
-            flowId: z8.string()
+          schema: z9.object({
+            status: z9.literal("success"),
+            flowId: z9.string()
           })
         }
       }
@@ -2191,8 +2265,8 @@ createRoute({
     400: {
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z9.object({
+            error: z9.string()
           })
         }
       },
@@ -2201,7 +2275,7 @@ createRoute({
     404: {
       content: {
         "application/json": {
-          schema: z8.object({ error: z8.string() })
+          schema: z9.object({ error: z9.string() })
         }
       },
       description: "Unable to retrieve trigger with this id"
@@ -2210,8 +2284,8 @@ createRoute({
       description: "Something wrong happened",
       content: {
         "application/json": {
-          schema: z8.object({
-            error: z8.string()
+          schema: z9.object({
+            error: z9.string()
           })
         }
       }
@@ -2356,13 +2430,13 @@ var CanvasIdParam = CanvasSchema.shape.id.openapi("CanvasId", {
 var dataReportNodeSchema = z.object({
   type: z.literal(DATA_REPORT_LABEL),
   data: z.object({
-    reportId: z.number()
+    reportId: z.string()
   })
 });
 var visualizationNodeSchema = z.object({
   type: z.literal(VISUALIZATION_LABEL),
   data: z.object({
-    visualizationId: z.number()
+    visualizationId: z.string()
   })
 });
 z.discriminatedUnion("type", [
@@ -2658,6 +2732,386 @@ var ChatMessages = createRoute({
     }
   }
 });
+var UPDATE_TASK = "updateTask";
+var TaskStatusSchema = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "failed"
+]);
+var TaskArtifactSchema = z.object({
+  type: z.enum(["report", "visualization"]),
+  id: z.string().describe("The ID returned by generateDataReport or generateVisualization")
+});
+var TaskSummarySchema = z.object({
+  outcome: z.string().describe("SHORT summary (max 10 words) e.g. 'Found 847 records' or 'Generated trend chart'"),
+  tool_calls: z.array(z.string()).describe("List of tools used during this task, e.g. ['generateDataReport x3', 'generateVisualization x1']")
+});
+var TaskPlanItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional().describe("Detailed steps or description of what the task will do")
+});
+var TaskPlanSchema = z.array(TaskPlanItemSchema);
+var AgentTaskSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  status: TaskStatusSchema,
+  parent_id: z.string().optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional(),
+  summary: TaskSummarySchema.optional(),
+  artifacts: z.array(TaskArtifactSchema).optional()
+});
+var AgentTasksStateSchema = z.array(AgentTaskSchema);
+var updateTaskInputSchema = z.object({
+  action: z.enum(["update", "create"]).default("update").describe('Action type \u2014 "update" (default) or "create"'),
+  id: z.string().optional().describe("The task ID (e.g. '1', '2', or '1.1' for subtasks) \u2014 required for update"),
+  title: z.string().optional().describe("Short title for the new task \u2014 required for create"),
+  status: TaskStatusSchema.optional().describe("The new status for this task \u2014 required for update"),
+  summary: TaskSummarySchema.optional().describe("Summary of outcome and tools used (required when status is 'completed')"),
+  artifacts: z.array(TaskArtifactSchema).optional().describe("Reports and visualizations produced during this task")
+});
+updateTaskInputSchema.extend({
+  action: z.literal("update").default("update").describe("Action type")
+});
+var TaskSummaryForContextSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  status: TaskStatusSchema
+});
+var TaskResultPublicSchema = z.object({
+  taskId: z.string(),
+  taskStatus: TaskStatusSchema,
+  message: z.string()
+});
+var TaskResultPrivateSchema = z.object({
+  updatedAt: z.string(),
+  // Current state of all tasks - injected so model stays aware of progress
+  currentTasks: z.array(TaskSummaryForContextSchema)
+});
+var UpdateTaskSuccessSchema = z.object({
+  status: z.literal("success"),
+  public: TaskResultPublicSchema,
+  // Private fields are redacted before sending to frontend (user sees tasks in UI already)
+  private: TaskResultPrivateSchema
+});
+var UpdateTaskErrorSchema = z.object({
+  status: z.literal("error"),
+  message: z.string()
+});
+z.object({
+  tool: z.literal(UPDATE_TASK),
+  result: z.discriminatedUnion("status", [
+    UpdateTaskSuccessSchema,
+    UpdateTaskErrorSchema
+  ]).optional()
+});
+
+// ../shared/dist/src/types/agentTypes.js
+var AgentType = {
+  KnowledgeFarmer: "knowledge_farmer",
+  KnowledgeConsistencyChecker: "knowledge_consistency_checker",
+  CompanyResearch: "company_research",
+  KnowledgeExtraction: "knowledge_extraction",
+  /** User-defined agents (via AgentRunScheduler) */
+  Custom: "custom"
+};
+var ExecutionPlatform = {
+  Native: "native",
+  Sandbox: "sandbox",
+  SandboxPublic: "sandbox_public"
+};
+
+// ../shared/dist/src/types/executionContext.js
+var ImpersonateContextSchema = z.object({
+  mode: z.literal("impersonate"),
+  external_user_id: z.string().min(1).describe("The user ID in the customer's system")
+}).openapi("ImpersonateContext");
+var CustomMetadataContextSchema = z.object({
+  mode: z.literal("custom"),
+  metadata: z.record(z.string(), z.unknown()).describe("Raw metadata key-value pairs for data access rules")
+}).openapi("CustomMetadataContext");
+var ExecutionContextInputSchema = z.discriminatedUnion("mode", [
+  ImpersonateContextSchema,
+  CustomMetadataContextSchema
+]).openapi("ExecutionContextInput");
+var ResolvedExecutionContextSchema = z.object({
+  companyId: z.number(),
+  userMetadata: z.record(z.string(), z.unknown())
+});
+
+// ../shared/dist/src/schemas/agents/agent.js
+var JsonSchemaObjectSchema = z.record(z.string(), z.unknown());
+var AgentInputFieldOptionSchema = z.object({
+  value: z.string(),
+  fragment: z.string().optional()
+});
+var AgentEnumInputFieldSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  type: z.literal("enum"),
+  options: z.array(AgentInputFieldOptionSchema).min(1),
+  useFragmentMapping: z.boolean().default(false),
+  required: z.boolean().default(false)
+});
+var AgentTextInputFieldSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  type: z.literal("text"),
+  useFragmentMapping: z.literal(false).default(false),
+  required: z.boolean().default(false)
+});
+var AgentInputFieldSchema = z.discriminatedUnion("type", [
+  AgentEnumInputFieldSchema,
+  AgentTextInputFieldSchema
+]);
+var AgentInputSchemaSchema = z.array(AgentInputFieldSchema);
+var GeminiModelConfigSchema = z.object({
+  model: z.literal("gemini-3.1-pro-preview"),
+  thinking: z.enum(["low", "high"]).optional()
+});
+var Gemini25ProModelConfigSchema = z.object({
+  model: z.literal("gemini-2.5-pro"),
+  thinking: z.enum(["low", "high"]).optional()
+});
+var ClaudeAdaptiveModelConfigSchema = z.object({
+  model: z.enum(["claude-sonnet-4-6", "claude-opus-4-6"]),
+  effort: z.enum(["low", "medium", "high"]).optional()
+});
+var ClaudeBasicModelConfigSchema = z.object({
+  model: z.enum(["claude-haiku-4-5", "claude-opus-4-5"])
+});
+var ModelConfigSchema = z.discriminatedUnion("model", [
+  GeminiModelConfigSchema,
+  Gemini25ProModelConfigSchema,
+  ClaudeAdaptiveModelConfigSchema,
+  ClaudeBasicModelConfigSchema
+]);
+var ExecutionPlatformSchema = z.enum([
+  ExecutionPlatform.Native,
+  ExecutionPlatform.Sandbox,
+  ExecutionPlatform.SandboxPublic
+]);
+var BaseAgentSchema = z.object({
+  id: z.uuid(),
+  company_id: z.number(),
+  is_removed: z.boolean().nullable(),
+  created_at: z.string()
+});
+var AgentBehaviorSchema = z.object({
+  name: z.string(),
+  objective: z.string().nullable(),
+  generated_objective_fragment: z.string().nullable(),
+  active_tools: z.array(z.string()).nullable(),
+  input_schema: AgentInputSchemaSchema.nullable(),
+  output_schema: JsonSchemaObjectSchema,
+  task_plan: TaskPlanSchema.nullable(),
+  model_config: ModelConfigSchema.nullable(),
+  execution_platform: ExecutionPlatformSchema
+});
+var AgentSchema = z.object({
+  ...BaseAgentSchema.shape,
+  ...AgentBehaviorSchema.shape,
+  updated_at: z.string(),
+  current_version_id: z.uuid()
+});
+z.object({
+  name: z.string().min(1, "Name is required"),
+  objective: z.string().optional(),
+  generated_objective_fragment: z.string().optional(),
+  active_tools: z.array(z.string()).default([]),
+  input_schema: AgentInputSchemaSchema.optional(),
+  output_schema: JsonSchemaObjectSchema,
+  task_plan: TaskPlanSchema.optional(),
+  model_config: ModelConfigSchema.optional(),
+  execution_platform: ExecutionPlatformSchema.default(ExecutionPlatform.Native)
+});
+var DbUpdateAgentSchema = z.object({
+  name: z.string().min(1).optional(),
+  objective: z.string().nullable().optional(),
+  generated_objective_fragment: z.string().nullable().optional(),
+  active_tools: z.array(z.string()).optional(),
+  input_schema: AgentInputSchemaSchema.nullable().optional(),
+  output_schema: JsonSchemaObjectSchema.optional(),
+  task_plan: TaskPlanSchema.nullable().optional(),
+  model_config: ModelConfigSchema.nullable().optional(),
+  execution_platform: ExecutionPlatformSchema.optional(),
+  restored_from_version: z.number().int().positive().nullable().optional()
+});
+DbUpdateAgentSchema.omit({
+  restored_from_version: true
+});
+AgentSchema.omit({
+  company_id: true,
+  is_removed: true,
+  current_version_id: true
+}).openapi("Agent");
+
+// ../shared/dist/src/schemas/agents/postProcessor.js
+var PostProcessorConfigSchema = z.discriminatedUnion("type", [
+  /**
+   * Resolve and insert knowledge item proposals from output_data.proposals
+   * and output_data.deletions into knowledge_item_proposals.
+   * Compatible with: farmer, consistency checker, knowledge extraction.
+   */
+  z.object({
+    type: z.literal("knowledge_proposals"),
+    params: z.object({
+      /** DB enum value to tag inserted proposals with. */
+      source: z.enum(["data_report", "consistency_check", "document"]),
+      /**
+       * Only insert proposals at or above this confidence level.
+       *  Proposals without a confidence field are always included.
+       */
+      minConfidence: z.enum(["low", "medium", "high"]).optional(),
+      /** Skip DB writes and only log what would be inserted. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Soft-delete few-shot prompt examples from output_data.few_shot_removals.
+   */
+  z.object({
+    type: z.literal("remove_few_shot_examples"),
+    params: z.object({
+      /** Identifies the calling agent in the audit trail comment. */
+      sourceLabel: z.string(),
+      /** Skip DB writes and only log what would be removed. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Record a knowledge farmer investigation. Must run before knowledge_proposals
+   * so ctx.investigationId is set for downstream post-processors.
+   */
+  z.object({
+    type: z.literal("knowledge_farmer_investigation"),
+    params: z.object({
+      /** Skip DB writes and only log what would be inserted. */
+      dryRun: z.boolean().optional()
+    })
+  }),
+  /**
+   * Persist the agent's entire output_data as company_settings.context_profile.
+   * Used by the company research agent.
+   */
+  z.object({
+    type: z.literal("save_context_profile")
+  })
+]);
+
+// ../shared/dist/src/schemas/agents/agentRun.js
+var AgentTypeSchema = z.enum([
+  AgentType.KnowledgeFarmer,
+  AgentType.KnowledgeConsistencyChecker,
+  AgentType.CompanyResearch,
+  AgentType.KnowledgeExtraction,
+  AgentType.Custom
+]);
+var ExecutionPlatformSchema2 = z.enum([
+  ExecutionPlatform.Native,
+  ExecutionPlatform.Sandbox,
+  ExecutionPlatform.SandboxPublic
+]);
+var AgentRunStatusSchema = z.enum([
+  "pending",
+  "running",
+  "post_processing",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var AgentChatMessageSchema = z.record(z.string(), z.unknown());
+z.object({
+  id: z.uuid(),
+  user_id: z.uuid(),
+  company_id: z.number().nullable(),
+  agent_id: z.uuid().nullable(),
+  agent_type: AgentTypeSchema.nullable(),
+  execution_platform: ExecutionPlatformSchema2.nullable(),
+  status: AgentRunStatusSchema,
+  created_at: z.string(),
+  started_at: z.string().nullable(),
+  completed_at: z.string().nullable(),
+  cancelled_at: z.string().nullable(),
+  job_id: z.string().nullable(),
+  chat_messages: z.array(AgentChatMessageSchema).nullable(),
+  allowed_tools: z.array(z.string()).nullable(),
+  input_data: z.record(z.string(), z.unknown()).nullable(),
+  output_data: z.record(z.string(), z.unknown()).nullable(),
+  output_schema: JsonSchemaObjectSchema.nullable(),
+  tasks: AgentTasksStateSchema.nullable(),
+  error_message: z.string().nullable(),
+  execution_context: ResolvedExecutionContextSchema.nullable(),
+  model_config: ModelConfigSchema.nullable(),
+  // Nullable with a default so pre-migration rows (where the column is absent)
+  // parse cleanly — undefined input becomes null output.
+  post_processors: z.array(PostProcessorConfigSchema).nullable().default(null),
+  agent_version_id: z.uuid().nullable().default(null)
+});
+z.object({
+  user_id: z.uuid(),
+  company_id: z.number(),
+  agent_id: z.uuid().nullable(),
+  agent_type: AgentTypeSchema.optional(),
+  execution_platform: ExecutionPlatformSchema2.optional(),
+  status: AgentRunStatusSchema.default("pending"),
+  chat_messages: z.array(AgentChatMessageSchema).optional(),
+  allowed_tools: z.array(z.string()).optional(),
+  input_data: z.record(z.string(), z.unknown()).optional(),
+  output_data: z.record(z.string(), z.unknown()).optional(),
+  output_schema: JsonSchemaObjectSchema.optional(),
+  execution_context: ResolvedExecutionContextSchema.optional(),
+  model_config: ModelConfigSchema.optional(),
+  post_processors: z.array(PostProcessorConfigSchema).optional(),
+  agent_version_id: z.uuid().optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional()
+});
+z.object({
+  status: AgentRunStatusSchema.optional(),
+  started_at: z.string().optional(),
+  completed_at: z.string().optional(),
+  cancelled_at: z.string().optional(),
+  job_id: z.string().optional(),
+  chat_messages: z.array(AgentChatMessageSchema).optional(),
+  input_data: z.record(z.string(), z.unknown()).optional(),
+  output_data: z.record(z.string(), z.unknown()).optional(),
+  tasks: AgentTasksStateSchema.optional(),
+  error_message: z.string().optional(),
+  model_config: ModelConfigSchema.optional(),
+  last_heartbeat_at: z.string().nullable().optional(),
+  post_processors: z.array(PostProcessorConfigSchema).optional()
+});
+var StartAgentRunRequestSchema = z.object({
+  agent_id: z.uuid(),
+  inputs: z.record(z.string(), z.unknown()).default({}),
+  execution_context: ExecutionContextInputSchema.optional()
+}).openapi("StartAgentRunRequest");
+var AgentRunResponseSchema = z.object({
+  id: z.uuid(),
+  agent_id: z.uuid().nullable(),
+  status: AgentRunStatusSchema,
+  created_at: z.string(),
+  started_at: z.string().nullable(),
+  completed_at: z.string().nullable(),
+  input_data: z.record(z.string(), z.unknown()).nullable(),
+  output_data: z.record(z.string(), z.unknown()).nullable(),
+  tasks: AgentTasksStateSchema.nullable().optional(),
+  error_message: z.string().nullable(),
+  execution_context: ResolvedExecutionContextSchema.nullable().optional(),
+  agent_version_id: z.uuid().nullable().optional(),
+  cached: z.boolean().optional()
+}).openapi("AgentRunResponse");
+z.object({
+  status: AgentRunStatusSchema.optional(),
+  agent_id: z.uuid().optional(),
+  agent_type: AgentTypeSchema.optional(),
+  limit: z.number().int().positive().max(100).default(20)
+});
 dayjs.extend(relativeTime);
 dayjs.extend(customParseFormat);
 dayjs.extend(utc);
@@ -3006,7 +3460,244 @@ var FrontendVisualizationWithDataSchema = FrontendVisualizationSchema.extend({
   _metadata: VisualizationMetadataSchema
 });
 
+// ../shared/dist/src/endpoints/agents/runs.routes.js
+var AgentRunIdParam = z.object({ id: z.uuid() }).openapi("AgentRunId");
+var ErrorResponseSchema = z.object({ error: z.string() });
+createRoute({
+  method: "post",
+  path: "/api/v1/agent-runs",
+  operationId: "startAgentRun",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseScopedHeaderSchema,
+    body: {
+      required: true,
+      content: {
+        "application/json": {
+          schema: StartAgentRunRequestSchema
+        }
+      }
+    }
+  },
+  responses: {
+    200: {
+      description: "The agent run was started",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema
+        }
+      }
+    },
+    400: {
+      description: "Invalid request or input validation failed",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Agent definition not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var AgentRunCountsResponseSchema = z.record(z.string().uuid(), z.number().int().nonnegative()).openapi("AgentRunCountsResponse");
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/counts",
+  operationId: "getAgentRunCounts",
+  tags: ["internal"],
+  request: {
+    headers: SupabaseHeaderSchema
+  },
+  responses: {
+    200: {
+      description: "Run counts per agent",
+      content: {
+        "application/json": {
+          schema: AgentRunCountsResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}",
+  operationId: "getAgentRun",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "The agent run",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs",
+  operationId: "listAgentRuns",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    query: z.object({
+      status: AgentRunStatusSchema.optional(),
+      agent_id: z.uuid().optional(),
+      limit: limitQueryParams
+    })
+  },
+  responses: {
+    200: {
+      description: "List of agent runs",
+      content: {
+        "application/json": {
+          schema: AgentRunResponseSchema.array()
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var GetAgentRunReports = createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}/reports",
+  operationId: "getAgentRunReports",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "Reports generated by this agent run",
+      content: {
+        "application/json": {
+          schema: FrontendReportSchema.array()
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+var GetAgentRunVisualizations = createRoute({
+  method: "get",
+  path: "/api/v1/agent-runs/{id}/visualizations",
+  operationId: "getAgentRunVisualizations",
+  tags: ["public", "documented"],
+  request: {
+    headers: SupabaseHeaderSchema,
+    params: AgentRunIdParam
+  },
+  responses: {
+    200: {
+      description: "Visualizations generated by this agent run",
+      content: {
+        "application/json": {
+          schema: FrontendVisualizationSchema.array()
+        }
+      }
+    },
+    404: {
+      description: "Agent run not found",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    },
+    500: {
+      description: "Internal server error",
+      content: {
+        "application/json": {
+          schema: ErrorResponseSchema
+        }
+      }
+    }
+  }
+});
+
 // ../shared/dist/src/endpoints/visualizations.routes.js
+var parseVisualizationId = (val, ctx) => {
+  const num = Number(val);
+  if (Number.isInteger(num) && num > 0)
+    return num;
+  const uuidResult = z.uuid().safeParse(val);
+  if (uuidResult.success)
+    return val;
+  ctx.addIssue("visualization_id must be a positive integer or a valid UUID");
+  return z.NEVER;
+};
+var VisualizationId = z.string().transform((val, ctx) => parseVisualizationId(val, ctx)).openapi({
+  type: "string",
+  description: "Numeric legacy ID or UUID"
+});
 var VisualizationWithDataResponse = z.union([
   FrontendVisualizationWithDataSchema,
   V1FrontendVisualizationWithDataSchema
@@ -3018,7 +3709,7 @@ createRoute({
   tags: ["public"],
   request: {
     headers: SupabaseHeaderSchema,
-    params: z.object({ visualization_id: z.string().pipe(z.coerce.number()) }).openapi("VisualizationId", { type: "number" })
+    params: z.object({ visualization_id: VisualizationId }).openapi("VisualizationId", { type: "string" })
   },
   responses: {
     200: {
@@ -3295,6 +3986,38 @@ var MageMetricsClient = class {
       }
       return data;
     },
+    getAgentRunReports: async (agentRunId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        GetAgentRunReports.path,
+        { params: { path: { id: agentRunId } } }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
+    getAgentRunVisualizations: async (agentRunId) => {
+      await this.waitForAuth();
+      const { data, error, response } = await this.internalApiClient.GET(
+        GetAgentRunVisualizations.path,
+        { params: { path: { id: agentRunId } } }
+      );
+      if (error) {
+        throw new ApiError(error.error, response, {
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          method: "GET"
+        });
+      }
+      return data;
+    },
     getFlow: async (flowId) => {
       await this.waitForAuth();
       const { data, error, response } = await this.internalApiClient.GET(
@@ -3558,7 +4281,7 @@ var MageMetricsClient = class {
         {
           params: {
             path: {
-              report_id: String(reportId)
+              report_id: reportId
             }
           },
           parseAs: format
@@ -3617,7 +4340,7 @@ var MageMetricsClient = class {
         {
           params: {
             path: {
-              report_id: reportId.toString()
+              report_id: reportId
             },
             query: {
               columns: columns?.join(","),
@@ -3655,7 +4378,7 @@ var MageMetricsClient = class {
       return data;
     },
     getReport: async (reportId) => {
-      const params = { params: { path: { report_id: String(reportId) } } };
+      const params = { params: { path: { report_id: reportId } } };
       const columnsPromise = this.internalApiClient.GET(
         GetReportColumns.path,
         params