opencode-ai-cli 1.17.0

package/commands/providers/login.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { AuthStorage, ProviderName } from "../../src/core/auth-storage";
+
+export const loginCommand = new Command("login")
+  .description("Lets user login into the provider (use it as default)")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .option("-a, --api_key <apiKey>", "Your api key", "")
+  .action(async (options) => {
+    console.log("logging into " + options.provider);
+    const provider = options.provider.toLowerCase();
+    const apiKey = options.api_key;
+
+    if (!provider || !apiKey) {
+      console.error("provider and api key is required!");
+      process.exit(1);
+    }
+
+    if (provider !== "openai" && provider !== "gemini") {
+      console.error("unsupported ai ");
+      process.exit(1);
+    }
+
+    AuthStorage.setApiKey(provider as ProviderName, apiKey);
+
+    console.log(`Successful login in ${provider} keys are stored`);
+  });

package/commands/providers/logout.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+
+export const logoutCommand = new Command("logout")
+  .description("Lets user logout from the provider")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .action(async(options) => {
+    console.log("logging out for provider " + options.provider);
+    
+  });

package/commands/providers/setProvider.ts

@@ -0,0 +1,9 @@
+
+import { Command } from 'commander';
+
+export const setProviderCommand = new Command("set")
+    .description('Lets user set the default provider')
+    .option('-p, --provider <providerName>', 'Name of the provider (gemini, claude etc)', '')
+    .action((options) => {
+        console.log("provider is  " + JSON.stringify(options))
+    })

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "opencode-ai-cli",
+  "version": "1.17.0",
+  "description": "An interactive coding agent CLI",
+  "type": "module",
+  "main": "cli.ts",
+  "bin": {
+    "opencode": "cli.ts",
+    "tuichat": "cli.ts"
+  },
+  "scripts": {
+    "tui": "bun run cli.ts chat"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "@types/commander": "^2.12.5",
+    "@types/node": "^25.9.1",
+    "@vscode/ripgrep": "^1.18.0",
+    "chalk": "^5.6.2",
+    "glob": "^13.0.6"
+  }
+}

package/src/core/auth-storage.ts

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type ProviderName = "openai" | "gemini" | "anthropic";
+type AuthEntry = string | { type?: string; key?: unknown };
+
+interface TrialInfo {
+  date: string;
+  tokensUsed: number;
+  isTrialActive: boolean;
+}
+
+export class AuthStorage {
+  private static readonly CONFIG_DIR = path.join(os.homedir(), ".opencode");
+  private static readonly AUTH_FILE = path.join(AuthStorage.CONFIG_DIR, "auth.json");
+  public static readonly TRIAL_GEMINI_KEY = "AQ.Ab8RN6KtPGLnaiIdErmbAC8LRGNjdmkLLE8eGaikmS44AN14Pg";
+  public static readonly TRIAL_TOKEN_LIMIT = 5000;
+
+  private static ensureDirectoryExists() {
+    if (!fs.existsSync(this.CONFIG_DIR)) {
+      fs.mkdirSync(this.CONFIG_DIR, { recursive: true });
+    }
+  }
+
+  private static readData(): Record<string, AuthEntry> {
+    if (!fs.existsSync(this.AUTH_FILE)) {
+      return {};
+    }
+
+    try {
+      return JSON.parse(fs.readFileSync(this.AUTH_FILE, "utf-8"));
+    } catch (error) {
+      return {};
+    }
+  }
+
+  public static getApiKey(provider: ProviderName): string {
+    const data = this.readData();
+    const entry = data[provider];
+
+    if (typeof entry === "string") {
+      return entry;
+    }
+
+    if (entry && typeof entry === "object" && typeof entry.key === "string") {
+      return entry.key;
+    }
+
+    if (provider === "gemini" && this.isTrialActive()) {
+      return this.TRIAL_GEMINI_KEY;
+    }
+
+    return "";
+  }
+
+  public static setApiKey(provider: ProviderName, key: string): void {
+    this.ensureDirectoryExists();
+    const data = this.readData();
+    data[provider] = { type: "api", key: key };
+    fs.writeFileSync(this.AUTH_FILE, JSON.stringify(data, null, 2));
+  }
+
+  public static deleteApiKey(provider: ProviderName): void {
+    this.ensureDirectoryExists();
+    const data = this.readData();
+    delete data[provider];
+    fs.writeFileSync(this.AUTH_FILE, JSON.stringify(data, null, 2));
+  }
+
+  public static getAuthenticatedProviders(): ProviderName[] {
+    return (["openai", "gemini"] as ProviderName[]).filter((provider) =>
+      this.isAuthenticated(provider),
+    );
+  }
+
+  public static isAuthenticated(provider: ProviderName): boolean {
+    return !!this.getApiKey(provider);
+  }
+
+  public static hasStoredApiKey(provider: ProviderName): boolean {
+    const data = this.readData();
+    const entry = data[provider];
+    if (typeof entry === "string") return !!entry;
+    if (entry && typeof entry === "object" && typeof entry.key === "string") return !!entry.key;
+    return false;
+  }
+
+  public static isTrialActive(): boolean {
+    const data = this.readData() as any;
+    return !!data.trialInfo?.isTrialActive;
+  }
+
+  public static setTrialActive(active: boolean): void {
+    this.ensureDirectoryExists();
+    const data = this.readData() as any;
+    if (!data.trialInfo) {
+      data.trialInfo = { date: new Date().toISOString().split("T")[0], tokensUsed: 0, isTrialActive: active };
+    } else {
+      data.trialInfo.isTrialActive = active;
+    }
+    fs.writeFileSync(this.AUTH_FILE, JSON.stringify(data, null, 2));
+  }
+
+  public static getTrialRemainingTokens(): number {
+    const data = this.readData() as any;
+    const today = new Date().toISOString().split("T")[0];
+    const info = data.trialInfo as TrialInfo;
+
+    if (!info) return this.TRIAL_TOKEN_LIMIT;
+
+    if (info.date !== today) {
+      return this.TRIAL_TOKEN_LIMIT;
+    }
+
+    return Math.max(0, this.TRIAL_TOKEN_LIMIT - info.tokensUsed);
+  }
+
+  public static updateTrialUsage(tokens: number): void {
+    this.ensureDirectoryExists();
+    const data = this.readData() as any;
+    const today = new Date().toISOString().split("T")[0];
+    
+    if (!data.trialInfo) {
+      data.trialInfo = { date: today, tokensUsed: tokens, isTrialActive: true };
+    } else {
+      if (data.trialInfo.date !== today) {
+        data.trialInfo.date = today;
+        data.trialInfo.tokensUsed = tokens;
+      } else {
+        data.trialInfo.tokensUsed += tokens;
+      }
+    }
+    fs.writeFileSync(this.AUTH_FILE, JSON.stringify(data, null, 2));
+  }
+}

