alchemy 0.62.2 → 0.63.0

package/src/ai/ark.ts

@@ -1,118 +0,0 @@
-import {
-  type Tool as AITool,
-  type Schema,
-  type ToolExecutionOptions,
-  tool as aitool,
-  jsonSchema,
-} from "ai";
-import { ArkErrors, type JsonSchema, type type } from "arktype";
-
-export namespace ark {
-  export function schema<T>(type: JsonSchema): Schema<T>;
-  export function schema<T extends type>(type: T): Schema<type.infer<T>> {
-    const jsonSchemaObj = type.toJsonSchema() as any;
-    const processedSchema = processSchema(jsonSchemaObj);
-
-    return jsonSchema(processedSchema, {
-      validate: (value) => {
-        const out = type(value) as type.infer<T> | type.errors;
-        if (out instanceof ArkErrors) {
-          return {
-            success: false,
-            error: new Error(out.summary),
-          };
-        }
-        return {
-          success: true,
-          value: out,
-        };
-      },
-    });
-  }
-
-  /**
-   * Recursively processes a JSON schema and sets additionalProperties: false
-   * for any object types.
-   *
-   * Structured Outputs requires additionalProperties: false
-   */
-  function processSchema(schema: any): any {
-    if (!schema || typeof schema !== "object") return schema;
-
-    // Create a copy to avoid mutating the original
-    const result = { ...schema };
-
-    // Convert anyOf with all const values to enum
-    if (result.anyOf && Array.isArray(result.anyOf)) {
-      const allConst = result.anyOf.every(
-        (item: any) => item && typeof item === "object" && "const" in item,
-      );
-
-      if (allConst) {
-        // Extract all const values
-        const enumValues = result.anyOf.map((item: any) => item.const);
-
-        // Determine the type based on the first const value
-        // Assuming all const values are of the same type
-        const firstType = typeof enumValues[0];
-
-        // Replace anyOf with enum
-        delete result.anyOf;
-        result.type = firstType;
-        result.enum = enumValues;
-      } else {
-        // Process each item in anyOf
-        result.anyOf = result.anyOf.map(processSchema);
-      }
-    }
-
-    // If this is an object type, set additionalProperties: false
-    if (result.type === "object") {
-      result.additionalProperties = false;
-      result.properties ??= {};
-    }
-
-    // Process properties of objects
-    if (result.properties && typeof result.properties === "object") {
-      result.properties = Object.fromEntries(
-        Object.entries(result.properties).map(([key, value]) => [
-          key,
-          processSchema(value),
-        ]),
-      );
-    }
-
-    // Process items in arrays
-    if (result.items) {
-      result.items = processSchema(result.items);
-    }
-
-    // Process allOf, oneOf
-    for (const key of ["allOf", "oneOf"]) {
-      if (Array.isArray(result[key])) {
-        result[key] = result[key].map(processSchema);
-      }
-    }
-
-    return result;
-  }
-
-  export interface Tool<Input extends type, Output>
-    extends Omit<AITool<Schema<type.infer<Input>>>, "parameters" | "execute"> {
-    description?: string;
-    parameters: Input;
-    execute: (
-      input: type.infer<Input>,
-      options: ToolExecutionOptions,
-    ) => Promise<Output>;
-  }
-
-  export function tool<Input extends type, Output>(
-    tool: Tool<Input, Output>,
-  ): AITool<Schema<type.infer<Input>>, Output> {
-    return aitool({
-      ...tool,
-      parameters: ark.schema<Input>(tool.parameters),
-    } as any);
-  }
-}

package/src/ai/astro-file.ts

