axexec 1.5.1 → 1.6.0

package/README.md

@@ -88,6 +88,7 @@ axexec --list-agents | tail -n +2 | awk -F'\t' '$3 ~ /openai/ {print $1}'
 -a, --agent <id>           Agent to use (claude, codex, gemini, opencode, copilot)
 -p, --prompt <text>        Prompt text (alternative to positional argument)
 -m, --model <model>        Model to use (agent-specific)
+--provider <provider>      Provider for OpenCode (anthropic, openai, google)
 --allow <perms>            Permission rules to allow (comma-separated)
 --deny <perms>             Permission rules to deny (comma-separated)
 -f, --format <fmt>         Output format: jsonl, tsv (default: tsv, truncated on TTY)
@@ -165,19 +166,21 @@ For Claude, `CLAUDE_CODE_OAUTH_TOKEN` (generated via `claude setup-token`) also
 For Copilot, token precedence is `COPILOT_GITHUB_TOKEN`, then `GH_TOKEN`, then
 `GITHUB_TOKEN`.
 
-For OpenCode, if multiple provider API keys are set, axexec uses the model
-prefix (`anthropic/...`, `openai/...`, `google/...`) to disambiguate. When
-multiple keys are present and no provider prefix is available, set
-`AX_OPENCODE_CREDENTIALS` explicitly. This value must be a JSON-encoded
-Credentials object (not a raw API key), for example:
-
-```json
-{
-  "agent": "opencode",
-  "type": "api-key",
-  "provider": "openai",
-  "data": { "apiKey": "sk-..." }
-}
+For OpenCode, set `AX_OPENCODE_CREDENTIALS` with your credentials. The `provider`
+field must match your `--provider` flag:
+
+```bash
+# Anthropic (provider defaults to "anthropic" if omitted)
+AX_OPENCODE_CREDENTIALS='{"agent":"opencode","type":"api-key","data":{"apiKey":"sk-ant-..."}}' \
+  axexec -a opencode --provider anthropic -m claude-sonnet-4 "Hello"
+
+# OpenAI (provider must be specified in credentials)
+AX_OPENCODE_CREDENTIALS='{"agent":"opencode","type":"api-key","provider":"openai","data":{"apiKey":"sk-..."}}' \
+  axexec -a opencode --provider openai -m gpt-4.1 "Hello"
+
+# OpenCode hosted models (provider must be "opencode")
+AX_OPENCODE_CREDENTIALS='{"agent":"opencode","type":"api-key","provider":"opencode","data":{"apiKey":"..."}}' \
+  axexec -a opencode --provider opencode -m glm-4.7-free "Hello"
 ```
 
 ## Isolation

package/dist/agents/opencode/adapter.js

@@ -73,12 +73,13 @@ async function* streamSession(options) {
         const session = await createSession(serverUrl, cwd);
         sessionId = session.id;
         sessionStartTime = Date.now();
-        await sendPrompt(serverUrl, sessionId, options.prompt, cwd, options.model);
+        await sendPrompt(serverUrl, sessionId, options.prompt, cwd, options.provider, options.model);
         // 5. Process SSE events
         const eventProcessor = processSSEEvents(sseGenerator, {
             serverUrl,
             sessionId,
             sessionStartTime,
+            requestedProvider: options.provider,
             requestedModel: options.model,
             cwd,
             signal,
@@ -103,6 +104,7 @@ async function* streamSession(options) {
                     sessionId,
                     timestamp: sessionStartTime ?? Date.now(),
                     modelInfo: undefined,
+                    requestedProvider: options.provider,
                     requestedModel: options.model,
                 });
             }

package/dist/agents/opencode/create-session-start-event.d.ts

@@ -9,6 +9,7 @@ interface SessionStartEventOptions {
     sessionId: string;
     timestamp: number;
     modelInfo: MessageModelInfo | undefined;
+    requestedProvider: string | undefined;
     requestedModel: string | undefined;
 }
 /**

package/dist/agents/opencode/create-session-start-event.js

@@ -7,11 +7,9 @@
  * Creates a session.start event with model and provider info.
  */
 function createSessionStartEvent(options) {
-    const { sessionId, timestamp, modelInfo, requestedModel } = options;
-    const model = modelInfo
-        ? `${modelInfo.providerID}/${modelInfo.modelID}`
-        : (requestedModel ?? "unknown");
-    const provider = modelInfo?.providerID;
+    const { sessionId, timestamp, modelInfo, requestedProvider, requestedModel } = options;
+    const model = modelInfo?.modelID ?? requestedModel ?? "unknown";
+    const provider = modelInfo?.providerID ?? requestedProvider;
     return {
         type: "session.start",
         sessionId,

package/dist/agents/opencode/process-sse-events.d.ts

@@ -7,6 +7,7 @@ interface ProcessEventsContext {
     serverUrl: string;
     sessionId: string;
     sessionStartTime: number;
+    requestedProvider?: string;
     requestedModel?: string;
     cwd: string;
     signal: AbortSignal;

package/dist/agents/opencode/process-sse-events.js

@@ -27,6 +27,7 @@ async function* processSSEEvents(sseGenerator, context) {
                 sessionId: context.sessionId,
                 timestamp: context.sessionStartTime,
                 modelInfo,
+                requestedProvider: context.requestedProvider,
                 requestedModel: context.requestedModel,
             });
             sessionStartEmitted = true;
@@ -38,6 +39,7 @@ async function* processSSEEvents(sseGenerator, context) {
                 sessionId: context.sessionId,
                 timestamp: context.sessionStartTime,
                 modelInfo: undefined,
+                requestedProvider: context.requestedProvider,
                 requestedModel: context.requestedModel,
             });
             sessionStartEmitted = true;

package/dist/agents/opencode/session-api.d.ts

@@ -37,7 +37,7 @@ declare function createSession(baseUrl: string, directory: string): Promise<Sess
  * Uses prompt_async endpoint which returns immediately and processes
  * the prompt asynchronously. Events are streamed via SSE.
  */
-declare function sendPrompt(baseUrl: string, sessionId: string, prompt: string, directory: string, model?: string): Promise<void>;
+declare function sendPrompt(baseUrl: string, sessionId: string, prompt: string, directory: string, provider?: string, model?: string): Promise<void>;
 /**
  * Aborts a running session with timeout.
  */

package/dist/agents/opencode/session-api.js

@@ -21,16 +21,6 @@ class PromptSubmitError extends Error {
         this.statusCode = statusCode;
     }
 }
-/** Parses "provider/model" string into components */
-function parseModel(model) {
-    const slashIndex = model.indexOf("/");
-    if (slashIndex === -1)
-        return undefined;
-    return {
-        providerID: model.slice(0, slashIndex),
-        modelID: model.slice(slashIndex + 1),
-    };
-}
 /**
  * Creates a new session on the OpenCode server.
  */
@@ -54,17 +44,14 @@ async function createSession(baseUrl, directory) {
  * Uses prompt_async endpoint which returns immediately and processes
  * the prompt asynchronously. Events are streamed via SSE.
  */
-async function sendPrompt(baseUrl, sessionId, prompt, directory, model) {
+async function sendPrompt(baseUrl, sessionId, prompt, directory, provider, model) {
     // Build request body
     const body = {
         parts: [{ type: "text", text: prompt }],
     };
-    // Add model if provided and valid
-    if (model) {
-        const parsed = parseModel(model);
-        if (parsed) {
-            body.model = parsed;
-        }
+    // Add model if provider and model are both provided
+    if (provider && model) {
+        body.model = { providerID: provider, modelID: model };
     }
     const response = await fetch(`${baseUrl}/session/${sessionId}/prompt_async`, {
         method: "POST",

package/dist/cli.js

@@ -35,6 +35,7 @@ const program = new Command()
     .option("-a, --agent <id>", "Agent to use (required)")
     .option("-p, --prompt <text>", "Prompt text")
     .option("-m, --model <model>", "Model to use")
+    .option("--provider <provider>", "Provider for OpenCode (required for OpenCode)")
     .option("--allow <perms>", "Permission rules to allow (comma-separated)")
     .option("--deny <perms>", "Permission rules to deny (comma-separated)")
     .option("-f, --format <fmt>", "Output format: jsonl, tsv (default: tsv, truncated on TTY)")
@@ -50,6 +51,7 @@ Requirements:
 
 Examples:
   axexec -a claude "Refactor auth flow"
+  axexec -a opencode --provider anthropic -m claude-sonnet-4 "Hello"
   axexec -a claude -f jsonl "Audit deps" | jq 'select(.type=="tool.call")'
   axexec --list-agents | tail -n +2 | cut -f1
 `)
