osagent 0.1.98 → 0.1.100

package/cli.js

@@ -141747,6 +141747,14 @@ var init_openai = __esm({
 });
 
 // packages/core/dist/src/core/credentialValidator.js
+var credentialValidator_exports = {};
+__export(credentialValidator_exports, {
+  getProviderHelpText: () => getProviderHelpText,
+  validateGroqCredentials: () => validateGroqCredentials,
+  validateOllamaCloudCredentials: () => validateOllamaCloudCredentials,
+  validateOllamaLocalCredentials: () => validateOllamaLocalCredentials,
+  validateOpenAICredentials: () => validateOpenAICredentials
+});
 function getProviderHelpText(authType) {
   return PROVIDER_HELP_TEXT[authType] || "Please check your API key and try again";
 }
@@ -141760,9 +141768,9 @@ async function validateOpenAICredentials(client, authType, timeout2 = DEFAULT_VA
   }
 }
 async function validateOllamaCloudCredentials(apiKey, timeout2 = DEFAULT_VALIDATION_TIMEOUT) {
-  const baseUrl = "https://api.ollama.com/v1";
+  const baseUrl = "https://ollama.com";
   try {
-    const response = await fetch(`${baseUrl}/models`, {
+    const response = await fetch(`${baseUrl}/api/tags`, {
       method: "GET",
       headers: {
         Authorization: `Bearer ${apiKey}`,
@@ -145280,6 +145288,23 @@ ${this.getTimeoutTroubleshootingTips(context2)}`);
           return `${errorMessage}
 
 \u{1F4A1} Model not found. Pull it with: ollama pull <model-name>`;
+        }
+        if (lowerMessage.includes("401") || lowerMessage.includes("unauthorized") || lowerMessage.includes("invalid api key") || lowerMessage.includes("invalid_api_key")) {
+          if (lowerMessage.includes("groq") || lowerMessage.includes("api.groq.com")) {
+            return `${errorMessage}
+
+\u{1F4A1} Invalid GROQ API key. Get one at: https://console.groq.com/keys
+Set it with: export GROQ_API_KEY=your_key`;
+          }
+          if (lowerMessage.includes("ollama")) {
+            return `${errorMessage}
+
+\u{1F4A1} Invalid Ollama Cloud API key. Get one at: https://ollama.com/settings/keys
+Set it with: export OLLAMA_API_KEY=your_key`;
+          }
+          return `${errorMessage}
+
+\u{1F4A1} Invalid API key. Please check your API key is correct and not expired.`;
         }
         if (lowerMessage.includes("groq") && lowerMessage.includes("rate limit")) {
           return `${errorMessage}
@@ -148117,6 +148142,459 @@ var init_openaiContentGenerator2 = __esm({
   }
 });
 
+// packages/core/dist/src/core/ollamaContentGenerator/index.js
+var ollamaContentGenerator_exports = {};
+__export(ollamaContentGenerator_exports, {
+  OllamaContentGenerator: () => OllamaContentGenerator,
+  createOllamaContentGenerator: () => createOllamaContentGenerator
+});
+function getEffectiveOllamaUrl2() {
+  const ollamaHost = process.env["OLLAMA_HOST"];
+  if (ollamaHost) {
+    const url3 = ollamaHost.startsWith("http") ? ollamaHost : `http://${ollamaHost}`;
+    return url3.replace(/\/$/, "");
+  }
+  const ollamaBaseUrl = process.env["OLLAMA_BASE_URL"];
+  if (ollamaBaseUrl) {
+    return ollamaBaseUrl.replace(/\/v1\/?$/, "").replace(/\/$/, "");
+  }
+  return "http://localhost:11434";
+}
+function isContentObject(content) {
+  return typeof content === "object" && content !== null && "role" in content;
+}
+function createOllamaContentGenerator(config2, cliConfig) {
+  return new OllamaContentGenerator(config2, cliConfig);
+}
+var OllamaContentGenerator;
+var init_ollamaContentGenerator = __esm({
+  "packages/core/dist/src/core/ollamaContentGenerator/index.js"() {
+    "use strict";
+    init_esbuild_shims();
+    __name(getEffectiveOllamaUrl2, "getEffectiveOllamaUrl");
+    __name(isContentObject, "isContentObject");
+    OllamaContentGenerator = class {
+      static {
+        __name(this, "OllamaContentGenerator");
+      }
+      config;
+      baseUrl;
+      constructor(config2, _cliConfig) {
+        this.config = config2;
+        this.baseUrl = config2.baseUrl?.replace(/\/v1\/?$/, "").replace(/\/$/, "") || getEffectiveOllamaUrl2();
+      }
+      /**
+       * Check if this is Ollama Cloud (requires auth)
+       */
+      isCloud() {
+        return this.baseUrl.includes("ollama.com");
+      }
+      /**
+       * Build headers for Ollama API requests
+       */
+      buildHeaders() {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (this.isCloud() && this.config.apiKey) {
+          headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+        }
+        return headers;
+      }
+      /**
+       * Extract text content from a ContentUnion
+       */
+      extractTextFromContentUnion(content) {
+        if (typeof content === "string") {
+          return content;
+        }
+        if (isContentObject(content) && content.parts) {
+          return this.extractTextFromParts(content.parts);
+        }
+        return "";
+      }
+      /**
+       * Extract text content from parts
+       */
+      extractTextFromParts(parts) {
+        return parts.map((part) => {
+          if (typeof part === "string")
+            return part;
+          if (part && typeof part === "object" && "text" in part)
+            return part.text;
+          return "";
+        }).join("");
+      }
+      /**
+       * Check if a part is a function call
+       */
+      isFunctionCall(part) {
+        return part !== null && typeof part === "object" && "functionCall" in part;
+      }
+      /**
+       * Check if a part is a function response
+       */
+      isFunctionResponse(part) {
+        return part !== null && typeof part === "object" && "functionResponse" in part;
+      }
+      /**
+       * Convert GenerateContentParameters to Ollama format
+       */
+      convertToOllamaRequest(params) {
+        const messages = [];
+        if (params.config?.systemInstruction) {
+          const systemContent = this.extractTextFromContentUnion(params.config.systemInstruction);
+          if (systemContent) {
+            messages.push({
+              role: "system",
+              content: systemContent
+            });
+          }
+        }
+        const contents = params.contents;
+        if (Array.isArray(contents)) {
+          for (const content of contents) {
+            if (!content)
+              continue;
+            if (typeof content === "string") {
+              messages.push({
+                role: "user",
+                content
+              });
+            } else if (isContentObject(content)) {
+              const parts = content.parts || [];
+              const functionCalls = parts.filter((p) => this.isFunctionCall(p));
+              const functionResponses = parts.filter((p) => this.isFunctionResponse(p));
+              if (functionCalls.length > 0 && content.role === "model") {
+                const textParts = parts.filter((p) => !this.isFunctionCall(p) && !this.isFunctionResponse(p));
+                const textContent2 = this.extractTextFromParts(textParts);
+                const toolCalls = functionCalls.map((fc, index) => {
+                  const funcCall = fc;
+                  return {
+                    type: "function",
+                    function: {
+                      index,
+                      name: funcCall.functionCall.name,
+                      arguments: funcCall.functionCall.args || {}
+                    }
+                  };
+                });
+                messages.push({
+                  role: "assistant",
+                  content: textContent2 || "",
+                  tool_calls: toolCalls
+                });
+              } else if (functionResponses.length > 0) {
+                for (const fr of functionResponses) {
+                  const funcResp = fr;
+                  const responseContent = typeof funcResp.functionResponse.response === "string" ? funcResp.functionResponse.response : JSON.stringify(funcResp.functionResponse.response);
+                  messages.push({
+                    role: "tool",
+                    tool_name: funcResp.functionResponse.name,
+                    content: responseContent
+                  });
+                }
+              } else {
+                const role = content.role === "model" ? "assistant" : content.role;
+                const text = this.extractTextFromParts(parts);
+                if (text) {
+                  messages.push({
+                    role,
+                    content: text
+                  });
+                }
+              }
+            }
+          }
+        } else if (contents) {
+          if (typeof contents === "string") {
+            messages.push({
+              role: "user",
+              content: contents
+            });
+          } else if (isContentObject(contents)) {
+            const role = contents.role === "model" ? "assistant" : contents.role;
+            const text = this.extractTextFromParts(contents.parts || []);
+            if (text) {
+              messages.push({
+                role,
+                content: text
+              });
+            }
+          }
+        }
+        const model = params.model || this.config.model;
+        const request4 = {
+          model,
+          messages,
+          stream: false
+        };
+        if (params.config?.tools && Array.isArray(params.config.tools)) {
+          const ollamaTools = [];
+          for (const tool of params.config.tools) {
+            if (tool && typeof tool === "object" && "functionDeclarations" in tool) {
+              const funcDecls = tool.functionDeclarations;
+              for (const func of funcDecls) {
+                ollamaTools.push({
+                  type: "function",
+                  function: {
+                    name: func.name,
+                    description: func.description || "",
+                    parameters: func.parameters || { type: "object", properties: {} }
+                  }
+                });
+              }
+            }
+          }
+          if (ollamaTools.length > 0) {
+            request4.tools = ollamaTools;
+          }
+        }
+        if (this.config.samplingParams) {
+          request4.options = {};
+          if (this.config.samplingParams.temperature !== void 0) {
+            request4.options.temperature = this.config.samplingParams.temperature;
+          }
+          if (this.config.samplingParams.top_p !== void 0) {
+            request4.options.top_p = this.config.samplingParams.top_p;
+          }
+          if (this.config.samplingParams.top_k !== void 0) {
+            request4.options.top_k = this.config.samplingParams.top_k;
+          }
+          if (this.config.samplingParams.max_tokens !== void 0) {
+            request4.options.num_predict = this.config.samplingParams.max_tokens;
+          }
+          if (this.config.samplingParams.repetition_penalty !== void 0) {
+            request4.options.repeat_penalty = this.config.samplingParams.repetition_penalty;
+          }
+          if (this.config.samplingParams.presence_penalty !== void 0) {
+            request4.options.presence_penalty = this.config.samplingParams.presence_penalty;
+          }
+          if (this.config.samplingParams.frequency_penalty !== void 0) {
+            request4.options.frequency_penalty = this.config.samplingParams.frequency_penalty;
+          }
+        }
+        return request4;
+      }
+      /**
+       * Convert Ollama response to GenerateContentResponse format
+       */
+      convertFromOllamaResponse(response) {
+        const parts = [];
+        if (response.message.content) {
+          parts.push({ text: response.message.content });
+        }
+        if (response.message.tool_calls && response.message.tool_calls.length > 0) {
+          for (const toolCall of response.message.tool_calls) {
+            parts.push({
+              functionCall: {
+                name: toolCall.function.name,
+                args: toolCall.function.arguments
+              }
+            });
+          }
+        }
+        if (parts.length === 0) {
+          parts.push({ text: "" });
+        }
+        return {
+          candidates: [
+            {
+              content: {
+                role: "model",
+                parts
+              },
+              finishReason: response.message.tool_calls?.length ? "TOOL_USE" : response.done_reason === "stop" ? "STOP" : "OTHER",
+              index: 0
+            }
+          ],
+          usageMetadata: {
+            promptTokenCount: response.prompt_eval_count || 0,
+            candidatesTokenCount: response.eval_count || 0,
+            totalTokenCount: (response.prompt_eval_count || 0) + (response.eval_count || 0)
+          },
+          modelVersion: response.model
+        };
+      }
+      /**
+       * Generate content using Ollama API
+       */
+      async generateContent(request4, _userPromptId) {
+        const ollamaRequest = this.convertToOllamaRequest(request4);
+        ollamaRequest.stream = false;
+        const url3 = `${this.baseUrl}/api/chat`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url3, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(ollamaRequest)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 401) {
+            throw new Error(`Ollama API error: 401 Unauthorized - ${errorText}
+
+\u{1F4A1} Invalid or missing Ollama Cloud API key.
+Get one at: https://ollama.com/settings/keys
+Set it with: export OLLAMA_API_KEY=your_key`);
+          }
+          if (response.status === 404) {
+            throw new Error(`Ollama API error: 404 Not Found - ${errorText}
+
+\u{1F4A1} Model not found. Make sure you're using a valid cloud model like: qwen3-coder:480b-cloud`);
+          }
+          throw new Error(`Ollama API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const ollamaResponse = await response.json();
+        return this.convertFromOllamaResponse(ollamaResponse);
+      }
+      /**
+       * Generate content stream using Ollama API
+       */
+      async generateContentStream(request4, _userPromptId) {
+        const ollamaRequest = this.convertToOllamaRequest(request4);
+        ollamaRequest.stream = true;
+        const url3 = `${this.baseUrl}/api/chat`;
+        const headers = this.buildHeaders();
+        const response = await fetch(url3, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(ollamaRequest)
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          if (response.status === 401) {
+            throw new Error(`Ollama API error: 401 Unauthorized - ${errorText}
+
+\u{1F4A1} Invalid or missing Ollama Cloud API key.
+Get one at: https://ollama.com/settings/keys
+Set it with: export OLLAMA_API_KEY=your_key`);
+          }
+          if (response.status === 404) {
+            throw new Error(`Ollama API error: 404 Not Found - ${errorText}
+
+\u{1F4A1} Model not found. Make sure you're using a valid cloud model like: qwen3-coder:480b-cloud`);
+          }
+          throw new Error(`Ollama API error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+          throw new Error("No response body");
+        }
+        const decoder2 = new TextDecoder();
+        async function* streamGenerator() {
+          let buffer = "";
+          const accumulatedToolCalls = [];
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder2.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim())
+                continue;
+              try {
+                const chunk = JSON.parse(line);
+                if (chunk.message.tool_calls?.length) {
+                  accumulatedToolCalls.push(...chunk.message.tool_calls);
+                }
+                const parts = [];
+                if (chunk.message.content) {
+                  parts.push({ text: chunk.message.content });
+                }
+                if (chunk.done && accumulatedToolCalls.length > 0) {
+                  for (const toolCall of accumulatedToolCalls) {
+                    parts.push({
+                      functionCall: {
+                        name: toolCall.function.name,
+                        args: toolCall.function.arguments
+                      }
+                    });
+                  }
+                }
+                if (parts.length === 0) {
+                  parts.push({ text: "" });
+                }
+                yield {
+                  candidates: [
+                    {
+                      content: {
+                        role: "model",
+                        parts
+                      },
+                      finishReason: chunk.done ? accumulatedToolCalls.length > 0 ? "TOOL_USE" : "STOP" : void 0,
+                      index: 0
+                    }
+                  ]
+                };
+              } catch {
+              }
+            }
+          }
+          if (buffer.trim()) {
+            try {
+              const chunk = JSON.parse(buffer);
+              if (chunk.message.tool_calls?.length) {
+                accumulatedToolCalls.push(...chunk.message.tool_calls);
+              }
+              const parts = [];
+              if (chunk.message.content) {
+                parts.push({ text: chunk.message.content });
+              }
+              if (accumulatedToolCalls.length > 0) {
+                for (const toolCall of accumulatedToolCalls) {
+                  parts.push({
+                    functionCall: {
+                      name: toolCall.function.name,
+                      args: toolCall.function.arguments
+                    }
+                  });
+                }
+              }
+              if (parts.length === 0) {
+                parts.push({ text: "" });
+              }
+              yield {
+                candidates: [
+                  {
+                    content: {
+                      role: "model",
+                      parts
+                    },
+                    finishReason: chunk.done ? accumulatedToolCalls.length > 0 ? "TOOL_USE" : "STOP" : void 0,
+                    index: 0
+                  }
+                ]
+              };
+            } catch {
+            }
+          }
+        }
+        __name(streamGenerator, "streamGenerator");
+        return streamGenerator();
+      }
+      /**
+       * Count tokens - Ollama doesn't have a direct token counting API,
+       * so we estimate based on character count
+       */
+      async countTokens(_request) {
+        return {
+          totalTokens: 0
+        };
+      }
+      /**
+       * Embed content - Use Ollama's embedding API if available
+       */
+      async embedContent(_request) {
+        throw new Error("Embedding not supported by Ollama content generator");
+      }
+    };
+    __name(createOllamaContentGenerator, "createOllamaContentGenerator");
+  }
+});
+
 // packages/core/dist/src/qwen/qwenContentGenerator.js
 var qwenContentGenerator_exports = {};
 __export(qwenContentGenerator_exports, {
@@ -148269,7 +148747,7 @@ var init_qwenContentGenerator = __esm({
 });
 
 // packages/core/dist/src/core/contentGenerator.js
-function getEffectiveOllamaUrl2(includeV1 = true) {
+function getEffectiveOllamaUrl3(includeV1 = true) {
   const ollamaHost = process.env["OLLAMA_HOST"];
   if (ollamaHost) {
     const url3 = ollamaHost.startsWith("http") ? ollamaHost : `http://${ollamaHost}`;
@@ -148343,7 +148821,8 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
     return {
       ...baseConfig,
       model: ollamaModel,
-      baseUrl: "https://api.ollama.com/v1",
+      // Ollama Cloud uses native API at https://ollama.com/api/chat (NOT OpenAI-compatible)
+      baseUrl: "https://ollama.com",
       apiKey: ollamaApiKey,
       authType: AuthType2.OLLAMA_CLOUD,
       // Ollama doesn't need special cache control handling
@@ -148358,7 +148837,7 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
     return {
       ...baseConfig,
       model: ollamaModel,
-      baseUrl: getEffectiveOllamaUrl2(true),
+      baseUrl: getEffectiveOllamaUrl3(true),
       // Gets OLLAMA_HOST or defaults to localhost:11434/v1
       apiKey: "ollama",
       authType: AuthType2.OLLAMA_LOCAL,
@@ -148394,7 +148873,7 @@ function createContentGeneratorConfig(config2, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config2, gcConfig, sessionId2, isInitialAuth) {
-  const version3 = "0.1.98";
+  const version3 = "0.1.100";
   const userAgent2 = `OSAgent/${version3} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -148432,15 +148911,12 @@ async function createContentGenerator(config2, gcConfig, sessionId2, isInitialAu
     return result instanceof Promise ? await result : result;
   }
   if (config2.authType === AuthType2.OLLAMA_CLOUD) {
-    const { createOpenAIContentGenerator: createOpenAIContentGenerator2 } = await Promise.resolve().then(() => (init_openaiContentGenerator2(), openaiContentGenerator_exports));
-    const cloudConfig = {
-      ...config2,
-      baseUrl: config2.baseUrl?.includes("/v1") ? config2.baseUrl : `${config2.baseUrl}/v1`
-    };
-    const result = createOpenAIContentGenerator2(cloudConfig, gcConfig, {
-      validateCredentials: isInitialAuth
-    });
-    return result instanceof Promise ? await result : result;
+    const { createOllamaContentGenerator: createOllamaContentGenerator2 } = await Promise.resolve().then(() => (init_ollamaContentGenerator(), ollamaContentGenerator_exports));
+    if (isInitialAuth && config2.apiKey) {
+      const { validateOllamaCloudCredentials: validateOllamaCloudCredentials2 } = await Promise.resolve().then(() => (init_credentialValidator(), credentialValidator_exports));
+      await validateOllamaCloudCredentials2(config2.apiKey);
+    }
+    return createOllamaContentGenerator2(config2, gcConfig);
   }
   if (config2.authType === AuthType2.OLLAMA_LOCAL) {
     const { createOpenAIContentGenerator: createOpenAIContentGenerator2 } = await Promise.resolve().then(() => (init_openaiContentGenerator2(), openaiContentGenerator_exports));
@@ -148481,7 +148957,7 @@ var init_contentGenerator = __esm({
     init_models();
     init_installationManager();
     init_loggingContentGenerator();
-    __name(getEffectiveOllamaUrl2, "getEffectiveOllamaUrl");
+    __name(getEffectiveOllamaUrl3, "getEffectiveOllamaUrl");
     (function(AuthType4) {
       AuthType4["LOGIN_WITH_OSAGENT"] = "oauth-personal";
       AuthType4["USE_OSA"] = "OSA-api-key";
@@ -337381,7 +337857,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.98";
+  return "0.1.100";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -341589,8 +342065,8 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "36be68d";
-var CLI_VERSION2 = "0.1.98";
+var GIT_COMMIT_INFO2 = "97ab282";
+var CLI_VERSION2 = "0.1.100";
 
 // packages/cli/src/utils/systemInfo.ts
 async function getNpmVersion() {
@@ -385477,7 +385953,7 @@ var useAuthCommand = /* @__PURE__ */ __name((settings, config2, addItem) => {
       }
       if (authType === AuthType2.OLLAMA_CLOUD) {
         if (credentials) {
-          const effectiveBaseUrl = credentials.baseUrl || "https://ollama.com/v1";
+          const effectiveBaseUrl = credentials.baseUrl || "https://ollama.com";
           const effectiveModel = credentials.model || "qwen3-coder:480b-cloud";
           config2.updateCredentials({
             apiKey: credentials.apiKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osagent",
-  "version": "0.1.98",
+  "version": "0.1.100",
   "description": "OS Agent - AI-powered CLI for autonomous coding with Ollama Cloud and Qwen models",
   "repository": {
     "type": "git",
@@ -20,7 +20,7 @@
     "locales"
   ],
   "config": {
-    "sandboxImageUri": "ghcr.io/osagent/osagent:0.1.98"
+    "sandboxImageUri": "ghcr.io/osagent/osagent:0.1.100"
   },
   "dependencies": {
     "punycode": "^2.3.1"