@agentex/agent 0.0.26 → 0.0.28

package/src/providers/cursor/discovery.ts

@@ -0,0 +1,114 @@
+import type { AgentMode, ListModelsOptions, ListModesOptions, ProviderModel } from "../../types.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess } from "../../utils/process.js";
+import { findCursorBinary } from "./runtime.js";
+
+function rec(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+export function parseCursorModels(output: string): ProviderModel[] {
+  const trimmed = output.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    const values = Array.isArray(parsed) ? parsed : Array.isArray(rec(parsed)["models"]) ? rec(parsed)["models"] as unknown[] : [];
+    const models = values.map((value) => {
+      if (typeof value === "string") return { id: value, name: value };
+      const model = rec(value);
+      const id = typeof model["id"] === "string"
+        ? model["id"]
+        : typeof model["slug"] === "string" ? model["slug"] : "";
+      return {
+        id,
+        name: typeof model["name"] === "string" ? model["name"] : id,
+      };
+    }).filter((model) => model.id);
+    if (models.length) return models;
+  } catch {
+    // Fall through to the version-aware text parser.
+  }
+
+  const seen = new Set<string>();
+  const models: ProviderModel[] = [];
+  for (const line of trimmed.split(/\r?\n/)) {
+    const cleaned = line.replace(/^\s*[-*•]\s*/, "").trim();
+    if (!cleaned || /^(available\s+)?models?:?$/i.test(cleaned)) continue;
+    const match = cleaned.match(/^([\w./:-]+)(?:\s{2,}|\s+-\s+|\s+\()?(.*)$/);
+    const id = match?.[1] ?? "";
+    if (!id || seen.has(id) || /^(usage|error|warning)$/i.test(id)) continue;
+    seen.add(id);
+    const label = match?.[2]?.replace(/[()]$/, "").trim();
+    models.push({ id, name: label || id });
+  }
+  return models;
+}
+
+export function cursorModesFromHelp(output: string): AgentMode[] {
+  if (!/--mode\b/.test(output)) return [];
+  const advertised = new Set<string>();
+  const modeLine = output.split(/\r?\n/).find((line) => /--mode\b/.test(line)) ?? "";
+  const match = modeLine.match(/--mode[^\n]*(?:<|\[)([^>\]]+)(?:>|\])/i);
+  if (match?.[1]) {
+    for (const value of match[1].split(/[|,\s]+/)) {
+      const mode = value.trim().toLowerCase();
+      if (mode) advertised.add(mode);
+    }
+  }
+  const candidates: AgentMode[] = [
+    { id: "agent", name: "Agent" },
+    { id: "plan", name: "Plan", description: "Read and plan before making changes" },
+    { id: "ask", name: "Ask", description: "Answer questions without editing" },
+  ];
+  for (const candidate of candidates) {
+    if (new RegExp(`\\b${candidate.id}\\b`, "i").test(modeLine)) {
+      advertised.add(candidate.id);
+    }
+  }
+  return candidates.filter((mode) => advertised.has(mode.id));
+}
+
+export async function listCursorModels(options: ListModelsOptions = {}): Promise<ProviderModel[]> {
+  const resolved = await findCursorBinary(options);
+  const env = buildEnv(options.env);
+  ensurePathInEnv(env);
+  const cwd = options.cwd ?? process.cwd();
+  const attempts = [
+    ["models", "--output-format", "json"],
+    ["models", "--json"],
+    ["--list-models"],
+    ["models"],
+  ];
+  for (const args of attempts) {
+    const result = await runChildProcess({
+      runId: "cursor-model-discovery",
+      command: resolved.bin,
+      args: [...resolved.prefixArgs, ...args],
+      cwd,
+      env,
+      timeoutSec: 15,
+    });
+    if (result.exitCode !== 0) continue;
+    const models = parseCursorModels(result.stdout || result.stderr);
+    if (models.length) return models;
+  }
+  throw new Error("The installed Cursor CLI does not expose model discovery");
+}
+
+export async function listCursorModes(options: ListModesOptions = {}): Promise<AgentMode[]> {
+  const resolved = await findCursorBinary(options);
+  const env = buildEnv(options.env);
+  ensurePathInEnv(env);
+  const result = await runChildProcess({
+    runId: "cursor-mode-probe",
+    command: resolved.bin,
+    args: [...resolved.prefixArgs, "--help"],
+    cwd: options.cwd ?? process.cwd(),
+    env,
+    timeoutSec: 10,
+  });
+  const output = `${result.stdout}\n${result.stderr}`;
+  return cursorModesFromHelp(output);
+}

