@cilow/sdk 0.2.0 → 0.2.1

package/dist/providers/vercel.mjs

@@ -0,0 +1,860 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+
+// src/providers/vercel.ts
+
+// src/client.ts
+async function fetchWithRetry(url, options, config) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  let lastError = null;
+  for (let attempt = 0; attempt <= config.retries; attempt++) {
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let apiError;
+        try {
+          apiError = JSON.parse(errorBody);
+        } catch {
+          apiError = {
+            code: `HTTP_${response.status}`,
+            message: errorBody || response.statusText
+          };
+        }
+        throw new CilowApiError(apiError.message, apiError.code, response.status, apiError.details);
+      }
+      return response;
+    } catch (error) {
+      lastError = error;
+      if (error instanceof CilowApiError) {
+        throw error;
+      }
+      if (config.debug) {
+        console.warn(`Cilow API request failed (attempt ${attempt + 1}/${config.retries + 1}):`, error);
+      }
+      if (attempt < config.retries) {
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 100));
+      }
+    }
+  }
+  clearTimeout(timeoutId);
+  throw lastError || new Error("Request failed");
+}
+var CilowApiError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "CilowApiError";
+  }
+};
+var CilowClient = class {
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+    this.retries = config.retries ?? 3;
+    this.debug = config.debug ?? false;
+    const authHeaders = this.apiKey.startsWith("cilow_") ? { "X-API-Key": this.apiKey } : { Authorization: `Bearer ${this.apiKey}` };
+    this.headers = {
+      "Content-Type": "application/json",
+      ...authHeaders,
+      ...config.headers
+    };
+  }
+  /**
+   * Make an API request
+   */
+  async request(method, path, body, queryParams) {
+    let url = `${this.baseUrl}${path}`;
+    if (queryParams) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== void 0) {
+          params.append(key, String(value));
+        }
+      }
+      const queryString = params.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    if (this.debug) {
+      console.log(`Cilow API: ${method} ${url}`);
+    }
+    const response = await fetchWithRetry(
+      url,
+      {
+        method,
+        headers: this.headers,
+        body: body ? JSON.stringify(body) : void 0
+      },
+      { timeout: this.timeout, retries: this.retries, debug: this.debug }
+    );
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  // ===========================================================================
+  // Simple API (remember, recall, forget)
+  // ===========================================================================
+  /**
+   * Store a memory (simple API)
+   *
+   * @param content - The content to remember
+   * @param options - Optional configuration
+   * @returns The created memory ID
+   *
+   * @example
+   * ```typescript
+   * await cilow.remember("User prefers dark mode", {
+   *   tags: ["preference"],
+   *   userId: "user-123"
+   * });
+   * ```
+   */
+  async remember(content, options) {
+    const response = await this.request("POST", "/api/v1/memory/add", {
+      content,
+      tags: options?.tags ?? [],
+      user_id: options?.userId,
+      session_id: options?.sessionId,
+      metadata: options?.metadata,
+      type: options?.tier
+    });
+    return response.memory_id || response.id || "";
+  }
+  /**
+   * Search memories (simple API)
+   *
+   * @param query - Search query text
+   * @param options - Search options
+   * @returns Array of search results
+   *
+   * @example
+   * ```typescript
+   * const memories = await cilow.recall("user preferences", {
+   *   limit: 10,
+   *   tags: ["preference"]
+   * });
+   * ```
+   */
+  async recall(query, options) {
+    const response = await this.request("POST", "/api/v1/memory/search", {
+      query,
+      limit: options?.limit ?? 10,
+      min_score: options?.minRelevance ?? 0.3,
+      tags: options?.tags,
+      user_id: options?.userId
+    });
+    return (response.results ?? []).map((r) => ({
+      memory: {
+        id: r.memory_id,
+        content: r.content,
+        tags: r.tags ?? [],
+        tier: "hot",
+        status: "active",
+        accessCount: 0,
+        tokenCount: Math.ceil(r.content.length / 4),
+        metadata: {},
+        createdAt: r.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: r.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      score: r.similarity,
+      highlights: []
+    }));
+  }
+  /**
+   * Delete memories (simple API)
+   *
+   * @param filter - Filter criteria for deletion
+   * @returns Number of memories deleted
+   *
+   * @example
+   * ```typescript
+   * // Delete by tags
+   * await cilow.forget({ tags: ["temporary"] });
+   *
+   * // Delete by user
+   * await cilow.forget({ userId: "user-123" });
+   *
+   * // Delete specific memory
+   * await cilow.forget({ memoryId: "mem-abc" });
+   * ```
+   */
+  async forget(filter) {
+    if (filter.memoryId) {
+      await this.deleteMemory(filter.memoryId);
+      return 1;
+    }
+    const response = await this.request("DELETE", "/api/v1/memories/bulk", {
+      filter_tags: filter.tags,
+      user_id: filter.userId,
+      session_id: filter.sessionId,
+      older_than: filter.olderThan
+    });
+    return response.deleted ?? 0;
+  }
+  // ===========================================================================
+  // Memory CRUD Operations
+  // ===========================================================================
+  /**
+   * Create a new memory
+   */
+  async createMemory(content, options) {
+    return this.request("POST", "/api/v1/memories", {
+      content,
+      tags: options?.tags ?? [],
+      user_id: options?.userId,
+      session_id: options?.sessionId,
+      metadata: options?.metadata,
+      tier: options?.tier
+    });
+  }
+  /**
+   * Get a memory by ID
+   */
+  async getMemory(memoryId) {
+    return this.request("GET", `/api/v1/memories/${memoryId}`);
+  }
+  /**
+   * Update a memory
+   */
+  async updateMemory(memoryId, updates) {
+    return this.request("PATCH", `/api/v1/memories/${memoryId}`, {
+      content: updates.content,
+      tags: updates.tags,
+      metadata: updates.metadata,
+      tier: updates.tier
+    });
+  }
+  /**
+   * Delete a memory
+   */
+  async deleteMemory(memoryId) {
+    await this.request("DELETE", `/api/v1/memories/${memoryId}`);
+  }
+  /**
+   * List memories with pagination
+   */
+  async listMemories(options) {
+    const response = await this.request(
+      "GET",
+      "/api/v1/memory/list",
+      void 0,
+      {
+        limit: options?.limit ?? 20,
+        offset: options?.offset ?? 0,
+        user_id: options?.userId,
+        session_id: options?.sessionId,
+        tags: options?.tags?.join(","),
+        type: options?.tier
+      }
+    );
+    const items = (response.memories ?? []).map((m) => ({
+      id: m.memory_id || m.id || "",
+      content: m.content,
+      tags: m.tags ?? [],
+      createdAt: m.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      tier: m.type || "hot"
+    }));
+    const limit = options?.limit ?? 20;
+    const offset = options?.offset ?? 0;
+    const total = response.total ?? items.length;
+    return {
+      items,
+      total,
+      limit,
+      offset,
+      hasMore: offset + items.length < total
+    };
+  }
+  // ===========================================================================
+  // Search Operations
+  // ===========================================================================
+  /**
+   * Search memories with full options
+   */
+  async searchMemories(query) {
+    const response = await this.request("POST", "/api/v1/memories/search", {
+      text: query.text,
+      limit: query.limit ?? 10,
+      min_relevance: query.minRelevance ?? 0.3,
+      filter_tags: query.tags,
+      user_id: query.userId,
+      session_id: query.sessionId,
+      tier: query.tier,
+      created_after: query.createdAfter,
+      created_before: query.createdBefore,
+      include_archived: query.includeArchived,
+      mode: query.mode ?? "hybrid"
+    });
+    return response.results ?? [];
+  }
+  /**
+   * Advanced search with reranking and boosts
+   */
+  async advancedSearch(query) {
+    const response = await this.request("POST", "/api/v1/memories/search/advanced", {
+      text: query.text,
+      limit: query.limit ?? 10,
+      min_relevance: query.minRelevance ?? 0.3,
+      filter_tags: query.tags,
+      required_tags: query.requiredTags,
+      excluded_tags: query.excludedTags,
+      user_id: query.userId,
+      session_id: query.sessionId,
+      recency_boost: query.recencyBoost,
+      frequency_boost: query.frequencyBoost,
+      metadata_filters: query.metadataFilters,
+      reranker: query.reranker
+    });
+    return response.results ?? [];
+  }
+  /**
+   * Get context for AI applications
+   */
+  async getContext(query, options) {
+    const maxTokens = options?.maxTokens ?? 4e3;
+    const tokensPerChar = 0.25;
+    const results = await this.searchMemories({
+      text: query,
+      limit: 30,
+      minRelevance: 0.3,
+      userId: options?.userId,
+      tags: options?.tags
+    });
+    let context = "";
+    let estimatedTokens = 0;
+    const memoryIds = [];
+    const scores = [];
+    for (const result of results) {
+      const memoryText = `[Relevance: ${(result.score * 100).toFixed(0)}%]
+${result.memory.content}
+
+`;
+      const memoryTokens = Math.ceil(memoryText.length * tokensPerChar);
+      if (estimatedTokens + memoryTokens > maxTokens) break;
+      context += memoryText;
+      estimatedTokens += memoryTokens;
+      memoryIds.push(result.memory.id);
+      scores.push(result.score);
+    }
+    return {
+      context: context.trim(),
+      memoriesUsed: memoryIds.length,
+      estimatedTokens,
+      memoryIds,
+      scores
+    };
+  }
+  // ===========================================================================
+  // Conversation Operations
+  // ===========================================================================
+  /**
+   * Store a conversation turn
+   */
+  async storeConversation(turn) {
+    const content = `User: ${turn.userMessage}
+
+Assistant: ${turn.assistantResponse}`;
+    const tags = ["conversation"];
+    if (turn.sessionId) {
+      tags.push(`session:${turn.sessionId}`);
+    }
+    return this.remember(content, {
+      tags,
+      userId: turn.userId,
+      sessionId: turn.sessionId,
+      metadata: {
+        type: "conversation",
+        ...turn.metadata
+      }
+    });
+  }
+  /**
+   * Get conversation history for a session
+   */
+  async getConversationHistory(sessionId, options) {
+    const response = await this.listMemories({
+      sessionId,
+      tags: ["conversation"],
+      limit: options?.limit ?? 50,
+      offset: options?.offset ?? 0
+    });
+    return response.items;
+  }
+  // ===========================================================================
+  // Graph Operations
+  // ===========================================================================
+  /**
+   * Get a graph node
+   */
+  async getGraphNode(nodeId) {
+    return this.request("GET", `/api/v1/graph/nodes/${nodeId}`);
+  }
+  /**
+   * Create a graph node
+   */
+  async createGraphNode(type, name, properties) {
+    return this.request("POST", "/api/v1/graph/nodes", {
+      type,
+      name,
+      properties: properties ?? {}
+    });
+  }
+  /**
+   * Create a graph edge
+   */
+  async createGraphEdge(sourceId, targetId, type, properties) {
+    return this.request("POST", "/api/v1/graph/edges", {
+      source_id: sourceId,
+      target_id: targetId,
+      type,
+      properties: properties ?? {}
+    });
+  }
+  /**
+   * Traverse the graph from a starting node
+   */
+  async traverseGraph(options) {
+    return this.request("POST", "/api/v1/graph/traverse", {
+      start_node_id: options.startNodeId,
+      max_depth: options.maxDepth ?? 3,
+      relationship_types: options.relationshipTypes,
+      limit: options.limit ?? 100,
+      direction: options.direction ?? "both"
+    });
+  }
+  /**
+   * Get related nodes for a memory
+   */
+  async getRelatedNodes(memoryId) {
+    const response = await this.request(
+      "GET",
+      `/api/v1/memories/${memoryId}/related-nodes`
+    );
+    return response.nodes ?? [];
+  }
+  // ===========================================================================
+  // Statistics & Admin
+  // ===========================================================================
+  /**
+   * Get memory statistics
+   */
+  async getStats() {
+    return this.request("GET", "/api/v1/stats");
+  }
+  /**
+   * Get all tags with counts
+   */
+  async getTags() {
+    const response = await this.request("GET", "/api/v1/tags");
+    return response.tags ?? [];
+  }
+  /**
+   * Get user statistics
+   */
+  async getUserStats(userId) {
+    return this.request("GET", `/api/v1/users/${userId}/stats`);
+  }
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    return this.request("GET", "/health");
+  }
+  // ===========================================================================
+  // Batch Operations
+  // ===========================================================================
+  /**
+   * Batch create memories
+   */
+  async batchCreate(items) {
+    const response = await this.request("POST", "/api/v1/memories/batch", {
+      memories: items.map((item) => ({
+        content: item.content,
+        tags: item.options?.tags ?? [],
+        user_id: item.options?.userId,
+        session_id: item.options?.sessionId,
+        metadata: item.options?.metadata
+      }))
+    });
+    return response.ids ?? [];
+  }
+  /**
+   * Batch delete memories
+   */
+  async batchDelete(memoryIds) {
+    const response = await this.request("DELETE", "/api/v1/memories/batch", {
+      ids: memoryIds
+    });
+    return response.deleted ?? 0;
+  }
+};
+
+// src/providers/vercel.ts
+var searchMemoriesSchema = z.object({
+  query: z.string().describe("The search query to find relevant memories"),
+  limit: z.number().optional().describe("Maximum results to return (default: 10)"),
+  minRelevance: z.number().optional().describe("Minimum relevance score 0-1 (default: 0.3)"),
+  tags: z.array(z.string()).optional().describe("Filter by specific tags"),
+  userId: z.string().optional().describe("User ID to scope the search")
+});
+var addMemorySchema = z.object({
+  content: z.string().describe("The content to remember"),
+  tags: z.array(z.string()).optional().describe("Tags to categorize the memory"),
+  userId: z.string().optional().describe("User ID to associate"),
+  metadata: z.record(z.any()).optional().describe("Additional metadata")
+});
+var getContextSchema = z.object({
+  query: z.string().describe("Query to find relevant context"),
+  maxTokens: z.number().optional().describe("Maximum tokens to return (default: 2000)"),
+  userId: z.string().optional().describe("User ID to scope context")
+});
+var rememberConversationSchema = z.object({
+  userMessage: z.string().describe("The user's message"),
+  assistantResponse: z.string().describe("The assistant's response"),
+  sessionId: z.string().optional().describe("Session ID for grouping"),
+  userId: z.string().optional().describe("User ID"),
+  topic: z.string().optional().describe("Topic or category")
+});
+var forgetMemorySchema = z.object({
+  memoryId: z.string().optional().describe("Memory ID to delete"),
+  tags: z.array(z.string()).optional().describe("Delete memories with these tags"),
+  userId: z.string().optional().describe("Delete memories for this user")
+});
+var emptySchema = z.object({});
+function createCilowTools(config) {
+  const client = new CilowClient(config);
+  const defaultUserId = config.defaultUserId;
+  const defaultSessionId = config.defaultSessionId;
+  const defaultLimit = config.defaultSearchLimit ?? 10;
+  const defaultMinRelevance = config.defaultMinRelevance ?? 0.3;
+  return {
+    /**
+     * Search through stored memories
+     */
+    searchMemories: tool({
+      description: "Search through stored memories using semantic similarity. Use this to recall information from past conversations or stored knowledge.",
+      parameters: searchMemoriesSchema,
+      execute: async (params) => {
+        const { query, limit, minRelevance, tags, userId } = params;
+        try {
+          const results = await client.recall(query, {
+            limit: limit ?? defaultLimit,
+            minRelevance: minRelevance ?? defaultMinRelevance,
+            tags,
+            userId: userId ?? defaultUserId
+          });
+          return {
+            success: true,
+            count: results.length,
+            memories: results.map((r) => ({
+              content: r.memory.content,
+              score: r.score,
+              tags: r.memory.tags,
+              createdAt: r.memory.createdAt
+            }))
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message,
+            memories: []
+          };
+        }
+      }
+    }),
+    /**
+     * Store a new memory
+     */
+    addMemory: tool({
+      description: "Store a new memory for future retrieval. Use this to save important information, user preferences, or insights.",
+      parameters: addMemorySchema,
+      execute: async (params) => {
+        const { content, tags, userId, metadata } = params;
+        try {
+          const memoryId = await client.remember(content, {
+            tags,
+            userId: userId ?? defaultUserId,
+            metadata
+          });
+          return {
+            success: true,
+            memoryId,
+            message: "Memory stored successfully"
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+      }
+    }),
+    /**
+     * Get context for a conversation
+     */
+    getContext: tool({
+      description: "Retrieve relevant context from memories based on a query. Returns formatted context for including in prompts.",
+      parameters: getContextSchema,
+      execute: async (params) => {
+        const { query, maxTokens = 2e3, userId } = params;
+        try {
+          const context = await client.getContext(query, {
+            maxTokens,
+            userId: userId ?? defaultUserId
+          });
+          return {
+            success: true,
+            context: context.context,
+            memoriesUsed: context.memoriesUsed,
+            estimatedTokens: context.estimatedTokens
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message,
+            context: ""
+          };
+        }
+      }
+    }),
+    /**
+     * Store a conversation turn
+     */
+    rememberConversation: tool({
+      description: "Store a conversation exchange (user message and assistant response) for future context.",
+      parameters: rememberConversationSchema,
+      execute: async (params) => {
+        const { userMessage, assistantResponse, sessionId, userId, topic } = params;
+        try {
+          const memoryId = await client.storeConversation({
+            userMessage,
+            assistantResponse,
+            sessionId: sessionId ?? defaultSessionId,
+            userId: userId ?? defaultUserId ?? "anonymous",
+            metadata: topic ? { topic } : void 0
+          });
+          return {
+            success: true,
+            memoryId,
+            message: "Conversation stored"
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+      }
+    }),
+    /**
+     * Delete a memory
+     */
+    forgetMemory: tool({
+      description: "Delete a specific memory by ID or filter criteria.",
+      parameters: forgetMemorySchema,
+      execute: async (params) => {
+        const { memoryId, tags, userId } = params;
+        try {
+          const count = await client.forget({
+            memoryId,
+            tags,
+            userId: userId ?? defaultUserId
+          });
+          return {
+            success: true,
+            deletedCount: count,
+            message: `Deleted ${count} memory(ies)`
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+      }
+    }),
+    /**
+     * Get memory statistics
+     */
+    getMemoryStats: tool({
+      description: "Get statistics about stored memories.",
+      parameters: emptySchema,
+      execute: async (_params) => {
+        try {
+          const stats = await client.getStats();
+          return {
+            success: true,
+            stats: {
+              totalMemories: stats.totalMemories,
+              hotMemories: stats.hotMemories,
+              warmMemories: stats.warmMemories,
+              coldMemories: stats.coldMemories,
+              totalTokens: stats.totalTokens,
+              averageTokensPerMemory: stats.averageTokensPerMemory
+            }
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+      }
+    }),
+    /**
+     * List all tags
+     */
+    listTags: tool({
+      description: "List all memory tags and their usage counts.",
+      parameters: emptySchema,
+      execute: async (_params) => {
+        try {
+          const tags = await client.getTags();
+          return {
+            success: true,
+            tags: tags.map((t) => ({ tag: t.tag, count: t.count })),
+            totalTags: tags.length
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error.message
+          };
+        }
+      }
+    })
+  };
+}
+function createCilowContext(config) {
+  const client = new CilowClient(config);
+  const defaultUserId = config.defaultUserId;
+  const defaultMaxTokens = config.maxTokens ?? 4e3;
+  return async function getContext(query, options) {
+    return client.getContext(query, {
+      maxTokens: options?.maxTokens ?? defaultMaxTokens,
+      userId: options?.userId ?? defaultUserId,
+      tags: options?.tags
+    });
+  };
+}
+function buildSystemPromptWithContext(basePrompt, context) {
+  if (!context.context || context.memoriesUsed === 0) {
+    return basePrompt;
+  }
+  return `${basePrompt}
+
+## Relevant Information from Memory (${context.memoriesUsed} items)
+
+${context.context}
+
+---
+
+Use the above context when relevant to provide informed and personalized responses.`;
+}
+function createContextMiddleware(config) {
+  const getContext = createCilowContext(config);
+  return async function withMemory(messages, options) {
+    if (messages.length === 0) return messages;
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+    if (!lastUserMessage) return messages;
+    const context = await getContext(lastUserMessage.content, options);
+    if (!context.context || context.memoriesUsed === 0) {
+      return messages;
+    }
+    const systemIndex = messages.findIndex((m) => m.role === "system");
+    if (systemIndex >= 0) {
+      const updatedMessages = [...messages];
+      updatedMessages[systemIndex] = {
+        ...messages[systemIndex],
+        content: buildSystemPromptWithContext(messages[systemIndex].content, context)
+      };
+      return updatedMessages;
+    } else {
+      return [
+        {
+          role: "system",
+          content: `## Relevant Context from Memory
+
+${context.context}
+
+Use this context when relevant to answer the user's question.`
+        },
+        ...messages
+      ];
+    }
+  };
+}
+var CilowMemoryProvider = class {
+  constructor(config) {
+    this.client = new CilowClient(config);
+    this.userId = config.defaultUserId;
+    this.sessionId = config.defaultSessionId;
+    this.defaultTags = config.defaultTags ?? [];
+    this.tokenBudget = config.tokenBudget ?? 4e3;
+  }
+  setUserId(userId) {
+    this.userId = userId;
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  async search(query, options) {
+    return this.client.recall(query, {
+      ...options,
+      userId: this.userId
+    });
+  }
+  async getContext(query, options) {
+    const result = await this.client.getContext(query, {
+      maxTokens: options?.maxTokens ?? this.tokenBudget,
+      userId: this.userId
+    });
+    return result.context;
+  }
+  async store(content, options) {
+    const tags = [...this.defaultTags, ...options?.tags ?? []];
+    if (this.sessionId) {
+      tags.push(`session:${this.sessionId}`);
+    }
+    return this.client.remember(content, {
+      tags,
+      userId: this.userId,
+      metadata: options?.metadata
+    });
+  }
+  async storeConversation(userMessage, assistantResponse) {
+    return this.client.storeConversation({
+      userMessage,
+      assistantResponse,
+      userId: this.userId ?? "anonymous",
+      sessionId: this.sessionId
+    });
+  }
+  async getSystemPrompt(basePrompt, query, options) {
+    const context = await this.client.getContext(query, {
+      maxTokens: options?.maxContextTokens ?? 2e3,
+      userId: this.userId
+    });
+    return buildSystemPromptWithContext(basePrompt, context);
+  }
+  async getStats() {
+    return this.client.getStats();
+  }
+};
+
+export { CilowMemoryProvider, buildSystemPromptWithContext, createCilowContext, createCilowTools, createContextMiddleware };
+//# sourceMappingURL=vercel.mjs.map
+//# sourceMappingURL=vercel.mjs.map