oh-my-opencode-kikokikok 2.15.0 → 2.15.1

package/dist/cli/index.js

@@ -2253,7 +2253,7 @@ var require_picocolors = __commonJS((exports, module) => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "oh-my-opencode-kikokikok",
-    version: "2.15.0",
+    version: "2.15.1",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -22646,6 +22646,21 @@ var Mem0ConfigSchema = exports_external.object({
   autoRehydrate: exports_external.boolean().default(true),
   rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
 });
+var LettaConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  endpoint: exports_external.string().url().optional().describe("Letta server endpoint (default: http://localhost:8283)"),
+  apiKey: exports_external.string().optional().describe("Optional API key for cloud Letta (not needed for self-hosted)"),
+  userId: exports_external.string().optional(),
+  projectId: exports_external.string().optional(),
+  teamId: exports_external.string().optional(),
+  orgId: exports_external.string().optional(),
+  companyId: exports_external.string().optional(),
+  agentPrefix: exports_external.string().optional().describe("Agent name prefix (default: opencode)"),
+  llmModel: exports_external.string().optional().describe("LLM model for agent (e.g., openai/gpt-4.1)"),
+  embeddingModel: exports_external.string().optional().describe("Embedding model for semantic search"),
+  autoRehydrate: exports_external.boolean().default(true),
+  rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
+});
 var CentralHubConfigSchema = exports_external.object({
   url: exports_external.string().url(),
   branch: exports_external.string().default("main"),
@@ -22749,7 +22764,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   skills: SkillsConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   mem0: Mem0ConfigSchema.optional(),
-  letta: Mem0ConfigSchema.optional(),
+  letta: LettaConfigSchema.optional(),
   knowledge_repo: KnowledgeRepoConfigSchema.optional(),
   knowledge_provider: KnowledgeProviderConfigSchema.optional(),
   openspec: OpenSpecConfigSchema.optional()

package/dist/config/schema.d.ts

@@ -1455,6 +1455,29 @@ export declare const Mem0ConfigSchema: z.ZodObject<{
         company: "company";
     }>>>;
 }, z.core.$strip>;
+export declare const LettaConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    orgId: z.ZodOptional<z.ZodString>;
+    companyId: z.ZodOptional<z.ZodString>;
+    agentPrefix: z.ZodOptional<z.ZodString>;
+    llmModel: z.ZodOptional<z.ZodString>;
+    embeddingModel: z.ZodOptional<z.ZodString>;
+    autoRehydrate: z.ZodDefault<z.ZodBoolean>;
+    rehydrateLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        session: "session";
+        project: "project";
+        team: "team";
+        org: "org";
+        company: "company";
+    }>>>;
+}, z.core.$strip>;
 export declare const CentralHubConfigSchema: z.ZodObject<{
     url: z.ZodString;
     branch: z.ZodDefault<z.ZodString>;
@@ -2900,15 +2923,16 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     letta: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
-        apiKey: z.ZodOptional<z.ZodString>;
         endpoint: z.ZodOptional<z.ZodString>;
+        apiKey: z.ZodOptional<z.ZodString>;
         userId: z.ZodOptional<z.ZodString>;
-        sessionId: z.ZodOptional<z.ZodString>;
         projectId: z.ZodOptional<z.ZodString>;
         teamId: z.ZodOptional<z.ZodString>;
         orgId: z.ZodOptional<z.ZodString>;
         companyId: z.ZodOptional<z.ZodString>;
-        agentId: z.ZodOptional<z.ZodString>;
+        agentPrefix: z.ZodOptional<z.ZodString>;
+        llmModel: z.ZodOptional<z.ZodString>;
+        embeddingModel: z.ZodOptional<z.ZodString>;
         autoRehydrate: z.ZodDefault<z.ZodBoolean>;
         rehydrateLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             user: "user";
@@ -3027,6 +3051,7 @@ export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
 export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;
 export type Mem0Config = z.infer<typeof Mem0ConfigSchema>;
+export type LettaConfig = z.infer<typeof LettaConfigSchema>;
 export type CentralHubConfig = z.infer<typeof CentralHubConfigSchema>;
 export type KnowledgeRepoConfig = z.infer<typeof KnowledgeRepoConfigSchema>;
 export type OpenSpecConfig = z.infer<typeof OpenSpecConfigSchema>;

package/dist/features/letta-memory/adapter.d.ts

@@ -0,0 +1,24 @@
+import type { LettaConfig, Memory, MemorySearchResult, AddMemoryInput, SearchMemoryInput, UpdateMemoryInput, MemoryStats, MemoryLayer } from "./types";
+export declare class LettaAdapter {
+    private config;
+    private endpoint;
+    private agentCache;
+    constructor(config: LettaConfig);
+    add(input: AddMemoryInput): Promise<Memory>;
+    search(input: SearchMemoryInput): Promise<MemorySearchResult[]>;
+    get(id: string): Promise<Memory | null>;
+    update(input: UpdateMemoryInput): Promise<Memory>;
+    delete(id: string): Promise<void>;
+    getAll(layer?: MemoryLayer): Promise<Memory[]>;
+    getStats(): Promise<MemoryStats>;
+    isAvailable(): Promise<boolean>;
+    private getOrCreateAgent;
+    private getAgent;
+    private listAgents;
+    private request;
+    private getAgentName;
+    private getUserId;
+    private normalizeLayers;
+    private getAllLayers;
+    private passageToMemory;
+}

package/dist/features/letta-memory/adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/letta-memory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { LettaAdapter } from "./adapter";

package/dist/features/letta-memory/types.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Letta (formerly MemGPT) Memory Types
+ *
+ * Letta organizes memory around Agents with:
+ * - Core Memory (Blocks): Always in-context, editable by agent
+ * - Archival Memory (Passages): Out-of-context, searchable via embeddings
+ */
+export type MemoryLayer = "user" | "session" | "project" | "team" | "org" | "company" | "agent";
+export interface LettaConfig {
+    enabled: boolean;
+    /** Letta server endpoint (default: http://localhost:8283) */
+    endpoint?: string;
+    /** Optional API key for cloud Letta (not needed for self-hosted) */
+    apiKey?: string;
+    /** User identifier for scoping agents */
+    userId?: string;
+    /** Project identifier */
+    projectId?: string;
+    /** Team identifier */
+    teamId?: string;
+    /** Organization identifier */
+    orgId?: string;
+    /** Company identifier */
+    companyId?: string;
+    /** Default agent name prefix */
+    agentPrefix?: string;
+    /** LLM model for agent (e.g., "openai/gpt-4.1") */
+    llmModel?: string;
+    /** Embedding model for semantic search */
+    embeddingModel?: string;
+    /** Auto-rehydrate memories on session start */
+    autoRehydrate?: boolean;
+    /** Layers to rehydrate */
+    rehydrateLayers?: MemoryLayer[];
+}
+/** Letta Agent representation */
+export interface LettaAgent {
+    id: string;
+    name: string;
+    description?: string;
+    created_at: string;
+    user_id?: string;
+    metadata?: Record<string, unknown>;
+    memory_blocks?: LettaBlock[];
+    tools?: string[];
+}
+/** Letta Memory Block (Core Memory - always in-context) */
+export interface LettaBlock {
+    id: string;
+    label: string;
+    value: string;
+    description?: string;
+    limit?: number;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+    updated_at?: string;
+}
+/** Letta Passage (Archival Memory - searchable) */
+export interface LettaPassage {
+    id: string;
+    text: string;
+    agent_id?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    embedding?: number[];
+}
+/** Letta Archive container for passages */
+export interface LettaArchive {
+    id: string;
+    name: string;
+    description?: string;
+    agent_id?: string;
+    created_at: string;
+}
+/** Unified memory representation (compatible with existing tools) */
+export interface Memory {
+    id: string;
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt?: string;
+    /** Letta-specific: source type */
+    source?: "block" | "passage";
+    /** Letta-specific: agent ID */
+    agentId?: string;
+}
+export interface MemorySearchResult {
+    memory: Memory;
+    score: number;
+}
+export interface AddMemoryInput {
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+    /** Store as block (core memory) or passage (archival). Default: passage */
+    type?: "block" | "passage";
+    /** Block label if storing as block */
+    blockLabel?: string;
+    /** Tags for passage search */
+    tags?: string[];
+}
+export interface SearchMemoryInput {
+    query: string;
+    layer?: MemoryLayer | MemoryLayer[];
+    limit?: number;
+    threshold?: number;
+    /** Filter by tags */
+    tags?: string[];
+    /** Tag match mode */
+    tagMatchMode?: "any" | "all";
+}
+export interface UpdateMemoryInput {
+    id: string;
+    content?: string;
+    metadata?: Record<string, unknown>;
+    tags?: string[];
+}
+export interface MemoryStats {
+    totalMemories: number;
+    byLayer: Record<MemoryLayer, number>;
+    /** Letta-specific stats */
+    totalAgents?: number;
+    totalBlocks?: number;
+    totalPassages?: number;
+}
+/** Letta API response types */
+export interface LettaApiResponse<T> {
+    data?: T;
+    error?: string;
+    message?: string;
+}
+export interface LettaSearchResponse {
+    passages: LettaPassage[];
+    total?: number;
+}
+export interface LettaAgentListResponse {
+    agents: LettaAgent[];
+}

package/dist/hooks/memory-rehydration/index.d.ts

@@ -1,4 +1,4 @@
-import type { Mem0Adapter } from "../../features/mem0-memory/adapter";
+import type { MemoryAdapter } from "../../tools/memory/types";
 import type { MemoryRehydrationConfig, RehydrationResult } from "./types";
 import { HOOK_NAME } from "./constants";
 export interface MemoryRehydrationHook {
@@ -12,6 +12,6 @@ export interface MemoryRehydrationHook {
     forceRehydrate: (sessionID: string) => Promise<RehydrationResult>;
     clearSession: (sessionID: string) => void;
 }
-export declare function createMemoryRehydrationHook(adapter: Mem0Adapter, config?: MemoryRehydrationConfig): MemoryRehydrationHook;
+export declare function createMemoryRehydrationHook(adapter: MemoryAdapter, config?: MemoryRehydrationConfig): MemoryRehydrationHook;
 export { HOOK_NAME };
 export type { MemoryRehydrationConfig } from "./types";

package/dist/index.js

@@ -43777,6 +43777,290 @@ class Mem0Adapter {
     });
   }
 }
