axexec 1.5.1 → 1.6.1

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/claude-code/types.d.ts

@@ -77,8 +77,8 @@ type ClaudeUserEvent = z.infer<typeof ClaudeUserEvent>;
 declare const ClaudeResultEvent: z.ZodObject<{
     type: z.ZodLiteral<"result">;
     subtype: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
         cancelled: "cancelled";
     }>;
     timestamp: z.ZodOptional<z.ZodString>;
@@ -153,8 +153,8 @@ declare const ClaudeEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"result">;
     subtype: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
         cancelled: "cancelled";
     }>;
     timestamp: z.ZodOptional<z.ZodString>;

package/dist/agents/gemini/types.d.ts

@@ -41,8 +41,8 @@ declare const GeminiToolResultEvent: z.ZodObject<{
     type: z.ZodLiteral<"tool_result">;
     tool_id: z.ZodString;
     status: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
     }>;
     output: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodObject<{
@@ -67,8 +67,8 @@ type GeminiErrorEvent = z.infer<typeof GeminiErrorEvent>;
 declare const GeminiResultEvent: z.ZodObject<{
     type: z.ZodLiteral<"result">;
     status: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
     }>;
     error: z.ZodOptional<z.ZodObject<{
         type: z.ZodString;
@@ -109,8 +109,8 @@ declare const GeminiEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"tool_result">;
     tool_id: z.ZodString;
     status: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
     }>;
     output: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodObject<{
@@ -129,8 +129,8 @@ declare const GeminiEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"result">;
     status: z.ZodEnum<{
-        error: "error";
         success: "success";
+        error: "error";
     }>;
     error: z.ZodOptional<z.ZodObject<{
         type: z.ZodString;

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/build-execution-metadata.d.ts

@@ -1,6 +1,5 @@
-import type { AgentCli } from "axshared";
+import type { AgentCli, Credentials } from "axshared";
 import type { RunAgentOptions, ExecutionMetadata } from "./types/run-result.js";
-import type { Credentials } from "./credentials/credentials.js";
 import type { installCredentials } from "./credentials/install-credentials.js";
 type CredentialInstallResult = Awaited<ReturnType<typeof installCredentials>>;
 /**

package/dist/build-execution-metadata.js

@@ -19,7 +19,7 @@ function buildExecutionMetadata(agentId, options, credentialResult, credentials,
     if (credentials) {
         execution.credentials = {
             type: credentials.type,
-            provider: credentials.provider,
+            provider: credentials.agent === "opencode" ? credentials.provider : undefined,
         };
     }
     return execution;

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/credentials/get-credential-environment.d.ts

@@ -4,7 +4,7 @@
  * Each agent has its own env var requirements. This module extracts
  * the appropriate values from Credentials and returns them as env vars.
  */
-import type { Credentials } from "./credentials.js";
+import type { Credentials } from "axshared";
 /**
  * Gets additional environment variables for credential-based auth.
  *

package/dist/credentials/get-credential-environment.js

@@ -51,7 +51,7 @@ function getCredentialEnvironment(credentials) {
         }
         case "opencode": {
             // OpenCode supports multiple providers, env var depends on provider
-            const provider = credentials.provider ?? "anthropic";
+            const provider = credentials.provider;
             if (credentials.type === "api-key" && apiKey) {
                 switch (provider) {
                     case "anthropic": {

package/dist/credentials/install-credentials.d.ts

@@ -6,8 +6,7 @@
  * directory. This ensures complete isolation - agents never discover or use
  * locally installed credentials.
  */
-import { type AgentCli } from "axshared";
-import type { Credentials } from "./credentials.js";
+import { type AgentCli, type Credentials } from "axshared";
 import type { InstallResult } from "./types.js";
 type WarningWriter = (message: string) => void;
 /**

package/dist/credentials/install-credentials.js

@@ -57,7 +57,9 @@ function installAgentCredentials(agentId, configDirectory, dataDirectory, creden
             break;
         }
         case "opencode": {
-            installOpenCodeCredentials(dataDirectory, credentials, warn);
+            if (credentials.agent === "opencode") {
+                installOpenCodeCredentials(dataDirectory, credentials, warn);
+            }
             break;
         }
         case "copilot": {

package/dist/credentials/write-agent-credentials.d.ts

@@ -5,7 +5,7 @@
  * write credentials in the agent-specific format, extracting what
  * they need from the canonical Credentials type.
  */
-import type { Credentials } from "./credentials.js";
+import type { Credentials } from "axshared";
 type WarningWriter = (message: string) => void;
 /**
  * Installs Claude credentials to a config directory.
@@ -54,5 +54,7 @@ declare function installGeminiCredentials(configDirectory: string, credentials:
  * - oauth-credentials: Written as { [provider]: { type: "oauth", ...data } }
  * - api-key: Written as { [provider]: { type: "api", key: "..." } }
  */
-declare function installOpenCodeCredentials(dataDirectory: string, credentials: Credentials, warn?: WarningWriter): void;
+declare function installOpenCodeCredentials(dataDirectory: string, credentials: Extract<Credentials, {
+    agent: "opencode";
+}>, warn?: WarningWriter): void;
 export { installClaudeCredentials, installCodexCredentials, installGeminiCredentials, installOpenCodeCredentials, };

package/dist/credentials/write-agent-credentials.js

@@ -8,11 +8,6 @@
 import path from "node:path";
 import { resolveStringField } from "./resolve-string-field.js";
 import { saveJsonFile } from "./save-json-file.js";
-function normalizeOpenCodeProvider(provider) {
-    if (!provider)
-        return "anthropic";
-    return provider === "gemini" ? "google" : provider;
-}
 function defaultWarningWriter(message) {
     const formatted = message.endsWith("\n") ? message : `${message}\n`;
     process.stderr.write(formatted);
@@ -107,7 +102,7 @@ function installGeminiCredentials(configDirectory, credentials) {
  */
 function installOpenCodeCredentials(dataDirectory, credentials, warn = defaultWarningWriter) {
     const authPath = path.join(dataDirectory, "auth.json");
-    const provider = normalizeOpenCodeProvider(credentials.provider);
+    const provider = credentials.provider;
     switch (credentials.type) {
         case "oauth-credentials": {
             saveJsonFile(authPath, {

package/dist/execute-agent.d.ts

@@ -1,7 +1,6 @@
 import type { AgentAdapter } from "./types/adapter.js";
-import type { AgentCli } from "axshared";
+import type { AgentCli, Credentials } from "axshared";
 import type { RunAgentOptions, RunResult } from "./types/run-result.js";
-import type { Credentials } from "./credentials/credentials.js";
 import type { installCredentials } from "./credentials/install-credentials.js";
 import type { DiagnosticWriter } from "./resolve-run-diagnostics.js";
 type CredentialInstallResult = Awaited<ReturnType<typeof installCredentials>>;

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/index.d.ts

@@ -13,4 +13,4 @@ export { runAgent } from "./run-agent.js";
 export { cleanupCredentials } from "./credentials/install-credentials.js";
 export type { ExecutionCredentials, ExecutionDirectories, ExecutionMetadata, RunAgentDiagnostics, RunAgentOptions, RunResult, } from "./types/run-result.js";
 export type { AxexecEvent } from "./types/events.js";
-export type { Credentials } from "./credentials/credentials.js";
+export type { Credentials } from "axshared";

package/dist/parse-credentials.d.ts

@@ -4,8 +4,7 @@
  * Used by axexec CLI to read credentials from environment when
  * not provided via the programmatic API.
  */
-import type { AgentCli } from "axshared";
-import { type Credentials } from "./credentials/credentials.js";
+import { type AgentCli, type Credentials } from "axshared";
 type ParseCredentialsResult = {
     ok: true;
     credentials: Credentials | undefined;
@@ -23,5 +22,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

@@ -4,8 +4,16 @@
  * Used by axexec CLI to read credentials from environment when
  * not provided via the programmatic API.
  */
-import { parseCredentials, } from "./credentials/credentials.js";
+import { parseCredentialsResult, } from "axshared";
 import { getEnvironmentTrimmed } from "./credentials/get-environment-trimmed.js";
+function formatZodError(error) {
+    return error.issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+        return `${path}: ${issue.message}`;
+    })
+        .join("; ");
+}
 /**
  * Parses credentials from environment variables.
  *
@@ -15,30 +23,30 @@ 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];
     if (credEnvironmentValue) {
         try {
             const parsed = JSON.parse(credEnvironmentValue);
-            const parseResult = parseCredentials(parsed);
+            const parseResult = parseCredentialsResult(parsed);
             if (parseResult.ok) {
-                if (parseResult.credentials.agent !== agentId) {
+                if (parseResult.value.agent !== agentId) {
                     return {
                         ok: false,
                         exitCode: 2,
                         message: `Error: ${credEnvironmentVariable} agent mismatch. ` +
-                            `Expected ${agentId}, got ${parseResult.credentials.agent}.`,
+                            `Expected ${agentId}, got ${parseResult.value.agent}.`,
                     };
                 }
-                return { ok: true, credentials: parseResult.credentials };
+                return { ok: true, credentials: parseResult.value };
             }
             return {
                 ok: false,
                 exitCode: 2,
                 message: `Error: Invalid credentials format in ${credEnvironmentVariable}: ` +
-                    parseResult.error,
+                    formatZodError(parseResult.error),
             };
         }
         catch (error) {
@@ -51,12 +59,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 +92,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 +115,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

@@ -1,10 +1,9 @@
 /**
  * Types for run-agent results and options.
  */
-import type { AgentCli } from "axshared";
+import type { AgentCli, Credentials } from "axshared";
 import type { AxexecEvent } from "./events.js";
 import type { OutputFormat } from "../resolve-output-mode.js";
-import type { Credentials } from "../credentials/credentials.js";
 interface RunAgentDiagnostics {
     error: (message: string) => void;
     warn: (message: string) => void;
@@ -17,6 +16,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.1",
   "description": "Unified CLI runner for AI coding agents with normalized event streaming",
   "repository": {
     "type": "git",

package/dist/credentials/credentials.d.ts

@@ -1,39 +0,0 @@
-/**
- * Credential schema and parser.
- *
- * Temporary local copy of the axshared credentials schema.
- * Remove once axshared exports an equivalent parser with matching validation.
- */
-import { z } from "zod";
-/** Zod schema for Credentials */
-declare const Credentials: z.ZodObject<{
-    agent: z.ZodEnum<{
-        claude: "claude";
-        codex: "codex";
-        gemini: "gemini";
-        opencode: "opencode";
-        copilot: "copilot";
-    }>;
-    type: z.ZodEnum<{
-        "oauth-credentials": "oauth-credentials";
-        "oauth-token": "oauth-token";
-        "api-key": "api-key";
-    }>;
-    provider: z.ZodOptional<z.ZodString>;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-type Credentials = z.infer<typeof Credentials>;
-type ParseCredentialsResult = {
-    ok: true;
-    credentials: Credentials;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Parse and validate credentials from unknown input.
- *
- * @returns Validated Credentials or error details
- */
-declare function parseCredentials(input: unknown): ParseCredentialsResult;
-export { Credentials, parseCredentials };

package/dist/credentials/credentials.js

@@ -1,73 +0,0 @@
-/**
- * Credential schema and parser.
- *
- * Temporary local copy of the axshared credentials schema.
- * Remove once axshared exports an equivalent parser with matching validation.
- */
-import { z } from "zod";
-import { AGENT_CLIS } from "axshared";
-import { resolveStringField } from "./resolve-string-field.js";
-/** Credential storage types */
-const CREDENTIAL_TYPES = [
-    "oauth-credentials",
-    "oauth-token",
-    "api-key",
-];
-/** Zod schema for credential type validation and parsing */
-const CredentialType = z.enum(CREDENTIAL_TYPES);
-/** Zod schema for Credentials */
-const Credentials = z
-    .object({
-    /** Agent this credential belongs to */
-    agent: z.enum(AGENT_CLIS),
-    /** Credential storage type */
-    type: CredentialType,
-    /** Provider identifier for multi-provider agents like OpenCode */
-    provider: z.string().trim().min(1).optional(),
-    /** The actual credential data (format depends on type and agent) */
-    data: z.record(z.string(), z.unknown()),
-})
-    .superRefine((value, context) => {
-    if (value.type === "api-key") {
-        const apiKey = resolveStringField(value.data, "apiKey", "key");
-        if (!apiKey) {
-            context.addIssue({
-                code: "custom",
-                path: ["data"],
-                message: 'api-key credentials require "apiKey" or "key"',
-            });
-        }
-    }
-    if (value.type === "oauth-token") {
-        const oauthToken = resolveStringField(value.data, "oauthToken", "token");
-        if (!oauthToken) {
-            context.addIssue({
-                code: "custom",
-                path: ["data"],
-                message: 'oauth-token credentials require "oauthToken" or "token"',
-            });
-        }
-    }
-    // oauth-credentials payloads are provider-specific and intentionally
-    // not validated beyond basic schema checks here.
-});
-function formatParseError(error) {
-    return error.issues
-        .map((issue) => {
-        const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-        return `${path}: ${issue.message}`;
-    })
-        .join("; ");
-}
-/**
- * Parse and validate credentials from unknown input.
- *
- * @returns Validated Credentials or error details
- */
-function parseCredentials(input) {
-    const result = Credentials.safeParse(input);
-    if (result.success)
-        return { ok: true, credentials: result.data };
-    return { ok: false, error: formatParseError(result.error) };
-}
-export { Credentials, parseCredentials };