@@ -1,270 +0,0 @@
-import { generateText } from "ai";
-import prettier from "prettier";
-import type { Context } from "../context.ts";
-import { StaticAstroFile } from "../fs/static-astro-file.ts";
-import { Resource } from "../resource.ts";
-import type { Secret } from "../secret.ts";
-import { logger } from "../util/logger.ts";
-import { type ModelConfig, createModel } from "./client.ts";
-
-/**
- * Properties for creating or updating an AstroFile
- */
-export interface AstroFileProps {
-  /**
-   * Path to the Astro file
-   */
-  path: string;
-
-  /**
-   * Base URL for the OpenAI API
-   * @default 'https://api.openai.com/v1'
-   */
-  baseURL?: string;
-
-  /**
-   * Prompt for generating content
-   * Use alchemy template literals to include file context:
-   * @example
-   * prompt: await alchemy`
-   *   Generate an Astro component using:
-   *   ${alchemy.file("src/types.ts")}
-   * `
-   */
-  prompt: string;
-
-  /**
-   * System prompt for the model
-   * This is used to provide instructions to the model about how to format the response
-   * The default system prompt instructs the model to return Astro code inside ```astro fences
-   * @default "You are an Astro component generator. Create Astro components based on the user's requirements. Your response MUST include only Astro code inside ```astro fences. Do not include any other text, explanations, or multiple code blocks."
-   */
-  system?: string;
-
-  /**
-   * OpenAI API key to use for generating content
-   * If not provided, will use OPENAI_API_KEY environment variable
-   */
-  apiKey?: Secret;
-
-  /**
-   * Model configuration
-   */
-  model?: ModelConfig;
-
-  /**
-   * Temperature for controlling randomness in generation.
-   * Higher values (e.g., 0.8) make output more random,
-   * lower values (e.g., 0.2) make it more deterministic.
-   * @default 0.7
-   */
-  temperature?: number;
-
-  /**
-   * Prettier configuration to use for formatting the Astro code
-   * If not provided, will use the default Prettier configuration
-   */
-  prettierConfig?: prettier.Options;
-}
-
-/**
- * An Astro file that can be created, updated, and deleted
- */
-export interface AstroFile extends AstroFileProps, Resource<"ai::AstroFile"> {
-  /**
-   * Content of the Astro file
-   */
-  content: string;
-
-  /**
-   * Time at which the file was created
-   */
-  createdAt: number;
-
-  /**
-   * Time at which the file was last updated
-   */
-  updatedAt: number;
-}
-
-/**
- * Default system prompt for Astro file generation
- */
-const DEFAULT_ASTRO_SYSTEM_PROMPT =
-  "You are an Astro component generator. Create Astro components based on the user's requirements. Your response MUST include only Astro code inside ```astro fences. Do not include any other text, explanations, or multiple code blocks.";
-
-/**
- * Resource for generating Astro files using AI models.
- * Extracts Astro code from between ```astro fences, validates the response,
- * and formats the code with Prettier.
- *
- * @example
- * // Create a simple Astro component
- * const header = await AstroFile("header", {
- *   path: "./src/components/Header.astro",
- *   prompt: await alchemy`
- *     Generate an Astro header component with:
- *     - Site logo
- *     - Navigation menu with Home, About, Services, Contact links
- *     - Mobile responsive design
- *     - Dark/light mode toggle
- *   `,
- *   model: {
- *     id: "gpt-4o",
- *     provider: "openai"
- *   }
- * });
- *
- * @example
- * // Generate an Astro page with data fetching
- * const blogPost = await AstroFile("blog-post", {
- *   path: "./src/pages/blog/[slug].astro",
- *   prompt: await alchemy`
- *     Create an Astro blog post page that:
- *     - Uses getStaticPaths to generate pages from a CMS
- *     - Renders markdown content
- *     - Includes author info, publication date, and related posts
- *     - Has social sharing buttons
- *
- *     Use the following types:
- *     ${alchemy.file("src/types/Blog.ts")}
- *   `,
- *   temperature: 0.2,
- *   prettierConfig: {
- *     semi: false,
- *     singleQuote: true,
- *     printWidth: 120
- *   }
- * });
- *
- * @example
- * // Generate a layout with custom system prompt
- * const mainLayout = await AstroFile("main-layout", {
- *   path: "./src/layouts/MainLayout.astro",
- *   prompt: await alchemy`
- *     Create the main layout for an Astro site that:
- *     - Includes common head metadata and SEO optimization
- *     - Has slots for page content, header, and footer
- *     - Imports and uses the Header and Footer components
- *     - Sets up viewport and responsive configurations
- *   `,
- *   system: "You are an expert Astro developer. Create a single Astro layout file inside ```astro fences with no additional text. Follow Astro best practices and include proper typing in the frontmatter section.",
- *   model: {
- *     id: "claude-3-opus-20240229",
- *     provider: "anthropic"
- *   }
- * });
- */
-export const AstroFile = Resource(
-  "ai::AstroFile",
-  async function (
-    this: Context<AstroFile>,
-    _id: string,
-    props: AstroFileProps,
-  ): Promise<AstroFile> {
-    // Handle deletion phase
-    if (this.phase === "delete") {
-      return this.destroy();
-    }
-
-    // Use provided system prompt or default
-    const system = props.system || DEFAULT_ASTRO_SYSTEM_PROMPT;
-
-    // Generate initial content
-    const { text } = await generateText({
-      model: createModel(props),
-      prompt: props.prompt,
-      system,
-      providerOptions: props.model?.options,
-      ...(props.temperature === undefined
-        ? {}
-        : { temperature: props.temperature }),
-    });
-
-    // Extract and validate Astro code
-    let { code, error } = await extractAstroCode(text);
-
-    // Re-prompt if there are validation errors
-    if (error) {
-      const errorSystem = `${system}\n\nERROR: ${error}\n\nPlease try again and ensure your response contains exactly one Astro code block inside \`\`\`astro fences.`;
-
-      const { text: retryText } = await generateText({
-        model: createModel(props),
-        prompt: props.prompt,
-        system: errorSystem,
-        providerOptions: props.model?.options,
-        ...(props.temperature === undefined
-          ? {}
-          : { temperature: props.temperature }),
-      });
-
-      const retryResult = await extractAstroCode(retryText);
-
-      if (retryResult.error) {
-        throw new Error(
-          `Failed to generate valid Astro code: ${retryResult.error}`,
-        );
-      }
-
-      code = retryResult.code;
-    }
-
-    // Format the code with Prettier
-    try {
-      // Set default parser to astro
-      const prettierOptions: prettier.Options = {
-        parser: "astro",
-        ...props.prettierConfig,
-      };
-
-      // Format the code
-      code = await prettier.format(code, prettierOptions);
-    } catch (error) {
-      // If Prettier formatting fails, just use the unformatted code
-      logger.warn("Failed to format Astro code with Prettier:", error);
-    }
-
-    // Use StaticAstroFile to create/update the file
-    const file = await StaticAstroFile("file", props.path, code);
-
-    // Return the resource
-    return this({
-      ...props,
-      content: file.content,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-    });
-  },
-);
-
-/**
- * Extracts Astro code from between ```astro fences
- * Validates that exactly one Astro code block exists
- *
- * @param text The text to extract Astro code from
- * @returns The extracted Astro code or error message
- */
-async function extractAstroCode(
-  text: string,
-): Promise<{ code: string; error?: string }> {
-  const astroCodeRegex = /```astro\s*([\s\S]*?)```/g;
-  const matches = Array.from(text.matchAll(astroCodeRegex));
-
-  if (matches.length === 0) {
-    return {
-      code: "",
-      error:
-        "No Astro code block found in the response. Please include your code within ```astro fences.",
-    };
-  }
-
-  if (matches.length > 1) {
-    return {
-      code: "",
-      error:
-        "Multiple Astro code blocks found in the response. Please provide exactly one code block within ```astro fences.",
-    };
-  }
-
-  return { code: matches[0][1].trim() };
-}

