@martinloop/mcp 0.3.9 → 0.5.1

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -1,11 +1,14 @@
 import { type ChildProcess, type SpawnOptions } from "node:child_process";
 import { diffStatsFromNumstat } from "./runtime-support.js";
+import type { VerifierExecutionBinding } from "../core/index.js";
 export type SpawnLike = (command: string, args?: readonly string[], options?: SpawnOptions) => ChildProcess;
 export interface SubprocessResult {
     exitCode: number;
     stdout: string;
     stderr: string;
     timedOut: boolean;
+    completed: boolean;
+    crashed: boolean;
     /**
      * True when the subprocess was terminated early because its combined
      * stdout+stderr exceeded `maxOutputBytes` — a circuit breaker against
@@ -30,10 +33,13 @@ export interface VerificationOutcome {
     summary: string;
     steps: VerificationStepOutcome[];
     warnings?: string[];
+    binding: VerifierExecutionBinding;
 }
 export interface VerificationStepOutcome {
     command: string;
     launched: boolean;
+    completed: boolean;
+    crashed: boolean;
     exitCode?: number;
     timedOut: boolean;
     fastFail: boolean;
@@ -60,12 +66,14 @@ export declare function runSubprocess(command: string, args: string[], options:
      * a runaway final usage figure.
      */
     onStdoutChunk?: (chunk: Buffer, terminate: (reason: string) => void) => void;
+    /** Optional abort signal — kills the subprocess when aborted. */
+    signal?: AbortSignal;
 }): Promise<SubprocessResult>;
 export declare function runVerification(commands: string[], cwd: string, timeoutMs: number, verificationStack?: Array<{
     command: string;
     type: string;
     fastFail?: boolean;
-}>, spawnImpl?: SpawnLike): Promise<VerificationOutcome>;
+}>, spawnImpl?: SpawnLike, binding?: Omit<VerifierExecutionBinding, "commands">): Promise<VerificationOutcome>;
 export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<{
     changedFiles?: string[];
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;

package/dist/vendor/adapters/cli-bridge.js

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
+import { basename, delimiter, dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { diffStatsFromNumstat } from "./runtime-support.js";
 const gitRepositoryRootCache = new Map();
@@ -32,7 +32,7 @@ export async function runSubprocess(command, args, options) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: message, launched: false, completed: false, crashed: true });
             return;
         }
         const trackOutput = (chunks, chunk) => {
@@ -53,6 +53,18 @@ export async function runSubprocess(command, args, options) {
             terminationReason = reason;
             proc.kill("SIGTERM");
         };
+        // Honour the harness abort signal — kill the subprocess immediately
+        if (options.signal !== undefined) {
+            const sig = options.signal;
+            if (sig.aborted) {
+                proc.kill("SIGTERM");
+            }
+            else {
+                const onAbort = () => { proc.kill("SIGTERM"); };
+                sig.addEventListener("abort", onAbort, { once: true });
+                proc.on("close", () => { sig.removeEventListener("abort", onAbort); });
+            }
+        }
         proc.stdout?.on("data", (chunk) => {
             if (outputCapped || timedOut || terminationReason) {
                 return;
@@ -93,15 +105,18 @@ export async function runSubprocess(command, args, options) {
         });
         proc.on("error", (error) => {
             clearTimeout(timer);
-            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false });
+            resolveOnce({ exitCode: 1, stdout: "", stderr: error.message, launched: false, completed: false, crashed: true });
         });
         proc.on("close", (code) => {
             clearTimeout(timer);
+            const completed = code !== null && !timedOut && !outputCapped && !terminationReason;
             resolveOnce({
                 exitCode: code ?? 1,
                 stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                 stderr: Buffer.concat(stderrChunks).toString("utf8"),
-                launched: true
+                launched: true,
+                completed,
+                crashed: !completed && !timedOut && !outputCapped && !terminationReason,
             });
         });
         if (options.stdinData !== undefined && proc.stdin) {
@@ -116,22 +131,30 @@ export async function runSubprocess(command, args, options) {
                         exitCode: 1,
                         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
                         stderr: stdinError.message,
-                        launched: false
+                        launched: false,
+                        completed: false,
+                        crashed: true,
                     });
                 }
             }
         }
     });
 }
