oh-my-opencode-kikokikok 2.15.8 → 2.15.10

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.10",
     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,34 @@ export declare class LettaAdapter {
     private config;
     private endpoint;
     private agentCache;
-    private detectedEmbeddingModel;
-    private modelDetectionPromise;
+    private modelCache;
+    private modelCachePromise;
+    private resolvedEmbeddingModel;
+    private resolvedLlmModel;
+    private providerInitPromise;
     constructor(config: LettaConfig);
-    private detectEmbeddingModel;
-    private normalizeModelHandle;
+    /**
+     * Ensures the openai-proxy provider is registered in Letta when:
+     * 1. Models with openai-proxy/ prefix exist (from OPENAI_API_BASE env var)
+     * 2. No user-created openai-proxy provider exists
+     * 3. Copilot proxy is available locally
+     *
+     * This fixes the provider mismatch where Letta's built-in OpenAI provider
+     * creates models with openai-proxy/ handles but the provider is named "openai",
+     * causing agent creation to fail.
+     */
+    ensureOpenAIProxyProvider(): Promise<void>;
+    private doEnsureOpenAIProxyProvider;
+    private isCopilotProxyAvailable;
+    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,87 @@ 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", "openai-proxy"];
+var COPILOT_PROXY_ENDPOINT = "http://host.docker.internal:4141/v1";
+var COPILOT_PROXY_LOCAL = "http://localhost:4141/v1";
 
 class LettaAdapter {
   config;
   endpoint;
   agentCache = new Map;
-  detectedEmbeddingModel = null;
-  modelDetectionPromise = null;
+  modelCache = null;
+  modelCachePromise = null;
+  resolvedEmbeddingModel = null;
+  resolvedLlmModel = null;
+  providerInitPromise = null;
   constructor(config3) {
     this.config = config3;
     this.endpoint = config3.endpoint ?? DEFAULT_ENDPOINT2;
   }
-  async detectEmbeddingModel() {
-    if (this.config.embeddingModel) {
-      return this.normalizeModelHandle(this.config.embeddingModel);
+  async ensureOpenAIProxyProvider() {
+    if (this.providerInitPromise) {
+      return this.providerInitPromise;
     }
-    if (this.detectedEmbeddingModel) {
-      return this.detectedEmbeddingModel;
+    this.providerInitPromise = this.doEnsureOpenAIProxyProvider();
+    return this.providerInitPromise;
+  }
+  async doEnsureOpenAIProxyProvider() {
+    try {
+      const models = await this.getModels();
+      const hasOpenAIProxyModels = models.some((m) => m.handle.startsWith("openai-proxy/"));
+      if (!hasOpenAIProxyModels) {
+        return;
+      }
+      const providersResponse = await fetch(`${this.endpoint}/v1/providers/`, {
+        method: "GET",
+        redirect: "follow",
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!providersResponse.ok) {
+        return;
+      }
+      const providers = await providersResponse.json();
+      const hasOpenAIProxyProvider = providers.some((p) => p.name === "openai-proxy");
+      if (hasOpenAIProxyProvider) {
+        return;
+      }
+      const proxyAvailable = await this.isCopilotProxyAvailable();
+      if (!proxyAvailable) {
+        return;
+      }
+      await fetch(`${this.endpoint}/v1/providers/`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        redirect: "follow",
+        signal: AbortSignal.timeout(1e4),
+        body: JSON.stringify({
+          name: "openai-proxy",
+          provider_type: "openai",
+          api_key: "dummy",
+          base_url: COPILOT_PROXY_ENDPOINT
+        })
+      });
+    } catch {}
+  }
+  async isCopilotProxyAvailable() {
+    try {
+      const response2 = await fetch(`${COPILOT_PROXY_LOCAL}/models`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5000)
+      });
+      return response2.ok;
+    } catch {
+      return false;
     }
-    if (this.modelDetectionPromise) {
-      await this.modelDetectionPromise;
-      return this.detectedEmbeddingModel ?? DEFAULT_EMBEDDING_MODEL;
+  }
+  async getModels() {
+    if (this.modelCache) {
+      return this.modelCache;
+    }
+    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 +43871,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;
+  }
+  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;
   }
-  normalizeModelHandle(model) {
-    if (model.startsWith("openai/") && !model.startsWith("openai-proxy/")) {
-      return model.replace("openai/", "openai-proxy/");
+  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 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 this.resolvedLlmModel;
   }
   async add(input) {
     if (!this.config.enabled) {
@@ -44001,7 +44122,11 @@ class LettaAdapter {
         redirect: "follow",
         signal: AbortSignal.timeout(5000)
       });
-      return response2.ok;
+      if (response2.ok) {
+        await this.ensureOpenAIProxyProvider();
+        return true;
+      }
+      return false;
     } catch {
       return false;
     }
@@ -44015,8 +44140,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 +44172,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 +44180,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.10",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",