@inkeep/agents-core 0.15.0 → 0.16.1

package/dist/utils/schema-conversion.cjs

@@ -0,0 +1,236 @@
+'use strict';
+
+var zod = require('zod');
+var pino = require('pino');
+var pinoPretty = require('pino-pretty');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var pinoPretty__default = /*#__PURE__*/_interopDefault(pinoPretty);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var PinoLogger = class {
+  constructor(name, config = {}) {
+    this.name = name;
+    __publicField(this, "transportConfigs", []);
+    __publicField(this, "pinoInstance");
+    __publicField(this, "options");
+    this.options = {
+      name: this.name,
+      level: process.env.LOG_LEVEL || (process.env.ENVIRONMENT === "test" ? "silent" : "info"),
+      serializers: {
+        obj: (value) => ({ ...value })
+      },
+      redact: ["req.headers.authorization", 'req.headers["x-inkeep-admin-authentication"]'],
+      ...config.options
+    };
+    if (config.transportConfigs) {
+      this.transportConfigs = config.transportConfigs;
+    }
+    if (this.transportConfigs.length > 0) {
+      this.pinoInstance = pino__default.default(this.options, pino__default.default.transport({ targets: this.transportConfigs }));
+    } else {
+      try {
+        const prettyStream = pinoPretty__default.default({
+          colorize: true,
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname"
+        });
+        this.pinoInstance = pino__default.default(this.options, prettyStream);
+      } catch (error) {
+        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
+        this.pinoInstance = pino__default.default(this.options);
+      }
+    }
+  }
+  /**
+   * Recreate the pino instance with current transports
+   */
+  recreateInstance() {
+    if (this.pinoInstance && typeof this.pinoInstance.flush === "function") {
+      this.pinoInstance.flush();
+    }
+    if (this.transportConfigs.length === 0) {
+      try {
+        const prettyStream = pinoPretty__default.default({
+          colorize: true,
+          translateTime: "HH:MM:ss",
+          ignore: "pid,hostname"
+        });
+        this.pinoInstance = pino__default.default(this.options, prettyStream);
+      } catch (error) {
+        console.warn("Warning: pino-pretty failed, using standard JSON output:", error);
+        this.pinoInstance = pino__default.default(this.options);
+      }
+    } else {
+      const multiTransport = { targets: this.transportConfigs };
+      const pinoTransport = pino__default.default.transport(multiTransport);
+      this.pinoInstance = pino__default.default(this.options, pinoTransport);
+    }
+  }
+  /**
+   * Add a new transport to the logger
+   */
+  addTransport(transportConfig) {
+    this.transportConfigs.push(transportConfig);
+    this.recreateInstance();
+  }
+  /**
+   * Remove a transport by index
+   */
+  removeTransport(index) {
+    if (index >= 0 && index < this.transportConfigs.length) {
+      this.transportConfigs.splice(index, 1);
+      this.recreateInstance();
+    }
+  }
+  /**
+   * Get current transports
+   */
+  getTransports() {
+    return [...this.transportConfigs];
+  }
+  /**
+   * Update logger options
+   */
+  updateOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+    this.recreateInstance();
+  }
+  /**
+   * Get the underlying pino instance for advanced usage
+   */
+  getPinoInstance() {
+    return this.pinoInstance;
+  }
+  error(data, message) {
+    this.pinoInstance.error(data, message);
+  }
+  warn(data, message) {
+    this.pinoInstance.warn(data, message);
+  }
+  info(data, message) {
+    this.pinoInstance.info(data, message);
+  }
+  debug(data, message) {
+    this.pinoInstance.debug(data, message);
+  }
+};
+var LoggerFactory = class {
+  constructor() {
+    __publicField(this, "config", {});
+    __publicField(this, "loggers", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Configure the logger factory
+   */
+  configure(config) {
+    this.config = config;
+    this.loggers.clear();
+  }
+  /**
+   * Get or create a logger instance
+   */
+  getLogger(name) {
+    if (this.loggers.has(name)) {
+      const logger3 = this.loggers.get(name);
+      if (!logger3) {
+        throw new Error(`Logger '${name}' not found in cache`);
+      }
+      return logger3;
+    }
+    let logger2;
+    if (this.config.loggerFactory) {
+      logger2 = this.config.loggerFactory(name);
+    } else if (this.config.defaultLogger) {
+      logger2 = this.config.defaultLogger;
+    } else {
+      logger2 = new PinoLogger(name, this.config.pinoConfig);
+    }
+    this.loggers.set(name, logger2);
+    return logger2;
+  }
+  /**
+   * Reset factory to default state
+   */
+  reset() {
+    this.config = {};
+    this.loggers.clear();
+  }
+};
+var loggerFactory = new LoggerFactory();
+function getLogger(name) {
+  return loggerFactory.getLogger(name);
+}
+
+// src/utils/schema-conversion.ts
+var logger = getLogger("schema-conversion");
+function convertZodToJsonSchema(zodSchema) {
+  try {
+    const jsonSchema = zod.z.toJSONSchema(zodSchema);
+    if (jsonSchema.$schema) {
+      delete jsonSchema.$schema;
+    }
+    return jsonSchema;
+  } catch (error) {
+    logger.error(
+      {
+        error: error instanceof Error ? error.message : "Unknown error",
+        stack: error instanceof Error ? error.stack : void 0
+      },
+      "Failed to convert Zod schema to JSON Schema"
+    );
+    throw new Error("Failed to convert Zod schema to JSON Schema");
+  }
+}
+var preview = (schema) => {
+  schema._def.inPreview = true;
+  return schema;
+};
+function convertZodToJsonSchemaWithPreview(zodSchema) {
+  const jsonSchema = convertZodToJsonSchema(zodSchema);
+  if (zodSchema instanceof zod.z.ZodObject && jsonSchema.properties) {
+    const shape = zodSchema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (fieldSchema?._def?.inPreview === true) {
+        jsonSchema.properties[key].inPreview = true;
+      }
+    }
+  }
+  return jsonSchema;
+}
+function isZodSchema(value) {
+  return value?._def?.type === "object";
+}
+function extractPreviewFields(schema) {
+  const previewFields = [];
+  if (schema instanceof zod.z.ZodObject) {
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      if (fieldSchema?._def?.inPreview === true) {
+        previewFields.push(key);
+      }
+    }
+    return previewFields;
+  }
+  if (schema?.type === "object" && schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (prop.inPreview === true) {
+        previewFields.push(key);
+      }
+    }
+  }
+  return previewFields;
+}
+
+exports.convertZodToJsonSchema = convertZodToJsonSchema;
+exports.convertZodToJsonSchemaWithPreview = convertZodToJsonSchemaWithPreview;
+exports.extractPreviewFields = extractPreviewFields;
+exports.isZodSchema = isZodSchema;
+exports.preview = preview;