@@ -98,10 +100,36 @@ Examples:
             return;
         }
     }
+    // Validate --provider is only used with OpenCode
+    if (options.provider && options.agent !== "opencode") {
+        process.stderr.write("Error: --provider is only supported for OpenCode agent\n");
+        process.exitCode = 2;
+        return;
+    }
+    // Validate OpenCode requires --provider
+    if (options.agent === "opencode") {
+        // Check for deprecated provider/model format
+        if (options.model?.includes("/")) {
+            const [provider, model] = options.model.split("/", 2);
+            process.stderr.write("Error: Model format 'provider/model' is no longer supported\n");
+            process.stderr.write("Use separate --provider and --model flags:\n");
+            process.stderr.write(`  axexec -a opencode --provider ${provider} -m ${model} ...\n`);
+            process.exitCode = 2;
+            return;
+        }
+        // Require --provider for OpenCode
+        if (!options.provider) {
+            process.stderr.write("Error: OpenCode requires --provider\n");
+            process.stderr.write("  axexec -a opencode --provider anthropic -m claude-sonnet-4 ...\n");
+            process.exitCode = 2;
+            return;
+        }
+    }
     // Run agent
     const result = await runAgent(options.agent, {
         prompt,
         model: options.model,
+        provider: options.provider,
         allow: options.allow,
         deny: options.deny,
         format,

package/dist/execute-agent.js

@@ -13,6 +13,7 @@ async function executeAgent(agentId, adapter, options, configEnvironment, creden
         prompt: options.prompt,
         verbose: options.verbose ?? false,
         model: options.model,
+        provider: options.provider,
         rawLogPath: options.rawLog,
         debug: options.debug,
         configEnv: configEnvironment,

package/dist/parse-credentials.d.ts

@@ -23,5 +23,5 @@ type ParseCredentialsResult = {
  *
  * Returns ok with undefined credentials if none are found.
  */
-declare function parseCredentialsFromEnvironment(agentId: AgentCli, model?: string): ParseCredentialsResult;
+declare function parseCredentialsFromEnvironment(agentId: AgentCli): ParseCredentialsResult;
 export { parseCredentialsFromEnvironment };

package/dist/parse-credentials.js

@@ -15,7 +15,7 @@ import { getEnvironmentTrimmed } from "./credentials/get-environment-trimmed.js"
  *
  * Returns ok with undefined credentials if none are found.
  */
-function parseCredentialsFromEnvironment(agentId, model) {
+function parseCredentialsFromEnvironment(agentId) {
     // Check for axexec credentials env var (full Credentials JSON)
     const credEnvironmentVariable = `AX_${agentId.toUpperCase()}_CREDENTIALS`;
     const credEnvironmentValue = process.env[credEnvironmentVariable];
@@ -51,12 +51,12 @@ function parseCredentialsFromEnvironment(agentId, model) {
         }
     }
     // Fall back to standard API key env vars
-    return parseApiKeyFromEnvironment(agentId, model);
+    return parseApiKeyFromEnvironment(agentId);
 }
 /**
  * Parses API key from standard environment variables.
  */
-function parseApiKeyFromEnvironment(agentId, model) {
+function parseApiKeyFromEnvironment(agentId) {
     let apiKey;
     switch (agentId) {
         case "claude": {
@@ -84,8 +84,8 @@ function parseApiKeyFromEnvironment(agentId, model) {
             break;
         }
         case "opencode": {
-            // OpenCode can use multiple providers
-            return parseOpenCodeApiKeyFromEnvironment(model);
+            // OpenCode requires AX_OPENCODE_CREDENTIALS - no env var fallback
+            return { ok: true, credentials: undefined };
         }
         case "copilot": {
             apiKey =
@@ -107,76 +107,4 @@ function parseApiKeyFromEnvironment(agentId, model) {
         },
     };
 }
-function normalizeOpenCodeProvider(provider) {
-    if (!provider)
-        return undefined;
-    return provider === "gemini" ? "google" : provider;
-}
-function parseOpenCodeApiKeyFromEnvironment(model) {
-    const providers = [
-        {
-            provider: "anthropic",
-            envVar: "ANTHROPIC_API_KEY",
-            value: getEnvironmentTrimmed("ANTHROPIC_API_KEY"),
-        },
-        {
-            provider: "openai",
-            envVar: "OPENAI_API_KEY",
-            value: getEnvironmentTrimmed("OPENAI_API_KEY"),
-        },
-        {
-            provider: "google",
-            envVar: "GEMINI_API_KEY",
-            value: getEnvironmentTrimmed("GEMINI_API_KEY"),
-        },
-    ];
-    const available = providers.filter((entry) => entry.value !== undefined);
-    const modelProvider = normalizeOpenCodeProvider(model?.split("/")[0]);
-    if (modelProvider &&
-        ["anthropic", "openai", "google"].includes(modelProvider)) {
-        const match = providers.find((entry) => entry.provider === modelProvider);
-        if (match?.value) {
-            return {
-                ok: true,
-                credentials: {
-                    agent: "opencode",
-                    type: "api-key",
-                    provider: modelProvider,
-                    data: { apiKey: match.value },
-                },
-            };
-        }
-        const requiredEnvironmentVariable = match?.envVar ?? "AX_OPENCODE_CREDENTIALS";
-        return {
-            ok: false,
-            exitCode: 2,
-            message: `Error: ${requiredEnvironmentVariable} is required for OpenCode ` +
-                `model provider "${modelProvider}".`,
-        };
-    }
-    if (available.length === 0) {
-        return { ok: true, credentials: undefined };
-    }
-    if (available.length === 1) {
-        const match = available[0];
-        if (!match)
-            return { ok: true, credentials: undefined };
-        return {
-            ok: true,
-            credentials: {
-                agent: "opencode",
-                type: "api-key",
-                provider: match.provider,
-                data: { apiKey: match.value },
-            },
-        };
-    }
-    const environmentList = available.map((entry) => entry.envVar).join(", ");
-    return {
-        ok: false,
-        exitCode: 2,
-        message: "Error: Multiple OpenCode API keys detected. " +
-            `Set AX_OPENCODE_CREDENTIALS to disambiguate (${environmentList}).`,
-    };
-}
 export { parseCredentialsFromEnvironment };

package/dist/run-agent.js

@@ -35,10 +35,23 @@ async function runAgent(agentId, options) {
         };
     }
     const { adapter } = validation;
+    // Validate --model format for OpenCode (reject "provider/model" format)
+    if (validation.agentId === "opencode" && options.model?.includes("/")) {
+        const [provider, model] = options.model.split("/", 2);
+        diagnostics.error(`Error: Model format 'provider/model' is no longer supported.\n` +
+            `Use separate --provider and --model flags instead:\n` +
+            `  --provider ${provider} --model ${model}`);
+        setExitCode(2);
+        return {
+            events: [],
+            success: false,
+            execution: { agent: validation.agentId },
+        };
+    }
     // Use provided credentials or parse from environment
     const credentialsResult = options.credentials
         ? { ok: true, credentials: options.credentials }
-        : parseCredentialsFromEnvironment(validation.agentId, options.model);
+        : parseCredentialsFromEnvironment(validation.agentId);
     if (!credentialsResult.ok) {
         diagnostics.error(credentialsResult.message);
         setExitCode(credentialsResult.exitCode);

package/dist/types/options.d.ts

@@ -24,9 +24,14 @@ interface RunOptions {
      * - Codex: model names ('o4-mini', 'gpt-5.1-codex')
      * - Gemini: aliases ('pro', 'flash') or full names ('gemini-2.5-pro')
      * - Copilot: model names ('gpt-5', 'claude-sonnet-4.5')
-     * - OpenCode: provider/model format ('anthropic/claude-sonnet-4')
+     * - OpenCode: model name only ('claude-sonnet-4'), provider specified separately
      */
     model?: string;
+    /**
+     * Provider for multi-provider agents (e.g., OpenCode).
+     * OpenCode providers: 'anthropic', 'openai', 'google'
+     */
+    provider?: string;
     /**
      * Preserve GITHUB_SHA environment variable.
      *

package/dist/types/run-result.d.ts

@@ -17,6 +17,11 @@ interface RunAgentOptions {
      */
     credentials?: Credentials;
     model?: string;
+    /**
+     * Provider for multi-provider agents (e.g., OpenCode).
+     * Used to select which API key to use when multiple are present.
+     */
+    provider?: string;
     allow?: string;
     deny?: string;
     format?: OutputFormat;

package/package.json

@@ -2,7 +2,7 @@
   "name": "axexec",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "Unified CLI runner for AI coding agents with normalized event streaming",
   "repository": {
     "type": "git",