@radaros/core 0.3.5 → 0.3.6

package/src/memory/user-memory.ts

@@ -1,211 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { z } from "zod";
-import { InMemoryStorage } from "../storage/in-memory.js";
-import type { StorageDriver } from "../storage/driver.js";
-import type { ModelProvider } from "../models/provider.js";
-import type { ChatMessage } from "../models/types.js";
-import type { ToolDef } from "../tools/types.js";
-
-const USER_MEMORY_NS = "memory:user";
-
-export interface UserMemoryConfig {
-  storage?: StorageDriver;
-  /** LLM used for auto-extraction of facts from conversations. */
-  model?: ModelProvider;
-  /** Maximum number of facts stored per user (default 100). */
-  maxFacts?: number;
-  /** Whether auto-extraction is enabled (default true). */
-  enabled?: boolean;
-}
-
-export interface UserFact {
-  id: string;
-  fact: string;
-  createdAt: Date;
-  source: "auto" | "manual";
-}
-
-const EXTRACTION_PROMPT = `You are a memory extraction assistant. Analyze the conversation below and extract important facts about the user that would be useful for future personalization.
-
-Rules:
-- Extract concrete facts like preferences, location, profession, interests, goals, communication style
-- Each fact should be a short, self-contained statement (e.g., "Lives in Mumbai", "Prefers concise answers")
-- Do NOT extract transient information (e.g., "asked about weather today")
-- Do NOT extract information about the assistant
-- If there are no new meaningful facts, return an empty array
-- Return ONLY a valid JSON array of strings, nothing else
-
-Existing facts about this user (avoid duplicates):
-{existingFacts}
-
-Conversation:
-{conversation}
-
-Return a JSON array of new fact strings:`;
-
-export class UserMemory {
-  private storage: StorageDriver;
-  private model?: ModelProvider;
-  private maxFacts: number;
-  private enabled: boolean;
-  private initPromise: Promise<void> | null = null;
-
-  constructor(config?: UserMemoryConfig) {
-    this.storage = config?.storage ?? new InMemoryStorage();
-    this.model = config?.model;
-    this.maxFacts = config?.maxFacts ?? 100;
-    this.enabled = config?.enabled ?? true;
-  }
-
-  private ensureInitialized(): Promise<void> {
-    if (!this.initPromise) {
-      this.initPromise = (async () => {
-        if (typeof (this.storage as any).initialize === "function") {
-          await (this.storage as any).initialize();
-        }
-      })();
-    }
-    return this.initPromise;
-  }
-
-  async getFacts(userId: string): Promise<UserFact[]> {
-    await this.ensureInitialized();
-    return (await this.storage.get<UserFact[]>(USER_MEMORY_NS, userId)) ?? [];
-  }
-
-  async addFacts(userId: string, facts: string[], source: "auto" | "manual" = "manual"): Promise<void> {
-    await this.ensureInitialized();
-    const existing = await this.getFacts(userId);
-    const existingSet = new Set(existing.map((f) => f.fact.toLowerCase()));
-
-    const newFacts: UserFact[] = [];
-    for (const fact of facts) {
-      const normalized = fact.trim();
-      if (!normalized || existingSet.has(normalized.toLowerCase())) continue;
-      newFacts.push({
-        id: uuidv4(),
-        fact: normalized,
-        createdAt: new Date(),
-        source,
-      });
-      existingSet.add(normalized.toLowerCase());
-    }
-
-    if (newFacts.length === 0) return;
-
-    let updated = [...existing, ...newFacts];
-    if (updated.length > this.maxFacts) {
-      updated = updated.slice(updated.length - this.maxFacts);
-    }
-
-    await this.storage.set(USER_MEMORY_NS, userId, updated);
-  }
-
-  async removeFact(userId: string, factId: string): Promise<void> {
-    await this.ensureInitialized();
-    const existing = await this.getFacts(userId);
-    const updated = existing.filter((f) => f.id !== factId);
-    await this.storage.set(USER_MEMORY_NS, userId, updated);
-  }
-
-  async clear(userId: string): Promise<void> {
-    await this.ensureInitialized();
-    await this.storage.delete(USER_MEMORY_NS, userId);
-  }
-
-  async getContextString(userId: string): Promise<string> {
-    if (!this.enabled) return "";
-    const facts = await this.getFacts(userId);
-    if (facts.length === 0) return "";
-    const factList = facts.map((f) => `- ${f.fact}`).join("\n");
-    return `What you know about this user:\n${factList}`;
-  }
-
-  asTool(config?: { name?: string; description?: string }): ToolDef {
-    const mem = this;
-    return {
-      name: config?.name ?? "recall_user_facts",
-      description:
-        config?.description ??
-        "Retrieve stored facts about the current user — preferences, background, interests, and other personal details from past conversations. Call this when the user asks what you know or remember about them.",
-      parameters: z.object({}),
-      execute: async (_args, ctx) => {
-        const uid = ctx.userId;
-        if (!uid) return "No user identified for this session.";
-        const facts = await mem.getFacts(uid);
-        if (facts.length === 0) return "No stored facts about this user yet.";
-        return facts.map((f) => `- ${f.fact}`).join("\n");
-      },
-    };
-  }
-
-  async extractAndStore(
-    userId: string,
-    messages: ChatMessage[],
-    fallbackModel?: ModelProvider
-  ): Promise<void> {
-    if (!this.enabled) return;
-
-    const model = this.model ?? fallbackModel;
-    if (!model) return;
-
-    try {
-      const existing = await this.getFacts(userId);
-      const existingStr =
-        existing.length > 0
-          ? existing.map((f) => `- ${f.fact}`).join("\n")
-          : "(none)";
-
-      const conversationStr = messages
-        .filter((m) => m.role === "user" || m.role === "assistant")
-        .map((m) => {
-          const content = typeof m.content === "string" ? m.content : "(multimodal)";
-          return `${m.role}: ${content}`;
-        })
-        .join("\n");
-
-      const prompt = EXTRACTION_PROMPT
-        .replace("{existingFacts}", existingStr)
-        .replace("{conversation}", conversationStr);
-
-      const response = await model.generate(
-        [{ role: "user", content: prompt }],
-        { temperature: 0, maxTokens: 500 }
-      );
-
-      const text =
-        typeof response.message.content === "string"
-          ? response.message.content
-          : "";
-
-      if (!text) return;
-
-      const jsonStr = this.extractJsonArray(text);
-      const parsed = JSON.parse(jsonStr);
-
-      if (Array.isArray(parsed) && parsed.length > 0) {
-        const validFacts = parsed.filter(
-          (f: unknown) => typeof f === "string" && f.trim().length > 0
-        );
-        if (validFacts.length > 0) {
-          await this.addFacts(userId, validFacts, "auto");
-        }
-      }
-    } catch (err) {
-      console.warn("[UserMemory] extractAndStore failed:", (err as Error).message ?? err);
-    }
-  }
-
-  private extractJsonArray(text: string): string {
-    const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-    if (fenceMatch) return fenceMatch[1].trim();
-
-    const bracketStart = text.indexOf("[");
-    const bracketEnd = text.lastIndexOf("]");
-    if (bracketStart !== -1 && bracketEnd > bracketStart) {
-      return text.slice(bracketStart, bracketEnd + 1);
-    }
-
-    return text.trim();
-  }
-}