-export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl) {
+export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl, binding) {
     const steps = verificationStack && verificationStack.length > 0
         ? verificationStack.map((step) => ({
             command: step.command,
             fastFail: step.fastFail !== false
         }))
         : commands.map((command) => ({ command, fastFail: true }));
+    const executionBinding = {
+        runId: binding?.runId ?? "unbound",
+        workspaceId: binding?.workspaceId ?? "unbound",
+        cwd: binding?.cwd ?? cwd,
+        commands: steps.map((step) => step.command),
+    };
     if (steps.length === 0) {
-        return { passed: true, summary: "No verification commands specified.", steps: [] };
+        return { passed: true, summary: "No verification commands specified.", steps: [], binding: executionBinding };
     }
     const failedSteps = [];
     const stepOutcomes = [];
@@ -169,6 +192,8 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         stepOutcomes.push({
             command: step.command,
             launched: result.launched,
+            completed: result.completed,
+            crashed: result.crashed,
             exitCode: result.exitCode,
             timedOut: result.timedOut,
             fastFail: step.fastFail,
@@ -179,6 +204,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
                 passed: false,
                 summary: `Verification timed out: ${step.command}`,
                 steps: stepOutcomes,
+                binding: executionBinding,
                 ...(warnings.length ? { warnings } : {})
             };
         }
@@ -188,7 +214,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
                 warnings.push(`Verifier never launched: ${step.command}`);
             }
             if (step.fastFail) {
-                return { passed: false, summary, steps: stepOutcomes, ...(warnings.length ? { warnings } : {}) };
+                return { passed: false, summary, steps: stepOutcomes, binding: executionBinding, ...(warnings.length ? { warnings } : {}) };
             }
             failedSteps.push(step.command);
         }
@@ -198,6 +224,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
             passed: false,
             summary: `Failed steps: ${failedSteps.join(", ")}`,
             steps: stepOutcomes,
+            binding: executionBinding,
             ...(warnings.length ? { warnings } : {})
         };
     }
@@ -205,6 +232,7 @@ export async function runVerification(commands, cwd, timeoutMs, verificationStac
         passed: true,
         summary: `All ${String(steps.length)} verification step(s) passed.`,
         steps: stepOutcomes,
+        binding: executionBinding,
         ...(warnings.length ? { warnings } : {})
     };
 }
@@ -365,19 +393,32 @@ export function resolveNpmShimScript(shimPath) {
     }
     const shimDir = dirname(shimPath);
     const scriptPathPattern = /["']?(?:%~?dp0%?|\$basedir)[\\/]([^"'\s]+\.[cm]?js)["']?/gi;
-    const matches = contents.matchAll(scriptPathPattern);
+    const matches = [...contents.matchAll(scriptPathPattern)];
+    // Collect all candidate scripts that exist on disk.
+    const candidates = [];
     for (const match of matches) {
         const relativeScript = match[1];
-        if (!relativeScript) {
+        if (!relativeScript)
             continue;
-        }
         const segments = relativeScript.split(/[\\/]+/u).filter(Boolean);
         const resolvedScript = resolve(shimDir, ...segments);
         if (existsSync(resolvedScript)) {
-            return resolvedScript;
+            candidates.push(resolvedScript);
         }
     }