package/src/ai/client.ts

@@ -1,117 +0,0 @@
-import { anthropic } from "@ai-sdk/anthropic";
-import { openai } from "@ai-sdk/openai";
-import type { Secret } from "../secret.ts";
-import { logger } from "../util/logger.ts";
-
-/**
- * Model configuration for AI operations
- */
-export interface ModelConfig {
-  /**
-   * Model ID to use
-   * @default 'gpt-4o'
-   */
-  id?: string;
-
-  /**
-   * Model provider name
-   * @default 'openai'
-   */
-  provider?: string;
-
-  /**
-   * Model-specific options
-   */
-  options?: Record<string, any>;
-}
-
-/**
- * Configuration for creating an OpenAI client
- */
-export interface ClientConfig {
-  /**
-   * Base URL for the OpenAI API
-   * @default 'https://api.openai.com/v1'
-   */
-  baseURL?: string;
-
-  /**
-   * OpenAI API key to use for generating content
-   * If not provided, will use OPENAI_API_KEY environment variable
-   */
-  apiKey?: Secret;
-
-  /**
-   * Model configuration
-   */
-  model?: ModelConfig;
-}
-
-/**
- * Creates an OpenAI-compatible client with the given configuration
- */
-export function createModel(config: ClientConfig) {
-  if (config.model?.provider === "anthropic") {
-    return anthropic(config.model?.id ?? "claude-3-7-sonnet-latest");
-  }
-  return openai(config.model?.id ?? "gpt-4o");
-}
-
-/**
- * Maximum time to retry in milliseconds (5 minutes)
- */
-const MAX_RETRY_TIME = 5 * 60 * 1000;
-
-/**
- * Initial delay between retries in milliseconds
- */
-const INITIAL_RETRY_DELAY = 1000;
-
-/**
- * Maximum number of retries
- */
-const MAX_RETRIES = 10;
-
-/**
- * Handles rate limiting with exponential backoff
- * @param fn Function to retry
- * @returns Result of the function
- * @throws Error if max retries or time is exceeded
- */
-export async function withRateLimitRetry<T>(fn: () => Promise<T>): Promise<T> {
-  let retryCount = 0;
-  let _lastError: Error | null = null;
-  const startTime = Date.now();
-
-  while (true) {
-    try {
-      return await fn();
-    } catch (error: any) {
-      _lastError = error;
-
-      logger.log("retry error", error);
-
-      // Check if we should retry
-      const isRateLimit = error.statusCode === 429;
-      const timeElapsed = Date.now() - startTime;
-      const shouldRetry =
-        isRateLimit && retryCount < MAX_RETRIES && timeElapsed < MAX_RETRY_TIME;
-
-      if (!shouldRetry) {
-        throw error;
-      }
-
-      // Calculate delay with exponential backoff
-      const delay = Math.min(
-        INITIAL_RETRY_DELAY * 2 ** retryCount,
-        MAX_RETRY_TIME - timeElapsed,
-      );
-
-      logger.log(`Retrying in ${delay}ms`);
-
-      // Wait before retrying
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      retryCount++;
-    }
-  }
-}