@memorylayerai/vercel-ai 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,554 @@
+import { z } from 'zod';
+import * as ai from 'ai';
+import { MemoryLayerClient as MemoryLayerClient$1 } from '@memorylayerai/sdk';
+
+/**
+ * Configuration options for the MemoryLayer client
+ */
+interface ClientConfig {
+    /** API key for authentication (can also be set via MEMORYLAYER_API_KEY env var) */
+    apiKey?: string;
+    /** Base URL for the API (default: https://api.memorylayer.com) */
+    baseURL?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds (default: 1000) */
+    retryDelay?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+    /** Logger for debugging */
+    logger?: {
+        debug(message: string, ...args: any[]): void;
+        info(message: string, ...args: any[]): void;
+        warn(message: string, ...args: any[]): void;
+        error(message: string, ...args: any[]): void;
+    };
+}
+/**
+ * Main MemoryLayer SDK client
+ */
+declare class MemoryLayerClient {
+    private httpClient;
+    private _memories?;
+    private _search?;
+    private _ingest?;
+    private _router?;
+    private _graph?;
+    constructor(config?: ClientConfig);
+    /**
+     * Access memory operations
+     */
+    get memories(): any;
+    /**
+     * Access search operations
+     */
+    get search(): any;
+    /**
+     * Access ingestion operations
+     */
+    get ingest(): any;
+    /**
+     * Access router operations
+     */
+    get router(): any;
+    /**
+     * Access graph visualization operations
+     */
+    get graph(): any;
+}
+
+/**
+ * Vercel AI SDK provider adapter for MemoryLayer
+ */
+
+/**
+ * Configuration for the MemoryLayer provider
+ */
+interface MemoryLayerProviderConfig {
+    /** MemoryLayer client instance */
+    client: MemoryLayerClient;
+    /** Project ID for memory context */
+    projectId: string;
+    /** Default model to use */
+    defaultModel?: string;
+}
+/**
+ * Create a Vercel AI SDK provider for MemoryLayer
+ *
+ * @param config - Provider configuration
+ * @returns Vercel AI SDK compatible provider
+ *
+ * @example
+ * ```typescript
+ * import { createMemoryLayerProvider } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const provider = createMemoryLayerProvider({
+ *   client,
+ *   projectId: 'proj_abc123',
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: provider,
+ *   prompt: 'What are my preferences?',
+ * });
+ * ```
+ */
+declare function createMemoryLayerProvider(config: MemoryLayerProviderConfig): any;
+
+/**
+ * Vercel AI SDK tool helpers for MemoryLayer
+ */
+
+/**
+ * Configuration for memory tools
+ */
+interface MemoryToolConfig {
+    /** MemoryLayer client instance */
+    client: MemoryLayerClient;
+    /** Project ID for memory operations */
+    projectId: string;
+}
+/**
+ * Create a Vercel AI SDK tool for adding memories
+ *
+ * @param config - Tool configuration
+ * @returns Vercel AI SDK tool definition
+ *
+ * @example
+ * ```typescript
+ * import { memoryTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: someModel,
+ *   prompt: 'Remember that I prefer dark mode',
+ *   tools: {
+ *     addMemory: memoryTool({ client, projectId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ */
+declare function memoryTool(config: MemoryToolConfig): {
+    description: string;
+    parameters: z.ZodObject<{
+        content: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        metadata?: Record<string, any> | undefined;
+    }, {
+        content: string;
+        metadata?: Record<string, any> | undefined;
+    }>;
+    execute: ({ content, metadata }: {
+        content: string;
+        metadata?: Record<string, any>;
+    }) => Promise<{
+        success: boolean;
+        memoryId: any;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        memoryId?: undefined;
+        message?: undefined;
+    }>;
+};
+/**
+ * Create a Vercel AI SDK tool for searching memories
+ *
+ * @param config - Tool configuration
+ * @returns Vercel AI SDK tool definition
+ *
+ * @example
+ * ```typescript
+ * import { searchTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: someModel,
+ *   prompt: 'What are my preferences?',
+ *   tools: {
+ *     searchMemory: searchTool({ client, projectId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ */
+declare function searchTool(config: MemoryToolConfig): {
+    description: string;
+    parameters: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+        threshold: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+        limit?: number | undefined;
+        threshold?: number | undefined;
+    }, {
+        query: string;
+        limit?: number | undefined;
+        threshold?: number | undefined;
+    }>;
+    execute: ({ query, limit, threshold }: {
+        query: string;
+        limit?: number;
+        threshold?: number;
+    }) => Promise<{
+        success: boolean;
+        results: any;
+        total: any;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        results?: undefined;
+        total?: undefined;
+    }>;
+};
+
+/**
+ * Configuration for graph tools
+ */
+interface GraphToolConfig {
+    /** MemoryLayer client instance */
+    client: MemoryLayerClient$1;
+    /** Space/project ID for graph context */
+    spaceId: string;
+}
+/**
+ * Create a tool for fetching graph data
+ *
+ * This tool allows AI models to fetch and visualize memory graph data.
+ *
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ *
+ * @example
+ * ```typescript
+ * import { graphTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Show me the memory graph',
+ *   tools: {
+ *     getGraph: graphTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ *
+ * Requirements: 6.1
+ */
+declare function graphTool(config: GraphToolConfig): ai.CoreTool<z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    nodeTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["memory", "document", "entity"]>, "many">>;
+    relationshipTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["extends", "updates", "derives", "similarity"]>, "many">>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+    relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}, {
+    limit?: number | undefined;
+    nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+    relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}>, {
+    nodes: any;
+    edges: any;
+    metadata: any;
+}> & {
+    execute: (args: {
+        limit?: number | undefined;
+        nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+        relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    }, options: {
+        abortSignal?: AbortSignal;
+    }) => PromiseLike<{
+        nodes: any;
+        edges: any;
+        metadata: any;
+    }>;
+};
+/**
+ * Create a tool for fetching node details
+ *
+ * This tool allows AI models to get detailed information about a specific node.
+ *
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ *
+ * @example
+ * ```typescript
+ * import { nodeDetailsTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Tell me about memory node-123',
+ *   tools: {
+ *     getNodeDetails: nodeDetailsTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ *
+ * Requirements: 6.2
+ */
+declare function nodeDetailsTool(config: GraphToolConfig): ai.CoreTool<z.ZodObject<{
+    nodeId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nodeId: string;
+}, {
+    nodeId: string;
+}>, {
+    node: {
+        id: any;
+        type: any;
+        label: any;
+        content: any;
+        status: any;
+        createdAt: any;
+        expiresAt: any;
+        metadata: any;
+    };
+    connectedNodes: any;
+    edges: any;
+}> & {
+    execute: (args: {
+        nodeId: string;
+    }, options: {
+        abortSignal?: AbortSignal;
+    }) => PromiseLike<{
+        node: {
+            id: any;
+            type: any;
+            label: any;
+            content: any;
+            status: any;
+            createdAt: any;
+            expiresAt: any;
+            metadata: any;
+        };
+        connectedNodes: any;
+        edges: any;
+    }>;
+};
+/**
+ * Create a tool for fetching node edges
+ *
+ * This tool allows AI models to get edges connected to a specific node.
+ *
+ * @param config - Graph tool configuration
+ * @returns Vercel AI SDK compatible tool
+ *
+ * @example
+ * ```typescript
+ * import { nodeEdgesTool } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'What is connected to memory node-123?',
+ *   tools: {
+ *     getNodeEdges: nodeEdgesTool({ client, spaceId: 'proj_abc123' }),
+ *   },
+ * });
+ * ```
+ *
+ * Requirements: 6.3
+ */
+declare function nodeEdgesTool(config: GraphToolConfig): ai.CoreTool<z.ZodObject<{
+    nodeId: z.ZodString;
+    edgeTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["extends", "updates", "derives", "similarity"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    nodeId: string;
+    edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+}, {
+    nodeId: string;
+    edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+}>, {
+    edges: any;
+    connectedNodes: any;
+}> & {
+    execute: (args: {
+        nodeId: string;
+        edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+    }, options: {
+        abortSignal?: AbortSignal;
+    }) => PromiseLike<{
+        edges: any;
+        connectedNodes: any;
+    }>;
+};
+/**
+ * Create all graph tools at once
+ *
+ * Convenience function to create all graph-related tools.
+ *
+ * @param config - Graph tool configuration
+ * @returns Object with all graph tools
+ *
+ * @example
+ * ```typescript
+ * import { createGraphTools } from '@memorylayer/vercel-ai';
+ * import { MemoryLayerClient } from '@memorylayer/sdk';
+ * import { generateText } from 'ai';
+ *
+ * const client = new MemoryLayerClient({
+ *   apiKey: process.env.MEMORYLAYER_API_KEY!,
+ * });
+ *
+ * const graphTools = createGraphTools({ client, spaceId: 'proj_abc123' });
+ *
+ * const { text } = await generateText({
+ *   model: openai('gpt-4'),
+ *   prompt: 'Analyze my memory graph',
+ *   tools: graphTools,
+ * });
+ * ```
+ *
+ * Requirements: 6.1, 6.2, 6.3
+ */
+declare function createGraphTools(config: GraphToolConfig): {
+    getGraph: ai.CoreTool<z.ZodObject<{
+        limit: z.ZodOptional<z.ZodNumber>;
+        nodeTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["memory", "document", "entity"]>, "many">>;
+        relationshipTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["extends", "updates", "derives", "similarity"]>, "many">>;
+        startDate: z.ZodOptional<z.ZodString>;
+        endDate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        limit?: number | undefined;
+        nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+        relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    }, {
+        limit?: number | undefined;
+        nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+        relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+        startDate?: string | undefined;
+        endDate?: string | undefined;
+    }>, {
+        nodes: any;
+        edges: any;
+        metadata: any;
+    }> & {
+        execute: (args: {
+            limit?: number | undefined;
+            nodeTypes?: ("memory" | "document" | "entity")[] | undefined;
+            relationshipTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+            startDate?: string | undefined;
+            endDate?: string | undefined;
+        }, options: {
+            abortSignal?: AbortSignal;
+        }) => PromiseLike<{
+            nodes: any;
+            edges: any;
+            metadata: any;
+        }>;
+    };
+    getNodeDetails: ai.CoreTool<z.ZodObject<{
+        nodeId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeId: string;
+    }, {
+        nodeId: string;
+    }>, {
+        node: {
+            id: any;
+            type: any;
+            label: any;
+            content: any;
+            status: any;
+            createdAt: any;
+            expiresAt: any;
+            metadata: any;
+        };
+        connectedNodes: any;
+        edges: any;
+    }> & {
+        execute: (args: {
+            nodeId: string;
+        }, options: {
+            abortSignal?: AbortSignal;
+        }) => PromiseLike<{
+            node: {
+                id: any;
+                type: any;
+                label: any;
+                content: any;
+                status: any;
+                createdAt: any;
+                expiresAt: any;
+                metadata: any;
+            };
+            connectedNodes: any;
+            edges: any;
+        }>;
+    };
+    getNodeEdges: ai.CoreTool<z.ZodObject<{
+        nodeId: z.ZodString;
+        edgeTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["extends", "updates", "derives", "similarity"]>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        nodeId: string;
+        edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+    }, {
+        nodeId: string;
+        edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+    }>, {
+        edges: any;
+        connectedNodes: any;
+    }> & {
+        execute: (args: {
+            nodeId: string;
+            edgeTypes?: ("updates" | "extends" | "derives" | "similarity")[] | undefined;
+        }, options: {
+            abortSignal?: AbortSignal;
+        }) => PromiseLike<{
+            edges: any;
+            connectedNodes: any;
+        }>;
+    };
+};
+
+export { type GraphToolConfig, type MemoryLayerProviderConfig, type MemoryToolConfig, createGraphTools, createMemoryLayerProvider, graphTool, memoryTool, nodeDetailsTool, nodeEdgesTool, searchTool };