-    return undefined;
+    if (candidates.length === 0)
+        return undefined;
+    // npm.cmd / npm.ps1 / npm.bat shims reference both npm-prefix.js and npm-cli.js.
+    // npm-cli.js is the semantic npm CLI entry point — never pick npm-prefix.js for
+    // these. Fail closed: if npm-cli.js is not among the resolved candidates, return
+    // undefined so the caller falls back to wrapper-shell behavior.
+    const shimBasename = basename(shimPath).toLowerCase();
+    if (/^npm(\.(cmd|ps1|bat))?$/.test(shimBasename)) {
+        return candidates.find((p) => basename(p).toLowerCase() === "npm-cli.js");
+    }
+    // For all other npm-installed executables (codex.cmd, claude.ps1, etc.), the
+    // shim wraps exactly one package bin target — use the first resolving candidate.
+    return candidates[0];
 }
 /**
  * Resolve a reliable `node` executable for spawning CLI scripts on Windows.

package/dist/vendor/adapters/codex-launcher.d.ts

@@ -43,7 +43,67 @@ export interface CodexExecArgsOptions {
     mode?: "prompt" | "probe";
 }
 type SpawnSyncLike = typeof spawnSync;
-export declare const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
+/**
+ * Outcome when the preflight probe confirms the working directory is writable.
+ * capabilitySource is always "probe" — result is measured, not assumed.
+ */
+export interface CodexSandboxPreflightOk {
+    ok: true;
+    effectiveSandbox: "read-only" | "workspace-write";
+    capabilitySource: "probe";
+    writableRoot: string;
+}
+/**
+ * Outcome when the working directory cannot be written but workspace-write
+ * was requested.  This is a first-class typed failure — distinct from a
+ * provider-unavailable or environment-mismatch error.  No model call has
+ * been attempted when this is returned.
+ */
+export interface CodexSandboxPreflightReadOnly {
+    ok: false;
+    code: "provider_sandbox_read_only";
+    requestedCapability: "workspace-write";
+    detectedCapability: "read-only";
+    effectiveSandbox: "read-only";
+    affectedPath: string;
+    writableRoot: string;
+    capabilitySource: "probe";
+    remediation: string;
+}
+export type CodexSandboxPreflightOutcome = CodexSandboxPreflightOk | CodexSandboxPreflightReadOnly;
+/**
+ * Probes whether the given directory is writable by the current process.
+ *
+ * Strategy: create a uniquely named temp file inside the directory, write a
+ * sentinel byte, then remove it.  This is a real filesystem action — not an
+ * inference from binary metadata or launch-probe output.
+ *
+ * The probe leaves no file behind on either success or failure.
+ *
+ * Exported for unit testing with a real tmp directory.
+ */
+export declare function probeFilesystemWriteCapability(directory: string): {
+    writable: true;
+} | {
+    writable: false;
+    reason: string;
+};
+/**
+ * Checks whether the requested sandbox mode is achievable for the given
+ * working directory.  The adapter receives `requestedSandbox` from CLI/core —
+ * it does not decide the mode itself.
+ *
+ * When `requestedSandbox` is "workspace-write" and the working directory is not
+ * writable, this function returns `provider_sandbox_read_only` before any model
+ * execution is attempted.
+ *
+ * When `requestedSandbox` is "read-only" no write probe is performed; the
+ * outcome is `ok: true, effectiveSandbox: "read-only"` immediately.
+ */
+export declare function checkCodexSandboxPreflight(input: {
+    requestedSandbox: "read-only" | "workspace-write";
+    workingDirectory: string;
+}): CodexSandboxPreflightOutcome;
 export interface CodexProbeCandidateResult {
     path: string;
     installKind: CodexInstallKind;

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

@@ -1,9 +1,100 @@
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, extname, join, resolve } from "node:path";
 import { resolveNpmShimScript } from "./cli-bridge.js";
 const codexLaunchProbeCache = new Map();
