@inkeep/agents-core 0.0.0-chat-to-edit-20251119071712

package/dist/chunk-TLSKVSBR.js

@@ -0,0 +1,1234 @@
+import { subAgents, subAgentRelations, agents, tasks, taskRelations, conversations, messages, contextCache, dataComponents, subAgentDataComponents, artifactComponents, subAgentArtifactComponents, externalAgents, apiKeys, credentialReferences, tools, functionTools, functions, contextConfigs, subAgentToolRelations, subAgentExternalAgentRelations, subAgentTeamAgentRelations, ledgerArtifacts, projects } from './chunk-A6JWG7FI.js';
+import { VALID_RELATION_TYPES, MCPTransportType, TOOL_STATUS_VALUES, CredentialStoreType, MCPServerType } from './chunk-YFHT5M2R.js';
+import { z } from '@hono/zod-openapi';
+import { createSelectSchema as createSelectSchema$1, createInsertSchema as createInsertSchema$1 } from 'drizzle-zod';
+import Ajv from 'ajv';
+
+// src/constants/schema-validation/defaults.ts
+var schemaValidationDefaults = {
+  // Agent Execution Transfer Count
+  // Controls how many times an agent can transfer control to sub-agents in a single conversation turn.
+  // This prevents infinite transfer loops while allowing multi-agent collaboration workflows.
+  AGENT_EXECUTION_TRANSFER_COUNT_MIN: 1,
+  AGENT_EXECUTION_TRANSFER_COUNT_MAX: 1e3,
+  AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT: 10,
+  // Sub-Agent Turn Generation Steps
+  // Limits how many AI generation steps a sub-agent can perform within a single turn.
+  // Each generation step typically involves sending a prompt to the LLM and processing its response.
+  // This prevents runaway token usage while allowing complex multi-step reasoning.
+  SUB_AGENT_TURN_GENERATION_STEPS_MIN: 1,
+  SUB_AGENT_TURN_GENERATION_STEPS_MAX: 1e3,
+  SUB_AGENT_TURN_GENERATION_STEPS_DEFAULT: 12,
+  // Status Update Thresholds
+  // Real-time status updates are triggered when either threshold is exceeded during longer operations.
+  // MAX_NUM_EVENTS: Maximum number of internal events before forcing a status update to the client.
+  // MAX_INTERVAL_SECONDS: Maximum time between status updates regardless of event count.
+  STATUS_UPDATE_MAX_NUM_EVENTS: 100,
+  STATUS_UPDATE_MAX_INTERVAL_SECONDS: 600,
+  // 10 minutes
+  // Prompt Text Length Validation
+  // Maximum character limits for agent and sub-agent system prompts to prevent excessive token usage.
+  // Enforced during agent configuration to ensure prompts remain focused and manageable.
+  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS: 2e3,
+  VALIDATION_AGENT_PROMPT_MAX_CHARS: 5e3,
+  // Context Fetcher HTTP Timeout
+  // Maximum time allowed for HTTP requests made by Context Fetchers (e.g., CRM lookups, external API calls).
+  // Context Fetchers automatically retrieve external data at the start of a conversation to enrich agent context.
+  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT: 1e4
+  // 10 seconds
+};
+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).describe("Resource identifier").regex(URL_SAFE_ID_PATTERN, {
+  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+}).openapi({
+  description: "Resource identifier",
+  example: "resource_789"
+});
+resourceIdSchema.meta({
+  description: "Resource identifier"
+});
+var FIELD_MODIFIERS = {
+  id: (schema) => {
+    const modified = schema.min(MIN_ID_LENGTH).max(MAX_ID_LENGTH).describe("Resource identifier").regex(URL_SAFE_ID_PATTERN, {
+      message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+    }).openapi({
+      description: "Resource identifier",
+      example: "resource_789"
+    });
+    modified.meta({
+      description: "Resource identifier"
+    });
+    return modified;
+  },
+  name: (_schema) => {
+    const modified = z.string().describe("Name");
+    modified.meta({ description: "Name" });
+    return modified;
+  },
+  description: (_schema) => {
+    const modified = z.string().describe("Description");
+    modified.meta({ description: "Description" });
+    return modified;
+  },
+  tenantId: (schema) => {
+    const modified = schema.describe("Tenant identifier");
+    modified.meta({ description: "Tenant identifier" });
+    return modified;
+  },
+  projectId: (schema) => {
+    const modified = schema.describe("Project identifier");
+    modified.meta({ description: "Project identifier" });
+    return modified;
+  },
+  agentId: (schema) => {
+    const modified = schema.describe("Agent identifier");
+    modified.meta({ description: "Agent identifier" });
+    return modified;
+  },
+  subAgentId: (schema) => {
+    const modified = schema.describe("Sub-agent identifier");
+    modified.meta({ description: "Sub-agent identifier" });
+    return modified;
+  },
+  createdAt: (schema) => {
+    const modified = schema.describe("Creation timestamp");
+    modified.meta({ description: "Creation timestamp" });
+    return modified;
+  },
+  updatedAt: (schema) => {
+    const modified = schema.describe("Last update timestamp");
+    modified.meta({ description: "Last update timestamp" });
+    return modified;
+  }
+};
+function createSelectSchemaWithModifiers(table, overrides) {
+  const tableColumns = table._?.columns;
+  if (!tableColumns) {
+    return createSelectSchema$1(table, overrides);
+  }
+  const tableFieldNames = Object.keys(tableColumns);
+  const modifiers = {};
+  for (const fieldName of tableFieldNames) {
+    const fieldNameStr = String(fieldName);
+    if (fieldNameStr in FIELD_MODIFIERS) {
+      modifiers[fieldNameStr] = FIELD_MODIFIERS[fieldNameStr];
+    }
+  }
+  const mergedModifiers = { ...modifiers, ...overrides };
+  return createSelectSchema$1(table, mergedModifiers);
+}
+function createInsertSchemaWithModifiers(table, overrides) {
+  const tableColumns = table._?.columns;
+  if (!tableColumns) {
+    return createInsertSchema$1(table, overrides);
+  }
+  const tableFieldNames = Object.keys(tableColumns);
+  const modifiers = {};
+  for (const fieldName of tableFieldNames) {
+    const fieldNameStr = String(fieldName);
+    if (fieldNameStr in FIELD_MODIFIERS) {
+      modifiers[fieldNameStr] = FIELD_MODIFIERS[fieldNameStr];
+    }
+  }
+  const mergedModifiers = { ...modifiers, ...overrides };
+  return createInsertSchema$1(table, mergedModifiers);
+}
+var createSelectSchema = createSelectSchemaWithModifiers;
+var createInsertSchema = createInsertSchemaWithModifiers;
+function registerFieldSchemas(schema) {
+  if (!(schema instanceof z.ZodObject)) {
+    return schema;
+  }
+  const shape = schema.shape;
+  const fieldMetadata = {
+    id: { description: "Resource identifier" },
+    name: { description: "Name" },
+    description: { description: "Description" },
+    tenantId: { description: "Tenant identifier" },
+    projectId: { description: "Project identifier" },
+    agentId: { description: "Agent identifier" },
+    subAgentId: { description: "Sub-agent identifier" },
+    createdAt: { description: "Creation timestamp" },
+    updatedAt: { description: "Last update timestamp" }
+  };
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    if (fieldName in fieldMetadata && fieldSchema) {
+      let zodFieldSchema = fieldSchema;
+      let innerSchema = null;
+      if (zodFieldSchema instanceof z.ZodOptional) {
+        innerSchema = zodFieldSchema._def.innerType;
+        zodFieldSchema = innerSchema;
+      }
+      zodFieldSchema.meta(fieldMetadata[fieldName]);
+      if (fieldName === "id" && zodFieldSchema instanceof z.ZodString) {
+        zodFieldSchema.openapi({
+          description: "Resource identifier",
+          minLength: MIN_ID_LENGTH,
+          maxLength: MAX_ID_LENGTH,
+          pattern: URL_SAFE_ID_PATTERN.source,
+          example: "resource_789"
+        });
+      } else if (zodFieldSchema instanceof z.ZodString) {
+        zodFieldSchema.openapi({
+          description: fieldMetadata[fieldName].description
+        });
+      }
+      if (innerSchema && fieldSchema instanceof z.ZodOptional) {
+        fieldSchema.meta(fieldMetadata[fieldName]);
+      }
+    }
+  }
+  return schema;
+}
+var {
+  AGENT_EXECUTION_TRANSFER_COUNT_MAX,
+  AGENT_EXECUTION_TRANSFER_COUNT_MIN,
+  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT,
+  STATUS_UPDATE_MAX_INTERVAL_SECONDS,
+  STATUS_UPDATE_MAX_NUM_EVENTS,
+  SUB_AGENT_TURN_GENERATION_STEPS_MAX,
+  SUB_AGENT_TURN_GENERATION_STEPS_MIN,
+  VALIDATION_AGENT_PROMPT_MAX_CHARS,
+  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS
+} = schemaValidationDefaults;
+var StopWhenSchema = z.object({
+  transferCountIs: z.number().min(AGENT_EXECUTION_TRANSFER_COUNT_MIN).max(AGENT_EXECUTION_TRANSFER_COUNT_MAX).optional().describe("The maximum number of transfers to trigger the stop condition."),
+  stepCountIs: z.number().min(SUB_AGENT_TURN_GENERATION_STEPS_MIN).max(SUB_AGENT_TURN_GENERATION_STEPS_MAX).optional().describe("The maximum number of steps to trigger the stop condition.")
+}).openapi("StopWhen");
+var AgentStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true }).openapi(
+  "AgentStopWhen"
+);
+var SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true }).openapi(
+  "SubAgentStopWhen"
+);
+var pageNumber = z.coerce.number().min(1).default(1).openapi("PaginationPageQueryParam");
+var limitNumber = z.coerce.number().min(1).max(100).default(10).openapi("PaginationLimitQueryParam");
+var ModelSettingsSchema = z.object({
+  model: z.string().optional().describe("The model to use for the project."),
+  providerOptions: z.record(z.string(), z.any()).optional().describe("The provider options to use for the project.")
+}).openapi("ModelSettings");
+var ModelSchema = z.object({
+  base: ModelSettingsSchema.optional(),
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+}).openapi("Model");
+var ProjectModelSchema = z.object({
+  base: ModelSettingsSchema,
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+}).openapi("ProjectModel");
+var FunctionToolConfigSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  inputSchema: z.record(z.string(), z.unknown()),
+  dependencies: z.record(z.string(), z.string()).optional(),
+  execute: z.union([z.function(), z.string()])
+});
+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 createAgentScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true }).partial();
+var SubAgentSelectSchema = createSelectSchema(subAgents);
+var SubAgentInsertSchema = createInsertSchema(subAgents).extend({
+  id: resourceIdSchema,
+  models: ModelSchema.optional()
+});
+var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
+var SubAgentApiSelectSchema = createAgentScopedApiSchema(SubAgentSelectSchema).openapi("SubAgent");
+var SubAgentApiInsertSchema = createAgentScopedApiInsertSchema(SubAgentInsertSchema).openapi("SubAgentCreate");
+var SubAgentApiUpdateSchema = createAgentScopedApiUpdateSchema(SubAgentUpdateSchema).openapi("SubAgentUpdate");
+var SubAgentRelationSelectSchema = createSelectSchema(subAgentRelations);
+var SubAgentRelationInsertSchema = createInsertSchema(subAgentRelations).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  sourceSubAgentId: resourceIdSchema,
+  targetSubAgentId: resourceIdSchema.optional(),
+  externalSubAgentId: resourceIdSchema.optional(),
+  teamSubAgentId: resourceIdSchema.optional()
+});
+var SubAgentRelationUpdateSchema = SubAgentRelationInsertSchema.partial();
+var SubAgentRelationApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentRelationSelectSchema
+).openapi("SubAgentRelation");
+var SubAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
+  SubAgentRelationInsertSchema
+).extend({
+  relationType: z.enum(VALID_RELATION_TYPES)
+}).refine(
+  (data) => {
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != null;
+    const hasTeam = data.teamSubAgentId != null;
+    const count = [hasTarget, hasExternal, hasTeam].filter(Boolean).length;
+    return count === 1;
+  },
+  {
+    message: "Must specify exactly one of targetSubAgentId, externalSubAgentId, or teamSubAgentId",
+    path: ["targetSubAgentId", "externalSubAgentId", "teamSubAgentId"]
+  }
+).openapi("SubAgentRelationCreate");
+var SubAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentRelationUpdateSchema
+).extend({
+  relationType: z.enum(VALID_RELATION_TYPES).optional()
+}).refine(
+  (data) => {
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != null;
+    const hasTeam = data.teamSubAgentId != null;
+    const count = [hasTarget, hasExternal, hasTeam].filter(Boolean).length;
+    if (count === 0) {
+      return true;
+    }
+    return count === 1;
+  },
+  {
+    message: "Must specify exactly one of targetSubAgentId, externalSubAgentId, or teamSubAgentId when updating sub-agent relationships",
+    path: ["targetSubAgentId", "externalSubAgentId", "teamSubAgentId"]
+  }
+).openapi("SubAgentRelationUpdate");
+var SubAgentRelationQuerySchema = z.object({
+  sourceSubAgentId: z.string().optional(),
+  targetSubAgentId: z.string().optional(),
+  externalSubAgentId: z.string().optional(),
+  teamSubAgentId: z.string().optional()
+});
+var ExternalSubAgentRelationInsertSchema = createInsertSchema(subAgentRelations).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  sourceSubAgentId: resourceIdSchema,
+  externalSubAgentId: resourceIdSchema
+});
+var ExternalSubAgentRelationApiInsertSchema = createApiInsertSchema(
+  ExternalSubAgentRelationInsertSchema
+);
+var AgentSelectSchema = createSelectSchema(agents);
+var AgentInsertSchema = createInsertSchema(agents).extend({
+  id: resourceIdSchema,
+  name: z.string().trim().nonempty()
+});
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema).openapi("Agent");
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema).extend({
+  id: resourceIdSchema
+}).openapi("AgentCreate");
+var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema).openapi("AgentUpdate");
+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(MCPTransportType),
+  requestInit: z.record(z.string(), z.unknown()).optional(),
+  eventSourceInit: z.record(z.string(), z.unknown()).optional(),
+  reconnectionOptions: z.any().optional().openapi({
+    type: "object",
+    description: "Reconnection options for streamable HTTP transport"
+  }),
+  sessionId: z.string().optional()
+}).openapi("McpTransportConfig");
+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,
+  config: z.object({
+    type: z.literal("mcp"),
+    mcp: z.object({
+      server: z.object({
+        url: z.url()
+      }),
+      transport: z.object({
+        type: z.enum(MCPTransportType),
+        requestInit: z.record(z.string(), z.unknown()).optional(),
+        eventSourceInit: z.record(z.string(), z.unknown()).optional(),
+        reconnectionOptions: z.any().optional().openapi({
+          type: "object",
+          description: "Reconnection options for streamable HTTP transport"
+        }),
+        sessionId: z.string().optional()
+      }).optional(),
+      activeTools: z.array(z.string()).optional()
+    })
+  })
+});
+var ConversationSelectSchema = createSelectSchema(conversations);
+var ConversationInsertSchema = createInsertSchema(conversations).extend({
+  id: resourceIdSchema,
+  contextConfigId: resourceIdSchema.optional()
+});
+var ConversationUpdateSchema = ConversationInsertSchema.partial();
+var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema).openapi("Conversation");
+var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema).openapi("ConversationCreate");
+var ConversationApiUpdateSchema = createApiUpdateSchema(ConversationUpdateSchema).openapi("ConversationUpdate");
+var MessageSelectSchema = createSelectSchema(messages);
+var MessageInsertSchema = createInsertSchema(messages).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema,
+  taskId: resourceIdSchema.optional()
+});
+var MessageUpdateSchema = MessageInsertSchema.partial();
+var MessageApiSelectSchema = createApiSchema(MessageSelectSchema).openapi("Message");
+var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema).openapi("MessageCreate");
+var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema).openapi("MessageUpdate");
+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).openapi("DataComponent");
+var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema).openapi("DataComponentCreate");
+var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema).openapi("DataComponentUpdate");
+var SubAgentDataComponentSelectSchema = createSelectSchema(subAgentDataComponents);
+var SubAgentDataComponentInsertSchema = createInsertSchema(subAgentDataComponents);
+var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
+var SubAgentDataComponentApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentDataComponentSelectSchema
+);
+var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+var SubAgentDataComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentDataComponentUpdateSchema
+);
+var ArtifactComponentSelectSchema = createSelectSchema(artifactComponents);
+var ArtifactComponentInsertSchema = createInsertSchema(artifactComponents).extend({
+  id: resourceIdSchema
+});
+var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
+var ArtifactComponentApiSelectSchema = createApiSchema(
+  ArtifactComponentSelectSchema
+).openapi("ArtifactComponent");
+var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  createdAt: true,
+  updatedAt: true
+}).openapi("ArtifactComponentCreate");
+var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+  ArtifactComponentUpdateSchema
+).openapi("ArtifactComponentUpdate");
+var SubAgentArtifactComponentSelectSchema = createSelectSchema(subAgentArtifactComponents);
+var SubAgentArtifactComponentInsertSchema = createInsertSchema(
+  subAgentArtifactComponents
+).extend({
+  id: resourceIdSchema,
+  subAgentId: resourceIdSchema,
+  artifactComponentId: resourceIdSchema
+});
+var SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentInsertSchema.partial();
+var SubAgentArtifactComponentApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentArtifactComponentSelectSchema
+);
+var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+var SubAgentArtifactComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentArtifactComponentUpdateSchema
+);
+var ExternalAgentSelectSchema = createSelectSchema(externalAgents).extend({
+  credentialReferenceId: z.string().nullable().optional()
+});
+var ExternalAgentInsertSchema = createInsertSchema(externalAgents).extend({
+  id: resourceIdSchema
+});
+var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
+var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema).openapi("ExternalAgent");
+var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema).openapi("ExternalAgentCreate");
+var ExternalAgentApiUpdateSchema = createApiUpdateSchema(ExternalAgentUpdateSchema).openapi("ExternalAgentUpdate");
+var AllAgentSchema = z.discriminatedUnion("type", [
+  SubAgentApiSelectSchema.extend({ type: z.literal("internal") }),
+  ExternalAgentApiSelectSchema.extend({ type: z.literal("external") })
+]);
+var ApiKeySelectSchema = createSelectSchema(apiKeys);
+var ApiKeyInsertSchema = createInsertSchema(apiKeys).extend({
+  id: resourceIdSchema,
+  agentId: 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
+}).openapi("ApiKey");
+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
+}).openapi("ApiKeyCreate");
+var ApiKeyApiUpdateSchema = ApiKeyUpdateSchema.openapi("ApiKeyUpdate");
+var CredentialReferenceSelectSchema = z.object({
+  id: z.string(),
+  tenantId: z.string(),
+  projectId: z.string(),
+  name: z.string(),
+  type: z.string(),
+  credentialStoreId: z.string(),
+  retrievalParams: z.record(z.string(), z.unknown()).nullish(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var CredentialReferenceInsertSchema = createInsertSchema(credentialReferences).extend({
+  id: resourceIdSchema,
+  type: z.string(),
+  credentialStoreId: resourceIdSchema,
+  retrievalParams: z.record(z.string(), z.unknown()).nullish()
+});
+var CredentialReferenceUpdateSchema = CredentialReferenceInsertSchema.partial();
+var CredentialReferenceApiSelectSchema = createApiSchema(CredentialReferenceSelectSchema).extend({
+  type: z.enum(CredentialStoreType),
+  tools: z.array(ToolSelectSchema).optional(),
+  externalAgents: z.array(ExternalAgentSelectSchema).optional()
+}).openapi("CredentialReference");
+var CredentialReferenceApiInsertSchema = createApiInsertSchema(
+  CredentialReferenceInsertSchema
+).extend({
+  type: z.enum(CredentialStoreType)
+}).openapi("CredentialReferenceCreate");
+var CredentialReferenceApiUpdateSchema = createApiUpdateSchema(
+  CredentialReferenceUpdateSchema
+).extend({
+  type: z.enum(CredentialStoreType).optional()
+}).openapi("CredentialReferenceUpdate");
+var CredentialStoreSchema = z.object({
+  id: z.string().describe("Unique identifier of the credential store"),
+  type: z.enum(CredentialStoreType),
+  available: z.boolean().describe("Whether the store is functional and ready to use"),
+  reason: z.string().nullable().describe("Reason why store is not available, if applicable")
+}).openapi("CredentialStore");
+var CredentialStoreListResponseSchema = z.object({
+  data: z.array(CredentialStoreSchema).describe("List of credential stores")
+}).openapi("CredentialStoreListResponse");
+var CreateCredentialInStoreRequestSchema = z.object({
+  key: z.string().describe("The credential key"),
+  value: z.string().describe("The credential value"),
+  metadata: z.record(z.string(), z.string()).nullish().describe("The metadata for the credential")
+}).openapi("CreateCredentialInStoreRequest");
+var CreateCredentialInStoreResponseSchema = z.object({
+  data: z.object({
+    key: z.string().describe("The credential key"),
+    storeId: z.string().describe("The store ID where credential was created"),
+    createdAt: z.string().describe("ISO timestamp of creation")
+  })
+}).openapi("CreateCredentialInStoreResponse");
+var RelatedAgentInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string()
+}).openapi("RelatedAgentInfo");
+var ComponentAssociationSchema = z.object({
+  subAgentId: z.string(),
+  createdAt: z.string()
+}).openapi("ComponentAssociation");
+var OAuthLoginQuerySchema = z.object({
+  tenantId: z.string().min(1, "Tenant ID is required"),
+  projectId: z.string().min(1, "Project ID is required"),
+  toolId: z.string().min(1, "Tool ID is required")
+}).openapi("OAuthLoginQuery");
+var OAuthCallbackQuerySchema = z.object({
+  code: z.string().min(1, "Authorization code is required"),
+  state: z.string().min(1, "State parameter is required"),
+  error: z.string().optional(),
+  error_description: z.string().optional()
+}).openapi("OAuthCallbackQuery");
+var McpToolSchema = ToolInsertSchema.extend({
+  imageUrl: imageUrlSchema,
+  availableTools: z.array(McpToolDefinitionSchema).optional(),
+  status: ToolStatusSchema.default("unknown"),
+  version: z.string().optional(),
+  expiresAt: z.string().optional(),
+  relationshipId: z.string().optional()
+}).openapi("McpTool");
+var MCPToolConfigSchema = McpToolSchema.omit({
+  config: true,
+  tenantId: true,
+  projectId: true,
+  status: true,
+  version: true,
+  createdAt: true,
+  updatedAt: true,
+  credentialReferenceId: true
+}).extend({
+  tenantId: z.string().optional(),
+  projectId: z.string().optional(),
+  description: z.string().optional(),
+  serverUrl: z.url(),
+  activeTools: z.array(z.string()).optional(),
+  mcpType: z.enum(MCPServerType).optional(),
+  transport: McpTransportConfigSchema.optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ToolUpdateSchema = ToolInsertSchema.partial();
+var ToolApiSelectSchema = createApiSchema(ToolSelectSchema).openapi("Tool");
+var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema).openapi("ToolCreate");
+var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema).openapi("ToolUpdate");
+var FunctionToolSelectSchema = createSelectSchema(functionTools);
+var FunctionToolInsertSchema = createInsertSchema(functionTools).extend({
+  id: resourceIdSchema
+});
+var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
+var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema).openapi("FunctionTool");
+var FunctionToolApiInsertSchema = createAgentScopedApiInsertSchema(FunctionToolInsertSchema).openapi("FunctionToolCreate");
+var FunctionToolApiUpdateSchema = createApiUpdateSchema(FunctionToolUpdateSchema).openapi("FunctionToolUpdate");
+var FunctionSelectSchema = createSelectSchema(functions);
+var FunctionInsertSchema = createInsertSchema(functions).extend({
+  id: resourceIdSchema
+});
+var FunctionUpdateSchema = FunctionInsertSchema.partial();
+var FunctionApiSelectSchema = createApiSchema(FunctionSelectSchema).openapi("Function");
+var FunctionApiInsertSchema = createApiInsertSchema(FunctionInsertSchema).openapi("FunctionCreate");
+var FunctionApiUpdateSchema = createApiUpdateSchema(FunctionUpdateSchema).openapi("FunctionUpdate");
+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(CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT).optional()
+}).openapi("FetchConfig");
+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.any().optional().openapi({
+    description: "Default value if fetch fails"
+  }),
+  credential: CredentialReferenceApiInsertSchema.optional()
+}).openapi("FetchDefinition");
+var ContextConfigSelectSchema = createSelectSchema(contextConfigs).extend({
+  headersSchema: z.any().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  })
+});
+var ContextConfigInsertSchema = createInsertSchema(contextConfigs).extend({
+  id: resourceIdSchema.optional(),
+  headersSchema: z.any().nullable().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  }),
+  contextVariables: z.any().nullable().optional().openapi({
+    type: "object",
+    description: "Context variables configuration with fetch definitions"
+  })
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
+var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema).omit({
+  agentId: true
+}).openapi("ContextConfig");
+var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema).omit({
+  agentId: true
+}).openapi("ContextConfigCreate");
+var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema).omit({
+  agentId: true
+}).openapi("ContextConfigUpdate");
+var SubAgentToolRelationSelectSchema = createSelectSchema(subAgentToolRelations);
+var SubAgentToolRelationInsertSchema = createInsertSchema(subAgentToolRelations).extend({
+  id: resourceIdSchema,
+  subAgentId: resourceIdSchema,
+  toolId: resourceIdSchema,
+  selectedTools: z.array(z.string()).nullish(),
+  headers: z.record(z.string(), z.string()).nullish(),
+  toolPolicies: z.record(z.string(), z.object({ needsApproval: z.boolean().optional() })).nullish()
+});
+var SubAgentToolRelationUpdateSchema = SubAgentToolRelationInsertSchema.partial();
+var SubAgentToolRelationApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentToolRelationSelectSchema
+).openapi("SubAgentToolRelation");
+var SubAgentToolRelationApiInsertSchema = createAgentScopedApiInsertSchema(
+  SubAgentToolRelationInsertSchema
+).openapi("SubAgentToolRelationCreate");
+var SubAgentToolRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentToolRelationUpdateSchema
+).openapi("SubAgentToolRelationUpdate");
+var SubAgentExternalAgentRelationSelectSchema = createSelectSchema(
+  subAgentExternalAgentRelations
+);
+var SubAgentExternalAgentRelationInsertSchema = createInsertSchema(
+  subAgentExternalAgentRelations
+).extend({
+  id: resourceIdSchema,
+  subAgentId: resourceIdSchema,
+  externalAgentId: resourceIdSchema,
+  headers: z.record(z.string(), z.string()).nullish()
+});
+var SubAgentExternalAgentRelationUpdateSchema = SubAgentExternalAgentRelationInsertSchema.partial();
+var SubAgentExternalAgentRelationApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentExternalAgentRelationSelectSchema
+).openapi("SubAgentExternalAgentRelation");
+var SubAgentExternalAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
+  SubAgentExternalAgentRelationInsertSchema
+).omit({ id: true, subAgentId: true }).openapi("SubAgentExternalAgentRelationCreate");
+var SubAgentExternalAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentExternalAgentRelationUpdateSchema
+).openapi("SubAgentExternalAgentRelationUpdate");
+var SubAgentTeamAgentRelationSelectSchema = createSelectSchema(subAgentTeamAgentRelations);
+var SubAgentTeamAgentRelationInsertSchema = createInsertSchema(
+  subAgentTeamAgentRelations
+).extend({
+  id: resourceIdSchema,
+  subAgentId: resourceIdSchema,
+  targetAgentId: resourceIdSchema,
+  headers: z.record(z.string(), z.string()).nullish()
+});
+var SubAgentTeamAgentRelationUpdateSchema = SubAgentTeamAgentRelationInsertSchema.partial();
+var SubAgentTeamAgentRelationApiSelectSchema = createAgentScopedApiSchema(
+  SubAgentTeamAgentRelationSelectSchema
+).openapi("SubAgentTeamAgentRelation");
+var SubAgentTeamAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
+  SubAgentTeamAgentRelationInsertSchema
+).omit({ id: true, subAgentId: true }).openapi("SubAgentTeamAgentRelationCreate");
+var SubAgentTeamAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentTeamAgentRelationUpdateSchema
+).openapi("SubAgentTeamAgentRelationUpdate");
+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()
+}).openapi("StatusComponent");
+var StatusUpdateSchema = z.object({
+  enabled: z.boolean().optional(),
+  numEvents: z.number().min(1).max(STATUS_UPDATE_MAX_NUM_EVENTS).optional(),
+  timeInSeconds: z.number().min(1).max(STATUS_UPDATE_MAX_INTERVAL_SECONDS).optional(),
+  prompt: z.string().max(
+    VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS,
+    `Custom prompt cannot exceed ${VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS} characters`
+  ).optional(),
+  statusComponents: z.array(StatusComponentSchema).optional()
+}).openapi("StatusUpdate");
+var CanUseItemSchema = z.object({
+  agentToolRelationId: z.string().optional(),
+  toolId: z.string(),
+  toolSelection: z.array(z.string()).nullish(),
+  headers: z.record(z.string(), z.string()).nullish(),
+  toolPolicies: z.record(z.string(), z.object({ needsApproval: z.boolean().optional() })).nullish()
+}).openapi("CanUseItem");
+var canDelegateToExternalAgentSchema = z.object({
+  externalAgentId: z.string(),
+  subAgentExternalAgentRelationId: z.string().optional(),
+  headers: z.record(z.string(), z.string()).nullish()
+}).openapi("CanDelegateToExternalAgent");
+var canDelegateToTeamAgentSchema = z.object({
+  agentId: z.string(),
+  subAgentTeamAgentRelationId: z.string().optional(),
+  headers: z.record(z.string(), z.string()).nullish()
+}).openapi("CanDelegateToTeamAgent");
+var TeamAgentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string()
+}).openapi("TeamAgent");
+var FullAgentAgentInsertSchema = SubAgentApiInsertSchema.extend({
+  type: z.literal("internal"),
+  canUse: z.array(CanUseItemSchema),
+  // All tools (both MCP and function tools)
+  dataComponents: z.array(z.string()).optional(),
+  artifactComponents: z.array(z.string()).optional(),
+  canTransferTo: z.array(z.string()).optional(),
+  prompt: z.string().trim().nonempty(),
+  canDelegateTo: z.array(
+    z.union([
+      z.string(),
+      // Internal subAgent ID
+      canDelegateToExternalAgentSchema,
+      // External agent with headers
+      canDelegateToTeamAgentSchema
+      // Team agent with headers
+    ])
+  ).optional()
+}).openapi("FullAgentAgentInsert");
+var AgentWithinContextOfProjectSchema = AgentApiInsertSchema.extend({
+  subAgents: z.record(z.string(), FullAgentAgentInsertSchema),
+  // Lookup maps for UI to resolve canUse items
+  tools: z.record(z.string(), ToolApiInsertSchema).optional(),
+  // MCP tools (project-scoped)
+  externalAgents: z.record(z.string(), ExternalAgentApiInsertSchema).optional(),
+  // External agents (project-scoped)
+  teamAgents: z.record(z.string(), TeamAgentSchema).optional(),
+  // Team agents contain basic metadata for the agent to be delegated to
+  functionTools: z.record(z.string(), FunctionToolApiInsertSchema).optional(),
+  // Function tools (agent-scoped)
+  functions: z.record(z.string(), FunctionApiInsertSchema).optional(),
+  // Get function code for function tools
+  contextConfig: z.optional(ContextConfigApiInsertSchema),
+  statusUpdates: z.optional(StatusUpdateSchema),
+  models: ModelSchema.optional(),
+  stopWhen: AgentStopWhenSchema.optional(),
+  prompt: z.string().max(
+    VALIDATION_AGENT_PROMPT_MAX_CHARS,
+    `Agent prompt cannot exceed ${VALIDATION_AGENT_PROMPT_MAX_CHARS} characters`
+  ).optional()
+}).openapi("AgentWithinContextOfProject");
+var PaginationSchema = z.object({
+  page: pageNumber,
+  limit: limitNumber,
+  total: z.number(),
+  pages: z.number()
+}).openapi("Pagination");
+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.any().optional().openapi({
+    description: "Additional error details"
+  })
+}).openapi("ErrorResponse");
+var ExistsResponseSchema = z.object({
+  exists: z.boolean()
+}).openapi("ExistsResponse");
+var RemovedResponseSchema = z.object({
+  message: z.string(),
+  removed: z.boolean()
+}).openapi("RemovedResponse");
+var ProjectSelectSchema = registerFieldSchemas(
+  createSelectSchema(projects).extend({
+    models: ProjectModelSchema.nullable(),
+    stopWhen: StopWhenSchema.nullable()
+  })
+);
+var ProjectInsertSchema = createInsertSchema(projects).extend({
+  models: ProjectModelSchema,
+  stopWhen: StopWhenSchema.optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ProjectUpdateSchema = ProjectInsertSchema.partial().omit({
+  id: true,
+  tenantId: true
+});
+var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true }).openapi(
+  "Project"
+);
+var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true }).openapi(
+  "ProjectCreate"
+);
+var ProjectApiUpdateSchema = ProjectUpdateSchema.openapi("ProjectUpdate");
+var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
+  agents: z.record(z.string(), AgentWithinContextOfProjectSchema),
+  tools: z.record(z.string(), ToolApiInsertSchema),
+  functionTools: z.record(z.string(), FunctionToolApiInsertSchema).optional(),
+  functions: z.record(z.string(), FunctionApiInsertSchema).optional(),
+  dataComponents: z.record(z.string(), DataComponentApiInsertSchema).optional(),
+  artifactComponents: z.record(z.string(), ArtifactComponentApiInsertSchema).optional(),
+  externalAgents: z.record(z.string(), ExternalAgentApiInsertSchema).optional(),
+  statusUpdates: z.optional(StatusUpdateSchema),
+  credentialReferences: z.record(z.string(), CredentialReferenceApiInsertSchema).optional(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+}).openapi("FullProjectDefinition");
+var ProjectResponse = z.object({ data: ProjectApiSelectSchema }).openapi("ProjectResponse");
+var SubAgentResponse = z.object({ data: SubAgentApiSelectSchema }).openapi("SubAgentResponse");
+var AgentResponse = z.object({ data: AgentApiSelectSchema }).openapi("AgentResponse");
+var ToolResponse = z.object({ data: ToolApiSelectSchema }).openapi("ToolResponse");
+var ExternalAgentResponse = z.object({ data: ExternalAgentApiSelectSchema }).openapi("ExternalAgentResponse");
+var ContextConfigResponse = z.object({ data: ContextConfigApiSelectSchema }).openapi("ContextConfigResponse");
+var ApiKeyResponse = z.object({ data: ApiKeyApiSelectSchema }).openapi("ApiKeyResponse");
+var CredentialReferenceResponse = z.object({ data: CredentialReferenceApiSelectSchema }).openapi("CredentialReferenceResponse");
+var FunctionResponse = z.object({ data: FunctionApiSelectSchema }).openapi("FunctionResponse");
+var FunctionToolResponse = z.object({ data: FunctionToolApiSelectSchema }).openapi("FunctionToolResponse");
+var DataComponentResponse = z.object({ data: DataComponentApiSelectSchema }).openapi("DataComponentResponse");
+var ArtifactComponentResponse = z.object({ data: ArtifactComponentApiSelectSchema }).openapi("ArtifactComponentResponse");
+var SubAgentRelationResponse = z.object({ data: SubAgentRelationApiSelectSchema }).openapi("SubAgentRelationResponse");
+var SubAgentToolRelationResponse = z.object({ data: SubAgentToolRelationApiSelectSchema }).openapi("SubAgentToolRelationResponse");
+var ConversationResponse = z.object({ data: ConversationApiSelectSchema }).openapi("ConversationResponse");
+var MessageResponse = z.object({ data: MessageApiSelectSchema }).openapi("MessageResponse");
+var ProjectListResponse = z.object({
+  data: z.array(ProjectApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ProjectListResponse");
+var SubAgentListResponse = z.object({
+  data: z.array(SubAgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentListResponse");
+var AgentListResponse = z.object({
+  data: z.array(AgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("AgentListResponse");
+var ToolListResponse = z.object({
+  data: z.array(ToolApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ToolListResponse");
+var ExternalAgentListResponse = z.object({
+  data: z.array(ExternalAgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ExternalAgentListResponse");
+var ContextConfigListResponse = z.object({
+  data: z.array(ContextConfigApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ContextConfigListResponse");
+var ApiKeyListResponse = z.object({
+  data: z.array(ApiKeyApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ApiKeyListResponse");
+var CredentialReferenceListResponse = z.object({
+  data: z.array(CredentialReferenceApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("CredentialReferenceListResponse");
+var FunctionListResponse = z.object({
+  data: z.array(FunctionApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("FunctionListResponse");
+var FunctionToolListResponse = z.object({
+  data: z.array(FunctionToolApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("FunctionToolListResponse");
+var DataComponentListResponse = z.object({
+  data: z.array(DataComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("DataComponentListResponse");
+var ArtifactComponentListResponse = z.object({
+  data: z.array(ArtifactComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ArtifactComponentListResponse");
+var SubAgentRelationListResponse = z.object({
+  data: z.array(SubAgentRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentRelationListResponse");
+var SubAgentToolRelationListResponse = z.object({
+  data: z.array(SubAgentToolRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentToolRelationListResponse");
+var ConversationListResponse = z.object({
+  data: z.array(ConversationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ConversationListResponse");
+var MessageListResponse = z.object({
+  data: z.array(MessageApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("MessageListResponse");
+var SubAgentDataComponentResponse = z.object({ data: SubAgentDataComponentApiSelectSchema }).openapi("SubAgentDataComponentResponse");
+var SubAgentArtifactComponentResponse = z.object({ data: SubAgentArtifactComponentApiSelectSchema }).openapi("SubAgentArtifactComponentResponse");
+var SubAgentDataComponentListResponse = z.object({
+  data: z.array(SubAgentDataComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentDataComponentListResponse");
+var SubAgentArtifactComponentListResponse = z.object({
+  data: z.array(SubAgentArtifactComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentArtifactComponentListResponse");
+var FullProjectDefinitionResponse = z.object({ data: FullProjectDefinitionSchema }).openapi("FullProjectDefinitionResponse");
+var AgentWithinContextOfProjectResponse = z.object({ data: AgentWithinContextOfProjectSchema }).openapi("AgentWithinContextOfProjectResponse");
+var RelatedAgentInfoListResponse = z.object({
+  data: z.array(RelatedAgentInfoSchema),
+  pagination: PaginationSchema
+}).openapi("RelatedAgentInfoListResponse");
+var ComponentAssociationListResponse = z.object({ data: z.array(ComponentAssociationSchema) }).openapi("ComponentAssociationListResponse");
+var McpToolResponse = z.object({ data: McpToolSchema }).openapi("McpToolResponse");
+var McpToolListResponse = z.object({
+  data: z.array(McpToolSchema),
+  pagination: PaginationSchema
+}).openapi("McpToolListResponse");
+var SubAgentTeamAgentRelationResponse = z.object({ data: SubAgentTeamAgentRelationApiSelectSchema }).openapi("SubAgentTeamAgentRelationResponse");
+var SubAgentTeamAgentRelationListResponse = z.object({
+  data: z.array(SubAgentTeamAgentRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentTeamAgentRelationListResponse");
+var SubAgentExternalAgentRelationResponse = z.object({ data: SubAgentExternalAgentRelationApiSelectSchema }).openapi("SubAgentExternalAgentRelationResponse");
+var SubAgentExternalAgentRelationListResponse = z.object({
+  data: z.array(SubAgentExternalAgentRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentExternalAgentRelationListResponse");
+var DataComponentArrayResponse = z.object({ data: z.array(DataComponentApiSelectSchema) }).openapi("DataComponentArrayResponse");
+var ArtifactComponentArrayResponse = z.object({ data: z.array(ArtifactComponentApiSelectSchema) }).openapi("ArtifactComponentArrayResponse");
+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-agent-id": z.string().optional().openapi({
+    description: "Agent identifier",
+    example: "agent_789"
+  })
+});
+var TenantId = z.string().openapi("TenantIdPathParam", {
+  param: {
+    name: "tenantId",
+    in: "path"
+  },
+  description: "Tenant identifier",
+  example: "tenant_123"
+});
+var ProjectId = z.string().openapi("ProjectIdPathParam", {
+  param: {
+    name: "projectId",
+    in: "path"
+  },
+  description: "Project identifier",
+  example: "project_456"
+});
+var AgentId = z.string().openapi("AgentIdPathParam", {
+  param: {
+    name: "agentId",
+    in: "path"
+  },
+  description: "Agent identifier",
+  example: "agent_789"
+});
+var SubAgentId = z.string().openapi("SubAgentIdPathParam", {
+  param: {
+    name: "subAgentId",
+    in: "path"
+  },
+  description: "Sub-agent identifier",
+  example: "sub_agent_123"
+});
+var TenantParamsSchema = z.object({
+  tenantId: TenantId
+});
+var TenantIdParamsSchema = TenantParamsSchema.extend({
+  id: resourceIdSchema
+});
+var TenantProjectParamsSchema = TenantParamsSchema.extend({
+  projectId: ProjectId
+});
+var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
+  id: resourceIdSchema
+});
+var TenantProjectAgentParamsSchema = TenantProjectParamsSchema.extend({
+  agentId: AgentId
+});
+var TenantProjectAgentIdParamsSchema = TenantProjectAgentParamsSchema.extend({
+  id: resourceIdSchema
+});
+var TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentParamsSchema.extend({
+  subAgentId: SubAgentId
+});
+var TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentParamsSchema.extend({
+  id: resourceIdSchema
+});
+var PaginationQueryParamsSchema = z.object({
+  page: pageNumber,
+  limit: limitNumber
+}).openapi("PaginationQueryParams");
+var PrebuiltMCPServerSchema = z.object({
+  id: z.string().describe("Unique identifier for the MCP server"),
+  name: z.string().describe("Display name of the MCP server"),
+  url: z.url().describe("URL endpoint for the MCP server"),
+  transport: z.enum(MCPTransportType).describe("Transport protocol type"),
+  imageUrl: z.url().optional().describe("Logo/icon URL for the MCP server"),
+  isOpen: z.boolean().optional().describe("Whether the MCP server is open (doesn't require authentication)"),
+  category: z.string().optional().describe("Category of the MCP server (e.g., communication, project_management)"),
+  description: z.string().optional().describe("Brief description of what the MCP server does"),
+  thirdPartyConnectAccountUrl: z.url().optional().describe("URL to connect to the third party account")
+});
+var MCPCatalogListResponse = z.object({
+  data: z.array(PrebuiltMCPServerSchema)
+}).openapi("MCPCatalogListResponse");
+var ThirdPartyMCPServerResponse = z.object({
+  data: PrebuiltMCPServerSchema.nullable()
+}).openapi("ThirdPartyMCPServerResponse");
+function validatePropsAsJsonSchema(props) {
+  if (!props || typeof props === "object" && Object.keys(props).length === 0) {
+    return {
+      isValid: true,
+      errors: []
+    };
+  }
+  if (typeof props !== "object" || Array.isArray(props)) {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props",
+          message: "Props must be a valid JSON Schema object",
+          value: props
+        }
+      ]
+    };
+  }
+  if (!props.type) {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props.type",
+          message: 'JSON Schema must have a "type" field'
+        }
+      ]
+    };
+  }
+  if (props.type !== "object") {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props.type",
+          message: 'JSON Schema type must be "object" for component props',
+          value: props.type
+        }
+      ]
+    };
+  }
+  if (!props.properties || typeof props.properties !== "object") {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props.properties",
+          message: 'JSON Schema must have a "properties" object'
+        }
+      ]
+    };
+  }
+  if (props.required !== void 0 && !Array.isArray(props.required)) {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props.required",
+          message: 'If present, "required" must be an array'
+        }
+      ]
+    };
+  }
+  try {
+    const schemaToValidate = { ...props };
+    delete schemaToValidate.$schema;
+    const schemaValidator = new Ajv({
+      strict: false,
+      // Allow unknown keywords like inPreview
+      validateSchema: true,
+      // Validate the schema itself
+      addUsedSchema: false
+      // Don't add schemas to the instance
+    });
+    const isValid = schemaValidator.validateSchema(schemaToValidate);
+    if (!isValid) {
+      const errors = schemaValidator.errors || [];
+      return {
+        isValid: false,
+        errors: errors.map((error) => ({
+          field: `props${error.instancePath || ""}`,
+          message: error.message || "Invalid schema"
+        }))
+      };
+    }
+    return {
+      isValid: true,
+      errors: []
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      errors: [
+        {
+          field: "props",
+          message: `Schema validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ]
+    };
+  }
+}
+
+export { AgentApiInsertSchema, AgentApiSelectSchema, AgentApiUpdateSchema, AgentInsertSchema, AgentListResponse, AgentResponse, AgentSelectSchema, AgentStopWhenSchema, AgentUpdateSchema, AgentWithinContextOfProjectResponse, AgentWithinContextOfProjectSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeyListResponse, ApiKeyResponse, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentArrayResponse, ArtifactComponentInsertSchema, ArtifactComponentListResponse, ArtifactComponentResponse, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, CanUseItemSchema, ComponentAssociationListResponse, ComponentAssociationSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigListResponse, ContextConfigResponse, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationListResponse, ConversationResponse, ConversationSelectSchema, ConversationUpdateSchema, CreateCredentialInStoreRequestSchema, CreateCredentialInStoreResponseSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceListResponse, CredentialReferenceResponse, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, CredentialStoreListResponseSchema, CredentialStoreSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentArrayResponse, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentListResponse, DataComponentResponse, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentListResponse, ExternalAgentResponse, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, ExternalSubAgentRelationApiInsertSchema, ExternalSubAgentRelationInsertSchema, FetchConfigSchema, FetchDefinitionSchema, FullAgentAgentInsertSchema, FullProjectDefinitionResponse, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionListResponse, FunctionResponse, FunctionSelectSchema, FunctionToolApiInsertSchema, FunctionToolApiSelectSchema, FunctionToolApiUpdateSchema, FunctionToolConfigSchema, FunctionToolInsertSchema, FunctionToolListResponse, FunctionToolResponse, FunctionToolSelectSchema, FunctionToolUpdateSchema, FunctionUpdateSchema, HeadersScopeSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPCatalogListResponse, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolListResponse, McpToolResponse, McpToolSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageListResponse, MessageResponse, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, OAuthCallbackQuerySchema, OAuthLoginQuerySchema, PaginationQueryParamsSchema, PaginationSchema, PrebuiltMCPServerSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectListResponse, ProjectModelSchema, ProjectResponse, ProjectSelectSchema, ProjectUpdateSchema, RelatedAgentInfoListResponse, RelatedAgentInfoSchema, RemovedResponseSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, StopWhenSchema, SubAgentApiInsertSchema, SubAgentApiSelectSchema, SubAgentApiUpdateSchema, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentApiSelectSchema, SubAgentArtifactComponentApiUpdateSchema, SubAgentArtifactComponentInsertSchema, SubAgentArtifactComponentListResponse, SubAgentArtifactComponentResponse, SubAgentArtifactComponentSelectSchema, SubAgentArtifactComponentUpdateSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentApiSelectSchema, SubAgentDataComponentApiUpdateSchema, SubAgentDataComponentInsertSchema, SubAgentDataComponentListResponse, SubAgentDataComponentResponse, SubAgentDataComponentSelectSchema, SubAgentDataComponentUpdateSchema, SubAgentExternalAgentRelationApiInsertSchema, SubAgentExternalAgentRelationApiSelectSchema, SubAgentExternalAgentRelationApiUpdateSchema, SubAgentExternalAgentRelationInsertSchema, SubAgentExternalAgentRelationListResponse, SubAgentExternalAgentRelationResponse, SubAgentExternalAgentRelationSelectSchema, SubAgentExternalAgentRelationUpdateSchema, SubAgentInsertSchema, SubAgentListResponse, SubAgentRelationApiInsertSchema, SubAgentRelationApiSelectSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationInsertSchema, SubAgentRelationListResponse, SubAgentRelationQuerySchema, SubAgentRelationResponse, SubAgentRelationSelectSchema, SubAgentRelationUpdateSchema, SubAgentResponse, SubAgentSelectSchema, SubAgentStopWhenSchema, SubAgentTeamAgentRelationApiInsertSchema, SubAgentTeamAgentRelationApiSelectSchema, SubAgentTeamAgentRelationApiUpdateSchema, SubAgentTeamAgentRelationInsertSchema, SubAgentTeamAgentRelationListResponse, SubAgentTeamAgentRelationResponse, SubAgentTeamAgentRelationSelectSchema, SubAgentTeamAgentRelationUpdateSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiSelectSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationInsertSchema, SubAgentToolRelationListResponse, SubAgentToolRelationResponse, SubAgentToolRelationSelectSchema, SubAgentToolRelationUpdateSchema, SubAgentUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TeamAgentSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, TenantProjectAgentSubAgentIdParamsSchema, TenantProjectAgentSubAgentParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ThirdPartyMCPServerResponse, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolListResponse, ToolResponse, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, canDelegateToExternalAgentSchema, canDelegateToTeamAgentSchema, resourceIdSchema, schemaValidationDefaults, validatePropsAsJsonSchema };