@ai.ntellect/core 0.6.17 → 0.6.20

package/utils/generate-object.ts

@@ -1,117 +0,0 @@
-import { CoreMessage, LanguageModelV1, generateText } from "ai";
-import { z } from "zod";
-
-export const describeZodSchema = (schema: z.ZodType): string => {
-  if (schema instanceof z.ZodObject) {
-    const entries = Object.entries(schema.shape);
-    const fields = entries.map(([key, value]) => {
-      const description = (value as any)._def.description || "";
-      const fieldSchema = describeZodSchema(value as z.ZodType);
-      return description
-        ? `${key}: ${fieldSchema} // ${description}`
-        : `${key}: ${fieldSchema}`;
-    });
-    return `z.object({${fields.join(", ")}})`;
-  }
-
-  if (schema instanceof z.ZodArray) {
-    return `z.array(${describeZodSchema(schema.element)})`;
-  }
-
-  if (schema instanceof z.ZodString) {
-    return "z.string()";
-  }
-
-  if (schema instanceof z.ZodNumber) {
-    return "z.number()";
-  }
-
-  if (schema instanceof z.ZodBoolean) {
-    return "z.boolean()";
-  }
-
-  if (schema instanceof z.ZodOptional) {
-    return `z.optional(${describeZodSchema(schema._def.innerType)})`;
-  }
-
-  if (schema instanceof z.ZodUnion) {
-    return `z.union([${schema._def.options
-      .map((option: z.ZodType) => describeZodSchema(option))
-      .join(", ")}])`;
-  }
-
-  if (schema instanceof z.ZodEnum) {
-    return `z.enum(${JSON.stringify(schema._def.values)})`;
-  }
-
-  if (schema instanceof z.ZodLiteral) {
-    return `z.literal(${JSON.stringify(schema._def.value)})`;
-  }
-
-  return "z.unknown()"; // Fallback for unknown types
-};
-
-export const generateObject = async <T>(config: {
-  model: LanguageModelV1;
-  schema: z.ZodSchema;
-  system: string;
-  temperature: number;
-  prompt?: string;
-  messages?: CoreMessage[];
-}): Promise<{ object: T }> => {
-  // Generate a detailed description of the schema
-  const schemaDescription = describeZodSchema(config.schema);
-
-  const baseContext = `
-  ${config.system}
-  EXPECTED SCHEMA:
-  ${schemaDescription}
-  
-  BAD EXAMPLE:
-  \`\`\`json
-  {
-    "key": "value"
-  }
-  \`\`\`
-
-  GOOD EXAMPLE:
-  {
-    "key": "value"
-  }
-
-  OUTPUT ONLY THE JSON SCHEMA, NO 'TRIPLE QUOTES'JSON OR ANY OTHER TEXT. ONLY THE JSON SCHEMA.
-  `;
-
-  console.log("🔍 Generating object with context:");
-  console.log(`${config.prompt}\n${baseContext}\n`);
-  const response = await generateText({
-    model: config.model,
-    messages: !config.prompt
-      ? [
-          {
-            role: "system",
-            content: baseContext,
-          },
-          ...(config.messages ?? []),
-        ]
-      : undefined,
-    system: config.system,
-    temperature: config.temperature,
-    prompt: !config.prompt ? undefined : `${config.prompt}\n\n${baseContext}`,
-  });
-
-  try {
-    // Clean the response text from any markdown or code block markers
-    const cleanText = response.text
-      .replace(/```json\s*/g, "")
-      .replace(/```\s*$/g, "")
-      .trim();
-
-    const parsedResponse = JSON.parse(cleanText);
-    const validatedResponse = config.schema.parse(parsedResponse);
-    return { object: validatedResponse as T };
-  } catch (error) {
-    console.error("Error parsing or validating JSON response:", error);
-    throw new Error("Failed to generate valid JSON response");
-  }
-};

