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

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-YECQCT5N.js';