@martinloop/mcp 0.2.7 → 0.3.1

package/dist/vendor/adapters/codex-launcher.js

@@ -0,0 +1,538 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+const codexLaunchProbeCache = new Map();
+const CODEX_LAUNCH_PROBE_PROMPT = [
+    "You are validating MartinLoop Codex host readiness.",
+    "Do not edit files.",
+    "Use the shell command executor exactly once to run: git status --short -- .",
+    "Do not use MCP tools, Node REPL, or any fallback tool if shell execution fails.",
+    "If the shell command succeeds, reply with READY only.",
+    "If it fails, reply with the exact failure in one sentence."
+].join("\n");
+function buildProbeCacheKey(input) {
+    return JSON.stringify({
+        workingDirectory: resolve(input.workingDirectory),
+        platform: input.platform,
+        candidatePaths: input.candidatePaths
+    });
+}
+function isInsideGitRepository(workingDirectory) {
+    let current = resolve(workingDirectory);
+    while (true) {
+        if (existsSync(resolve(current, ".git"))) {
+            return true;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            return false;
+        }
+        current = parent;
+    }
+}
+function normalizeCandidates(lines) {
+    return [...new Set(lines.map((line) => line.trim()).filter(Boolean))];
+}
+function readLocatorCandidates(command, platform, spawnSyncImpl) {
+    const locator = platform === "win32" ? "where.exe" : "which";
+    const result = spawnSyncImpl(locator, [command], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    return {
+        locator,
+        candidates: result.status === 0
+            ? normalizeCandidates((result.stdout ?? "").split(/\r?\n/u))
+            : [],
+        foundOnPath: result.status === 0
+    };
+}
+function discoverWindowsDesktopCodexCandidates(env) {
+    const localAppData = env["LOCALAPPDATA"];
+    if (!localAppData) {
+        return [];
+    }
+    const baseDirectory = join(localAppData, "OpenAI", "Codex", "bin");
+    if (!existsSync(baseDirectory)) {
+        return [];
+    }
+    const candidates = [];
+    const directCandidate = join(baseDirectory, "codex.exe");
+    if (existsSync(directCandidate)) {
+        candidates.push({ path: directCandidate, mtimeMs: statSync(directCandidate).mtimeMs });
+    }
+    for (const entry of readdirSync(baseDirectory, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const candidate = join(baseDirectory, entry.name, "codex.exe");
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        candidates.push({ path: candidate, mtimeMs: statSync(candidate).mtimeMs });
+    }
+    candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    return normalizeCandidates(candidates.map((candidate) => candidate.path));
+}
+function codexProbePreference(diagnosis) {
+    if (diagnosis.installKind === "native" && diagnosis.invocationMode === "direct") {
+        return 0;
+    }
+    if (diagnosis.installKind === "native") {
+        return 1;
+    }
+    if (diagnosis.installKind === "windows_shim") {
+        return 2;
+    }
+    return 3;
+}
+function buildProbeCandidates(input) {
+    const pathCandidates = normalizeCandidates(input.availability.candidatePaths ?? [input.availability.resolvedPath ?? input.availability.command]);
+    const desktopCandidates = input.platform === "win32" && input.includeDesktopCandidates
+        ? discoverWindowsDesktopCodexCandidates(input.env).filter((candidatePath) => !pathCandidates.includes(candidatePath))
+        : [];
+    return [...pathCandidates, ...desktopCandidates]
+        .map((path, discoveryIndex) => {
+        const diagnosis = diagnoseCodexHost({
+            ...input.availability,
+            resolvedPath: path
+        }, {
+            env: input.env,
+            platform: input.platform
+        });
+        return {
+            path,
+            diagnosis,
+            preference: input.platform === "win32" ? codexProbePreference(diagnosis) : 0,
+            discoveryIndex
+        };
+    })
+        .sort((left, right) => left.preference === right.preference
+        ? left.discoveryIndex - right.discoveryIndex
+        : left.preference - right.preference);
+}
+function buildProbeCommand(command, args, platform) {
+    if (platform !== "win32") {
+        return { command, args, invocationMode: "direct" };
+    }
+    const extension = extname(command).toLowerCase();
+    switch (extension) {
+        case ".cmd":
+        case ".bat":
+            return {
+                command: process.env.ComSpec || "cmd.exe",
+                args: ["/d", "/c", command, ...args],
+                invocationMode: "cmd_shell"
+            };
+        case ".ps1":
+            return {
+                command: "powershell.exe",
+                args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", command, ...args],
+                invocationMode: "powershell"
+            };
+        default:
+            return { command, args, invocationMode: "direct" };
+    }
+}
+function detectInstallKind(resolvedPath, hostPlatform) {
+    if (!resolvedPath) {
+        return "missing";
+    }
+    const normalizedPath = resolvedPath.replace(/\\/gu, "/").toLowerCase();
+    const looksWindowsShim = normalizedPath.endsWith(".cmd") ||
+        normalizedPath.endsWith(".bat") ||
+        normalizedPath.endsWith(".ps1") ||
+        normalizedPath.includes("/appdata/roaming/npm/");
+    const looksMountedWindowsPath = normalizedPath.startsWith("/mnt/c/");
+    if ((hostPlatform === "linux" || hostPlatform === "wsl") && looksMountedWindowsPath) {
+        return "windows_mounted_path";
+    }
+    if (looksWindowsShim) {
+        return "windows_shim";
+    }
+    return "native";
+}
+function detectInvocationMode(resolvedPath, platform) {
+    if (platform !== "win32" || !resolvedPath) {
+        return "direct";
+    }
+    const extension = extname(resolvedPath).toLowerCase();
+    if (extension === ".ps1") {
+        return "powershell";
+    }
+    if (extension === ".cmd" || extension === ".bat") {
+        return "cmd_shell";
+    }
+    return "direct";
+}
+function classifyProbeFailure(stderr, stdout, diagnosis) {
+    const combined = `${stderr}\n${stdout}`;
+    if (/@openai\/codex-linux-x64/iu.test(combined) ||
+        /cannot find module ['"]@openai\/codex-linux-x64['"]/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const missingDependencyWarning = "Codex is missing the native Linux package '@openai/codex-linux-x64' required for this host.";
+        if (!warnings.includes(missingDependencyWarning)) {
+            warnings.push(missingDependencyWarning);
+        }
+        return {
+            summary: "Codex native dependency '@openai/codex-linux-x64' is missing for this Linux/WSL environment.",
+            diagnosis: {
+                ...diagnosis,
+                nativeInstallValid: false,
+                sandboxCompatible: false,
+                warnings,
+                nativeDependencyStatus: "missing",
+                nativeDependencyPackage: "@openai/codex-linux-x64",
+                remediation: "Reinstall Codex natively inside this Linux/WSL environment so the '@openai/codex-linux-x64' package is present before running governed Codex work."
+            }
+        };
+    }
+    if (/CreateProcessAsUserW failed:\s*5/iu.test(combined) ||
+        /windows sandbox: runner error: CreateProcessAsUserW failed:\s*5/iu.test(combined) ||
+        /spawn setup refresh/iu.test(combined)) {
+        const warnings = [...diagnosis.warnings];
+        const sandboxFailureWarning = "Codex workspace-write sandbox could not launch subprocesses on this Windows host.";
+        if (!warnings.includes(sandboxFailureWarning)) {
+            warnings.push(sandboxFailureWarning);
+        }
+        return {
+            summary: "Codex workspace-write sandbox could not launch subprocesses on this Windows host.",
+            diagnosis: {
+                ...diagnosis,
+                sandboxCompatible: false,
+                warnings,
+                remediation: "Update or reinstall Codex on this Windows host until `codex exec --sandbox workspace-write` can launch a simple shell command before running governed Codex work."
+            }
+        };
+    }
+    return {};
+}
+export function buildCodexExecArgs(options) {
+    const sandbox = options.sandbox ?? "workspace-write";
+    const modelArgs = options.model ? ["--model", options.model] : [];
+    const extraArgs = options.extraArgs ?? [];
+    return [
+        "exec",
+        "--cd",
+        options.workingDirectory,
+        "--sandbox",
+        sandbox,
+        "--json",
+        "--color",
+        "never",
+        ...modelArgs,
+        ...extraArgs,
+        "-"
+    ];
+}
+function parseCodexProbeEvents(stdout) {
+    return stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((event) => event !== undefined);
+}
+function hasSuccessfulCommandExecution(events) {
+    return events.some((event) => event.type === "item.completed" &&
+        event.item?.type === "command_execution" &&
+        event.item?.status === "completed" &&
+        event.item?.exit_code === 0);
+}
+export function resolveCliCommandAvailability(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const spawnSyncImpl = options.spawnSyncImpl ?? spawnSync;
+    const discovery = readLocatorCandidates(command, platform, spawnSyncImpl);
+    const resolvedPath = discovery.candidates[0];
+    return discovery.candidates.length > 0
+        ? {
+            command,
+            available: true,
+            locator: discovery.locator,
+            detail: `${command} is available on PATH.`,
+            ...(resolvedPath ? { resolvedPath } : {}),
+            candidatePaths: discovery.candidates
+        }
+        : {
+            command,
+            available: false,
+            locator: discovery.locator,
+            detail: `${command} is not available on PATH.`
+        };
+}
+export function detectCodexHostPlatform(env = process.env, platform = process.platform) {
+    if (platform === "win32") {
+        return "windows";
+    }
+    if (platform === "darwin") {
+        return "macos";
+    }
+    if (env["WSL_DISTRO_NAME"] || env["WSL_INTEROP"]) {
+        return "wsl";
+    }
+    return "linux";
+}
+export function diagnoseCodexHost(availability, options = {}) {
+    const hostPlatform = detectCodexHostPlatform(options.env ?? process.env, options.platform ?? process.platform);
+    const resolvedPath = availability.resolvedPath;
+    const installKind = detectInstallKind(resolvedPath, hostPlatform);
+    const invocationMode = detectInvocationMode(resolvedPath, options.platform ?? process.platform);
+    const warnings = [];
+    if (!availability.available) {
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            installKind,
+            invocationMode,
+            sandboxMode: "workspace-write",
+            sandboxCompatible: false,
+            ...(resolvedPath ? { resolvedPath } : {}),
+            warnings,
+            remediation: "Install or expose the Codex CLI on PATH before running governed Codex work."
+        };
+    }
+    if ((hostPlatform === "linux" || hostPlatform === "wsl") &&
+        (installKind === "windows_shim" || installKind === "windows_mounted_path")) {
+        warnings.push("Codex resolves to a Windows-hosted install from a Linux/WSL environment.");
+        return {
+            hostPlatform,
+            nativeInstallValid: false,
+            installKind,
+            invocationMode,
+            sandboxMode: "workspace-write",
+            sandboxCompatible: false,
+            ...(resolvedPath ? { resolvedPath } : {}),
+            warnings,
+            remediation: "Install Codex natively inside this Linux/WSL environment instead of relying on a Windows PATH shim."
+        };
+    }
+    return {
+        hostPlatform,
+        nativeInstallValid: true,
+        installKind,
+        invocationMode,
+        sandboxMode: "workspace-write",
+        sandboxCompatible: true,
+        ...(resolvedPath ? { resolvedPath } : {}),
+        ...(hostPlatform === "linux" || hostPlatform === "wsl"
+            ? { nativeDependencyStatus: "unknown" }
+            : {}),
+        warnings
+    };
+}
+export function probeCodexLaunch(input) {
+    const availability = input.availability ??
+        resolveCliCommandAvailability("codex", {
+            platform: input.platform,
+            spawnSyncImpl: input.spawnSyncImpl
+        });
+    const diagnosis = diagnoseCodexHost(availability, {
+        env: input.env,
+        platform: input.platform
+    });
+    const args = buildCodexExecArgs({
+        workingDirectory: input.workingDirectory,
+        mode: "probe"
+    });
+    if (!availability.available) {
+        return {
+            ok: false,
+            summary: availability.detail,
+            availability,
+            diagnosis,
+            command: availability.command,
+            args
+        };
+    }
+    if (!isInsideGitRepository(input.workingDirectory)) {
+        return {
+            ok: false,
+            summary: "Working directory is not inside a git repository. Codex exec requires a trusted repo unless --skip-git-repo-check is explicitly enabled.",
+            availability,
+            diagnosis,
+            command: availability.resolvedPath ?? availability.command,
+            args
+        };
+    }
+    const spawnSyncImpl = input.spawnSyncImpl ?? spawnSync;
+    const platform = input.platform ?? process.platform;
+    const env = input.env ?? process.env;
+    const probeCandidates = buildProbeCandidates({
+        availability,
+        env,
+        platform,
+        includeDesktopCandidates: input.spawnSyncImpl === undefined
+    });
+    const candidatePaths = probeCandidates.map((candidate) => candidate.path);
+    const cacheKey = buildProbeCacheKey({
+        workingDirectory: input.workingDirectory,
+        platform,
+        candidatePaths
+    });
+    if (input.spawnSyncImpl === undefined) {
+        const cached = codexLaunchProbeCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+    }
+    const candidateResults = [];
+    const probeCandidatePath = (candidate) => {
+        const candidateDiagnosis = candidate.diagnosis;
+        if (!candidateDiagnosis.nativeInstallValid) {
+            candidateResults.push({
+                path: candidate.path,
+                diagnosis: candidateDiagnosis,
+                ok: false,
+                summary: candidateDiagnosis.remediation ?? "Codex host installation is not valid for this environment."
+            });
+            return false;
+        }
+        const spawnPlan = buildProbeCommand(candidate.path, args, platform);
+        const result = spawnSyncImpl(spawnPlan.command, spawnPlan.args, {
+            cwd: input.workingDirectory,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            input: CODEX_LAUNCH_PROBE_PROMPT
+        });
+        const probedDiagnosis = {
+            ...candidateDiagnosis,
+            invocationMode: spawnPlan.invocationMode
+        };
+        if (result.error) {
+            const classifiedFailure = classifyProbeFailure(result.stderr ?? "", result.stdout ?? "", probedDiagnosis);
+            candidateResults.push({
+                path: candidate.path,
+                diagnosis: classifiedFailure.diagnosis ?? probedDiagnosis,
+                ok: false,
+                summary: classifiedFailure.summary ?? `Codex launch probe failed: ${result.error.message}`,
+                stderr: result.stderr ?? "",
+                stdout: result.stdout ?? ""
+            });
+            return false;
+        }
+        if (result.status !== 0) {
+            const stderr = (result.stderr ?? "").trim();
+            const classifiedFailure = classifyProbeFailure(result.stderr ?? "", result.stdout ?? "", probedDiagnosis);
+            candidateResults.push({
+                path: candidate.path,
+                diagnosis: classifiedFailure.diagnosis ?? probedDiagnosis,
+                ok: false,
+                summary: classifiedFailure.summary ??
+                    (stderr.length > 0 ? `Codex launch probe failed: ${stderr}` : "Codex launch probe exited non-zero."),
+                exitCode: result.status ?? undefined,
+                stderr: result.stderr ?? "",
+                stdout: result.stdout ?? ""
+            });
+            return false;
+        }
+        const events = parseCodexProbeEvents(result.stdout ?? "");
+        if (!hasSuccessfulCommandExecution(events)) {
+            const classifiedFailure = classifyProbeFailure(result.stderr ?? "", result.stdout ?? "", probedDiagnosis);
+            candidateResults.push({
+                path: candidate.path,
+                diagnosis: classifiedFailure.diagnosis ?? probedDiagnosis,
+                ok: false,
+                summary: classifiedFailure.summary ?? "Codex launch probe did not complete a shell command successfully.",
+                exitCode: result.status ?? undefined,
+                stderr: result.stderr ?? "",
+                stdout: result.stdout ?? ""
+            });
+            return false;
+        }
+        candidateResults.push({
+            path: candidate.path,
+            diagnosis: probedDiagnosis,
+            ok: true,
+            summary: "Codex exec prompt-and-shell probe passed for the current MartinLoop invocation shape.",
+            exitCode: result.status ?? undefined,
+            stderr: result.stderr ?? "",
+            stdout: result.stdout ?? ""
+        });
+        return true;
+    };
+    for (const candidate of probeCandidates) {
+        if (probeCandidatePath(candidate)) {
+            break;
+        }
+    }
+    const successfulCandidates = candidateResults.filter((candidate) => candidate.ok);
+    const selectedCandidate = successfulCandidates[0];
+    const candidateProbeResults = candidateResults.map((candidate) => ({
+        path: candidate.path,
+        installKind: candidate.diagnosis.installKind,
+        invocationMode: candidate.diagnosis.invocationMode,
+        nativeInstallValid: candidate.diagnosis.nativeInstallValid,
+        sandboxCompatible: candidate.diagnosis.sandboxCompatible,
+        launchReady: candidate.ok,
+        summary: candidate.summary,
+        ...(candidate.diagnosis.remediation ? { remediation: candidate.diagnosis.remediation } : {}),
+        ...(candidate.diagnosis.nativeDependencyStatus
+            ? { nativeDependencyStatus: candidate.diagnosis.nativeDependencyStatus }
+            : {}),
+        ...(candidate.diagnosis.nativeDependencyPackage
+            ? { nativeDependencyPackage: candidate.diagnosis.nativeDependencyPackage }
+            : {})
+    }));
+    if (selectedCandidate) {
+        const successResult = {
+            ok: true,
+            summary: selectedCandidate.summary,
+            availability: {
+                ...availability,
+                resolvedPath: selectedCandidate.path,
+                candidatePaths
+            },
+            diagnosis: {
+                ...selectedCandidate.diagnosis,
+                resolvedPath: selectedCandidate.path
+            },
+            command: selectedCandidate.path,
+            args,
+            exitCode: selectedCandidate.exitCode,
+            stderr: selectedCandidate.stderr,
+            stdout: selectedCandidate.stdout,
+            candidateProbeResults
+        };
+        if (input.spawnSyncImpl === undefined) {
+            codexLaunchProbeCache.set(cacheKey, successResult);
+        }
+        return successResult;
+    }
+    const bestFailure = platform === "win32"
+        ? candidateResults.find((candidate) => candidate.diagnosis.nativeInstallValid && candidate.diagnosis.installKind === "native") ??
+            candidateResults.find((candidate) => candidate.diagnosis.nativeInstallValid) ??
+            candidateResults[0]
+        : candidateResults[0];
+    const failureResult = {
+        ok: false,
+        summary: bestFailure?.summary ?? diagnosis.remediation ?? "Codex launch probe failed.",
+        availability: {
+            ...availability,
+            ...(bestFailure ? { resolvedPath: bestFailure.path } : {}),
+            ...(candidatePaths.length ? { candidatePaths } : {})
+        },
+        diagnosis: bestFailure
+            ? {
+                ...bestFailure.diagnosis,
+                resolvedPath: bestFailure.path
+            }
+            : diagnosis,
+        command: bestFailure?.path ?? availability.resolvedPath ?? availability.command,
+        args,
+        exitCode: bestFailure?.exitCode,
+        stderr: bestFailure?.stderr,
+        stdout: bestFailure?.stdout,
+        candidateProbeResults
+    };
+    if (input.spawnSyncImpl === undefined) {
+        codexLaunchProbeCache.set(cacheKey, failureResult);
+    }
+    return failureResult;
+}

package/dist/vendor/adapters/index.d.ts

@@ -1,7 +1,8 @@
 export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "./direct-provider.js";
 export { createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type GeminiCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
 export { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
-export { createOpenAiCompatibleAdapter, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig, type OpenAiCompatibleAdapterOptions } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult } from "./codex-launcher.js";
 export { createSpawnPlan, type SpawnLike, type SpawnPlan, type SubprocessResult, type VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -1,7 +1,8 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
 export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
 export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
-export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter } from "./claude-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
 export { createVerifierOnlyAdapter } from "./verifier-only.js";
-export { createOpenAiCompatibleAdapter } from "./openai-compatible.js";
+export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

package/dist/vendor/adapters/openai-compatible.d.ts

@@ -12,24 +12,30 @@
  *   Llama 3.x, Mistral 7B, Phi-4, Gemma 3, any GGUF model.
  *
  * Usage:
+ *   # Defaults to OpenAI's hosted endpoint when MARTIN_OPENAI_BASE_URL is unset.
+ *   MARTIN_OPENAI_API_KEY=sk-...
+ *   MARTIN_OPENAI_MODEL=gpt-4.1-mini
+ *   martin-loop run "fix the bug" --engine openai
+ *
+ *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
  *   MARTIN_OPENAI_BASE_URL=https://openrouter.ai/api
  *   MARTIN_OPENAI_API_KEY=sk-or-...
  *   MARTIN_OPENAI_MODEL=deepseek/deepseek-chat
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  *
  * Or for Ollama:
  *   MARTIN_OPENAI_BASE_URL=http://localhost:11434
  *   MARTIN_OPENAI_MODEL=llama3.3
- *   martin run "fix the bug" --engine openai
+ *   martin-loop run "fix the bug" --engine openai
  */
 import type { MartinAdapter } from "../core/index.js";
 export interface OpenAiCompatibleAdapterOptions {
     /** Base URL of the OpenAI-compatible API. No trailing slash. */
-    baseUrl: string;
+    baseUrl?: string;
     /** API key. Empty string for local (Ollama/LM Studio) endpoints. */
     apiKey?: string;
     /** Model identifier passed as-is to the API (e.g. "deepseek/deepseek-chat"). */
-    model: string;
+    model?: string;
     /**
      * System prompt prepended before the MartinLoop task prompt.
      * Default instructs the model to act as a focused coding assistant.
@@ -44,4 +50,13 @@ export interface OpenAiCompatibleAdapterOptions {
     /** Optional fetch override for testing. */
     fetchImpl?: typeof fetch;
 }
+export declare const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+export declare function resolveOpenAiCompatibleRuntimeConfig(env?: NodeJS.ProcessEnv): {
+    baseUrl: string;
+    model: string;
+    apiKey: string;
+    apiKeyConfigured: boolean;
+    authPosture: "api_key" | "anonymous_or_local";
+};
 export declare function createOpenAiCompatibleAdapter(options: OpenAiCompatibleAdapterOptions): MartinAdapter;