@cilow/sdk 0.2.1 → 0.3.0

package/dist/providers/openai.js

@@ -1,737 +0,0 @@
-'use strict';
-
-// 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/openai.ts
-function createCilowOpenAI(openai, config) {
-  const cilowClient = new CilowClient(config);
-  const defaultUserId = config.defaultUserId;
-  const maxContextTokens = config.maxContextTokens ?? 4e3;
-  config.minRelevance ?? 0.3;
-  const autoStore = config.autoStore ?? false;
-  const systemPromptPrefix = config.systemPromptPrefix ?? "The following is relevant context from memory. Use it when appropriate:";
-  async function injectMemoryContext(messages, options) {
-    if (options?.skipMemory) {
-      return { messages, memoriesUsed: 0, memoryIds: [] };
-    }
-    const lastUserMessage = [...messages].reverse().find(
-      (m) => m.role === "user" && typeof m.content === "string"
-    );
-    if (!lastUserMessage) {
-      return { messages, memoriesUsed: 0, memoryIds: [] };
-    }
-    const context = await cilowClient.getContext(lastUserMessage.content, {
-      maxTokens: maxContextTokens,
-      userId: options?.userId ?? defaultUserId,
-      tags: options?.tags
-    });
-    if (!context.context || context.memoriesUsed === 0) {
-      return { messages, memoriesUsed: 0, memoryIds: [] };
-    }
-    const memoryContext = `${systemPromptPrefix}
-
-${context.context}`;
-    const messagesCopy = [...messages];
-    const systemIndex = messagesCopy.findIndex((m) => m.role === "system");
-    if (systemIndex >= 0) {
-      const existingSystem = messagesCopy[systemIndex];
-      if (typeof existingSystem.content === "string") {
-        messagesCopy[systemIndex] = {
-          ...existingSystem,
-          content: `${existingSystem.content}
-
----
-
-${memoryContext}`
-        };
-      }
-    } else {
-      messagesCopy.unshift({
-        role: "system",
-        content: memoryContext
-      });
-    }
-    return {
-      messages: messagesCopy,
-      memoriesUsed: context.memoriesUsed,
-      memoryIds: context.memoryIds
-    };
-  }
-  async function storeConversation(userMessage, assistantResponse, options) {
-    if (options?.skipStore || !autoStore) {
-      return void 0;
-    }
-    return cilowClient.storeConversation({
-      userMessage,
-      assistantResponse,
-      userId: options?.userId ?? defaultUserId ?? "anonymous",
-      sessionId: options?.sessionId
-    });
-  }
-  const chatCompletions = {
-    async create(params, options) {
-      const { messages, memoriesUsed, memoryIds } = await injectMemoryContext(
-        params.messages,
-        options
-      );
-      const completion = await openai.chat.completions.create({
-        ...params,
-        messages
-      });
-      let storedMemoryId;
-      const lastUserMessage = [...params.messages].reverse().find(
-        (m) => m.role === "user" && typeof m.content === "string"
-      );
-      const assistantResponse = completion.choices[0]?.message?.content;
-      if (lastUserMessage && assistantResponse) {
-        storedMemoryId = await storeConversation(
-          lastUserMessage.content,
-          assistantResponse,
-          options
-        );
-      }
-      return {
-        completion,
-        memoriesUsed,
-        memoryIds,
-        storedMemoryId
-      };
-    },
-    async createStream(params, options) {
-      const { messages, memoriesUsed, memoryIds } = await injectMemoryContext(
-        params.messages,
-        options
-      );
-      const stream = await openai.chat.completions.create({
-        ...params,
-        messages,
-        stream: true
-      });
-      return {
-        stream,
-        memoriesUsed,
-        memoryIds
-      };
-    }
-  };
-  return {
-    chat: {
-      completions: chatCompletions
-    },
-    memory: cilowClient,
-    openai,
-    async remember(content, options) {
-      return cilowClient.remember(content, {
-        tags: options?.tags,
-        userId: options?.userId ?? defaultUserId
-      });
-    },
-    async recall(query, options) {
-      return cilowClient.recall(query, {
-        limit: options?.limit,
-        userId: options?.userId ?? defaultUserId
-      });
-    },
-    async forget(filter) {
-      return cilowClient.forget({
-        ...filter,
-        userId: filter.userId ?? defaultUserId
-      });
-    }
-  };
-}
-var cilowFunctions = [
-  {
-    name: "search_memories",
-    description: "Search through stored memories using semantic similarity",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "The search query to find relevant memories"
-        },
-        limit: {
-          type: "number",
-          description: "Maximum number of results (default: 10)"
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Filter by specific tags"
-        }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: "store_memory",
-    description: "Store a new memory for future retrieval",
-    parameters: {
-      type: "object",
-      properties: {
-        content: {
-          type: "string",
-          description: "The content to remember"
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Tags to categorize the memory"
-        }
-      },
-      required: ["content"]
-    }
-  },
-  {
-    name: "delete_memory",
-    description: "Delete memories by ID or filter criteria",
-    parameters: {
-      type: "object",
-      properties: {
-        memoryId: {
-          type: "string",
-          description: "Specific memory ID to delete"
-        },
-        tags: {
-          type: "array",
-          items: { type: "string" },
-          description: "Delete memories with these tags"
-        }
-      }
-    }
-  }
-];
-async function executeCilowFunction(client, functionName, args, userId) {
-  switch (functionName) {
-    case "search_memories":
-      return client.recall(args.query, {
-        limit: args.limit,
-        tags: args.tags,
-        userId
-      });
-    case "store_memory":
-      return client.remember(args.content, {
-        tags: args.tags,
-        userId
-      });
-    case "delete_memory":
-      return client.forget({
-        memoryId: args.memoryId,
-        tags: args.tags,
-        userId
-      });
-    default:
-      throw new Error(`Unknown function: ${functionName}`);
-  }
-}
-function createFunctionExecutor(config) {
-  const client = new CilowClient(config);
-  return async function execute(functionName, args, userId) {
-    return executeCilowFunction(client, functionName, args, userId);
-  };
-}
-
-exports.cilowFunctions = cilowFunctions;
-exports.createCilowOpenAI = createCilowOpenAI;
-exports.createFunctionExecutor = createFunctionExecutor;
-exports.executeCilowFunction = executeCilowFunction;
-//# sourceMappingURL=openai.js.map
-//# sourceMappingURL=openai.js.map