package/src/providers/cursor/execute.ts

@@ -1,6 +1,5 @@
 import * as path from "node:path";
-import type { ExecutionContext, ExecutionResult } from "../../types.js";
-import { findBinary } from "../../utils/binary.js";
+import type { ExecutionContext, ExecutionResult, StreamEvent } from "../../types.js";
 import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
 import { runChildProcess, deriveErrorCode } from "../../utils/process.js";
 import { detectAuth } from "../../utils/auth.js";
@@ -16,6 +15,7 @@ import {
   isCursorUnknownSessionError,
   isCursorAuthRequired,
 } from "./parse.js";
+import { findCursorBinary } from "./runtime.js";
 
 export async function executeCursorProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
   const runId = ctx.runId ?? uuidv7();
@@ -28,7 +28,7 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
   ctx.onLifecycle?.({ phase: "preparing", step: "binary" });
   let resolvedBinary;
   try {
-    resolvedBinary = await findBinary("agent", config.command);
+    resolvedBinary = await findCursorBinary({ cwd, env: ctx.env, config });
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : "Binary not found";
     ctx.onLifecycle?.({ phase: "error", message: errorMessage });
@@ -96,11 +96,12 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
 
   // 5. Build args
   const buildArgs = (resumeSessionId: string | null): string[] => {
-    const args = [...resolvedBinary.prefixArgs, "-p", "--output-format", "stream-json", "--workspace", cwd];
+    const args = [...resolvedBinary.prefixArgs, "-p", "--output-format", "stream-json"];
     if (resumeSessionId) args.push("--resume", resumeSessionId);
     if (model) args.push("--model", model);
-    if (config.mode) args.push("--mode", config.mode);
-    if (config.skipPermissions) args.push("--yolo");
+    const selectedMode = config.planMode ? "plan" : (config.modeId ?? config.mode);
+    if (selectedMode) args.push("--mode", selectedMode);
+    if (config.skipPermissions) args.push("--force");
     if (config.extraArgs) args.push(...config.extraArgs);
     return args;
   };
@@ -109,6 +110,49 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
   const runAttempt = async (resumeSessionId: string | null) => {
     const args = buildArgs(resumeSessionId);
     let stdoutLineBuffer = "";
+    let accepted = false;
+    let protocolViolation = false;
+    const bufferedEvents: StreamEvent[] = [];
+    const bufferedOutput: Array<{ stream: "stdout" | "stderr"; chunk: string }> = [];
+
+    const flushOutput = async (): Promise<void> => {
+      if (!ctx.onOutput) return;
+      for (const output of bufferedOutput.splice(0)) {
+        try { await ctx.onOutput(output.stream, output.chunk); } catch { /* swallow */ }
+      }
+    };
+
+    const dispatchOutput = async (stream: "stdout" | "stderr", chunk: string): Promise<void> => {
+      if (!accepted) {
+        bufferedOutput.push({ stream, chunk });
+        return;
+      }
+      if (ctx.onOutput) {
+        try { await ctx.onOutput(stream, chunk); } catch { /* swallow */ }
+      }
+    };
+
+    const dispatch = async (event: StreamEvent): Promise<void> => {
+      if (!accepted) {
+        bufferedEvents.push(event);
+        if (event.type !== "system" || event.subtype !== "init") {
+          if (event.type !== "unknown") protocolViolation = true;
+          return;
+        }
+        if (protocolViolation) return;
+        accepted = true;
+        await flushOutput();
+        if (ctx.onEvent) {
+          for (const buffered of bufferedEvents.splice(0)) {
+            try { await ctx.onEvent(buffered); } catch { /* swallow */ }
+          }
+        }
+        return;
+      }
+      if (ctx.onEvent) {
+        try { await ctx.onEvent(event); } catch { /* swallow */ }
+      }
+    };
 
     ctx.onLifecycle?.({ phase: "spawning" });
     const proc = await runChildProcess({
@@ -127,9 +171,7 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
       signal: ctx.signal,
       onOutput: async (stream, chunk) => {
         if (stream !== "stdout") {
-          if (ctx.onOutput) {
-            try { await ctx.onOutput(stream, chunk); } catch { /* swallow */ }
-          }
+          await dispatchOutput(stream, chunk);
           return;
         }
 
@@ -142,16 +184,10 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
           const normalized = normalizeCursorStreamLine(rawLine);
           if (!normalized.line) continue;
 
-          if (ctx.onOutput) {
-            try { await ctx.onOutput(normalized.stream ?? "stdout", `${normalized.line}\n`); } catch { /* swallow */ }
-          }
+          await dispatchOutput(normalized.stream ?? "stdout", `${normalized.line}\n`);
 
-          if (ctx.onEvent) {
-            const event = parseCursorStreamLine(rawLine);
-            if (event) {
-              try { await ctx.onEvent(event); } catch { /* swallow */ }
-            }
-          }
+          const event = parseCursorStreamLine(rawLine);
+          if (event) await dispatch(event);
         }
       },
     });
@@ -159,22 +195,17 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
     // Flush remaining buffer
     if (stdoutLineBuffer.trim()) {
       const normalized = normalizeCursorStreamLine(stdoutLineBuffer);
-      if (normalized.line && ctx.onOutput) {
-        try { await ctx.onOutput(normalized.stream ?? "stdout", `${normalized.line}\n`); } catch { /* swallow */ }
-      }
-      if (ctx.onEvent) {
-        const event = parseCursorStreamLine(stdoutLineBuffer);
-        if (event) {
-          try { await ctx.onEvent(event); } catch { /* swallow */ }
-        }
-      }
+      if (normalized.line) await dispatchOutput(normalized.stream ?? "stdout", `${normalized.line}\n`);
+      const event = parseCursorStreamLine(stdoutLineBuffer);
+      if (event) await dispatch(event);
     }
 
-    return proc;
+    return { proc, accepted, protocolViolation: protocolViolation || (!accepted && proc.exitCode === 0) };
   };
 
   // 7. Initial attempt
