@inkeep/agents-core 0.0.0-dev-20250910233133 → 0.0.0-dev-20250910233151

package/dist/chunk-ODONDMHT.js

@@ -0,0 +1,665 @@
+import { VALID_RELATION_TYPES, TOOL_STATUS_VALUES } from './chunk-BIIFENNH.js';
+import { agents, agentRelations, agentGraph, tasks, taskRelations, tools, conversations, messages, contextCache, dataComponents, agentDataComponents, artifactComponents, agentArtifactComponents, externalAgents, apiKeys, contextConfigs, agentToolRelations, ledgerArtifacts, projects } from './chunk-TSPWAF64.js';
+import { z } from '@hono/zod-openapi';
+import { createSelectSchema, createInsertSchema } from 'drizzle-zod';
+
+var MIN_ID_LENGTH = 1;
+var MAX_ID_LENGTH = 255;
+var URL_SAFE_ID_PATTERN = /^[a-zA-Z0-9\-_.]+$/;
+var resourceIdSchema = z.string().min(MIN_ID_LENGTH).max(MAX_ID_LENGTH).regex(URL_SAFE_ID_PATTERN, {
+  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+}).openapi({
+  description: "Resource identifier",
+  example: "resource_789"
+});
+var ModelSettingsSchema = z.object({
+  model: z.string().optional(),
+  providerOptions: z.record(z.string(), z.unknown()).optional()
+});
+var ModelSchema = z.object({
+  base: ModelSettingsSchema.optional(),
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+});
+var createApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
+var createApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
+var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true }).partial();
+var AgentSelectSchema = createSelectSchema(agents);
+var AgentInsertSchema = createInsertSchema(agents).extend({
+  id: resourceIdSchema,
+  models: ModelSchema.optional()
+});
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema);
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema);
+var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema);
+var AgentRelationSelectSchema = createSelectSchema(agentRelations);
+var AgentRelationInsertSchema = createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  targetAgentId: resourceIdSchema.optional(),
+  externalAgentId: resourceIdSchema.optional()
+});
+var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
+var AgentRelationApiSelectSchema = createApiSchema(AgentRelationSelectSchema);
+var AgentRelationApiInsertSchema = createApiInsertSchema(AgentRelationInsertSchema).extend({
+  relationType: z.enum(VALID_RELATION_TYPES)
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+var AgentRelationApiUpdateSchema = createApiUpdateSchema(AgentRelationUpdateSchema).extend({
+  relationType: z.enum(VALID_RELATION_TYPES).optional()
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    if (!hasTarget && !hasExternal) {
+      return true;
+    }
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId when updating agent relationships",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+var AgentRelationQuerySchema = z.object({
+  sourceAgentId: z.string().optional(),
+  targetAgentId: z.string().optional(),
+  externalAgentId: z.string().optional()
+});
+var ExternalAgentRelationInsertSchema = createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  externalAgentId: resourceIdSchema
+});
+var ExternalAgentRelationApiInsertSchema = createApiInsertSchema(
+  ExternalAgentRelationInsertSchema
+);
+var AgentGraphSelectSchema = createSelectSchema(agentGraph);
+var AgentGraphInsertSchema = createInsertSchema(agentGraph).extend({
+  id: resourceIdSchema
+});
+var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
+var AgentGraphApiSelectSchema = createApiSchema(AgentGraphSelectSchema);
+var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
+  id: resourceIdSchema.optional()
+});
+var AgentGraphApiUpdateSchema = createApiUpdateSchema(AgentGraphUpdateSchema);
+var TaskSelectSchema = createSelectSchema(tasks);
+var TaskInsertSchema = createInsertSchema(tasks).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema.optional()
+});
+var TaskUpdateSchema = TaskInsertSchema.partial();
+var TaskApiSelectSchema = createApiSchema(TaskSelectSchema);
+var TaskApiInsertSchema = createApiInsertSchema(TaskInsertSchema);
+var TaskApiUpdateSchema = createApiUpdateSchema(TaskUpdateSchema);
+var TaskRelationSelectSchema = createSelectSchema(taskRelations);
+var TaskRelationInsertSchema = createInsertSchema(taskRelations).extend({
+  id: resourceIdSchema,
+  parentTaskId: resourceIdSchema,
+  childTaskId: resourceIdSchema
+});
+var TaskRelationUpdateSchema = TaskRelationInsertSchema.partial();
+var TaskRelationApiSelectSchema = createApiSchema(TaskRelationSelectSchema);
+var TaskRelationApiInsertSchema = createApiInsertSchema(TaskRelationInsertSchema);
+var TaskRelationApiUpdateSchema = createApiUpdateSchema(TaskRelationUpdateSchema);
+var imageUrlSchema = z.string().optional().refine(
+  (url) => {
+    if (!url) return true;
+    if (url.startsWith("data:image/")) {
+      const base64Part = url.split(",")[1];
+      if (!base64Part) return false;
+      return base64Part.length < 14e5;
+    }
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Image URL must be a valid HTTP(S) URL or a base64 data URL (max 1MB)"
+  }
+);
+var McpTransportConfigSchema = z.object({
+  type: z.enum(["streamable_http", "sse"]),
+  requestInit: z.record(z.string(), z.unknown()).optional(),
+  eventSourceInit: z.record(z.string(), z.unknown()).optional(),
+  reconnectionOptions: z.record(z.string(), z.unknown()).optional(),
+  sessionId: z.string().optional()
+});
+var ToolStatusSchema = z.enum(TOOL_STATUS_VALUES);
+var McpToolDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  inputSchema: z.record(z.string(), z.unknown()).optional()
+});
+var ToolSelectSchema = createSelectSchema(tools);
+var ToolInsertSchema = createInsertSchema(tools).extend({
+  id: resourceIdSchema,
+  imageUrl: imageUrlSchema
+});
+var ConversationSelectSchema = createSelectSchema(conversations);
+var ConversationInsertSchema = createInsertSchema(conversations).extend({
+  id: resourceIdSchema,
+  contextConfigId: resourceIdSchema.optional()
+});
+var ConversationUpdateSchema = ConversationInsertSchema.partial();
+var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema);
+var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema);
+var ConversationApiUpdateSchema = createApiUpdateSchema(ConversationUpdateSchema);
+var MessageSelectSchema = createSelectSchema(messages);
+var MessageInsertSchema = createInsertSchema(messages).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema,
+  taskId: resourceIdSchema.optional()
+});
+var MessageUpdateSchema = MessageInsertSchema.partial();
+var MessageApiSelectSchema = createApiSchema(MessageSelectSchema);
+var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema);
+var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema);
+var ContextCacheSelectSchema = createSelectSchema(contextCache);
+var ContextCacheInsertSchema = createInsertSchema(contextCache);
+var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
+var ContextCacheApiSelectSchema = createApiSchema(ContextCacheSelectSchema);
+var ContextCacheApiInsertSchema = createApiInsertSchema(ContextCacheInsertSchema);
+var ContextCacheApiUpdateSchema = createApiUpdateSchema(ContextCacheUpdateSchema);
+var DataComponentSelectSchema = createSelectSchema(dataComponents);
+var DataComponentInsertSchema = createInsertSchema(dataComponents).extend({
+  id: resourceIdSchema
+});
+var DataComponentBaseSchema = DataComponentInsertSchema.omit({
+  createdAt: true,
+  updatedAt: true
+});
+var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
+var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema);
+var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
+var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema);
+var AgentDataComponentSelectSchema = createSelectSchema(agentDataComponents);
+var AgentDataComponentInsertSchema = createInsertSchema(agentDataComponents);
+var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
+var AgentDataComponentApiSelectSchema = createApiSchema(AgentDataComponentSelectSchema);
+var AgentDataComponentApiInsertSchema = createApiInsertSchema(
+  AgentDataComponentInsertSchema
+);
+var AgentDataComponentApiUpdateSchema = createApiUpdateSchema(
+  AgentDataComponentUpdateSchema
+);
+var ArtifactComponentSelectSchema = createSelectSchema(artifactComponents);
+var ArtifactComponentInsertSchema = createInsertSchema(artifactComponents).extend({
+  id: resourceIdSchema
+});
+var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
+var ArtifactComponentApiSelectSchema = createApiSchema(ArtifactComponentSelectSchema);
+var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  id: resourceIdSchema.optional()
+});
+var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+  ArtifactComponentUpdateSchema
+);
+var AgentArtifactComponentSelectSchema = createSelectSchema(agentArtifactComponents);
+var AgentArtifactComponentInsertSchema = createInsertSchema(
+  agentArtifactComponents
+).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  artifactComponentId: resourceIdSchema
+});
+var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
+var AgentArtifactComponentApiSelectSchema = createApiSchema(
+  AgentArtifactComponentSelectSchema
+);
+var AgentArtifactComponentApiInsertSchema = AgentArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+var AgentArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+  AgentArtifactComponentUpdateSchema
+);
+var ExternalAgentSelectSchema = createSelectSchema(externalAgents).extend({
+  credentialReferenceId: z.string().nullable().optional(),
+  headers: z.record(z.string(), z.string()).nullable().optional()
+});
+var ExternalAgentInsertSchema = createInsertSchema(externalAgents).extend({
+  id: resourceIdSchema
+});
+var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
+var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema);
+var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema);
+var ExternalAgentApiUpdateSchema = createApiUpdateSchema(ExternalAgentUpdateSchema);
+var AllAgentSchema = z.discriminatedUnion("type", [
+  AgentApiSelectSchema.extend({ type: z.literal("internal") }),
+  ExternalAgentApiSelectSchema.extend({ type: z.literal("external") })
+]);
+var ApiKeySelectSchema = createSelectSchema(apiKeys);
+var ApiKeyInsertSchema = createInsertSchema(apiKeys).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema
+});
+var ApiKeyUpdateSchema = ApiKeyInsertSchema.partial().omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  publicId: true,
+  keyHash: true,
+  keyPrefix: true,
+  createdAt: true
+});
+var ApiKeyApiSelectSchema = ApiKeySelectSchema.omit({
+  tenantId: true,
+  projectId: true,
+  keyHash: true
+  // Never expose the hash
+});
+var ApiKeyApiCreationResponseSchema = z.object({
+  data: z.object({
+    apiKey: ApiKeyApiSelectSchema,
+    key: z.string().describe("The full API key (shown only once)")
+  })
+});
+var ApiKeyApiInsertSchema = ApiKeyInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  // Auto-generated
+  publicId: true,
+  // Auto-generated
+  keyHash: true,
+  // Auto-generated
+  keyPrefix: true,
+  // Auto-generated
+  lastUsedAt: true
+  // Not set on creation
+});
+var ApiKeyApiUpdateSchema = ApiKeyUpdateSchema;
+var CredentialReferenceSelectSchema = z.object({
+  id: z.string(),
+  tenantId: z.string(),
+  projectId: z.string(),
+  type: z.string(),
+  credentialStoreId: z.string(),
+  retrievalParams: z.record(z.string(), z.unknown()).nullish(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CredentialReferenceInsertSchema = z.object({
+  id: resourceIdSchema,
+  tenantId: z.string(),
+  projectId: z.string(),
+  type: z.string(),
+  credentialStoreId: resourceIdSchema,
+  retrievalParams: z.record(z.string(), z.unknown()).nullish()
+});
+var CredentialReferenceUpdateSchema = CredentialReferenceInsertSchema.partial();
+var CredentialReferenceApiSelectSchema = createApiSchema(CredentialReferenceSelectSchema);
+var CredentialReferenceApiInsertSchema = createApiInsertSchema(
+  CredentialReferenceInsertSchema
+);
+var CredentialReferenceApiUpdateSchema = createApiUpdateSchema(
+  CredentialReferenceUpdateSchema
+);
+var McpToolSchema = ToolInsertSchema.extend({
+  imageUrl: imageUrlSchema,
+  status: ToolStatusSchema.default("unknown"),
+  lastHealthCheck: z.date().optional(),
+  lastToolsSync: z.date().optional(),
+  version: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var McpToolServerConfigSchema = z.object({
+  type: z.string(),
+  version: z.string().optional()
+});
+var MCPToolConfigSchema = McpToolSchema.omit({
+  config: true,
+  tenantId: true,
+  projectId: true,
+  status: true,
+  lastHealthCheck: true,
+  lastToolsSync: true,
+  version: true,
+  createdAt: true,
+  updatedAt: true,
+  credentialReferenceId: true
+}).extend({
+  tenantId: z.string().optional(),
+  projectId: z.string().optional(),
+  description: z.string().optional(),
+  server: McpToolServerConfigSchema.optional(),
+  serverUrl: z.url(),
+  toolName: z.string().optional(),
+  activeTools: z.array(z.string()).optional(),
+  mcpType: z.enum(["nango", "generic"]).optional(),
+  transport: McpTransportConfigSchema.optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ToolUpdateSchema = ToolInsertSchema.partial();
+var ToolApiSelectSchema = createApiSchema(ToolSelectSchema);
+var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
+var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema);
+var FetchConfigSchema = z.object({
+  url: z.string().min(1, "URL is required"),
+  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default("GET"),
+  headers: z.record(z.string(), z.string()).optional(),
+  body: z.record(z.string(), z.unknown()).optional(),
+  transform: z.string().optional(),
+  // JSONPath or JS transform function
+  timeout: z.number().min(0).optional().default(1e4).optional()
+});
+var FetchDefinitionSchema = z.object({
+  id: z.string().min(1, "Fetch definition ID is required"),
+  name: z.string().optional(),
+  trigger: z.enum(["initialization", "invocation"]),
+  fetchConfig: FetchConfigSchema,
+  responseSchema: z.any().optional(),
+  // JSON Schema for validating HTTP response
+  defaultValue: z.unknown().optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ContextConfigSelectSchema = createSelectSchema(contextConfigs).extend({
+  requestContextSchema: z.unknown().optional()
+});
+var ContextConfigInsertSchema = createInsertSchema(contextConfigs).extend({
+  id: resourceIdSchema,
+  requestContextSchema: z.unknown().optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
+var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema);
+var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema);
+var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema);
+var AgentToolRelationSelectSchema = createSelectSchema(agentToolRelations);
+var AgentToolRelationInsertSchema = createInsertSchema(agentToolRelations).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  toolId: resourceIdSchema
+});
+var AgentToolRelationUpdateSchema = AgentToolRelationInsertSchema.partial();
+var AgentToolRelationApiSelectSchema = createApiSchema(AgentToolRelationSelectSchema);
+var AgentToolRelationApiInsertSchema = createApiInsertSchema(
+  AgentToolRelationInsertSchema
+);
+var AgentToolRelationApiUpdateSchema = createApiUpdateSchema(
+  AgentToolRelationUpdateSchema
+);
+var LedgerArtifactSelectSchema = createSelectSchema(ledgerArtifacts);
+var LedgerArtifactInsertSchema = createInsertSchema(ledgerArtifacts);
+var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
+var LedgerArtifactApiSelectSchema = createApiSchema(LedgerArtifactSelectSchema);
+var LedgerArtifactApiInsertSchema = createApiInsertSchema(LedgerArtifactInsertSchema);
+var LedgerArtifactApiUpdateSchema = createApiUpdateSchema(LedgerArtifactUpdateSchema);
+var StatusComponentSchema = z.object({
+  type: z.string(),
+  description: z.string().optional(),
+  detailsSchema: z.object({
+    type: z.literal("object"),
+    properties: z.record(z.string(), z.any()),
+    required: z.array(z.string()).optional()
+  }).optional()
+});
+var StatusUpdateSchema = z.object({
+  enabled: z.boolean().optional(),
+  numEvents: z.number().min(1).max(100).optional(),
+  timeInSeconds: z.number().min(1).max(600).optional(),
+  prompt: z.string().max(2e3, "Custom prompt cannot exceed 2000 characters").optional(),
+  statusComponents: z.array(StatusComponentSchema).optional()
+});
+var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+  tools: z.array(z.string()),
+  dataComponents: z.array(z.string()).optional(),
+  artifactComponents: z.array(z.string()).optional(),
+  canTransferTo: z.array(z.string()).optional(),
+  canDelegateTo: z.array(z.string()).optional()
+});
+var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
+  agents: z.record(z.string(), z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  tools: z.record(z.string(), ToolApiInsertSchema),
+  credentialReferences: z.array(CredentialReferenceApiInsertSchema).optional(),
+  dataComponents: z.record(z.string(), DataComponentApiInsertSchema).optional(),
+  artifactComponents: z.record(z.string(), ArtifactComponentApiInsertSchema).optional(),
+  contextConfig: z.optional(ContextConfigApiInsertSchema),
+  statusUpdates: z.optional(StatusUpdateSchema),
+  models: ModelSchema.optional(),
+  stopWhen: z.object({
+    transferCountIs: z.number().min(1).max(100).optional()
+  }).optional(),
+  graphPrompt: z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+});
+var PaginationSchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10),
+  total: z.number(),
+  pages: z.number()
+});
+var ListResponseSchema = (itemSchema) => z.object({
+  data: z.array(itemSchema),
+  pagination: PaginationSchema
+});
+var SingleResponseSchema = (itemSchema) => z.object({
+  data: itemSchema
+});
+var ErrorResponseSchema = z.object({
+  error: z.string(),
+  message: z.string().optional(),
+  details: z.unknown().optional()
+});
+var ExistsResponseSchema = z.object({
+  exists: z.boolean()
+});
+var RemovedResponseSchema = z.object({
+  message: z.string(),
+  removed: z.boolean()
+});
+var ProjectSelectSchema = createSelectSchema(projects);
+var ProjectInsertSchema = createInsertSchema(projects).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ProjectUpdateSchema = ProjectInsertSchema.partial();
+var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true });
+var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true });
+var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
+var HeadersScopeSchema = z.object({
+  "x-inkeep-tenant-id": z.string().optional().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  "x-inkeep-project-id": z.string().optional().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  "x-inkeep-graph-id": z.string().optional().openapi({
+    description: "Graph identifier",
+    example: "graph_789"
+  })
+});
+var TenantParamsSchema = z.object({
+  tenantId: z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  })
+}).openapi("TenantParams");
+var TenantProjectParamsSchema = z.object({
+  tenantId: z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  })
+}).openapi("TenantProjectParams");
+var TenantProjectIdParamsSchema = z.object({
+  tenantId: z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantProjectIdParams");
+var TenantIdParamsSchema = z.object({
+  tenantId: z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantIdParams");
+var IdParamsSchema = z.object({
+  id: resourceIdSchema
+}).openapi("IdParams");
+var PaginationQueryParamsSchema = z.object({
+  page: z.coerce.number().min(1).default(1),
+  limit: z.coerce.number().min(1).max(100).default(10)
+});
+
+// src/validation/graphFull.ts
+function isInternalAgent(agent) {
+  return "prompt" in agent;
+}
+function isExternalAgent(agent) {
+  return "baseUrl" in agent;
+}
+function validateAndTypeGraphData(data) {
+  return FullGraphDefinitionSchema.parse(data);
+}
+function validateToolReferences(graphData) {
+  const errors = [];
+  const availableToolIds = new Set(Object.keys(graphData.tools));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.tools && Array.isArray(agentData.tools)) {
+      for (const toolId of agentData.tools) {
+        if (!availableToolIds.has(toolId)) {
+          errors.push(`Agent '${agentId}' references non-existent tool '${toolId}'`);
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Tool reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateDataComponentReferences(graphData) {
+  const errors = [];
+  const availableDataComponentIds = new Set(Object.keys(graphData.dataComponents || {}));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.dataComponents) {
+      for (const dataComponentId of agentData.dataComponents) {
+        if (!availableDataComponentIds.has(dataComponentId)) {
+          errors.push(
+            `Agent '${agentId}' references non-existent dataComponent '${dataComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`DataComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateArtifactComponentReferences(graphData) {
+  const errors = [];
+  const availableArtifactComponentIds = new Set(Object.keys(graphData.artifactComponents || {}));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.artifactComponents) {
+      for (const artifactComponentId of agentData.artifactComponents) {
+        if (!availableArtifactComponentIds.has(artifactComponentId)) {
+          errors.push(
+            `Agent '${agentId}' references non-existent artifactComponent '${artifactComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`ArtifactComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateAgentRelationships(graphData) {
+  const errors = [];
+  const availableAgentIds = new Set(Object.keys(graphData.agents));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData)) {
+      if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo)) {
+        for (const targetId of agentData.canTransferTo) {
+          if (!availableAgentIds.has(targetId)) {
+            errors.push(
+              `Agent '${agentId}' has transfer target '${targetId}' that doesn't exist in graph`
+            );
+          }
+        }
+      }
+      if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo)) {
+        for (const targetId of agentData.canDelegateTo) {
+          if (!availableAgentIds.has(targetId)) {
+            errors.push(
+              `Agent '${agentId}' has delegation target '${targetId}' that doesn't exist in graph`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Agent relationship validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateGraphStructure(graphData) {
+  if (!graphData.agents[graphData.defaultAgentId]) {
+    throw new Error(`Default agent '${graphData.defaultAgentId}' does not exist in agents`);
+  }
+  validateToolReferences(graphData);
+  validateDataComponentReferences(graphData);
+  validateArtifactComponentReferences(graphData);
+  validateAgentRelationships(graphData);
+}
+
+// src/validation/id-validation.ts
+function isValidResourceId(id) {
+  const result = resourceIdSchema.safeParse(id);
+  return result.success;
+}
+function generateIdFromName(name) {
+  const id = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  if (!id) {
+    throw new Error("Cannot generate valid ID from provided name");
+  }
+  const truncatedId = id.substring(0, MAX_ID_LENGTH);
+  const result = resourceIdSchema.safeParse(truncatedId);
+  if (!result.success) {
+    throw new Error(`Generated ID "${truncatedId}" is not valid: ${result.error.message}`);
+  }
+  return truncatedId;
+}
+
+export { AgentApiInsertSchema, AgentApiSelectSchema, AgentApiUpdateSchema, AgentArtifactComponentApiInsertSchema, AgentArtifactComponentApiSelectSchema, AgentArtifactComponentApiUpdateSchema, AgentArtifactComponentInsertSchema, AgentArtifactComponentSelectSchema, AgentArtifactComponentUpdateSchema, AgentDataComponentApiInsertSchema, AgentDataComponentApiSelectSchema, AgentDataComponentApiUpdateSchema, AgentDataComponentInsertSchema, AgentDataComponentSelectSchema, AgentDataComponentUpdateSchema, AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, AgentInsertSchema, AgentRelationApiInsertSchema, AgentRelationApiSelectSchema, AgentRelationApiUpdateSchema, AgentRelationInsertSchema, AgentRelationQuerySchema, AgentRelationSelectSchema, AgentRelationUpdateSchema, AgentSelectSchema, AgentToolRelationApiInsertSchema, AgentToolRelationApiSelectSchema, AgentToolRelationApiUpdateSchema, AgentToolRelationInsertSchema, AgentToolRelationSelectSchema, AgentToolRelationUpdateSchema, AgentUpdateSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentInsertSchema, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationSelectSchema, ConversationUpdateSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentRelationApiInsertSchema, ExternalAgentRelationInsertSchema, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullGraphDefinitionSchema, HeadersScopeSchema, IdParamsSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolSchema, McpToolServerConfigSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, PaginationQueryParamsSchema, PaginationSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectSelectSchema, ProjectUpdateSchema, RemovedResponseSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, resourceIdSchema, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences };