oh-my-opencode-kikokikok 2.14.2 → 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.14.2",
+    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"),
@@ -22685,11 +22700,17 @@ var OpenSpecConfigSchema = exports_external.object({
   ]),
   rootDir: exports_external.string().default(".opencode/openspec")
 });
+var MCPTransportTypeSchema = exports_external.enum(["stdio", "sse"]);
 var MCPKnowledgeProviderConfigSchema = exports_external.object({
   name: exports_external.string(),
-  searchTool: exports_external.string(),
-  getTool: exports_external.string().optional(),
-  config: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  transport: MCPTransportTypeSchema.optional().describe("Transport type: 'stdio' (default) or 'sse'"),
+  command: exports_external.string().optional().describe("Command to start the MCP server (required for stdio transport)"),
+  args: exports_external.array(exports_external.string()).optional().describe("Arguments for the command (stdio transport)"),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Environment variables (stdio transport)"),
+  url: exports_external.string().optional().describe("SSE endpoint URL (required for sse transport, e.g., 'http://localhost:60062/sse')"),
+  searchTool: exports_external.string().describe("MCP tool name for search operations"),
+  getTool: exports_external.string().optional().describe("MCP tool name for get-by-id operations"),
+  config: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe("Additional config passed to MCP tools")
 });
 var NotebookLMProviderConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
@@ -22743,6 +22764,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   skills: SkillsConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   mem0: 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>;
@@ -1512,8 +1535,20 @@ export declare const OpenSpecConfigSchema: z.ZodObject<{
     }>>>;
     rootDir: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
+export declare const MCPTransportTypeSchema: z.ZodEnum<{
+    stdio: "stdio";
+    sse: "sse";
+}>;
 export declare const MCPKnowledgeProviderConfigSchema: z.ZodObject<{
     name: z.ZodString;
+    transport: z.ZodOptional<z.ZodEnum<{
+        stdio: "stdio";
+        sse: "sse";
+    }>>;
+    command: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
     searchTool: z.ZodString;
     getTool: z.ZodOptional<z.ZodString>;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -1551,6 +1586,14 @@ export declare const KnowledgeProviderConfigSchema: z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
             servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
+                transport: z.ZodOptional<z.ZodEnum<{
+                    stdio: "stdio";
+                    sse: "sse";
+                }>>;
+                command: z.ZodOptional<z.ZodString>;
+                args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                url: z.ZodOptional<z.ZodString>;
                 searchTool: z.ZodString;
                 getTool: z.ZodOptional<z.ZodString>;
                 config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -2878,6 +2921,29 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
             company: "company";
         }>>>;
     }, z.core.$strip>>;
+    letta: z.ZodOptional<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>>;
     knowledge_repo: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         rootDir: z.ZodDefault<z.ZodString>;
@@ -2921,6 +2987,14 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
                 enabled: z.ZodDefault<z.ZodBoolean>;
                 servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
                     name: z.ZodString;
+                    transport: z.ZodOptional<z.ZodEnum<{
+                        stdio: "stdio";
+                        sse: "sse";
+                    }>>;
+                    command: z.ZodOptional<z.ZodString>;
+                    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    url: z.ZodOptional<z.ZodString>;
                     searchTool: z.ZodString;
                     getTool: z.ZodOptional<z.ZodString>;
                     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -2977,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/knowledge-provider/index.d.ts

@@ -6,3 +6,4 @@ export { MCPKnowledgeProvider } from "./providers/mcp";
 export type { MCPInvoker } from "./providers/mcp";
 export { NotebookLMKnowledgeProvider } from "./providers/notebooklm";
 export type { NotebookLMProviderConfig } from "./providers/notebooklm";
+export { KnowledgeMcpManager } from "./mcp-manager";

package/dist/features/knowledge-provider/mcp-manager.d.ts

@@ -0,0 +1,67 @@
+import type { MCPInvoker } from "./providers/mcp";
+import type { MCPProviderConfig } from "./types";
+/**
+ * Manages MCP server connections for knowledge providers.
+ * Implements MCPInvoker interface to allow MCPKnowledgeProvider to invoke tools.
+ *
+ * Based on SkillMcpManager pattern but simplified for knowledge provider use case.
+ */
+export declare class KnowledgeMcpManager implements MCPInvoker {
+    private clients;
+    private pendingConnections;
+    private serverConfigs;
+    private cleanupRegistered;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    /**
+     * Register an MCP server configuration.
+     * The server will be started lazily on first invoke.
+     */
+    registerServer(config: MCPProviderConfig): void;
+    /**
+     * Unregister an MCP server and disconnect if connected.
+     */
+    unregisterServer(serverName: string): Promise<void>;
+    /**
+     * Check if an MCP server is available (registered and can connect).
+     */
+    isServerAvailable(serverName: string): Promise<boolean>;
+    /**
+     * Invoke a tool on an MCP server.
+     */
+    invoke(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Get or create a client for the given server.
+     */
+    private getOrCreateClient;
+    /**
+     * Create a new MCP client connection.
+     */
+    private createClient;
+    private createStdioTransport;
+    private createSseTransport;
+    /**
+     * Disconnect a specific server.
+     */
+    private disconnectServer;
+    /**
+     * Disconnect all servers and clean up.
+     */
+    disconnectAll(): Promise<void>;
+    private registerProcessCleanup;
+    private startCleanupTimer;
+    private stopCleanupTimer;
+    private cleanupIdleClients;
+    /**
+     * Get list of registered server names.
+     */
+    getRegisteredServers(): string[];
+    /**
+     * Get list of connected server names.
+     */
+    getConnectedServers(): string[];
+    /**
+     * Check if a server is currently connected.
+     */
+    isConnected(serverName: string): boolean;
+}

package/dist/features/knowledge-provider/mcp-manager.test.d.ts

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

package/dist/features/knowledge-provider/types.d.ts

@@ -232,17 +232,37 @@ export interface Mem0ProviderConfig {
     /** Layers to search */
     searchLayers?: MemoryLayer[];
 }
+/**
+ * Transport type for MCP connections.
+ * - stdio: Spawns a local process and communicates via stdin/stdout (default)
+ * - sse: Connects to an HTTP/SSE endpoint (for servers like Dust CLI that run as HTTP servers)
+ */
+export type MCPTransportType = "stdio" | "sse";
 /**
  * Configuration for an MCP knowledge provider.
  */
 export interface MCPProviderConfig {
-    /** MCP server name (from .mcp.json) */
+    /** MCP server name (unique identifier) */
     name: string;
+    /**
+     * Transport type for connecting to the MCP server.
+     * - "stdio" (default): Spawn a local process
+     * - "sse": Connect to an HTTP/SSE endpoint
+     */
+    transport?: MCPTransportType;
+    /** Command to start the MCP server (e.g., 'npx'). Required for stdio transport. */
+    command?: string;
+    /** Arguments for the command */
+    args?: string[];
+    /** Environment variables for the MCP process */
+    env?: Record<string, string>;
+    /** URL for SSE transport (e.g., 'http://localhost:60062/sse'). Required for sse transport. */
+    url?: string;
     /** Tool name for search operations */
     searchTool: string;
     /** Tool name for get-by-id operations */
     getTool?: string;
-    /** Additional config for the MCP */
+    /** Additional config passed to MCP tools */
     config?: Record<string, unknown>;
 }
 /**

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";