+
+// src/features/letta-memory/adapter.ts
+var DEFAULT_ENDPOINT2 = "http://localhost:8283";
+var DEFAULT_AGENT_PREFIX = "opencode";
+var DEFAULT_LLM_MODEL = "openai/gpt-4.1";
+var DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+
+class LettaAdapter {
+  config;
+  endpoint;
+  agentCache = new Map;
+  constructor(config3) {
+    this.config = config3;
+    this.endpoint = config3.endpoint ?? DEFAULT_ENDPOINT2;
+  }
+  async add(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    const agent = await this.getOrCreateAgent(input.layer);
+    const tags = [
+      `layer:${input.layer}`,
+      ...input.tags ?? [],
+      ...input.metadata ? Object.entries(input.metadata).map(([k, v]) => `${k}:${v}`) : []
+    ];
+    const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, {
+      method: "POST",
+      body: JSON.stringify({
+        text: input.content,
+        tags
+      })
+    });
+    const passage = await response2.json();
+    return this.passageToMemory(passage, input.layer, agent.id);
+  }
+  async search(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    const layers = this.normalizeLayers(input.layer);
+    const results = [];
+    for (const layer of layers) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        const params = new URLSearchParams;
+        params.set("query", input.query);
+        if (input.limit)
+          params.set("limit", String(input.limit));
+        if (input.tags?.length) {
+          params.set("tags", input.tags.join(","));
+          params.set("tag_match_mode", input.tagMatchMode ?? "any");
+        }
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory/search?${params.toString()}`, { method: "GET" });
+        const data = await response2.json();
+        const layerResults = data.map((passage, index) => ({
+          memory: this.passageToMemory(passage, layer, agent.id),
+          score: 1 - index * 0.05
+        }));
+        results.push(...layerResults);
+      } catch {
+        continue;
+      }
+    }
+    return results.filter((r) => !input.threshold || r.score >= input.threshold).sort((a, b) => b.score - a.score).slice(0, input.limit ?? 10);
+  }
+  async get(id) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    for (const layer of this.getAllLayers()) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, { method: "GET" });
+        const passages = await response2.json();
+        const passage = passages.find((p) => p.id === id);
+        if (passage) {
+          return this.passageToMemory(passage, layer, agent.id);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  async update(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    const existing = await this.get(input.id);
+    if (!existing) {
+      throw new Error(`Memory not found: ${input.id}`);
+    }
+    await this.delete(input.id);
+    return this.add({
+      content: input.content ?? existing.content,
+      layer: existing.layer,
+      metadata: input.metadata ? { ...existing.metadata, ...input.metadata } : existing.metadata,
+      tags: input.tags
+    });
+  }
+  async delete(id) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    for (const layer of this.getAllLayers()) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        await this.request(`/v1/agents/${agent.id}/archival-memory/${id}`, {
+          method: "DELETE"
+        });
+        return;
+      } catch {
+        continue;
+      }
+    }
+    throw new Error(`Memory not found: ${id}`);
+  }
+  async getAll(layer) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    const layers = layer ? [layer] : this.getAllLayers();
+    const memories = [];
+    for (const l of layers) {
+      try {
+        const agent = await this.getAgent(l);
+        if (!agent)
+          continue;
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, { method: "GET" });
+        const passages = await response2.json();
+        memories.push(...passages.map((p) => this.passageToMemory(p, l, agent.id)));
+      } catch {
+        continue;
+      }
+    }
+    return memories;
+  }
+  async getStats() {
+    const memories = await this.getAll();
+    const byLayer = {
+      user: 0,
+      session: 0,
+      project: 0,
+      team: 0,
+      org: 0,
+      company: 0,
+      agent: 0
+    };
+    for (const memory of memories) {
+      byLayer[memory.layer]++;
+    }
+    const agents = await this.listAgents();
+    return {
+      totalMemories: memories.length,
+      byLayer,
+      totalAgents: agents.length,
+      totalPassages: memories.length
+    };
+  }
+  async isAvailable() {
+    try {
+      const response2 = await fetch(`${this.endpoint}/v1/health`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5000)
+      });
+      return response2.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getOrCreateAgent(layer) {
+    const existing = await this.getAgent(layer);
+    if (existing)
+      return existing;
+    const agentName = this.getAgentName(layer);
+    const response2 = await this.request("/v1/agents", {
+      method: "POST",
+      body: JSON.stringify({
+        name: agentName,
+        model: this.config.llmModel ?? DEFAULT_LLM_MODEL,
+        embedding: this.config.embeddingModel ?? DEFAULT_EMBEDDING_MODEL,
+        memory_blocks: [
+          { label: "persona", value: `OpenCode memory agent for ${layer} layer` },
+          { label: "human", value: this.getUserId(layer) }
+        ],
+        metadata: {
+          layer,
+          user_id: this.getUserId(layer),
+          created_by: "oh-my-opencode"
+        }
+      })
+    });
+    const agent = await response2.json();
+    this.agentCache.set(layer, agent);
+    return agent;
+  }
+  async getAgent(layer) {
+    if (this.agentCache.has(layer)) {
+      return this.agentCache.get(layer);
+    }
+    const agentName = this.getAgentName(layer);
+    const agents = await this.listAgents();
+    const agent = agents.find((a) => a.name === agentName);
+    if (agent) {
+      this.agentCache.set(layer, agent);
+    }
+    return agent ?? null;
+  }
+  async listAgents() {
+    try {
+      const response2 = await this.request("/v1/agents", { method: "GET" });
+      const data = await response2.json();
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  async request(path7, options) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const response2 = await fetch(`${this.endpoint}${path7}`, {
+      method: options.method,
+      headers,
+      body: options.body
+    });
+    if (!response2.ok) {
+      const text = await response2.text().catch(() => "");
+      throw new Error(`Letta API error: ${response2.status} ${response2.statusText} - ${text}`);
+    }
+    return response2;
+  }
+  getAgentName(layer) {
+    const prefix = this.config.agentPrefix ?? DEFAULT_AGENT_PREFIX;
+    const userId = this.getUserId(layer);
+    return `${prefix}-${layer}-${userId}`;
+  }
+  getUserId(layer) {
+    switch (layer) {
+      case "user":
+        return this.config.userId ?? "default-user";
+      case "session":
+        return `session-${this.config.userId ?? "default"}`;
+      case "project":
+        return this.config.projectId ?? "default-project";
+      case "team":
+        return this.config.teamId ?? "default-team";
+      case "org":
+        return this.config.orgId ?? "default-org";
+      case "company":
+        return this.config.companyId ?? "default-company";
+      case "agent":
+        return "default-agent";
+    }
+  }
+  normalizeLayers(layer) {
+    if (!layer)
+      return this.getAllLayers();
+    return Array.isArray(layer) ? layer : [layer];
+  }
+  getAllLayers() {
+    return ["user", "session", "project", "team", "org", "company", "agent"];
+  }
+  passageToMemory(passage, layer, agentId) {
+    return {
+      id: passage.id,
+      content: passage.text,
+      layer,
+      metadata: passage.metadata,
+      createdAt: passage.created_at,
+      source: "passage",
+      agentId
+    };
+  }
+}
 // src/features/knowledge-provider/registry.ts
 var DEFAULT_CONFIG2 = {
   defaultLimit: 10,
@@ -49637,6 +49921,21 @@ var Mem0ConfigSchema = exports_external.object({
   autoRehydrate: exports_external.boolean().default(true),
   rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
 });
+var LettaConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  endpoint: exports_external.string().url().optional().describe("Letta server endpoint (default: http://localhost:8283)"),
+  apiKey: exports_external.string().optional().describe("Optional API key for cloud Letta (not needed for self-hosted)"),
+  userId: exports_external.string().optional(),
+  projectId: exports_external.string().optional(),
+  teamId: exports_external.string().optional(),
+  orgId: exports_external.string().optional(),
+  companyId: exports_external.string().optional(),
+  agentPrefix: exports_external.string().optional().describe("Agent name prefix (default: opencode)"),
+  llmModel: exports_external.string().optional().describe("LLM model for agent (e.g., openai/gpt-4.1)"),
+  embeddingModel: exports_external.string().optional().describe("Embedding model for semantic search"),
+  autoRehydrate: exports_external.boolean().default(true),
+  rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
+});
 var CentralHubConfigSchema = exports_external.object({
   url: exports_external.string().url(),
   branch: exports_external.string().default("main"),
@@ -49740,22 +50039,12 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   skills: SkillsConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   mem0: Mem0ConfigSchema.optional(),
-  letta: Mem0ConfigSchema.optional(),
+  letta: LettaConfigSchema.optional(),
   knowledge_repo: KnowledgeRepoConfigSchema.optional(),
   knowledge_provider: KnowledgeProviderConfigSchema.optional(),
   openspec: OpenSpecConfigSchema.optional()
 });
 // src/plugin-config.ts
-function normalizeLettaToMem0(config3) {
-  if (!config3.letta) {
-    return config3;
-  }
-  const { letta, ...rest } = config3;
-  if (config3.mem0) {
-    return { ...rest, mem0: deepMerge(letta, config3.mem0) };
-  }
-  return { ...rest, mem0: letta };
-}
 function loadConfigFromPath2(configPath, ctx) {
   try {
     if (fs9.existsSync(configPath)) {
@@ -49772,9 +50061,8 @@ function loadConfigFromPath2(configPath, ctx) {
         });
         return null;
       }
-      const normalized = normalizeLettaToMem0(result.data);
-      log(`Config loaded from ${configPath}`, { agents: normalized.agents });
-      return normalized;
+      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+      return result.data;
     }
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -49789,6 +50077,7 @@ function mergeConfigs(base, override) {
     ...override,
     agents: deepMerge(base.agents, override.agents),
     mem0: deepMerge(base.mem0, override.mem0),
+    letta: deepMerge(base.letta, override.letta),
     disabled_agents: [
       ...new Set([
         ...base.disabled_agents ?? [],
@@ -55444,16 +55733,30 @@ var OhMyOpenCodePlugin = async (ctx) => {
     companyId: pluginConfig.mem0.companyId,
     agentId: pluginConfig.mem0.agentId
   }) : null;
-  const memoryTools = mem0Adapter ? createMemoryTools(mem0Adapter) : {};
+  const lettaAdapter = pluginConfig.letta?.enabled ? new LettaAdapter({
+    enabled: true,
+    endpoint: pluginConfig.letta.endpoint,
+    apiKey: pluginConfig.letta.apiKey,
+    userId: pluginConfig.letta.userId,
+    projectId: pluginConfig.letta.projectId,
+    teamId: pluginConfig.letta.teamId,
+    orgId: pluginConfig.letta.orgId,
+    companyId: pluginConfig.letta.companyId,
+    agentPrefix: pluginConfig.letta.agentPrefix,
+    llmModel: pluginConfig.letta.llmModel,
+    embeddingModel: pluginConfig.letta.embeddingModel
+  }) : null;
+  const memoryAdapter = lettaAdapter ?? mem0Adapter;
+  const memoryTools = memoryAdapter ? createMemoryTools(memoryAdapter) : {};
   const knowledgeProviderRegistry = pluginConfig.knowledge_provider?.enabled ? await initializeKnowledgeProviderRegistry(pluginConfig, mem0Adapter) : null;
   const knowledgeMonitor = isHookEnabled("knowledge-monitor") && pluginConfig.knowledge_repo?.enabled ? createKnowledgeMonitorHook(ctx.directory, {
     enabled: true,
     checkPreTool: true,
     checkPostTool: false
   }) : null;
-  const memoryRehydration = isHookEnabled("memory-rehydration") && mem0Adapter && pluginConfig.mem0?.autoRehydrate !== false ? createMemoryRehydrationHook(mem0Adapter, {
+  const memoryRehydration = isHookEnabled("memory-rehydration") && memoryAdapter && (pluginConfig.letta?.autoRehydrate !== false || pluginConfig.mem0?.autoRehydrate !== false) ? createMemoryRehydrationHook(memoryAdapter, {
     enabled: true,
-    layers: pluginConfig.mem0?.rehydrateLayers
+    layers: pluginConfig.letta?.rehydrateLayers ?? pluginConfig.mem0?.rehydrateLayers
   }) : null;
   const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }) : null;

package/dist/tools/memory/index.d.ts

@@ -1,2 +1,2 @@
 export { createMemoryTools } from "./tools";
-export type { MemoryToolsConfig, MemoryLayer } from "./types";
+export type { MemoryAdapter, MemoryLayer, Memory, MemorySearchResult, MemoryStats } from "./types";

package/dist/tools/memory/tools.d.ts

@@ -1,3 +1,3 @@
 import { type ToolDefinition } from "@opencode-ai/plugin/tool";
-import type { Mem0Adapter } from "../../features/mem0-memory/adapter";
-export declare function createMemoryTools(adapter: Mem0Adapter): Record<string, ToolDefinition>;
+import type { MemoryAdapter } from "./types";
+export declare function createMemoryTools(adapter: MemoryAdapter): Record<string, ToolDefinition>;

package/dist/tools/memory/types.d.ts

@@ -1,6 +1,44 @@
-import type { Mem0Adapter } from "../../features/mem0-memory/adapter";
 import type { MemoryLayer } from "../../features/mem0-memory/types";
-export interface MemoryToolsConfig {
-    adapter: Mem0Adapter;
+export interface Memory {
+    id: string;
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface MemorySearchResult {
+    memory: Memory;
+    score: number;
+}
+export interface AddMemoryInput {
+    content: string;
+    layer: MemoryLayer;
+    metadata?: Record<string, unknown>;
+}
+export interface SearchMemoryInput {
+    query: string;
+    layer?: MemoryLayer | MemoryLayer[];
+    limit?: number;
+    threshold?: number;
+}
+export interface UpdateMemoryInput {
+    id: string;
+    content?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryStats {
+    totalMemories: number;
+    byLayer: Record<MemoryLayer, number>;
+}
+export interface MemoryAdapter {
+    add(input: AddMemoryInput): Promise<Memory>;
+    search(input: SearchMemoryInput): Promise<MemorySearchResult[]>;
+    get(id: string): Promise<Memory | null>;
+    update(input: UpdateMemoryInput): Promise<Memory>;
+    delete(id: string): Promise<void>;
+    getAll(layer?: MemoryLayer): Promise<Memory[]>;
+    getStats(): Promise<MemoryStats>;
+    isAvailable?(): Promise<boolean>;
 }
 export type { MemoryLayer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-kikokikok",
-  "version": "2.15.0",
+  "version": "2.15.1",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",