package/src/models/provider.ts

@@ -1,22 +0,0 @@
-import type {
-  ChatMessage,
-  ModelConfig,
-  ModelResponse,
-  StreamChunk,
-  ToolDefinition,
-} from "./types.js";
-
-export interface ModelProvider {
-  readonly providerId: string;
-  readonly modelId: string;
-
-  generate(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): Promise<ModelResponse>;
-
-  stream(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): AsyncGenerator<StreamChunk>;
-}

package/src/models/providers/anthropic.ts

@@ -1,360 +0,0 @@
-import { createRequire } from "node:module";
-import type { ModelProvider } from "../provider.js";
-import {
-  getTextContent,
-  isMultiModal,
-  type ChatMessage,
-  type ContentPart,
-  type ModelConfig,
-  type ModelResponse,
-  type StreamChunk,
-  type ToolDefinition,
-  type TokenUsage,
-  type ToolCall,
-} from "../types.js";
-
-const _require = createRequire(import.meta.url);
-
-interface AnthropicConfig {
-  apiKey?: string;
-}
-
-export class AnthropicProvider implements ModelProvider {
-  readonly providerId = "anthropic";
-  readonly modelId: string;
-  private client: any;
-  private AnthropicCtor: any;
-  private clientCache = new Map<string, any>();
-
-  constructor(modelId: string, config?: AnthropicConfig) {
-    this.modelId = modelId;
-    try {
-      const mod = _require("@anthropic-ai/sdk");
-      this.AnthropicCtor = mod.default ?? mod;
-      const key = config?.apiKey ?? process.env.ANTHROPIC_API_KEY;
-      if (key) {
-        this.client = new this.AnthropicCtor({ apiKey: key });
-      }
-    } catch {
-      throw new Error(
-        "@anthropic-ai/sdk is required for AnthropicProvider. Install it: npm install @anthropic-ai/sdk"
-      );
-    }
-  }
-
-  private getClient(apiKey?: string): any {
-    if (apiKey) {
-      let cached = this.clientCache.get(apiKey);
-      if (!cached) {
-        cached = new this.AnthropicCtor({ apiKey });
-        this.clientCache.set(apiKey, cached);
-      }
-      return cached;
-    }
-    if (this.client) return this.client;
-    const envKey = process.env.ANTHROPIC_API_KEY;
-    if (envKey) {
-      this.client = new this.AnthropicCtor({ apiKey: envKey });
-      return this.client;
-    }
-    throw new Error("No Anthropic API key provided. Pass it via the x-anthropic-api-key header, apiKey in request body, or set ANTHROPIC_API_KEY env var.");
-  }
-
-  async generate(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): Promise<ModelResponse> {
-    const { systemMsg, anthropicMessages } =
-      this.toAnthropicMessages(messages);
-
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      messages: anthropicMessages,
-      max_tokens: options?.maxTokens ?? 4096,
-    };
-
-    if (systemMsg) params.system = systemMsg;
-    if (options?.temperature !== undefined)
-      params.temperature = options.temperature;
-    if (options?.topP !== undefined) params.top_p = options.topP;
-    if (options?.stop) params.stop_sequences = options.stop;
-    if (options?.tools?.length) {
-      params.tools = this.toAnthropicTools(options.tools);
-    }
-    if (options?.reasoning?.enabled) {
-      params.thinking = {
-        type: "enabled",
-        budget_tokens: options.reasoning.budgetTokens ?? 10000,
-      };
-      delete params.temperature;
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const response = await client.messages.create(params);
-    return this.normalizeResponse(response);
-  }
-
-  async *stream(
-    messages: ChatMessage[],
-    options?: ModelConfig & { tools?: ToolDefinition[] }
-  ): AsyncGenerator<StreamChunk> {
-    const { systemMsg, anthropicMessages } =
-      this.toAnthropicMessages(messages);
-
-    const params: Record<string, unknown> = {
-      model: this.modelId,
-      messages: anthropicMessages,
-      max_tokens: options?.maxTokens ?? 4096,
-      stream: true,
-    };
-
-    if (systemMsg) params.system = systemMsg;
-    if (options?.temperature !== undefined)
-      params.temperature = options.temperature;
-    if (options?.topP !== undefined) params.top_p = options.topP;
-    if (options?.stop) params.stop_sequences = options.stop;
-    if (options?.tools?.length) {
-      params.tools = this.toAnthropicTools(options.tools);
-    }
-    if (options?.reasoning?.enabled) {
-      params.thinking = {
-        type: "enabled",
-        budget_tokens: options.reasoning.budgetTokens ?? 10000,
-      };
-      delete params.temperature;
-    }
-
-    const client = this.getClient(options?.apiKey);
-    const stream = await client.messages.create(params);
-
-    let currentToolId = "";
-    let inThinkingBlock = false;
-
-    for await (const event of stream) {
-      switch (event.type) {
-        case "content_block_start": {
-          if (event.content_block?.type === "tool_use") {
-            currentToolId = event.content_block.id;
-            yield {
-              type: "tool_call_start",
-              toolCall: {
-                id: event.content_block.id,
-                name: event.content_block.name,
-              },
-            };
-          } else if (event.content_block?.type === "thinking") {
-            inThinkingBlock = true;
-          }
-          break;
-        }
-        case "content_block_delta": {
-          if (event.delta?.type === "thinking_delta") {
-            yield { type: "thinking", text: event.delta.thinking };
-          } else if (event.delta?.type === "text_delta") {
-            yield { type: "text", text: event.delta.text };
-          } else if (event.delta?.type === "input_json_delta") {
-            yield {
-              type: "tool_call_delta",
-              toolCallId: currentToolId,
-              argumentsDelta: event.delta.partial_json,
-            };
-          }
-          break;
-        }
-        case "content_block_stop": {
-          if (inThinkingBlock) {
-            inThinkingBlock = false;
-          } else if (currentToolId) {
-            yield { type: "tool_call_end", toolCallId: currentToolId };
-            currentToolId = "";
-          }
-          break;
-        }
-        case "message_delta": {
-          const usage: TokenUsage | undefined = event.usage
-            ? {
-                promptTokens: 0,
-                completionTokens: event.usage.output_tokens ?? 0,
-                totalTokens: event.usage.output_tokens ?? 0,
-              }
-            : undefined;
-
-          let finishReason = event.delta?.stop_reason ?? "stop";
-          if (finishReason === "tool_use") finishReason = "tool_calls";
-          if (finishReason === "end_turn") finishReason = "stop";
-
-          yield { type: "finish", finishReason, usage };
-          break;
-        }
-        case "message_start": {
-          if (event.message?.usage) {
-            // Input tokens available at start
-          }
-          break;
-        }
-      }
-    }
-  }
-
-  private toAnthropicMessages(messages: ChatMessage[]): {
-    systemMsg: string | undefined;
-    anthropicMessages: unknown[];
-  } {
-    let systemMsg: string | undefined;
-    const anthropicMessages: unknown[] = [];
-
-    for (const msg of messages) {
-      if (msg.role === "system") {
-        systemMsg = getTextContent(msg.content) || undefined;
-        continue;
-      }
-
-      if (msg.role === "user") {
-        if (isMultiModal(msg.content)) {
-          anthropicMessages.push({
-            role: "user",
-            content: msg.content.map((p) => this.partToAnthropic(p)),
-          });
-        } else {
-          anthropicMessages.push({
-            role: "user",
-            content: [{ type: "text", text: msg.content ?? "" }],
-          });
-        }
-        continue;
-      }
-
-      if (msg.role === "assistant") {
-        const content: unknown[] = [];
-        if (msg.content) {
-          content.push({ type: "text", text: msg.content });
-        }
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            content.push({
-              type: "tool_use",
-              id: tc.id,
-              name: tc.name,
-              input: tc.arguments,
-            });
-          }
-        }
-        anthropicMessages.push({
-          role: "assistant",
-          content: content.length > 0 ? content : [{ type: "text", text: "" }],
-        });
-        continue;
-      }
-
-      if (msg.role === "tool") {
-        anthropicMessages.push({
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: msg.toolCallId,
-              content: msg.content ?? "",
-            },
-          ],
-        });
-        continue;
-      }
-    }
-
-    return { systemMsg, anthropicMessages };
-  }
-
-  private partToAnthropic(part: ContentPart): unknown {
-    switch (part.type) {
-      case "text":
-        return { type: "text", text: part.text };
-      case "image": {
-        const isUrl = part.data.startsWith("http://") || part.data.startsWith("https://");
-        if (isUrl) {
-          return { type: "image", source: { type: "url", url: part.data } };
-        }
-        return {
-          type: "image",
-          source: {
-            type: "base64",
-            media_type: part.mimeType ?? "image/png",
-            data: part.data,
-          },
-        };
-      }
-      case "audio":
-        return {
-          type: "text",
-          text: `[Audio content: ${part.mimeType ?? "audio"}]`,
-        };
-      case "file":
-        if (part.mimeType === "application/pdf") {
-          return {
-            type: "document",
-            source: { type: "base64", media_type: "application/pdf", data: part.data },
-          };
-        }
-        return {
-          type: "text",
-          text: `[File: ${part.filename ?? "attachment"} (${part.mimeType})]`,
-        };
-    }
-  }
-
-  private toAnthropicTools(tools: ToolDefinition[]): unknown[] {
-    return tools.map((t) => ({
-      name: t.name,
-      description: t.description,
-      input_schema: t.parameters,
-    }));
-  }
-
-  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
-    const toolCalls: ToolCall[] = [];
-    let textContent = "";
-    let thinkingContent = "";
-
-    for (const block of response.content ?? []) {
-      if (block.type === "text") {
-        textContent += block.text;
-      } else if (block.type === "thinking") {
-        thinkingContent += block.thinking;
-      } else if (block.type === "tool_use") {
-        toolCalls.push({
-          id: block.id,
-          name: block.name,
-          arguments: block.input ?? {},
-        });
-      }
-    }
-
-    const usage: TokenUsage = {
-      promptTokens: response.usage?.input_tokens ?? 0,
-      completionTokens: response.usage?.output_tokens ?? 0,
-      totalTokens:
-        (response.usage?.input_tokens ?? 0) +
-        (response.usage?.output_tokens ?? 0),
-    };
-
-    let finishReason: ModelResponse["finishReason"] = "stop";
-    if (response.stop_reason === "tool_use") finishReason = "tool_calls";
-    else if (response.stop_reason === "max_tokens") finishReason = "length";
-
-    const result: ModelResponse & { thinking?: string } = {
-      message: {
-        role: "assistant",
-        content: textContent || null,
-        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      },
-      usage,
-      finishReason,
-      raw: response,
-    };
-
-    if (thinkingContent) {
-      result.thinking = thinkingContent;
-    }
-
-    return result;
-  }
-}