@radaros/core 0.1.0

package/src/memory/memory.ts

@@ -0,0 +1,87 @@
+import { InMemoryStorage } from "../storage/in-memory.js";
+import type { StorageDriver } from "../storage/driver.js";
+import { getTextContent, type ChatMessage } from "../models/types.js";
+import type { MemoryConfig, MemoryEntry } from "./types.js";
+
+const SHORT_TERM_NS = "memory:short";
+const LONG_TERM_NS = "memory:long";
+
+export class Memory {
+  private storage: StorageDriver;
+  private maxShortTermMessages: number;
+  private enableLongTerm: boolean;
+
+  constructor(config?: MemoryConfig) {
+    this.storage = config?.storage ?? new InMemoryStorage();
+    this.maxShortTermMessages = config?.maxShortTermMessages ?? 50;
+    this.enableLongTerm = config?.enableLongTerm ?? false;
+  }
+
+  async addMessages(
+    sessionId: string,
+    messages: ChatMessage[]
+  ): Promise<void> {
+    const existing =
+      (await this.storage.get<ChatMessage[]>(SHORT_TERM_NS, sessionId)) ?? [];
+    const updated = [...existing, ...messages];
+
+    if (updated.length > this.maxShortTermMessages) {
+      const overflow = updated.splice(
+        0,
+        updated.length - this.maxShortTermMessages
+      );
+
+      if (this.enableLongTerm && overflow.length > 0) {
+        await this.summarizeAndStore(sessionId, overflow);
+      }
+    }
+
+    await this.storage.set(SHORT_TERM_NS, sessionId, updated);
+  }
+
+  async getMessages(sessionId: string): Promise<ChatMessage[]> {
+    return (
+      (await this.storage.get<ChatMessage[]>(SHORT_TERM_NS, sessionId)) ?? []
+    );
+  }
+
+  async getSummaries(sessionId: string): Promise<string[]> {
+    if (!this.enableLongTerm) return [];
+
+    const entries = await this.storage.list<MemoryEntry>(
+      LONG_TERM_NS,
+      sessionId
+    );
+    return entries.map((e) => e.value.summary);
+  }
+
+  async getContextString(sessionId: string): Promise<string> {
+    const summaries = await this.getSummaries(sessionId);
+    if (summaries.length === 0) return "";
+    return `Previous context:\n${summaries.join("\n")}`;
+  }
+
+  private async summarizeAndStore(
+    sessionId: string,
+    messages: ChatMessage[]
+  ): Promise<void> {
+    const textParts = messages
+      .filter((m) => m.content)
+      .map((m) => `${m.role}: ${getTextContent(m.content)}`);
+
+    if (textParts.length === 0) return;
+
+    const summary = textParts.join(" | ").slice(0, 500);
+    const entry: MemoryEntry = {
+      key: `${sessionId}:${Date.now()}`,
+      summary,
+      createdAt: new Date(),
+    };
+
+    await this.storage.set(LONG_TERM_NS, entry.key, entry);
+  }
+
+  async clear(sessionId: string): Promise<void> {
+    await this.storage.delete(SHORT_TERM_NS, sessionId);
+  }
+}

package/src/memory/types.ts

@@ -0,0 +1,13 @@
+import type { StorageDriver } from "../storage/driver.js";
+
+export interface MemoryConfig {
+  storage?: StorageDriver;
+  maxShortTermMessages?: number;
+  enableLongTerm?: boolean;
+}
+
+export interface MemoryEntry {
+  key: string;
+  summary: string;
+  createdAt: Date;
+}

package/src/models/provider.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,330 @@
+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);
+    }
+
+    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);
+    }
+
+    const client = this.getClient(options?.apiKey);
+    const stream = await client.messages.create(params);
+
+    let currentToolId = "";
+
+    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,
+              },
+            };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          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 (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 {
+    const toolCalls: ToolCall[] = [];
+    let textContent = "";
+
+    for (const block of response.content ?? []) {
+      if (block.type === "text") {
+        textContent += block.text;
+      } 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";
+
+    return {
+      message: {
+        role: "assistant",
+        content: textContent || null,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      },
+      usage,
+      finishReason,
+      raw: response,
+    };
+  }
+}