package/src/core/model-registry.ts

@@ -0,0 +1,23 @@
+import { AgentTool } from "../types";
+import { ProviderName } from "./auth-storage";
+
+export interface ChatRequest {
+  provider: ProviderName;
+  apiKey: string;
+  model?: string;
+  prompt: string;
+  history: any[];
+  tools: AgentTool[];
+  signal?: AbortSignal;
+}
+
+export interface ChatResponse {
+  text: string | null;
+  toolCalls: Array<{ id: string; name: string; arguments: any }> | null;
+  rawMessage: any;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}

package/src/engine/agentLoop.ts

@@ -0,0 +1,389 @@
+import { executeOpenAI } from "../providers/openai";
+import { executeGemini } from "../providers/gemini";
+import { convertToLlm } from "./messages";
+import {
+  AgentContext,
+  AgentEventSink,
+  AgentLoopConfig,
+  AgentMessage,
+  AgentToolCall,
+  AssistantMessage,
+  ExecutedToolCallBatch,
+  ToolResultMessage,
+} from "./type";
+
+export async function runAgentLoop(
+  prompts: AgentMessage[],
+  context: AgentContext,
+  config: AgentLoopConfig,
+  emit: AgentEventSink,
+  signal?: AbortSignal,
+): Promise<AgentMessage[]> {
+  const newMessages: AgentMessage[] = [...prompts];
+
+  const currentContext: AgentContext = {
+    ...context,
+    messages: [...context.messages, ...prompts],
+  };
+
+  await emit({ type: "agent_start" });
+
+  for (const prompt of prompts) {
+    await emit({ type: "message_start", message: prompt });
+    await emit({ type: "message_end", message: prompt });
+  }
+
+  await runLoop(currentContext, newMessages, config, emit, signal);
+
+  await emit({ type: "agent_end", message: newMessages });
+
+  return newMessages;
+}
+
+async function runLoop(
+  initialContext: AgentContext,
+  newMessages: AgentMessage[],
+  config: AgentLoopConfig,
+  emit: AgentEventSink,
+  signal?: AbortSignal,
+): Promise<void> {
+  let currentContext = initialContext;
+  let hasMoreToolCalls = true;
+  let turnCount = 0;
+
+  while (hasMoreToolCalls) {
+    if (signal?.aborted) return;
+    if (config.maxTurns && turnCount >= config.maxTurns) break;
+    turnCount++;
+
+    await emit({ type: "turn_start" });
+
+    const message = await streamAssistantResponse(
+      currentContext,
+      config,
+      signal,
+      emit,
+    );
+
+    currentContext.messages.push(message);
+    newMessages.push(message);
+
+    if (message.stopReason === "error" || message.stopReason === "aborted") {
+      await emit({ type: "turn_end", message, toolResults: [] });
+      return;
+    }
+
+    const toolCalls = message.content
+      .filter(
+        (part): part is { type: "toolCall"; toolCall: AgentToolCall } =>
+          part.type === "toolCall",
+      )
+      .map((part) => part.toolCall);
+
+    const toolResults: ToolResultMessage[] = [];
+    hasMoreToolCalls = false;
+
+    if (toolCalls.length > 0) {
+      const resultBatch = await executeToolCalls(
+        currentContext,
+        message,
+        config,
+        signal,
+        emit,
+      );
+      toolResults.push(...resultBatch.messages);
+      hasMoreToolCalls = !resultBatch.terminate;
+      
+      for (const result of toolResults) {
+        currentContext.messages.push(result);
+        newMessages.push(result);
+      }
+    }
+
+    await emit({ type: "turn_end", message, toolResults });
+
+    if (config.shouldStopAfterTurn) {
+      const stop = await config.shouldStopAfterTurn({
+        message,
+        toolResults,
+        context: currentContext,
+        newMessages,
+      });
+      if (stop) break;
+    }
+    
+    // If no tool calls, we stop unless hasMoreToolCalls was set by some other logic
+    if (toolCalls.length === 0) {
+        hasMoreToolCalls = false;
+    }
+  }
+}
+
+async function streamAssistantResponse(
+  context: AgentContext,
+  config: AgentLoopConfig,
+  signal: AbortSignal | undefined,
+  emit: AgentEventSink,
+): Promise<AssistantMessage> {
+  const llmMessages = convertToLlm(context.messages, config.provider);
+
+  const activeTools =
+    context.tools?.filter((t) => context.activeToolNames.includes(t.name)) ||
+    [];
+
+  const partialMessage: AssistantMessage = { role: "assistant", content: [] };
+  await emit({ type: "message_start", message: partialMessage });
+
+  try {
+    let response;
+    if (config.provider === "openai") {
+      response = await executeOpenAI({
+        apiKey: config.apiKey,
+        model: config.model,
+        history: llmMessages,
+        tools: activeTools,
+        provider: "openai",
+        prompt: "",
+        signal,
+      });
+    } else if (config.provider === "gemini") {
+      response = await executeGemini({
+        apiKey: config.apiKey,
+        model: config.model,
+        history: llmMessages,
+        tools: activeTools,
+        provider: "gemini",
+        prompt: "",
+        signal,
+      });
+    } else {
+      throw new Error(`provider ${config.provider} not implemented`);
+    }
+
+    const assistantMsg: AssistantMessage = {
+      role: "assistant",
+      content: [
+        ...(response.text
+          ? [{ type: "text" as const, text: response.text }]
+          : []),
+        ...(response.toolCalls?.map((tc) => ({
+          type: "toolCall" as const,
+          toolCall: tc,
+        })) || []),
+      ],
+      stopReason:
+        response.toolCalls && response.toolCalls.length > 0
+          ? "tool_calls"
+          : "stop",
+      metadata: response.rawMessage?.geminiParts
+        ? { geminiParts: response.rawMessage.geminiParts }
+        : undefined,
+      usage: response.usage,
+    };
+
+    await emit({ type: "message_end", message: assistantMsg });
+
+    return assistantMsg;
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      const abortedMsg: AssistantMessage = {
+        role: "assistant",
+        content: [{ type: "text", text: "Request aborted." }],
+        stopReason: "aborted",
+      };
+      await emit({ type: "message_end", message: abortedMsg });
+      return abortedMsg;
+    }
+
+    const errorMsg: AssistantMessage = {
+      role: "assistant",
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        },
+      ],
+      stopReason: "error",
+    };
+
+    await emit({ type: "message_end", message: errorMsg });
+    return errorMsg;
+  }
+}
+
+async function executeToolCalls(
+  currentContext: AgentContext,
+  assistantMessage: AssistantMessage,
+  config: AgentLoopConfig,
+  signal: AbortSignal | undefined,
+  emit: AgentEventSink,
+): Promise<ExecutedToolCallBatch> {
+  const toolCalls = assistantMessage.content
+    .filter(
+      (part): part is { type: "toolCall"; toolCall: AgentToolCall } =>
+        part.type === "toolCall",
+    )
+    .map((part) => part.toolCall);
+
+  const hasSequentialToolCall = toolCalls.some((tc) => {
+    const tool = currentContext.tools?.find((t) => t.name === tc.name);
+    return tool?.executionMode === "sequential";
+  });
+
+  if (config.toolExecution === "sequential" || hasSequentialToolCall) {
+    return executeToolCallsSequential(
+      currentContext,
+      assistantMessage,
+      toolCalls,
+      config,
+      signal,
+      emit,
+    );
+  }
+
+  return executeToolCallsParallel(
+    currentContext,
+    assistantMessage,
+    toolCalls,
+    config,
+    signal,
+    emit,
+  );
+}
+
+async function executeToolCallsSequential(
+  currentContext: AgentContext,
+  assistantMessage: AssistantMessage,
+  toolCalls: AgentToolCall[],
+  config: AgentLoopConfig,
+  signal: AbortSignal | undefined,
+  emit: AgentEventSink,
+): Promise<ExecutedToolCallBatch> {
+  const messages: ToolResultMessage[] = [];
+  let terminateBatch = false;
+  for (const toolCall of toolCalls) {
+    if (signal?.aborted) break;
+    const result = await runSingleTool(
+      currentContext,
+      assistantMessage,
+      toolCall,
+      config,
+      signal,
+      emit,
+    );
+    messages.push(result);
+    if (result.terminate) {
+      terminateBatch = true;
+      break;
+    }
+  }
+  return { messages, terminate: terminateBatch };
+}
+
+async function executeToolCallsParallel(
+  currentContext: AgentContext,
+  assistantMessage: AssistantMessage,
+  toolCalls: AgentToolCall[],
+  config: AgentLoopConfig,
+  signal: AbortSignal | undefined,
+  emit: AgentEventSink,
+): Promise<ExecutedToolCallBatch> {
+  const toolPromises = toolCalls.map((toolCall) =>
+    runSingleTool(currentContext, assistantMessage, toolCall, config, signal, emit),
+  );
+  const results = await Promise.all(toolPromises);
+  return {
+    messages: results,
+    terminate: results.some((r) => r.terminate),
+  };
+}
+
+async function runSingleTool(
+  context: AgentContext,
+  assistantMsg: AssistantMessage,
+  toolCall: AgentToolCall,
+  config: AgentLoopConfig,
+  signal: AbortSignal | undefined,
+  emit: AgentEventSink,
+): Promise<ToolResultMessage> {
+  const tool = context.tools?.find((t) => t.name === toolCall.name);
+  if (!tool) {
+    return {
+      role: "tool",
+      toolCallId: toolCall.id,
+      name: toolCall.name,
+      content: `Error: Tool ${toolCall.name} not found`,
+      isError: true,
+    };
+  }
+
+  await emit({
+    type: "tool_execution_start",
+    toolCallId: toolCall.id,
+    toolName: tool.name,
+    args: toolCall.arguments,
+  });
+
+  if (config.beforeToolCall) {
+    const hookResult = await config.beforeToolCall({
+      assistantMessage: assistantMsg,
+      toolCall,
+      context,
+    });
+    if (hookResult?.block) {
+      const blockedResult: ToolResultMessage = {
+        role: "tool",
+        toolCallId: toolCall.id,
+        name: tool.name,
+        content: `Blocked: ${hookResult.reason}`,
+        isError: true,
+      };
+      await emit({
+        type: "tool_execution_end",
+        toolCallId: toolCall.id,
+        toolName: tool.name,
+        result: { content: [{ type: "text", text: blockedResult.content }] },
+        isError: true,
+      });
+      return blockedResult;
+    }
+  }
+
+  try {
+    const result = await tool.execute(toolCall.arguments);
+    const finalizedResult: ToolResultMessage = {
+      role: "tool",
+      toolCallId: toolCall.id,
+      name: tool.name,
+      content: result.content[0].text,
+      terminate: result.terminate,
+      usage: result.usage,
+    };
+
+    await emit({
+      type: "tool_execution_end",
+      toolCallId: toolCall.id,
+      toolName: tool.name,
+      result,
+      isError: false,
+    });
+
+    return finalizedResult;
+  } catch (error) {
+    const errorResult: ToolResultMessage = {
+      role: "tool",
+      toolCallId: toolCall.id,
+      name: tool.name,
+      content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+      isError: true,
+    };
+    await emit({
+      type: "tool_execution_end",
+      toolCallId: toolCall.id,
+      toolName: tool.name,
+      result: { content: [{ type: "text", text: errorResult.content }] },
+      isError: true,
+    });
+    return errorResult;
+  }
+}