@heysalad/cheri-cli 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heysalad/cheri-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Cheri CLI - AI-powered cloud IDE by HeySalad. Like Claude Code, but for cloud workspaces.",
   "type": "module",
   "bin": {

package/src/commands/agent.js

@@ -1,6 +1,6 @@
 import { apiClient } from "../lib/api-client.js";
 import { getConfigValue, setConfigValue } from "../lib/config-store.js";
-import { streamChatCompletion } from "../lib/deepseek-client.js";
+import { createProvider } from "../lib/providers/index.js";
 import { log } from "../lib/logger.js";
 import chalk from "chalk";
 
@@ -8,129 +8,96 @@ const SYSTEM_PROMPT = `You are Cheri Agent, an AI assistant for the Cheri cloud
 
 const TOOLS = [
   {
-    type: "function",
-    function: {
-      name: "get_account_info",
-      description: "Get the current user's account information",
-      parameters: { type: "object", properties: {}, required: [] },
-    },
+    name: "get_account_info",
+    description: "Get the current user's account information",
+    parameters: { type: "object", properties: {}, required: [] },
   },
   {
-    type: "function",
-    function: {
-      name: "list_workspaces",
-      description: "List all cloud workspaces for the current user",
-      parameters: { type: "object", properties: {}, required: [] },
-    },
+    name: "list_workspaces",
+    description: "List all cloud workspaces for the current user",
+    parameters: { type: "object", properties: {}, required: [] },
   },
   {
-    type: "function",
-    function: {
-      name: "create_workspace",
-      description: "Launch a new cloud workspace for a GitHub repository",
-      parameters: {
-        type: "object",
-        properties: {
-          repo: { type: "string", description: "GitHub repo in owner/name format" },
-        },
-        required: ["repo"],
+    name: "create_workspace",
+    description: "Launch a new cloud workspace for a GitHub repository",
+    parameters: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "GitHub repo in owner/name format" },
       },
+      required: ["repo"],
     },
   },
   {
-    type: "function",
-    function: {
-      name: "stop_workspace",
-      description: "Stop and delete a running workspace",
-      parameters: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "Workspace ID to stop" },
-        },
-        required: ["id"],
+    name: "stop_workspace",
+    description: "Stop and delete a running workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Workspace ID to stop" },
       },
+      required: ["id"],
     },
   },
   {
-    type: "function",
-    function: {
-      name: "get_workspace_status",
-      description: "Get the status of a specific workspace",
-      parameters: {
-        type: "object",
-        properties: {
-          id: { type: "string", description: "Workspace ID" },
-        },
-        required: ["id"],
+    name: "get_workspace_status",
+    description: "Get the status of a specific workspace",
+    parameters: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Workspace ID" },
       },
+      required: ["id"],
     },
   },
   {
-    type: "function",
-    function: {
-      name: "get_memory",
-      description: "Retrieve all stored memory entries",
-      parameters: { type: "object", properties: {}, required: [] },
-    },
+    name: "get_memory",
+    description: "Retrieve all stored memory entries",
+    parameters: { type: "object", properties: {}, required: [] },
   },
   {
-    type: "function",
-    function: {
-      name: "add_memory",
-      description: "Add a new memory entry for the user",
-      parameters: {
-        type: "object",
-        properties: {
-          content: { type: "string", description: "Memory content to store" },
-          category: { type: "string", description: "Optional category (defaults to 'general')" },
-        },
-        required: ["content"],
+    name: "add_memory",
+    description: "Add a new memory entry for the user",
+    parameters: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Memory content to store" },
+        category: { type: "string", description: "Optional category (defaults to 'general')" },
       },
+      required: ["content"],
     },
   },
   {
-    type: "function",
-    function: {
-      name: "clear_memory",
-      description: "Clear all stored memory entries",
-      parameters: { type: "object", properties: {}, required: [] },
-    },
+    name: "clear_memory",
+    description: "Clear all stored memory entries",
+    parameters: { type: "object", properties: {}, required: [] },
   },
   {
-    type: "function",
-    function: {
-      name: "get_usage",
-      description: "Get the user's API usage and rate limit statistics",
-      parameters: { type: "object", properties: {}, required: [] },
-    },
+    name: "get_usage",
+    description: "Get the user's API usage and rate limit statistics",
+    parameters: { type: "object", properties: {}, required: [] },
   },
   {
-    type: "function",
-    function: {
-      name: "get_config",
-      description: "Get a configuration value by key (dot notation supported)",
-      parameters: {
-        type: "object",
-        properties: {
-          key: { type: "string", description: "Config key, e.g. 'ai.provider'" },
-        },
-        required: ["key"],
+    name: "get_config",
+    description: "Get a configuration value by key (dot notation supported)",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Config key, e.g. 'ai.provider'" },
       },
+      required: ["key"],
     },
   },
   {
-    type: "function",
-    function: {
-      name: "set_config",
-      description: "Set a configuration value",
-      parameters: {
-        type: "object",
-        properties: {
-          key: { type: "string", description: "Config key" },
-          value: { type: "string", description: "Value to set" },
-        },
-        required: ["key", "value"],
+    name: "set_config",
+    description: "Set a configuration value",
+    parameters: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Config key" },
+        value: { type: "string", description: "Value to set" },
       },
+      required: ["key", "value"],
     },
   },
 ];
@@ -170,87 +137,86 @@ async function executeTool(name, args) {
 }
 
 export async function runAgent(userRequest) {
+  const providerName = getConfigValue("agent.provider") || getConfigValue("ai.provider") || "anthropic";
+  const model = getConfigValue("agent.model") || undefined;
+
+  const provider = await createProvider({ provider: providerName, model });
+
   const messages = [
-    { role: "system", content: SYSTEM_PROMPT },
     { role: "user", content: userRequest },
   ];
 
   const MAX_ITERATIONS = 10;
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
-    let textContent = "";
-    const toolCalls = {};
-
-    for await (const chunk of streamChatCompletion(messages, TOOLS)) {
-      const delta = chunk.choices?.[0]?.delta;
-      if (!delta) continue;
-
-      // Stream text content to stdout
-      if (delta.content) {
-        process.stdout.write(delta.content);
-        textContent += delta.content;
-      }
-
-      // Accumulate tool call deltas
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index;
-          if (!toolCalls[idx]) {
-            toolCalls[idx] = { id: tc.id || "", function: { name: "", arguments: "" } };
+    let fullText = "";
+    const toolCalls = [];
+
+    for await (const event of provider.chat(messages, TOOLS, { systemPrompt: SYSTEM_PROMPT })) {
+      switch (event.type) {
+        case "text":
+          process.stdout.write(event.content);
+          fullText += event.content;
+          break;
+
+        case "tool_use_start":
+          toolCalls.push({ id: event.id, name: event.name, input: {} });
+          break;
+
+        case "tool_input_delta":
+          // accumulated by provider, final input comes in tool_use_end
+          break;
+
+        case "tool_use_end":
+          if (toolCalls.length > 0) {
+            toolCalls[toolCalls.length - 1].input = event.input;
           }
-          if (tc.id) toolCalls[idx].id = tc.id;
-          if (tc.function?.name) toolCalls[idx].function.name += tc.function.name;
-          if (tc.function?.arguments) toolCalls[idx].function.arguments += tc.function.arguments;
-        }
+          break;
+
+        case "done":
+          break;
       }
     }
 
-    const toolCallList = Object.values(toolCalls);
-
     // No tool calls — final text response, done
-    if (toolCallList.length === 0) {
-      if (textContent) process.stdout.write("\n");
+    if (toolCalls.length === 0) {
+      if (fullText) process.stdout.write("\n");
       return;
     }
 
-    // Append assistant message with tool calls
-    const assistantMsg = { role: "assistant", content: textContent || null, tool_calls: [] };
-    for (const tc of toolCallList) {
-      assistantMsg.tool_calls.push({
-        id: tc.id,
-        type: "function",
-        function: { name: tc.function.name, arguments: tc.function.arguments },
-      });
-    }
-    messages.push(assistantMsg);
+    if (fullText) process.stdout.write("\n");
 
-    // Execute each tool call and append results
-    for (const tc of toolCallList) {
-      const fnName = tc.function.name;
-      let args = {};
-      try {
-        args = JSON.parse(tc.function.arguments || "{}");
-      } catch {
-        args = {};
-      }
+    // Build assistant message in Anthropic content-block format
+    const assistantContent = [];
+    if (fullText) {
+      assistantContent.push({ type: "text", text: fullText });
+    }
+    for (const tc of toolCalls) {
+      assistantContent.push({ type: "tool_use", id: tc.id, name: tc.name, input: tc.input });
+    }
+    messages.push({ role: "assistant", content: assistantContent });
 
-      log.info(`Calling ${chalk.cyan(fnName)}${Object.keys(args).length ? chalk.dim(" " + JSON.stringify(args)) : ""}`);
+    // Execute each tool call and build tool results
+    const toolResults = [];
+    for (const tc of toolCalls) {
+      log.info(`Calling ${chalk.cyan(tc.name)}${Object.keys(tc.input).length ? chalk.dim(" " + JSON.stringify(tc.input)) : ""}`);
 
-      const result = await executeTool(fnName, args);
-      const resultStr = JSON.stringify(result);
+      const result = await executeTool(tc.name, tc.input);
 
       if (result.error) {
         log.error(result.error);
       } else {
-        log.success(fnName);
+        log.success(tc.name);
       }
 
-      messages.push({
-        role: "tool",
-        tool_call_id: tc.id,
-        content: resultStr,
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: tc.id,
+        content: JSON.stringify(result),
       });
     }
+
+    messages.push({ role: "user", content: toolResults });
   }
 
   log.warn("Agent reached maximum iterations (10). Stopping.");

package/src/lib/branding.js

@@ -31,6 +31,7 @@ export function getDefaultModel(provider) {
     openai: "gpt-4o",
     deepseek: "deepseek-chat",
     gemini: "gemini-2.0-flash",
+    bedrock: "anthropic.claude-opus-4-6-v1:0",
   };
   return defaults[provider] || "unknown";
 }

package/src/lib/config-store.js

@@ -82,7 +82,11 @@ function getDefaultConfig() {
         openai: "",
         deepseek: "",
         gemini: "",
+        bedrock: "",
       },
     },
+    bedrock: {
+      region: "us-east-1",
+    },
   };
 }

package/src/lib/providers/anthropic.js

@@ -5,7 +5,7 @@ export class AnthropicProvider extends BaseProvider {
     super(apiKey, model);
   }
 
-  async *chat(messages, tools) {
+  async *chat(messages, tools, options = {}) {
     const { default: Anthropic } = await import("@anthropic-ai/sdk");
     const client = new Anthropic({ apiKey: this.apiKey });
 
@@ -18,7 +18,7 @@ export class AnthropicProvider extends BaseProvider {
     const stream = await client.messages.stream({
       model: this.model,
       max_tokens: 8192,
-      system: SYSTEM_PROMPT,
+      system: options.systemPrompt || SYSTEM_PROMPT,
       messages,
       tools: anthropicTools.length > 0 ? anthropicTools : undefined,
     });

package/src/lib/providers/base.js

@@ -24,7 +24,7 @@ export class BaseProvider {
    *   { type: "tool_use_end", id: string, name: string, input: object }
    *   { type: "done", stopReason: string }
    */
-  async *chat(messages, tools) {
+  async *chat(messages, tools, options = {}) {
     throw new Error("chat() must be implemented by subclass");
   }
 

package/src/lib/providers/bedrock.js

@@ -0,0 +1,7 @@
+import { OpenAIProvider } from "./openai.js";
+
+export class BedrockProvider extends OpenAIProvider {
+  constructor(apiKey, model = "anthropic.claude-opus-4-6-v1:0", region = "us-east-1") {
+    super(apiKey, model, `https://bedrock-runtime.${region}.amazonaws.com/openai/v1`);
+  }
+}

