@myagentroam/node 0.1.3 → 0.1.6

package/dist/native-session-history.js

@@ -1,59 +1,18 @@
 import { createHash } from 'node:crypto';
-import { open, readdir, unlink } from 'node:fs/promises';
+import { readFile, readdir, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
+import { forEachJsonlRecord, listJsonlFiles, mapConcurrent, readJsonlWindow } from './native-jsonl-reader.js';
+import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
-const DISCOVERY_READ_BYTES = 128 * 1024;
+const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_READ_BYTES = 4 * 1024 * 1024;
 const CONTEXT_USAGE_READ_BYTES = 256 * 1024;
-const TASK_ACTIVITY_READ_BYTES = 32 * 1024 * 1024;
+const CLAUDE_CONTEXT_USAGE_READ_BYTES = [CONTEXT_USAGE_READ_BYTES, 1024 * 1024, 4 * 1024 * 1024];
 const transcriptIndex = new Map();
-/** Reads the latest durable Codex task lifecycle event without exposing it. */
-export async function readCodexNativeTaskActivity(workspacePath, externalSessionId, now = Date.now()) {
-    const wanted = canonical(workspacePath);
-    let path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
-    if (path === undefined) {
-        await discoverNativeSessions('codex', workspacePath);
-        path = transcriptIndex.get(indexKey('codex', wanted, externalSessionId));
-    }
-    if (path === undefined)
-        return undefined;
-    let content;
-    try {
-        const handle = await open(path, 'r');
-        try {
-            const metadata = await handle.stat();
-            const start = Math.max(0, metadata.size - TASK_ACTIVITY_READ_BYTES);
-            const buffer = Buffer.alloc(metadata.size - start);
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
-            content = buffer.subarray(0, bytesRead).toString('utf8');
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch {
-        return undefined;
-    }
-    let latest;
-    for (const line of content.split('\n')) {
-        try {
-            const value = JSON.parse(line);
-            const payload = value.type === 'event_msg' && isRecord(value.payload) ? value.payload : undefined;
-            if (payload?.type !== 'task_started' && payload?.type !== 'task_complete')
-                continue;
-            const seconds = payload.type === 'task_started' ? payload.started_at : payload.completed_at;
-            const at = typeof seconds === 'number' ? seconds * 1000 : 0;
-            latest = { state: payload.type === 'task_started' ? 'ACTIVE' : 'IDLE', at };
-        }
-        catch {
-            // 单条损坏的 JSONL 记录不影响后续活动状态记录。
-        }
-    }
-    if (latest === undefined)
-        return undefined;
-    return latest.state === 'ACTIVE' && now - latest.at > 60 * 60_000 ? 'STALE' : latest.state;
-}
+const discoveryReads = new Map();
+const DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS = 200_000;
+const CLAUDE_CONTEXT_WINDOW_ENV = 'MAR_CLAUDE_CONTEXT_WINDOW_TOKENS';
 /**
  * Read-only adapter for the supported vendor JSONL stores.  It requires an
  * explicit cwd on the record and returns normalized visible messages and tool
@@ -69,8 +28,23 @@ export async function discoverNativeSessions(runner, workspacePath) {
  * hide older sessions from a project with a large global history.
  */
 export async function discoverAllNativeSessions(runner) {
+    const current = discoveryReads.get(runner);
+    if (current !== undefined)
+        return current;
+    const discovery = performNativeSessionDiscovery(runner).finally(() => discoveryReads.delete(runner));
+    discoveryReads.set(runner, discovery);
+    return discovery;
+}
+async function performNativeSessionDiscovery(runner) {
+    const startedAt = performance.now();
     const found = new Map();
-    const files = await listJsonl(transcriptRoot(runner));
+    nodeLog('native.session.discovery.started', { runner });
+    const files = await listJsonlFiles(transcriptRoot(runner));
+    nodeLog('native.session.discovery.files-listed', {
+        runner,
+        files: files.length,
+        durationMs: Math.round(performance.now() - startedAt)
+    });
     const parsedFiles = await readDiscoveryHeaders(files, runner);
     for (const [index, parsed] of parsedFiles.entries()) {
         // Discovery only needs a session identity, cwd and an optional early
@@ -82,24 +56,29 @@ export async function discoverAllNativeSessions(runner) {
         transcriptIndex.set(indexKey(runner, cwd, parsed.externalSessionId), files[index]);
         found.set(`${cwd}\u0000${parsed.externalSessionId}`, parsed);
     }
+    nodeLog('native.session.discovery.completed', {
+        runner,
+        files: files.length,
+        sessions: found.size,
+        durationMs: Math.round(performance.now() - startedAt)
+    });
     return [...found.values()];
 }
 async function readDiscoveryHeaders(files, runner) {
-    const values = Array.from({ length: files.length });
-    let next = 0;
-    const worker = async () => {
-        while (true) {
-            const index = next;
-            next += 1;
-            if (index >= files.length)
-                return;
-            values[index] = await readTranscript(files[index], runner, DISCOVERY_READ_BYTES);
-        }
-    };
-    // Header reads are independent. Bounded concurrency avoids serial startup
-    // delays without opening an unbounded number of descriptors on large homes.
-    await Promise.all(Array.from({ length: Math.min(32, files.length) }, worker));
-    return values;
+    let completed = 0;
+    const startedAt = performance.now();
+    return mapConcurrent(files, 32, async (path) => {
+        const value = await readTranscript(path, runner, DISCOVERY_READ_BYTES);
+        completed += 1;
+        if (completed % 250 === 0)
+            nodeLog('native.session.discovery.progress', {
+                runner,
+                completed,
+                files: files.length,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
+        return value;
+    });
 }
 /** Reads one already-discovered external session again to follow appended JSONL records. */
 export async function readNativeSession(runner, workspacePath, externalSessionId) {
@@ -131,37 +110,94 @@ export async function readCodexNativeContextUsage(workspacePath, externalSession
     }
     if (path === undefined)
         return undefined;
-    let content;
+    const window = await readJsonlWindow(path, { tailBytes: CONTEXT_USAGE_READ_BYTES });
+    if (window === undefined)
+        return undefined;
+    let usage;
+    forEachJsonlRecord(window.content, (record) => {
+        const next = codexContextUsage(record);
+        if (next !== undefined)
+            usage = next;
+    });
+    return usage;
+}
+/** Reads the latest actual Claude prompt occupancy without starting a CLI/SDK control stream. */
+export async function readClaudeNativeContextUsage(workspacePath, externalSessionId, options = {}) {
+    const wanted = canonical(workspacePath);
+    let path = transcriptIndex.get(indexKey('claude-code', wanted, externalSessionId));
+    path ??= await locateClaudeTranscript(wanted, externalSessionId);
+    if (path === undefined) {
+        await discoverNativeSessions('claude-code', workspacePath);
+        path = transcriptIndex.get(indexKey('claude-code', wanted, externalSessionId));
+    }
+    if (path === undefined)
+        return undefined;
+    const latest = await readLatestClaudeContextUsage(path);
+    if (latest === undefined)
+        return undefined;
+    return {
+        ...latest,
+        maxTokens: await claudeContextWindowTokens(options)
+    };
+}
+async function readLatestClaudeContextUsage(path) {
+    for (const tailBytes of CLAUDE_CONTEXT_USAGE_READ_BYTES) {
+        const window = await readJsonlWindow(path, { tailBytes });
+        if (window === undefined)
+            return undefined;
+        let latest;
+        forEachJsonlRecord(window.content, (record) => {
+            const usage = claudeContextUsage(record);
+            if (usage !== undefined)
+                latest = usage;
+        });
+        if (latest !== undefined)
+            return latest;
+        if (!window.truncated)
+            return undefined;
+    }
+    return undefined;
+}
+/** Claude main transcripts use the native session ID as their filename. */
+async function locateClaudeTranscript(wantedCwd, externalSessionId) {
+    const root = transcriptRoot('claude-code');
+    let entries;
     try {
-        const handle = await open(path, 'r');
-        try {
-            const metadata = await handle.stat();
-            const start = Math.max(0, metadata.size - CONTEXT_USAGE_READ_BYTES);
-            const buffer = Buffer.alloc(metadata.size - start);
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
-            content = buffer.subarray(0, bytesRead).toString('utf8');
-        }
-        finally {
-            await handle.close();
-        }
+        entries = await readdir(root, { withFileTypes: true });
     }
     catch {
         return undefined;
     }
-    let usage;
-    for (const line of content.split('\n')) {
-        let record;
-        try {
-            record = JSON.parse(line);
-        }
-        catch {
-            continue;
+    const candidates = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(root, entry.name, `${externalSessionId}.jsonl`));
+    const parsed = await mapConcurrent(candidates, 16, async (path) => ({
+        path,
+        history: await readTranscript(path, 'claude-code', DISCOVERY_READ_BYTES)
+    }));
+    const match = parsed.find(({ history }) => history?.externalSessionId === externalSessionId && canonical(history.cwd) === wantedCwd);
+    if (match === undefined)
+        return undefined;
+    transcriptIndex.set(indexKey('claude-code', wantedCwd, externalSessionId), match.path);
+    return match.path;
+}
+export async function claudeContextWindowTokens(options = {}) {
+    const environment = options.environment ?? process.env;
+    const direct = positiveInteger(environment[CLAUDE_CONTEXT_WINDOW_ENV]);
+    if (direct !== undefined)
+        return direct;
+    try {
+        const settings = JSON.parse(await readFile(options.settingsPath ?? join(homedir(), '.claude', 'settings.json'), 'utf8'));
+        if (isRecord(settings) && isRecord(settings.env)) {
+            const configured = positiveInteger(settings.env[CLAUDE_CONTEXT_WINDOW_ENV]);
+            if (configured !== undefined)
+                return configured;
         }
-        const next = codexContextUsage(record);
-        if (next !== undefined)
-            usage = next;
     }
-    return usage;
+    catch {
+        // Missing or malformed optional Claude settings use the stable default.
+    }
+    return DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS;
 }
 /**
  * Permanently removes exactly one previously discovered transcript. The
@@ -200,78 +236,18 @@ function transcriptRoot(runner) {
         ? join(homedir(), '.codex', 'sessions')
         : join(homedir(), '.claude', 'projects');
 }
-async function listJsonl(directory) {
-    const files = [];
-    const walk = async (current) => {
-        let entries;
-        try {
-            entries = await readdir(current, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const path = join(current, entry.name);
-            if (entry.isDirectory())
-                await walk(path);
-            else if (entry.isFile() && entry.name.endsWith('.jsonl'))
-                files.push(path);
-        }
-    };
-    await walk(directory);
-    return files;
-}
 async function readTranscript(path, runner, byteLimit) {
-    let content;
-    let truncated = false;
-    try {
-        const handle = await open(path, 'r');
-        try {
-            const metadata = await handle.stat();
-            const headSize = Math.min(byteLimit, metadata.size);
-            const head = Buffer.alloc(headSize);
-            const { bytesRead: headBytesRead } = await handle.read(head, 0, head.length, 0);
-            if (headSize === metadata.size) {
-                content = head.subarray(0, headBytesRead).toString('utf8');
-            }
-            else {
-                // Discovery needs identity from the header and genuine recency from
-                // the latest visible records.  Keep both bounded instead of falling
-                // back to mtime, whose changes do not necessarily mean a new chat.
-                const tailSize = Math.min(byteLimit, metadata.size - headSize);
-                truncated = headSize + tailSize < metadata.size;
-                const tail = Buffer.alloc(tailSize);
-                const { bytesRead: tailBytesRead } = await handle.read(tail, 0, tail.length, metadata.size - tailSize);
-                content = `${head.subarray(0, headBytesRead).toString('utf8')}\n${tail
-                    .subarray(0, tailBytesRead)
-                    .toString('utf8')}`;
-            }
-        }
-        finally {
-            await handle.close();
-        }
-    }
-    catch {
+    const window = await readJsonlWindow(path, { headBytes: byteLimit, tailBytes: byteLimit });
+    if (window === undefined)
         return undefined;
-    }
+    const { content, truncated } = window;
     let cwd;
     let id;
     const items = [];
     const toolIndexes = new Map();
     const pendingToolResults = new Map();
     const metaRecordIds = new Set();
-    for (const line of content.split('\n')) {
-        if (line.length === 0)
-            continue;
-        let value;
-        try {
-            value = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (!isRecord(value))
-            continue;
+    forEachJsonlRecord(content, (value) => {
         cwd ??= workspacePath(value);
         id ??= sessionId(value);
         const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
@@ -280,9 +256,13 @@ async function readTranscript(path, runner, byteLimit) {
             metaRecordIds.add(recordId);
         if (isHiddenTranscriptRecord(value) ||
             (parentId !== undefined && metaRecordIds.has(parentId))) {
-            continue;
+            return;
         }
-        for (const item of transcriptItems(value)) {
+        const generatedImage = codexGeneratedImageEvent(value);
+        if (generatedImage !== undefined)
+            items.push(generatedImage);
+        for (const parsedItem of transcriptItems(value)) {
+            const item = recordId === undefined ? parsedItem : { ...parsedItem, nativeId: recordId };
             if (item.kind === 'tool_result') {
                 const toolIndex = toolIndexes.get(item.toolUseId);
                 if (toolIndex === undefined)
@@ -301,7 +281,7 @@ async function readTranscript(path, runner, byteLimit) {
             }
             items.push(item);
         }
-    }
+    });
     for (const result of pendingToolResults.values())
         items.push({
             kind: 'tool_call',
@@ -312,6 +292,9 @@ async function readTranscript(path, runner, byteLimit) {
             inputTruncated: false,
             outputSummary: result.output,
             outputTruncated: result.truncated,
+            ...(result.imageAttachments === undefined
+                ? {}
+                : { imageAttachments: result.imageAttachments }),
             failed: result.failed,
             createdAt: result.createdAt
         });
@@ -375,6 +358,37 @@ function codexContextUsage(value) {
         return undefined;
     return { usedTokens: promptUsage.input_tokens, maxTokens };
 }
+function claudeContextUsage(value) {
+    if (value.type !== 'assistant' || !isRecord(value.message))
+        return undefined;
+    const model = value.message.model;
+    const usage = value.message.usage;
+    if (typeof model !== 'string' ||
+        model.length === 0 ||
+        model === '<synthetic>' ||
+        !isRecord(usage))
+        return undefined;
+    const inputTokens = nonNegativeInteger(usage.input_tokens);
+    const cacheCreationTokens = optionalNonNegativeInteger(usage.cache_creation_input_tokens);
+    const cacheReadTokens = optionalNonNegativeInteger(usage.cache_read_input_tokens);
+    if (inputTokens === undefined ||
+        cacheCreationTokens === undefined ||
+        cacheReadTokens === undefined)
+        return undefined;
+    return { model, usedTokens: inputTokens + cacheCreationTokens + cacheReadTokens };
+}
+function optionalNonNegativeInteger(value) {
+    return value === undefined ? 0 : nonNegativeInteger(value);
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function positiveInteger(value) {
+    if (typeof value !== 'string' || !/^\d+$/.test(value.trim()))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
 function transcriptItems(record) {
     const createdAt = timestampOf(record);
     const results = [...toolResultsOf(record, createdAt), ...codexToolResultsOf(record, createdAt)];
@@ -382,7 +396,10 @@ function transcriptItems(record) {
         return results;
     const values = [
         ...toolUsesOf(record, createdAt),
-        ...codexToolUsesOf(record, createdAt)
+        ...codexToolUsesOf(record, createdAt),
+        ...codexReasoningSummariesOf(record, createdAt),
+        ...unsupportedCodexResponseItems(record, createdAt),
+        ...unsupportedTranscriptItems(record, createdAt)
     ];
     const role = roleOf(record);
     if (role === undefined)
@@ -398,6 +415,65 @@ function transcriptItems(record) {
     values.unshift({ kind: 'message', role, text, createdAt });
     return values;
 }
+function unsupportedCodexResponseItems(record, createdAt) {
+    const payload = codexToolPayload(record);
+    const type = typeof payload?.type === 'string' ? payload.type : undefined;
+    if (type === undefined ||
+        typeof payload?.role === 'string' ||
+        type === 'reasoning' ||
+        type === 'custom_tool_call' ||
+        type === 'custom_tool_call_output' ||
+        type === 'function_call' ||
+        type === 'function_call_output')
+        return [];
+    return [
+        {
+            kind: 'unknown',
+            sourceEventType: `codex:${type}`,
+            label: `Codex ${compact(type).slice(0, 128)}`,
+            createdAt
+        }
+    ];
+}
+function codexReasoningSummariesOf(record, createdAt) {
+    const payload = codexToolPayload(record);
+    if (payload?.type !== 'reasoning')
+        return [];
+    const sections = Array.isArray(payload.summary)
+        ? payload.summary.flatMap((value, index) => {
+            if (typeof value !== 'string')
+                return [];
+            const text = compact(value).slice(0, 10_000);
+            return text.length === 0 ? [] : [{ index, text }];
+        })
+        : [];
+    return [{ kind: 'reasoning_summary', sections, createdAt }];
+}
+function unsupportedTranscriptItems(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        const type = typeof block.type === 'string' ? block.type : undefined;
+        if (type === undefined ||
+            type === 'text' ||
+            type === 'input_text' ||
+            type === 'output_text' ||
+            type === 'image' ||
+            type === 'input_image' ||
+            type === 'thinking' ||
+            type === 'redacted_thinking' ||
+            type === 'encrypted_thinking' ||
+            type === 'tool_use' ||
+            type === 'tool_result')
+            return [];
+        return [
+            {
+                kind: 'unknown',
+                sourceEventType: `transcript:${type}`,
+                label: `Agent ${compact(type).slice(0, 128)}`,
+                createdAt
+            }
+        ];
+    });
+}
 function toolUsesOf(record, createdAt) {
     return contentBlocks(record).flatMap((block) => {
         if (block['type'] !== 'tool_use' ||
@@ -479,6 +555,7 @@ function codexToolResultsOf(record, createdAt) {
     if (toolUseId === undefined)
         return [];
     const output = compactValue(codexToolOutput(payload['output'] ?? payload['contentItems']), 10_000);
+    const imageAttachments = codexImagePlaceholders(payload['output'] ?? payload['contentItems']);
     return [
         {
             kind: 'tool_result',
@@ -486,6 +563,7 @@ function codexToolResultsOf(record, createdAt) {
             output: output.text,
             failed: payload['status'] === 'failed' || payload['error'] !== undefined,
             truncated: output.truncated,
+            ...(imageAttachments.length === 0 ? {} : { imageAttachments }),
             createdAt
         }
     ];
@@ -495,6 +573,31 @@ function codexToolPayload(record) {
         ? record['payload']
         : undefined;
 }
+function codexGeneratedImageEvent(record) {
+    if (record['type'] !== 'event_msg' || !isRecord(record['payload']))
+        return undefined;
+    const payload = record['payload'];
+    if (payload['type'] !== 'image_generation_end' ||
+        typeof payload['call_id'] !== 'string' ||
+        typeof payload['saved_path'] !== 'string')
+        return undefined;
+    const localPath = payload['saved_path'];
+    if (!localPath.includes('/.codex/generated_images/') || !/\.(?:png|jpe?g|webp)$/i.test(localPath))
+        return undefined;
+    return {
+        kind: 'tool_call',
+        toolUseId: payload['call_id'],
+        toolName: 'imagegen',
+        input: null,
+        inputSummary: null,
+        inputTruncated: false,
+        outputSummary: payload['status'] === 'completed' ? '图片生成完成' : '图片生成失败',
+        outputTruncated: false,
+        imageAttachments: [{ name: basename(localPath), mime: imageMime(localPath), localPath }],
+        failed: payload['status'] !== 'completed',
+        createdAt: timestampOf(record)
+    };
+}
 /** Extract Codex output text blocks instead of rendering their JSON envelopes. */
 function codexToolOutput(value) {
     if (!Array.isArray(value))
@@ -505,15 +608,94 @@ function codexToolOutput(value) {
         if (!isRecord(block))
             return [];
         const direct = firstString(block, ['text', 'content']);
-        return direct === undefined ? [] : [direct];
+        return direct === undefined ? [] : [codexVisibleToolText(direct)];
     });
     return text.length > 0 ? text.join('') : value;
 }
+function codexVisibleToolText(value) {
+    const marker = 'data:image/';
+    let cursor = 0;
+    let visible = '';
+    while (cursor < value.length) {
+        const start = value.indexOf(marker, cursor);
+        if (start < 0)
+            return visible + value.slice(cursor);
+        visible += `${value.slice(cursor, start)}[图片内容已过滤]`;
+        const doubleQuote = value.indexOf('"', start);
+        const singleQuote = value.indexOf("'", start);
+        const end = doubleQuote < 0
+            ? singleQuote
+            : singleQuote < 0
+                ? doubleQuote
+                : Math.min(doubleQuote, singleQuote);
+        if (end < 0)
+            return visible;
+        cursor = end;
+    }
+    return visible;
+}
+/** Extract only image placeholder metadata from native Codex output. */
+function codexImagePlaceholders(value) {
+    const paths = [];
+    let visited = 0;
+    const visit = (current, depth) => {
+        if (paths.length >= 5 || visited >= 128 || depth > 5 || current == null)
+            return;
+        visited += 1;
+        if (typeof current === 'string') {
+            collectGeneratedImagePaths(current, paths);
+            return;
+        }
+        if (Array.isArray(current)) {
+            for (const entry of current)
+                visit(entry, depth + 1);
+            return;
+        }
+        if (!isRecord(current))
+            return;
+        for (const child of Object.values(current))
+            visit(child, depth + 1);
+    };
+    visit(value, 0);
+    return paths.map((localPath) => ({
+        name: basename(localPath),
+        mime: imageMime(localPath),
+        localPath
+    }));
+}
+function collectGeneratedImagePaths(value, paths) {
+    const marker = '/.codex/generated_images/';
+    let cursor = 0;
+    while (paths.length < 5) {
+        const markerIndex = value.indexOf(marker, cursor);
+        if (markerIndex < 0)
+            return;
+        let start = markerIndex;
+        while (start > 0 && !/[\s"']/.test(value[start - 1]))
+            start -= 1;
+        let end = markerIndex + marker.length;
+        while (end < value.length && !/[\s"']/.test(value[end]))
+            end += 1;
+        const path = value.slice(start, end).replace(/[),.;:]+$/, '');
+        if (/\.(?:png|jpe?g|webp)$/i.test(path) && !paths.includes(path))
+            paths.push(path);
+        cursor = end;
+    }
+}
+function imageMime(path) {
+    const extension = path.slice(path.lastIndexOf('.') + 1).toLowerCase();
+    if (extension === 'jpg' || extension === 'jpeg')
+        return 'image/jpeg';
+    if (extension === 'webp')
+        return 'image/webp';
+    return 'image/png';
+}
 function withToolResult(call, result) {
     return {
         ...call,
         outputSummary: result.output,
         outputTruncated: result.truncated,
+        ...(result.imageAttachments === undefined ? {} : { imageAttachments: result.imageAttachments }),
         failed: result.failed
     };
 }
@@ -649,4 +831,3 @@ function indexKey(runner, cwd, externalSessionId) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=native-session-history.js.map

package/dist/opencode-runtime.d.ts

@@ -0,0 +1,33 @@
+export interface OpenCodeProbe {
+    readonly available: boolean;
+    readonly compatible: boolean;
+    readonly version?: string;
+}
+export interface OpenCodeProviderCatalog {
+    readonly connected?: readonly string[];
+    readonly default?: Readonly<Record<string, string>>;
+    readonly all?: readonly {
+        readonly id?: string;
+        readonly name?: string;
+        readonly source?: 'env' | 'config' | 'custom' | 'api';
+        readonly models?: Readonly<Record<string, {
+            readonly id?: string;
+            readonly name?: string;
+            readonly variants?: Readonly<Record<string, {
+                readonly disabled?: boolean;
+            }>>;
+            readonly limit?: {
+                readonly context?: number;
+            };
+        }>>;
+    }[];
+}
+export interface OpenCodeProfileModel {
+    readonly id: string;
+    readonly label: string;
+    readonly supportedEfforts: string[];
+}
+export declare function probeOpenCode(command?: string): OpenCodeProbe;
+export declare function probeOpenCodeAsync(command?: string): Promise<OpenCodeProbe>;
+export declare function openCodeProfileModels(catalog: OpenCodeProviderCatalog): OpenCodeProfileModel[];
+export declare function openCodeContextLimits(catalog: OpenCodeProviderCatalog): ReadonlyMap<string, number>;