-export const DEFAULT_CODEX_CHATGPT_MODEL = "gpt-5.4";
+/**
+ * Probes whether the given directory is writable by the current process.
+ *
+ * Strategy: create a uniquely named temp file inside the directory, write a
+ * sentinel byte, then remove it.  This is a real filesystem action — not an
+ * inference from binary metadata or launch-probe output.
+ *
+ * The probe leaves no file behind on either success or failure.
+ *
+ * Exported for unit testing with a real tmp directory.
+ */
+export function probeFilesystemWriteCapability(directory) {
+    // Ensure the directory exists before probing.
+    try {
+        mkdirSync(directory, { recursive: true });
+    }
+    catch (err) {
+        return {
+            writable: false,
+            reason: `Could not create directory ${directory}: ${err instanceof Error ? err.message : String(err)}`
+        };
+    }
+    // Use mkdtempSync so the filename is guaranteed unique even under concurrent runs.
+    let tempDir;
+    try {
+        tempDir = mkdtempSync(join(directory, ".ml-write-probe-"));
+        const tempFile = join(tempDir, "capability.tmp");
+        writeFileSync(tempFile, "\x01", { encoding: "binary", flag: "wx" });
+        unlinkSync(tempFile);
+        return { writable: true };
+    }
+    catch (err) {
+        return {
+            writable: false,
+            reason: err instanceof Error ? err.message : String(err)
+        };
+    }
+    finally {
+        if (tempDir) {
+            try {
+                rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch { /* ignore cleanup errors */ }
+        }
+    }
+}
+/**
+ * Checks whether the requested sandbox mode is achievable for the given
+ * working directory.  The adapter receives `requestedSandbox` from CLI/core —
+ * it does not decide the mode itself.
+ *
+ * When `requestedSandbox` is "workspace-write" and the working directory is not
+ * writable, this function returns `provider_sandbox_read_only` before any model
+ * execution is attempted.
+ *
+ * When `requestedSandbox` is "read-only" no write probe is performed; the
+ * outcome is `ok: true, effectiveSandbox: "read-only"` immediately.
+ */
+export function checkCodexSandboxPreflight(input) {
+    const dir = resolve(input.workingDirectory);
+    if (input.requestedSandbox === "read-only") {
+        return {
+            ok: true,
+            effectiveSandbox: "read-only",
+            capabilitySource: "probe",
+            writableRoot: dir
+        };
+    }
+    // workspace-write: run the actual filesystem probe.
+    const probeResult = probeFilesystemWriteCapability(dir);
+    if (probeResult.writable) {
+        return {
+            ok: true,
+            effectiveSandbox: "workspace-write",
+            capabilitySource: "probe",
+            writableRoot: dir
+        };
+    }
+    return {
+        ok: false,
+        code: "provider_sandbox_read_only",
+        requestedCapability: "workspace-write",
+        detectedCapability: "read-only",
+        effectiveSandbox: "read-only",
+        affectedPath: dir,
+        writableRoot: dir,
+        capabilitySource: "probe",
+        remediation: `The working directory ${dir} is not writable by the current process. ` +
+            "Launch MartinLoop in a session with write access to that directory, or use " +
+            "`--sandbox read-only` for inspection-only work."
+    };
+}
 const CODEX_LAUNCH_PROBE_PROMPT = [
     "You are validating MartinLoop Codex host readiness.",
     "Do not edit files.",
@@ -17,7 +108,7 @@ function buildProbeCacheKey(input) {
         workingDirectory: resolve(input.workingDirectory),
         platform: input.platform,
         candidatePaths: input.candidatePaths,
-        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL
+        model: input.model
     });
 }
 function isInsideGitRepository(workingDirectory) {
@@ -89,6 +180,17 @@ function codexProbePreference(diagnosis) {
     }
     return 3;
 }
+function codexProbeCandidatePreference(path, diagnosis, platform) {
+    const hostPreference = codexProbePreference(diagnosis) * 10;
+    if (platform !== "win32" || diagnosis.installKind !== "windows_shim") {
+        return hostPreference;
+    }
+    // `where codex` commonly returns npm's extensionless POSIX shim before
+    // `codex.cmd`. Node cannot spawn that text shim directly on Windows, while
+    // the .cmd/.ps1 shim has a supported invocation path (or can be unwrapped).
+    const extension = extname(path).toLowerCase();
+    return hostPreference + (extension === ".cmd" || extension === ".bat" || extension === ".ps1" ? 0 : 1);
+}
 function buildProbeCandidates(input) {
     const pathCandidates = normalizeCandidates(input.availability.candidatePaths ?? [input.availability.resolvedPath ?? input.availability.command]);
     const desktopCandidates = input.platform === "win32" && input.includeDesktopCandidates
@@ -106,7 +208,9 @@ function buildProbeCandidates(input) {
         return {
             path,
             diagnosis,
-            preference: input.platform === "win32" ? codexProbePreference(diagnosis) : 0,
+            preference: input.platform === "win32"
+                ? codexProbeCandidatePreference(path, diagnosis, input.platform)
+                : 0,
             discoveryIndex
         };
     })
@@ -205,11 +309,11 @@ function classifyProbeFailure(stderr, stdout, diagnosis) {
             warnings.push(unsupportedModelWarning);
         }
         return {
-            summary: `Codex launched with a model that is not supported for ChatGPT-account authentication. Use an explicit supported model such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` for governed Codex work.`,
+            summary: "Codex launched with a model that is not supported for ChatGPT-account authentication. Pass an explicit model that your ChatGPT account supports for governed Codex work.",
             diagnosis: {
                 ...diagnosis,
                 warnings,
-                remediation: `Override the Codex launch model to a ChatGPT-account-supported option such as \`${DEFAULT_CODEX_CHATGPT_MODEL}\` before running governed Codex work.`
+                remediation: "Override the Codex launch model to a ChatGPT-account-supported option before running governed Codex work."
             }
         };
     }