package/dist/utils/schema-conversion.d.cts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+/**
+ * Utility function for converting Zod schemas to JSON Schema
+ * Uses Zod's built-in toJSONSchema method
+ */
+declare function convertZodToJsonSchema(zodSchema: any): Record<string, unknown>;
+/**
+ * Simple helper to mark a Zod schema field as a preview field
+ * Adds metadata to the schema definition without modifying Zod's core
+ */
+declare const preview: <T extends z.ZodTypeAny>(schema: T) => T;
+/**
+ * Convert Zod schema to JSON Schema while preserving preview metadata
+ */
+declare function convertZodToJsonSchemaWithPreview(zodSchema: z.ZodTypeAny): Record<string, unknown>;
+/**
+ * Type guard to check if a value is a Zod schema
+ */
+declare function isZodSchema(value: any): value is z.ZodObject<any>;
+/**
+ * Extract preview fields from either JSON Schema or Zod schema
+ */
+declare function extractPreviewFields(schema: any): string[];
+
+export { convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, isZodSchema, preview };

package/dist/utils/schema-conversion.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+/**
+ * Utility function for converting Zod schemas to JSON Schema
+ * Uses Zod's built-in toJSONSchema method
+ */
+declare function convertZodToJsonSchema(zodSchema: any): Record<string, unknown>;
+/**
+ * Simple helper to mark a Zod schema field as a preview field
+ * Adds metadata to the schema definition without modifying Zod's core
+ */
+declare const preview: <T extends z.ZodTypeAny>(schema: T) => T;
+/**
+ * Convert Zod schema to JSON Schema while preserving preview metadata
+ */
+declare function convertZodToJsonSchemaWithPreview(zodSchema: z.ZodTypeAny): Record<string, unknown>;
+/**
+ * Type guard to check if a value is a Zod schema
+ */
+declare function isZodSchema(value: any): value is z.ZodObject<any>;
+/**
+ * Extract preview fields from either JSON Schema or Zod schema
+ */
+declare function extractPreviewFields(schema: any): string[];
+
+export { convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, isZodSchema, preview };