package/utils/inject-actions.ts

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import { ActionSchema } from "../types";
-
-export const injectActions = (actions: ActionSchema[]) => {
-  return actions.map((action) => {
-    const parameters = action.parameters as z.ZodObject<any>;
-    const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-    const actionString = `* ${action.name}( { ${schemaShape} }) (${
-      action.description
-    }) ${
-      action.examples
-        ? `Eg: ${action.examples.map((example: any) => {
-            return JSON.stringify(example);
-          })}`
-        : ""
-    }`;
-    return actionString;
-  });
-};

package/utils/queue-item-transformer.ts

@@ -1,38 +0,0 @@
-import { QueueItem, QueueItemParameter, QueueResult } from "../types";
-
-export class QueueItemTransformer {
-  static transformActionToQueueItem(action: {
-    name: string;
-    parameters: Record<string, any>;
-  }): QueueItem {
-    return {
-      name: action.name || "",
-      parameters: QueueItemTransformer.transformParameters(
-        action.parameters || {}
-      ),
-    };
-  }
-
-  static transformFromSimilarActions(
-    similarActions: QueueResult[]
-  ): QueueItem[] | undefined {
-    return similarActions?.map((action: QueueResult) =>
-      QueueItemTransformer.transformActionToQueueItem(action)
-    );
-  }
-
-  private static transformParameters(
-    parameters: Record<string, any>
-  ): QueueItemParameter[] {
-    return Object.entries(parameters).map(([name, value]) => ({
-      name,
-      value: typeof value === "object" ? JSON.stringify(value) : String(value),
-    }));
-  }
-
-  static transformActionsToQueueItems(
-    actions: { name: string; parameters: Record<string, any> }[] | undefined
-  ): QueueItem[] | undefined {
-    return actions?.map((action) => this.transformActionToQueueItem(action));
-  }
-}

package/utils/sanitize-results.ts

@@ -1,66 +0,0 @@
-/**
- * Utility class to sanitize JSON results for evaluation
- */
-export class ResultSanitizer {
-  /**
-   * Sanitizes JSON results by removing special characters and formatting
-   * @param results - The results to sanitize
-   * @returns Sanitized string
-   */
-  static sanitize(results: any): string {
-    if (!results) return "";
-
-    try {
-      const jsonString = JSON.stringify(results);
-      return (
-        jsonString
-          // Basic cleanup
-          .replace(/\\n/g, " ") // Remove newlines
-          .replace(/\s+/g, " ") // Remove extra spaces
-          .replace(/\\"/g, '"') // Fix escaped quotes
-          .replace(/\\+/g, "") // Remove extra backslashes
-
-          // Remove unnecessary quotes around objects and arrays
-          .replace(/"\[/g, "[") // Remove quotes around arrays start
-          .replace(/\]"/g, "]") // Remove quotes around arrays end
-          .replace(/"{/g, "{") // Remove quotes around objects start
-          .replace(/}"/g, "}") // Remove quotes around objects end
-
-          // Clean up numbers and values
-          .replace(/"(\d+\.?\d*)"/g, "$1") // Remove quotes around numbers
-          .replace(/:\s*"(true|false|null)"/g, ": $1") // Remove quotes around booleans and null
-
-          // Clean up URLs and content
-          .replace(
-            /(?<=content":")([^"]+)(?=")/g,
-            (match) => match.trim().replace(/\s+/g, " ") // Clean content spacing
-          )
-          .replace(
-            /(?<=link":")([^"]+)(?=")/g,
-            (match) => match.replace(/&amp;/g, "&") // Fix URL encodings
-          )
-
-          // Final cleanup
-          .replace(/,\s*([}\]])/g, "$1") // Remove trailing commas
-          .replace(/:\s+/g, ":") // Remove spaces after colons
-          .replace(/,\s+/g, ",") // Remove spaces after commas
-          .trim()
-      ); // Remove leading/trailing whitespace
-    } catch (error) {
-      console.error("Error sanitizing results:", error);
-      return String(results);
-    }
-  }
-
-  /**
-   * Formats numbers to a consistent format
-   * @param value - The number to format
-   * @returns Formatted number string
-   */
-  private static formatNumber(value: number): string {
-    return value.toLocaleString("en-US", {
-      maximumFractionDigits: 2,
-      useGrouping: false,
-    });
-  }
-}