@@ -275,14 +379,18 @@ export function buildCodexExecArgs(options) {
     const sandbox = options.sandbox ?? "workspace-write";
     const modelArgs = options.model ? ["--model", options.model] : [];
     const extraArgs = options.extraArgs ?? [];
+    const sandboxArgs = sandbox === "workspace-write"
+        // In Codex CLI, --approve-for-me is the write-enabled automatic-review
+        // mode and is mutually exclusive with --sandbox workspace-write.
+        ? ["--approve-for-me"]
+        : ["--sandbox", sandbox];
     return [
         "exec",
         // Governed MartinLoop runs should not inherit auth-sensitive default MCP/plugin state.
         "--ignore-user-config",
         "--cd",
         options.workingDirectory,
-        "--sandbox",
-        sandbox,
+        ...sandboxArgs,
         "--json",
         "--color",
         "never",
@@ -357,10 +465,6 @@ function discoverCommandOffPath(command, platform, env) {
         const localAppData = env.LOCALAPPDATA;
         if (localAppData)
             dirs.push(join(localAppData, "OpenAI", "Codex", "bin"));
-        // Claude Code native installer places binary at %USERPROFILE%\.local\bin
-        const userProfile = env.USERPROFILE ?? env.HOMEPATH;
-        if (userProfile)
-            dirs.push(join(userProfile, ".local", "bin"));
         if (home)
             dirs.push(join(home, "scoop", "shims"));
     }
@@ -387,13 +491,8 @@ function discoverCommandOffPath(command, platform, env) {
     return undefined;
 }
 function suggestInstall(command) {
-    if (command === "claude") {
-        const installCmd = process.platform === "win32"
-            ? "irm https://claude.ai/install.ps1 | iex"
-            : "curl -fsSL https://claude.ai/install.sh | bash";
-        return `Install with: ${installCmd}`;
-    }
     const installs = {
+        claude: "Install with: npm install -g @anthropic-ai/claude-code",
         codex: "Install with: npm install -g @openai/codex",
         gemini: "Install with: npm install -g @google/gemini-cli"
     };
@@ -471,7 +570,7 @@ export function probeCodexLaunch(input) {
     });
     const args = buildCodexExecArgs({
         workingDirectory: input.workingDirectory,
-        model: input.model ?? DEFAULT_CODEX_CHATGPT_MODEL,
+        model: input.model,
         mode: "probe"
     });
     if (!availability.available) {

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

@@ -1,8 +1,6 @@
 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, 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, 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 { createVerifierOnlyAdapter, type VerifierOnlyAdapterOptions } from "./verifier-only.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, type CliCommandAvailability, type CodexHostDiagnosis, type CodexHostPlatform, type CodexLaunchProbeResult, checkCodexSandboxPreflight, probeFilesystemWriteCapability, type CodexSandboxPreflightOk, type CodexSandboxPreflightOutcome, type CodexSandboxPreflightReadOnly } 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,8 +1,6 @@
 export { createDirectProviderAdapter } from "./direct-provider.js";
-export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
-export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
 export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, createGeminiCliAdapter } from "./claude-cli.js";
-export { createVerifierOnlyAdapter } from "./verifier-only.js";
 export { createOpenAiCompatibleAdapter, resolveOpenAiCompatibleRuntimeConfig } from "./openai-compatible.js";
-export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability } from "./codex-launcher.js";
+export { createVerifierOnlyAdapter } from "./verifier-only.js";
+export { detectCodexHostPlatform, diagnoseCodexHost, probeCodexLaunch, resolveCliCommandAvailability, checkCodexSandboxPreflight, probeFilesystemWriteCapability } from "./codex-launcher.js";
 export { createSpawnPlan } from "./cli-bridge.js";

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

@@ -14,7 +14,7 @@
  * 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_OPENAI_MODEL=<provider-model-id>
  *   martin-loop run "fix the bug" --engine openai
  *
  *   # Or route to a third-party / self-hosted OpenAI-compatible endpoint:
@@ -51,10 +51,9 @@ export interface OpenAiCompatibleAdapterOptions {
     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;
+    model?: string;
     apiKey: string;
     apiKeyConfigured: boolean;
     authPosture: "api_key" | "anonymous_or_local";