package/dist/utils/schema-conversion.js

@@ -0,0 +1 @@
+export { convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, isZodSchema, preview } from '../chunk-R2EERZSW.js';

package/dist/validation/index.cjs

@@ -4,6 +4,11 @@ var zodOpenapi = require('@hono/zod-openapi');
 var drizzleZod = require('drizzle-zod');
 var drizzleOrm = require('drizzle-orm');
 var sqliteCore = require('drizzle-orm/sqlite-core');
+var Ajv = require('ajv');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 
 // src/validation/schemas.ts
 var tenantScoped = {
@@ -39,6 +44,8 @@ var projects = sqliteCore.sqliteTable(
     models: sqliteCore.text("models", { mode: "json" }).$type(),
     // Project-level stopWhen configuration that can be inherited by graphs and agents
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    // Project-level sandbox configuration for function execution
+    sandboxConfig: sqliteCore.text("sandbox_config", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
@@ -76,9 +83,8 @@ var contextConfigs = sqliteCore.sqliteTable(
   "context_configs",
   {
     ...graphScoped,
-    ...uiProperties,
     // Developer-defined Zod schema for validating incoming request context
-    requestContextSchema: sqliteCore.blob("request_context_schema", { mode: "json" }).$type(),
+    headersSchema: sqliteCore.blob("headers_schema", { mode: "json" }).$type(),
     // Stores serialized Zod schema
     // Object mapping template keys to fetch definitions that use request context data
     contextVariables: sqliteCore.blob("context_variables", { mode: "json" }).$type(),
@@ -285,8 +291,7 @@ var artifactComponents = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     ...uiProperties,
-    summaryProps: sqliteCore.blob("summary_props", { mode: "json" }).$type(),
-    fullProps: sqliteCore.blob("full_props", { mode: "json" }).$type(),
+    props: sqliteCore.blob("props", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [
@@ -332,13 +337,16 @@ var tools = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
-    // Enhanced MCP configuration
+    description: sqliteCore.text("description"),
+    // Tool configuration - supports both MCP and function tools
     config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
+    // For function tools, reference the global functions table
+    functionId: sqliteCore.text("function_id"),
     credentialReferenceId: sqliteCore.text("credential_reference_id"),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
     // Image URL for custom tool icon (supports regular URLs and base64 encoded images)
     imageUrl: sqliteCore.text("image_url"),
-    // Server capabilities and status
+    // Server capabilities and status (only for MCP tools)
     capabilities: sqliteCore.blob("capabilities", { mode: "json" }).$type(),
     lastError: sqliteCore.text("last_error"),
     ...timestamps
@@ -349,6 +357,30 @@ var tools = sqliteCore.sqliteTable(
       columns: [table.tenantId, table.projectId],
       foreignColumns: [projects.tenantId, projects.id],
       name: "tools_project_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to functions table (for function tools)
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.functionId],
+      foreignColumns: [functions.tenantId, functions.projectId, functions.id],
+      name: "tools_function_fk"
+    }).onDelete("cascade")
+  ]
+);
+var functions = sqliteCore.sqliteTable(
+  "functions",
+  {
+    ...projectScoped,
+    inputSchema: sqliteCore.blob("input_schema", { mode: "json" }).$type(),
+    executeCode: sqliteCore.text("execute_code").notNull(),
+    dependencies: sqliteCore.blob("dependencies", { mode: "json" }).$type(),
+    ...timestamps
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "functions_project_fk"
     }).onDelete("cascade")
   ]
 );
@@ -683,6 +715,10 @@ drizzleOrm.relations(tools, ({ one, many }) => ({
   credentialReference: one(credentialReferences, {
     fields: [tools.credentialReferenceId],
     references: [credentialReferences.id]
+  }),
+  function: one(functions, {
+    fields: [tools.functionId],
+    references: [functions.id]
   })
 }));
 drizzleOrm.relations(conversations, ({ one, many }) => ({
@@ -780,6 +816,9 @@ drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
     references: [tasks.id]
   })
 }));