-  let proc = await runAttempt(sessionId);
+  let attempt = await runAttempt(sessionId);
+  let proc = attempt.proc;
   let clearSession = false;
 
   // 8. Check for unknown session — retry once
@@ -182,9 +213,11 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
     sessionId &&
     !proc.timedOut &&
     (proc.exitCode ?? 0) !== 0 &&
+    !attempt.accepted &&
     isCursorUnknownSessionError(proc.stdout, proc.stderr)
   ) {
-    proc = await runAttempt(null);
+    attempt = await runAttempt(null);
+    proc = attempt.proc;
     clearSession = true;
   }
 
@@ -193,6 +226,7 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
   const processErrorCode = deriveErrorCode(proc);
 
   let errorCode = processErrorCode;
+  if (attempt.protocolViolation) errorCode = "protocol_degraded";
   if (!errorCode && isCursorAuthRequired(proc.stdout, proc.stderr)) {
     errorCode = "auth_required";
     if (ctx.onEvent) {
@@ -219,6 +253,9 @@ export async function executeCursorProvider(ctx: ExecutionContext): Promise<Exec
   const errorMessage = (() => {
     if (proc.timedOut) return `Timed out after ${config.timeoutSec ?? 0}s`;
     if (errorCode === "auth_required") return "Cursor requires authentication.";
+    if (errorCode === "protocol_degraded") {
+      return "Cursor did not emit the supported stream-json acceptance marker before visible output.";
+    }
     if (parsed.errorMessage) return parsed.errorMessage;
     if ((proc.exitCode ?? 0) !== 0 && !parsed.summary) {
       const stderrLine = proc.stderr.split(/\r?\n/).map((l) => l.trim()).find(Boolean);

package/src/providers/cursor/index.ts

@@ -1,25 +1,39 @@
-import type { ProviderModule } from "../../types.js";
+import type { AgentSession, ProviderModule, SessionContext } from "../../types.js";
 import { cursorSessionCodec } from "./codec.js";
 import { resolveAuthForProvider } from "../../utils/auth.js";
 
 export const cursorProvider: ProviderModule = {
   type: "cursor",
   capabilities: {
-    sessions: false,
-    modelDiscovery: false,
+    sessions: true,
+    modelDiscovery: true,
     quotaProbing: false,
     mcp: false,
     skills: true,
     instructions: true,
     workspace: true,
-    planMode: false,
+    planMode: true,
     concurrentSend: false,
     cancelQueuedMessage: false,
     stopTask: false,
-    modes: false,
+    modes: true,
+    resume: true,
+    modelVariants: false,
+    permissionRequests: false,
+    questionRequests: false,
+    upstreamProviderDisconnect: false,
+    sessionModelChange: false,
+    sessionVariantChange: false,
+    sessionEffortChange: false,
+    sessionModeChange: false,
   },
   // execute.ts loads lazily on first use.
   execute: async (ctx) => (await import("./execute.js")).executeCursorProvider(ctx),
+  createSession: async (ctx: SessionContext): Promise<AgentSession> =>
+    (await import("./session.js")).createCursorSession(ctx),
   resolveAuth: (ctx) => resolveAuthForProvider("cursor", ctx),
   sessionCodec: cursorSessionCodec,
+  listModels: (options) => import("./discovery.js").then((m) => m.listCursorModels(options)),
+  listModes: (options) => import("./discovery.js").then((m) => m.listCursorModes(options)),
+  probeCapabilities: (ctx) => import("./probe.js").then((m) => m.probeCursorCapabilities(ctx)),
 };

package/src/providers/cursor/parse.ts

@@ -281,7 +281,7 @@ export function isCursorUnknownSessionError(stdout: string, stderr: string): boo
   return CURSOR_UNKNOWN_SESSION_RE.test(stdout) || CURSOR_UNKNOWN_SESSION_RE.test(stderr);
 }
 
-const CURSOR_AUTH_RE = /CURSOR_API_KEY\s+is\s+not\s+set|OPENAI_API_KEY\s+is\s+not\s+set|unauthorized|authentication.*required/i;
+const CURSOR_AUTH_RE = /CURSOR_API_KEY\s+is\s+not\s+set|unauthorized|authentication.*required|not\s+logged\s+in/i;
 
 export function isCursorAuthRequired(stdout: string, stderr: string): boolean {
   return CURSOR_AUTH_RE.test(stdout) || CURSOR_AUTH_RE.test(stderr);

package/src/providers/cursor/probe.ts

@@ -0,0 +1,90 @@
+import type { ProviderRuntimeContext, ProviderRuntimeReport } from "../../types.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess } from "../../utils/process.js";
+import { listCursorModels, listCursorModes } from "./discovery.js";
+import { findCursorBinary } from "./runtime.js";
+
+export async function probeCursorCapabilities(
+  ctx: ProviderRuntimeContext = {},
+): Promise<ProviderRuntimeReport> {
+  let resolved;
+  try {
+    resolved = await findCursorBinary(ctx);
+  } catch (error) {
+    return {
+      binary: {
+        status: "missing",
+        command: null,
+        version: null,
+        protocolProfile: null,
+        reason: error instanceof Error ? error.message : String(error),
+      },
+      capabilities: {},
+    };
+  }
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+  let version: string | null = null;
+  try {
+    const result = await runChildProcess({
+      runId: "cursor-version-probe",
+      command: resolved.bin,
+      args: [...resolved.prefixArgs, "--version"],
+      cwd: ctx.cwd ?? process.cwd(),
+      env,
+      timeoutSec: 5,
+    });
+    version = (result.stdout || result.stderr).match(/\d+\.\d+(?:\.\d+)?/)?.[0] ?? null;
+  } catch {
+    // Feature probes remain authoritative.
+  }
+  const [models, modes] = await Promise.all([
+    listCursorModels(ctx).catch(() => []),
+    listCursorModes(ctx).catch(() => []),
+  ]);
+  const help = await runChildProcess({
+    runId: "cursor-protocol-probe",
+    command: resolved.bin,
+    args: [...resolved.prefixArgs, "--help"],
+    cwd: ctx.cwd ?? process.cwd(),
+    env,
+    timeoutSec: 10,
+  }).catch(() => null);
+  const helpOutput = help ? `${help.stdout}\n${help.stderr}` : "";
+  const protocolSupported = help?.exitCode === 0
+    && /(?:^|\s)(?:-p(?:,|\s))?.*--print\b/m.test(helpOutput)
+    && /--output-format\b/.test(helpOutput)
+    && /\bstream-json\b/i.test(helpOutput)
+    && /--resume\b/.test(helpOutput);
+  const modelDiscovery = models.length > 0;
+  const modeIds = new Set(modes.map((mode) => mode.id));
+  const supported = (value: boolean, reason?: string) => ({
+    supported: value,
+    status: value ? "supported" as const : "upgrade_required" as const,
+    ...(!value && reason ? { reason } : {}),
+  });
+  return {
+    binary: {
+      status: modelDiscovery && protocolSupported ? "supported" : "upgrade_required",
+      command: resolved.bin,
+      version,
+      protocolProfile: protocolSupported ? "cursor-stream-json-system-init-v1" : null,
+      ...(!modelDiscovery
+        ? { reason: "Upgrade Cursor CLI to a version with model listing" }
+        : !protocolSupported
+          ? { reason: "Cursor CLI does not advertise print, stream output, and resume support" }
+          : {}),
+    },
+    capabilities: {
+      sessions: supported(Boolean(protocolSupported), "Cursor stream-json session flags are unavailable"),
+      resume: supported(Boolean(protocolSupported), "Cursor resume support is unavailable"),
+      modelDiscovery: supported(modelDiscovery, "Cursor model listing is unavailable"),
+      planMode: supported(modeIds.has("plan")),
+      modes: supported(modes.length > 0),
+      sessionModelChange: supported(false),
+      sessionVariantChange: supported(false),
+      sessionEffortChange: supported(false),
+      sessionModeChange: supported(false),
+    },
+  };
+}

package/src/providers/cursor/runtime.ts

@@ -0,0 +1,11 @@
+import type { ProviderRuntimeContext } from "../../types.js";
+import { findBinary, type ResolvedBinary } from "../../utils/binary.js";
+
+export async function findCursorBinary(ctx: ProviderRuntimeContext = {}): Promise<ResolvedBinary> {
+  if (ctx.config?.command) return findBinary("agent", ctx.config.command);
+  try {
+    return await findBinary("agent");
+  } catch {
+    return findBinary("cursor-agent");
+  }
+}

package/src/providers/cursor/session.ts

@@ -0,0 +1,15 @@
+import type { AgentSession, SessionContext } from "../../types.js";
+import { createExecBackedSession } from "../../sessions/exec-backed.js";
+import { EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+import { executeCursorProvider } from "./execute.js";
+import { cursorSessionCodec } from "./codec.js";
+
+export async function createCursorSession(ctx: SessionContext): Promise<AgentSession> {
+  return createExecBackedSession({
+    providerType: "cursor",
+    execute: executeCursorProvider,
+    sessionCodec: cursorSessionCodec,
+    ctx,
+    capabilities: { goals: EMULATED_GOAL_CAPABILITY },
+  });
+}

package/src/providers/opencode/client.ts

@@ -0,0 +1,44 @@
+export class OpenCodeHttpError extends Error {
+  constructor(
+    readonly status: number,
+    readonly code: string,
+  ) {
+    super(`OpenCode request failed (${status})`);
+    this.name = "OpenCodeHttpError";
+  }
+}
+
+export class OpenCodeClient {
+  private readonly authorization: string;
+
+  constructor(
+    readonly baseUrl: string,
+    password: string,
+  ) {
+    this.authorization = `Basic ${Buffer.from(`opencode:${password}`, "utf8").toString("base64")}`;
+  }
+
+  async request(path: string, init: RequestInit = {}): Promise<Response> {
+    const headers = new Headers(init.headers);
+    headers.set("authorization", this.authorization);
+    if (init.body !== undefined && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    return fetch(`${this.baseUrl}${path}`, { ...init, headers });
+  }
+
+  async json<T>(path: string, init: RequestInit = {}): Promise<T> {
+    const response = await this.request(path, init);
+    if (!response.ok) {
+      throw new OpenCodeHttpError(response.status, `http_${response.status}`);
+    }
+    return await response.json() as T;
+  }
+
+  async ok(path: string, init: RequestInit = {}): Promise<void> {
+    const response = await this.request(path, init);
+    if (!response.ok) {
+      throw new OpenCodeHttpError(response.status, `http_${response.status}`);
+    }
+  }
+}

package/src/providers/opencode/discovery.ts

@@ -0,0 +1,69 @@
+import type { ListModelsOptions, ProviderModel } from "../../types.js";
+import { acquireOpenCodeRuntime } from "./runtime.js";
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+function number(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+export function openCodeModelsFromPayload(payload: Record<string, unknown>): ProviderModel[] {
+  const providers = Array.isArray(payload["all"]) ? payload["all"] : [];
+  const models: ProviderModel[] = [];
+  for (const rawProvider of providers) {
+      const provider = record(rawProvider);
+      const providerId = typeof provider["id"] === "string" ? provider["id"] : "";
+      const providerName = typeof provider["name"] === "string" ? provider["name"] : providerId;
+      if (!providerId) continue;
+      for (const [key, rawModel] of Object.entries(record(provider["models"]))) {
+        const model = record(rawModel);
+        const modelId = typeof model["id"] === "string" ? model["id"] : key;
+        if (!modelId) continue;
+        const limits = record(model["limit"]);
+        const cost = record(model["cost"]);
+        const capabilities = record(model["capabilities"]);
+        const capabilityInput = record(capabilities["input"]);
+        const modalities = record(model["modalities"]);
+        const inputModalities = Array.isArray(modalities["input"])
+          ? modalities["input"].filter((item): item is string => typeof item === "string")
+          : [];
+        const variants = Object.entries(record(model["variants"])).map(([id, rawVariant]) => {
+          const variant = record(rawVariant);
+          return {
+            id,
+            name: typeof variant["name"] === "string" ? variant["name"] : id,
+            ...(typeof variant["description"] === "string" ? { description: variant["description"] } : {}),
+            ...(variant["disabled"] === true ? { disabled: true } : {}),
+          };
+        });
+        models.push({
+          id: `${providerId}/${modelId}`,
+          name: typeof model["name"] === "string" ? model["name"] : modelId,
+          provider: providerId,
+          providerName,
+          ...(variants.length ? { variants } : {}),
+          ...(number(limits["context"]) !== undefined ? { contextWindow: number(limits["context"]) } : {}),
+          ...(number(limits["output"]) !== undefined ? { maxOutputTokens: number(limits["output"]) } : {}),
+          ...(number(cost["input"]) !== undefined ? { inputCostPerMillion: number(cost["input"]) } : {}),
+          ...(number(cost["output"]) !== undefined ? { outputCostPerMillion: number(cost["output"]) } : {}),
+          supportsImages: capabilityInput["image"] === true || inputModalities.includes("image"),
+          supportsTools: capabilities["toolcall"] === true || model["tool_call"] === true,
+        });
+      }
+  }
+  return models;
+}
+
+export async function listOpenCodeModels(options: ListModelsOptions = {}): Promise<ProviderModel[]> {
+  const runtime = await acquireOpenCodeRuntime(options);
+  try {
+    const payload = await runtime.server.client.json<Record<string, unknown>>("/provider");
+    return openCodeModelsFromPayload(payload);
+  } finally {
+    runtime.server.release();
+  }
+}