package/src/lib/providers/gemini.js

@@ -5,7 +5,7 @@ export class GeminiProvider extends BaseProvider {
     super(apiKey, model);
   }
 
-  async *chat(messages, tools) {
+  async *chat(messages, tools, options = {}) {
     const { GoogleGenerativeAI } = await import("@google/generative-ai");
     const genAI = new GoogleGenerativeAI(this.apiKey);
 
@@ -19,7 +19,7 @@ export class GeminiProvider extends BaseProvider {
 
     const genModel = genAI.getGenerativeModel({
       model: this.model,
-      systemInstruction: SYSTEM_PROMPT,
+      systemInstruction: options.systemPrompt || SYSTEM_PROMPT,
       tools: geminiTools,
     });
 

package/src/lib/providers/index.js

@@ -11,6 +11,7 @@ export async function createProvider(options = {}) {
     openai: "OPENAI_API_KEY",
     deepseek: "DEEPSEEK_API_KEY",
     gemini: "GEMINI_API_KEY",
+    bedrock: "AWS_BEARER_TOKEN_BEDROCK",
   };
 
   const apiKey = process.env[envKeys[provider]] || getConfigValue(`ai.keys.${provider}`);
@@ -41,7 +42,12 @@ export async function createProvider(options = {}) {
       const { GeminiProvider } = await import("./gemini.js");
       return new GeminiProvider(apiKey, model);
     }
+    case "bedrock": {
+      const { BedrockProvider } = await import("./bedrock.js");
+      const region = getConfigValue("bedrock.region") || "us-east-1";
+      return new BedrockProvider(apiKey, model, region);
+    }
     default:
-      throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, deepseek, gemini`);
+      throw new Error(`Unknown provider: ${provider}. Supported: anthropic, openai, deepseek, gemini, bedrock`);
   }
 }

package/src/lib/providers/openai.js

@@ -6,14 +6,14 @@ export class OpenAIProvider extends BaseProvider {
     this.baseURL = baseURL;
   }
 
-  async *chat(messages, tools) {
+  async *chat(messages, tools, options = {}) {
     const { default: OpenAI } = await import("openai");
     const clientOpts = { apiKey: this.apiKey };
     if (this.baseURL) clientOpts.baseURL = this.baseURL;
     const client = new OpenAI(clientOpts);
 
     // Convert from Anthropic message format to OpenAI format
-    const openaiMessages = [{ role: "system", content: SYSTEM_PROMPT }];
+    const openaiMessages = [{ role: "system", content: options.systemPrompt || SYSTEM_PROMPT }];
     for (const msg of messages) {
       if (typeof msg.content === "string") {
         openaiMessages.push({ role: msg.role, content: msg.content });

package/src/lib/deepseek-client.js

@@ -1,64 +0,0 @@
-import { getConfigValue } from "./config-store.js";
-
-export function getApiKey() {
-  const key = getConfigValue("deepseekApiKey") || getConfigValue("ai.keys.deepseek");
-  if (!key) {
-    throw new Error(
-      "DeepSeek API key not set. Run: cheri config set deepseekApiKey sk-..."
-    );
-  }
-  return key;
-}
-
-export function getModel() {
-  return getConfigValue("agent.model") || "deepseek-chat";
-}
-
-export async function* streamChatCompletion(messages, tools) {
-  const apiKey = getApiKey();
-  const model = getModel();
-
-  const body = {
-    model,
-    messages,
-    stream: true,
-  };
-  if (tools && tools.length > 0) {
-    body.tools = tools;
-  }
-
-  const res = await fetch("https://api.deepseek.com/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`DeepSeek API error (${res.status}): ${text}`);
-  }
-
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  for await (const chunk of res.body) {
-    buffer += decoder.decode(chunk, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop();
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith("data: ")) continue;
-      const data = trimmed.slice(6);
-      if (data === "[DONE]") return;
-      try {
-        yield JSON.parse(data);
-      } catch {
-        // skip malformed chunks
-      }
-    }
-  }
-}