+drizzleOrm.relations(functions, ({ many }) => ({
+  tools: many(tools)
+}));
 drizzleOrm.relations(agentRelations, ({ one }) => ({
   graph: one(agentGraph, {
     fields: [agentRelations.graphId],
@@ -848,6 +887,19 @@ var ProjectModelSchema = zodOpenapi.z.object({
   structuredOutput: ModelSettingsSchema.optional(),
   summarizer: ModelSettingsSchema.optional()
 });
+var SandboxConfigSchema = zodOpenapi.z.object({
+  provider: zodOpenapi.z.enum(["vercel", "local"]),
+  runtime: zodOpenapi.z.enum(["node22", "typescript"]),
+  timeout: zodOpenapi.z.number().min(1e3).max(3e5).optional(),
+  vcpus: zodOpenapi.z.number().min(1).max(8).optional()
+});
+var FunctionToolConfigSchema = zodOpenapi.z.object({
+  name: zodOpenapi.z.string(),
+  description: zodOpenapi.z.string(),
+  inputSchema: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()),
+  dependencies: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).optional(),
+  execute: zodOpenapi.z.union([zodOpenapi.z.function(), zodOpenapi.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();
@@ -984,7 +1036,33 @@ var McpToolDefinitionSchema = zodOpenapi.z.object({
 var ToolSelectSchema = drizzleZod.createSelectSchema(tools);
 var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
   id: resourceIdSchema,
-  imageUrl: imageUrlSchema
+  imageUrl: imageUrlSchema,
+  functionId: resourceIdSchema.optional(),
+  // For function tools, reference to global functions table
+  config: zodOpenapi.z.discriminatedUnion("type", [
+    // MCP tools
+    zodOpenapi.z.object({
+      type: zodOpenapi.z.literal("mcp"),
+      mcp: zodOpenapi.z.object({
+        server: zodOpenapi.z.object({
+          url: zodOpenapi.z.string().url()
+        }),
+        transport: zodOpenapi.z.object({
+          type: zodOpenapi.z.enum(MCPTransportType),
+          requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+          eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+          reconnectionOptions: zodOpenapi.z.custom().optional(),
+          sessionId: zodOpenapi.z.string().optional()
+        }).optional(),
+        activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
+      })
+    }),
+    // Function tools (reference-only, no inline duplication)
+    zodOpenapi.z.object({
+      type: zodOpenapi.z.literal("function")
+      // No inline function details - they're in the functions table via functionId
+    })
+  ])
 });
 var ConversationSelectSchema = drizzleZod.createSelectSchema(conversations);
 var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).extend({
@@ -1194,6 +1272,14 @@ var ToolUpdateSchema = ToolInsertSchema.partial();
 var ToolApiSelectSchema = createApiSchema(ToolSelectSchema);
 var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
 var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema);
+var FunctionSelectSchema = drizzleZod.createSelectSchema(functions);
+var FunctionInsertSchema = drizzleZod.createInsertSchema(functions).extend({
+  id: resourceIdSchema
+});
+var FunctionUpdateSchema = FunctionInsertSchema.partial();
+var FunctionApiSelectSchema = createApiSchema(FunctionSelectSchema);
+var FunctionApiInsertSchema = createApiInsertSchema(FunctionInsertSchema);
+var FunctionApiUpdateSchema = createApiUpdateSchema(FunctionUpdateSchema);
 var FetchConfigSchema = zodOpenapi.z.object({
   url: zodOpenapi.z.string().min(1, "URL is required"),
   method: zodOpenapi.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default("GET"),
@@ -1214,11 +1300,11 @@ var FetchDefinitionSchema = zodOpenapi.z.object({
   credential: CredentialReferenceApiInsertSchema.optional()
 });
 var ContextConfigSelectSchema = drizzleZod.createSelectSchema(contextConfigs).extend({
-  requestContextSchema: zodOpenapi.z.unknown().optional()
+  headersSchema: zodOpenapi.z.unknown().optional()
 });
 var ContextConfigInsertSchema = drizzleZod.createInsertSchema(contextConfigs).extend({
-  id: resourceIdSchema,
-  requestContextSchema: zodOpenapi.z.unknown().optional()
+  id: resourceIdSchema.optional(),
+  headersSchema: zodOpenapi.z.unknown().optional()
 }).omit({
   createdAt: true,
   updatedAt: true
@@ -1282,6 +1368,7 @@ var CanUseItemSchema = zodOpenapi.z.object({
 var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
   type: zodOpenapi.z.literal("internal"),
   canUse: zodOpenapi.z.array(CanUseItemSchema),
+  // All tools (both MCP and function tools)
   dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   artifactComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
@@ -1289,9 +1376,11 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
 });
 var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
   agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
-  // Removed project-scoped resources - these are now managed at project level:
-  // tools, credentialReferences, dataComponents, artifactComponents
-  // Agent relationships to these resources are maintained via agent.tools, agent.dataComponents, etc.
+  // Lookup maps for UI to resolve canUse items
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
+  // Get tool name/description from toolId
+  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
+  // Get function code for function tools
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
@@ -1340,7 +1429,8 @@ var RemovedResponseSchema = zodOpenapi.z.object({
 var ProjectSelectSchema = drizzleZod.createSelectSchema(projects);
 var ProjectInsertSchema = drizzleZod.createInsertSchema(projects).extend({
   models: ProjectModelSchema,
-  stopWhen: StopWhenSchema.optional()
+  stopWhen: StopWhenSchema.optional(),
+  sandboxConfig: SandboxConfigSchema.optional()
 }).omit({
   createdAt: true,
   updatedAt: true
@@ -1352,6 +1442,9 @@ var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
 var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
   graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
+  // Now includes both MCP and function tools
+  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
+  // Global functions
   dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
@@ -1574,6 +1667,108 @@ function generateIdFromName(name) {
   }
   return truncatedId;
 }
+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__default.default({
+      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"}`
+        }
+      ]
+    };
+  }
+}
 
 exports.AgentApiInsertSchema = AgentApiInsertSchema;
 exports.AgentApiSelectSchema = AgentApiSelectSchema;
@@ -1674,6 +1869,13 @@ exports.FetchDefinitionSchema = FetchDefinitionSchema;
 exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
 exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
+exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
+exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
+exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
+exports.FunctionInsertSchema = FunctionInsertSchema;
+exports.FunctionSelectSchema = FunctionSelectSchema;
+exports.FunctionToolConfigSchema = FunctionToolConfigSchema;
+exports.FunctionUpdateSchema = FunctionUpdateSchema;
 exports.GraphStopWhenSchema = GraphStopWhenSchema;
 exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
 exports.HeadersScopeSchema = HeadersScopeSchema;
@@ -1709,6 +1911,7 @@ exports.ProjectModelSchema = ProjectModelSchema;
 exports.ProjectSelectSchema = ProjectSelectSchema;
 exports.ProjectUpdateSchema = ProjectUpdateSchema;
 exports.RemovedResponseSchema = RemovedResponseSchema;
+exports.SandboxConfigSchema = SandboxConfigSchema;
 exports.SingleResponseSchema = SingleResponseSchema;
 exports.StatusComponentSchema = StatusComponentSchema;
 exports.StatusUpdateSchema = StatusUpdateSchema;
@@ -1749,4 +1952,5 @@ exports.validateAndTypeGraphData = validateAndTypeGraphData;
 exports.validateArtifactComponentReferences = validateArtifactComponentReferences;
 exports.validateDataComponentReferences = validateDataComponentReferences;
 exports.validateGraphStructure = validateGraphStructure;
+exports.validatePropsAsJsonSchema = validatePropsAsJsonSchema;
 exports.validateToolReferences = validateToolReferences;