oh-my-opencode-kikokikok 2.15.8 → 2.15.9

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.8",
+    version: "2.15.9",
     description: "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
     main: "dist/index.js",
     types: "dist/index.d.ts",

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

@@ -3,11 +3,20 @@ export declare class LettaAdapter {
     private config;
     private endpoint;
     private agentCache;
-    private detectedEmbeddingModel;
-    private modelDetectionPromise;
+    private modelCache;
+    private modelCachePromise;
+    private resolvedEmbeddingModel;
+    private resolvedLlmModel;
     constructor(config: LettaConfig);
-    private detectEmbeddingModel;
-    private normalizeModelHandle;
+    private getModels;
+    /**
+     * Resolves user model name to Letta handle. Letta requires exact handle matches
+     * AND valid provider prefix (letta/, openai/). Models with other prefixes like
+     * openai-proxy/ will fail agent creation even if registered in the model list.
+     */
+    private resolveModelHandle;
+    private getEmbeddingModel;
+    private getLlmModel;
     add(input: AddMemoryInput): Promise<Memory>;
     search(input: SearchMemoryInput): Promise<MemorySearchResult[]>;
     get(id: string): Promise<Memory | null>;

package/dist/index.js

@@ -43783,29 +43783,28 @@ var DEFAULT_ENDPOINT2 = "http://localhost:8283";
 var DEFAULT_AGENT_PREFIX = "opencode";
 var DEFAULT_LLM_MODEL = "letta/letta-free";
 var DEFAULT_EMBEDDING_MODEL = "letta/letta-free";
+var VALID_PROVIDERS = ["letta", "openai"];
 
 class LettaAdapter {
   config;
   endpoint;
   agentCache = new Map;
-  detectedEmbeddingModel = null;
-  modelDetectionPromise = null;
+  modelCache = null;
+  modelCachePromise = null;
+  resolvedEmbeddingModel = null;
+  resolvedLlmModel = null;
   constructor(config3) {
     this.config = config3;
     this.endpoint = config3.endpoint ?? DEFAULT_ENDPOINT2;
   }
-  async detectEmbeddingModel() {
-    if (this.config.embeddingModel) {
-      return this.normalizeModelHandle(this.config.embeddingModel);
-    }
-    if (this.detectedEmbeddingModel) {
-      return this.detectedEmbeddingModel;
+  async getModels() {
+    if (this.modelCache) {
+      return this.modelCache;
     }
-    if (this.modelDetectionPromise) {
-      await this.modelDetectionPromise;
-      return this.detectedEmbeddingModel ?? DEFAULT_EMBEDDING_MODEL;
+    if (this.modelCachePromise) {
+      return this.modelCachePromise;
     }
-    this.modelDetectionPromise = (async () => {
+    this.modelCachePromise = (async () => {
       try {
         const response2 = await fetch(`${this.endpoint}/v1/models`, {
           method: "GET",
@@ -43813,26 +43812,89 @@ class LettaAdapter {
           signal: AbortSignal.timeout(1e4)
         });
         if (!response2.ok) {
-          return;
+          return [];
         }
         const models = await response2.json();
-        const proxyEmbeddingModels = models.filter((m) => m.name.includes("embedding") && m.model_endpoint.includes("host.docker.internal") && m.provider_name === "openai");
-        if (proxyEmbeddingModels.length > 0) {
-          const preferredName = this.config.preferredEmbeddingModel ?? "text-embedding-3-small";
-          const preferred = proxyEmbeddingModels.find((m) => m.name.includes(preferredName));
-          const model = preferred ?? proxyEmbeddingModels[0];
-          this.detectedEmbeddingModel = model.handle;
-        }
-      } catch {}
+        this.modelCache = models;
+        return models;
+      } catch {
+        return [];
+      }
     })();
-    await this.modelDetectionPromise;
-    return this.detectedEmbeddingModel ?? DEFAULT_EMBEDDING_MODEL;
+    return this.modelCachePromise;
   }
-  normalizeModelHandle(model) {
-    if (model.startsWith("openai/") && !model.startsWith("openai-proxy/")) {
-      return model.replace("openai/", "openai-proxy/");
+  async resolveModelHandle(requestedModel, isEmbedding = false) {
+    const models = await this.getModels();
+    if (models.length === 0) {
+      return requestedModel;
+    }
+    const hasValidProvider = (handle) => {
+      const provider = handle.split("/")[0];
+      return VALID_PROVIDERS.includes(provider);
+    };
+    const exactMatch = models.find((m) => m.handle === requestedModel && hasValidProvider(m.handle));
+    if (exactMatch) {
+      return exactMatch.handle;
+    }
+    const requestedName = requestedModel.includes("/") ? requestedModel.split("/").pop() : requestedModel;
+    const candidates = models.filter((m) => {
+      if (!hasValidProvider(m.handle)) {
+        return false;
+      }
+      if (isEmbedding && !m.name.includes("embedding")) {
+        return false;
+      }
+      return m.name.includes(requestedName) || m.handle.includes(requestedName);
+    });
+    if (candidates.length > 0) {
+      const proxyModel = candidates.find((m) => m.model_endpoint?.includes("host.docker.internal"));
+      return proxyModel?.handle ?? candidates[0].handle;
+    }
+    if (isEmbedding) {
+      const validEmbeddingModels = models.filter((m) => m.name.includes("embedding") && hasValidProvider(m.handle));
+      if (validEmbeddingModels.length > 0) {
+        const preferredName = this.config.preferredEmbeddingModel ?? "text-embedding-3-small";
+        const preferred = validEmbeddingModels.find((m) => m.name.includes(preferredName));
+        return preferred?.handle ?? validEmbeddingModels[0].handle;
+      }
+    }
+    return isEmbedding ? DEFAULT_EMBEDDING_MODEL : DEFAULT_LLM_MODEL;
+  }
+  async getEmbeddingModel() {
+    if (this.resolvedEmbeddingModel) {
+      return this.resolvedEmbeddingModel;
+    }
+    const configModel = this.config.embeddingModel;
+    if (configModel) {
+      this.resolvedEmbeddingModel = await this.resolveModelHandle(configModel, true);
+    } else {
+      const models = await this.getModels();
+      const hasValidProvider = (handle) => {
+        const provider = handle.split("/")[0];
+        return VALID_PROVIDERS.includes(provider);
+      };
+      const validEmbeddingModels = models.filter((m) => m.name.includes("embedding") && hasValidProvider(m.handle));
+      if (validEmbeddingModels.length > 0) {
+        const preferredName = this.config.preferredEmbeddingModel ?? "text-embedding-3-small";
+        const preferred = validEmbeddingModels.find((m) => m.name.includes(preferredName));
+        this.resolvedEmbeddingModel = preferred?.handle ?? validEmbeddingModels[0].handle;
+      } else {
+        this.resolvedEmbeddingModel = DEFAULT_EMBEDDING_MODEL;
+      }
+    }
+    return this.resolvedEmbeddingModel;
+  }
+  async getLlmModel() {
+    if (this.resolvedLlmModel) {
+      return this.resolvedLlmModel;
+    }
+    const configModel = this.config.llmModel;
+    if (configModel) {
+      this.resolvedLlmModel = await this.resolveModelHandle(configModel, false);
+    } else {
+      this.resolvedLlmModel = DEFAULT_LLM_MODEL;
     }
-    return model;
+    return this.resolvedLlmModel;
   }
   async add(input) {
     if (!this.config.enabled) {
@@ -44015,8 +44077,8 @@ class LettaAdapter {
       }
       return existing;
     }
-    const embeddingModel = await this.detectEmbeddingModel();
-    const llmModel = this.normalizeModelHandle(this.config.llmModel ?? DEFAULT_LLM_MODEL);
+    const embeddingModel = await this.getEmbeddingModel();
+    const llmModel = await this.getLlmModel();
     const agentName = this.getAgentName(layer);
     const response2 = await this.request("/v1/agents", {
       method: "POST",
@@ -44047,7 +44109,7 @@ class LettaAdapter {
     if (!embeddingHandle)
       return false;
     if (embeddingHandle === "letta/letta-free") {
-      const detected = await this.detectEmbeddingModel();
+      const detected = await this.getEmbeddingModel();
       return detected !== "letta/letta-free";
     }
     return false;
@@ -44055,8 +44117,8 @@ class LettaAdapter {
   async recreateAgentWithCorrectEmbedding(existingAgent, layer) {
     await this.request(`/v1/agents/${existingAgent.id}`, { method: "DELETE" }).catch(() => {});
     this.agentCache.delete(layer);
-    const embeddingModel = await this.detectEmbeddingModel();
-    const llmModel = this.normalizeModelHandle(this.config.llmModel ?? DEFAULT_LLM_MODEL);
+    const embeddingModel = await this.getEmbeddingModel();
+    const llmModel = await this.getLlmModel();
     const agentName = this.getAgentName(layer);
     const response2 = await this.request("/v1/agents", {
       method: "POST",

package/package.json

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