cursor-opencode-provider 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oleksiy Akimov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,200 @@
+# cursor-opencode-provider
+
+Use [Cursor](https://cursor.com) subscription models from [OpenCode](https://opencode.ai) by speaking Cursor's Connect-RPC agent protocol.
+
+This project is a custom **AI SDK provider** (`LanguageModelV3`) plus an **OpenCode plugin** that handles authentication and model discovery. Instead of calling a generic chat-completions API, it encodes and decodes Cursor's protobuf agent protocol over HTTP/2 to `agentn.global.api5.cursor.sh`.
+
+> **Status:** Usable end-to-end in OpenCode (auth, models, streaming, tools). See [Known limitations](#known-limitations).
+
+## Features
+
+- **OpenCode integration** — registers a `cursor` provider with auth hooks and cached model list
+- **Authentication** — browser OAuth (PKCE), or API key from [cursor.com/settings](https://cursor.com/settings)
+- **Model discovery** — fetches available models from Cursor's API and caches them locally
+- **Streaming** — bidirectional Connect-RPC stream for agent runs
+- **Tool calls** — maps Cursor exec-server messages to AI SDK tool-call parts
+- **Thinking / reasoning** — surfaces extended-thinking deltas where the model supports it
+
+## Requirements
+
+- [Bun](https://bun.sh) (for development and tests)
+- [OpenCode](https://opencode.ai) with plugin support
+- An active Cursor account with API access
+
+## Installation
+
+### From npm (after publish)
+
+Add the package name to OpenCode config. OpenCode installs npm plugins with Bun at startup (cached under `~/.cache/opencode/node_modules/`):
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["cursor-opencode-provider"],
+  "provider": {
+    "cursor": {
+      "npm": "cursor-opencode-provider",
+      "name": "Cursor",
+      "models": {}
+    }
+  }
+}
+```
+
+Pin a version if you want: `"cursor-opencode-provider@0.1.1"`.
+
+### From a local clone
+
+```bash
+git clone https://github.com/oakimov/cursor-opencode-provider.git
+cd cursor-opencode-provider
+bun install
+bun run build
+```
+
+Point config at the built files with absolute `file://` URLs:
+
+```json
+{
+  "plugin": ["file:///absolute/path/to/cursor-opencode-provider/dist/plugin.js"],
+  "provider": {
+    "cursor": {
+      "npm": "file:///absolute/path/to/cursor-opencode-provider/dist/index.js",
+      "name": "Cursor",
+      "models": {}
+    }
+  }
+}
+```
+
+## OpenCode setup
+
+If the `cursor` provider block is omitted, the classic plugin auto-registers it on startup (as **Cursor Integration**) using this package's entry. Model entries are filled from the local cache after you authenticate.
+
+For OpenCode builds that use the Effect/Promise **v2** plugin API (`plugins` field), also load:
+
+```json
+{
+  "plugins": ["cursor-opencode-provider/plugin/v2"]
+}
+```
+
+Local clone equivalent: `"file:///absolute/path/to/cursor-opencode-provider/dist/plugin-v2.js"`.
+
+That entry registers the provider via `ctx.aisdk.sdk` / `ctx.aisdk.language`. Keep the classic `plugin` entry for auth.
+
+### Authenticate
+
+```bash
+opencode auth login
+```
+
+Choose the **cursor** provider, then one of:
+
+| Method | Description |
+|--------|-------------|
+| **Cursor account (browser login)** | PKCE OAuth — opens cursor.com to sign in |
+| **API key** | Paste a key from [cursor.com/settings](https://cursor.com/settings) (`sk-...`) |
+
+After login, the plugin fetches your available models and writes them to `cursor-models.json` (OpenCode config directory, or `CURSOR_CONFIG_DIR` if set).
+
+### Select a model
+
+Pick a model from the cached list (for example `composer-2.5`, `default`, or a Claude/GPT variant exposed by your subscription):
+
+```bash
+opencode run --model cursor/composer-2.5 "Hello from Cursor via OpenCode"
+```
+
+## Programmatic usage
+
+```ts
+import { createCursor } from "cursor-opencode-provider"
+
+const cursor = createCursor({
+  name: "cursor",
+  accessToken: process.env.CURSOR_ACCESS_TOKEN,
+})
+
+const model = cursor.languageModel("composer-2.5")
+// model implements AI SDK LanguageModelV3 (doStream / doGenerate)
+```
+
+Pass either `accessToken` (JWT from OAuth or key exchange) or `apiKey` (raw `sk-...` key). Optional: `baseURL`, `headers`.
+
+## Environment variables
+
+| Variable | Description |
+|----------|-------------|
+| `CURSOR_CONFIG_DIR` | Override directory for `cursor-models.json` cache (defaults to the OpenCode directory passed into the plugin) |
+| `CURSOR_WEBSITE_URL` | Override OAuth login base URL (default `https://cursor.com`) |
+| `CURSOR_API_BASE_URL` | Override API base for auth and model discovery (default `https://api2.cursor.sh`) |
+| `CURSOR_PROVIDER_DEBUG` | Set to `1` or `true` to enable wire-level debug logging |
+| `CURSOR_PROVIDER_DEBUG_FILE` | Debug log path (default `/tmp/cursor-provider-debug.log`) |
+
+`createCursor({ baseURL })` also overrides the agent Run host (default `https://agentn.global.api5.cursor.sh`).
+
+## Development
+
+```bash
+bun install          # install dependencies
+bun run build        # compile TypeScript → dist/
+bun run typecheck    # type-check without emit
+bun test             # run unit tests
+bun run test:watch   # watch mode
+```
+
+## Architecture
+
+```
+OpenCode
+  └── CursorPlugin (auth, model cache, config hook)
+        └── createCursor() → LanguageModelV3
+              ├── session.ts  held-open Run stream + exec bridge
+              ├── protocol/   protobuf messages, framing, tools, thinking
+              └── transport/  Connect-RPC over HTTP/2 to agentn.global.api5.cursor.sh
+```
+
+| Module | Role |
+|--------|------|
+| `src/plugin.ts` | Classic OpenCode hooks: provider registration, OAuth, API key exchange, token refresh |
+| `src/plugin-v2.ts` | OpenCode Effect/Promise v2 plugin (`ctx.aisdk.*`); load via `./plugin/v2` only |
+| `src/index.ts` | `createCursor` factory; default export is `CursorPlugin` |
+| `src/language-model.ts` | AI SDK `LanguageModelV3` adapter (`doStream`, `doGenerate`) |
+| `src/session.ts` | Held-open agent Run session and pending exec correlation |
+| `src/auth.ts` | PKCE OAuth, API key exchange, JWT refresh |
+| `src/models.ts` | `AvailableModels` fetch and `cursor-models.json` cache |
+| `src/transport/connect.ts` | HTTP/2 bidi stream and unary RPC calls |
+| `src/protocol/` | Protobuf encode/decode, checksum/device ids, tool-call mapping |
+
+## Package exports
+
+| Import path | Export |
+|-------------|--------|
+| `cursor-opencode-provider` | `createCursor`, `CursorPlugin` (named + default) |
+| `cursor-opencode-provider/plugin` | `CursorPlugin` (classic Hooks — auth) |
+| `cursor-opencode-provider/plugin/v2` | OpenCode Effect/Promise v2 plugin (`ctx.aisdk.*`) |
+
+`CursorPluginV2` is **not** re-exported from the package root — the classic plugin loader would treat it as a broken Hooks export. Always load it via `./plugin/v2`.
+
+## Troubleshooting
+
+| Problem | What to try |
+|---------|-------------|
+| No Cursor models in the picker | Run `opencode auth login`, choose **cursor**, then restart OpenCode so the plugin reloads `cursor-models.json`. Confirm `provider.cursor.npm` is the package name (or a built `file://…/dist/index.js`). |
+| Auth / 401 errors mid-session | Re-login. OAuth and exchanged API-key JWTs refresh automatically when near expiry; a revoked refresh token needs a fresh login. |
+| “Too many connections from different devices” | Device IDs are derived from stable OS identifiers (same approach as the Cursor CLI). Avoid running multiple clients that invent different machine fingerprints for the same account. |
+| Empty or stale model list | Delete `cursor-models.json` under the OpenCode config dir (or the dir set by `CURSOR_CONFIG_DIR`) and re-auth / restart so models are fetched again. Cache TTL is 24h; a failed background refresh keeps serving the previous cache. |
+| Stream hangs or HTTP/2 errors | Abort the turn and retry. The agent Run uses a bidirectional HTTP/2 stream to `agentn.global.api5.cursor.sh`; a dropped connection leaves the in-flight session unusable. |
+| Need wire-level logs | Set `CURSOR_PROVIDER_DEBUG=1` (optional `CURSOR_PROVIDER_DEBUG_FILE`, default `/tmp/cursor-provider-debug.log`) and reproduce the issue. |
+
+## Known limitations
+
+- **Personal use / ToS** — this provider speaks Cursor’s private agent protocol (CLI-shaped client identity). Use only with an account you own; Cursor may change or restrict the API without notice.
+- **`request_context` from OpenCode** — each Run sends Cursor `RequestContext` built from OpenCode project context (workspace env, `AGENTS.md` / `instructions`, `.opencode` agents/skills/plugins, git, layout, plus `.claude`/`.agents` skill fallbacks). Same discovery as OpenCode — including `.cursor/` paths only when listed in `instructions`. Cursor-only cloud/sandbox marketplace surfaces are omitted.
+- **Tool-call display stub** — semantic `tool_call_started` frames are only partially decoded. Tool execution itself goes through the exec channel and works; UI that relied solely on the display type would be incomplete.
+- **No fallback models** — if Cursor’s `AvailableModels` API is unreachable and there is no local cache, the provider exposes no models.
+
+## License
+
+MIT

package/dist/auth.d.ts

@@ -0,0 +1,48 @@
+export declare class AuthExchangeError extends Error {
+    cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class AuthRefreshError extends Error {
+    cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class AuthPollError extends Error {
+    cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+export declare class AuthTimeoutError extends Error {
+    constructor(message: string);
+}
+export declare function isExpiringSoon(jwt: string, thresholdS?: number): boolean;
+export declare function decodeJwtPayload(jwt: string): Record<string, unknown> | null;
+export declare function useAuthToken(token: string): {
+    accessToken: string;
+};
+export type TokenPair = {
+    accessToken: string;
+    refreshToken: string;
+};
+export declare function exchangeApiKey(apiKey: string, baseUrl?: string): Promise<TokenPair>;
+export declare function refreshAccessToken(refreshToken: string, baseUrl?: string): Promise<TokenPair>;
+/** Clear the apiKey→JWT cache (tests). */
+export declare function clearBearerTokenCache(): void;
+/**
+ * Resolve a Bearer JWT for Cursor API calls. Prefer an already-exchanged
+ * `accessToken`; otherwise exchange (and cache) from `apiKey`, refreshing
+ * when the cached JWT is near expiry.
+ */
+export declare function resolveBearerToken(input: {
+    accessToken?: string;
+    apiKey?: string;
+    baseUrl?: string;
+}): Promise<string>;
+export type PkceParams = {
+    verifier: string;
+    challenge: string;
+    uuid: string;
+};
+export declare function generatePkceParams(): PkceParams;
+export declare function generatePkceChallenge(verifier: string): Promise<string>;
+export declare function buildLoginUrl(challenge: string, uuid: string, websiteUrl?: string): string;
+export declare function pollForTokens(uuid: string, verifier: string, baseUrl?: string, signal?: AbortSignal, maxAttempts?: number): Promise<TokenPair>;
+export declare function loginWithBrowser(websiteUrl?: string, apiBaseUrl?: string, signal?: AbortSignal): Promise<TokenPair>;

package/dist/auth.js

@@ -0,0 +1,200 @@
+import { CURSOR_API_HOST, CURSOR_WEBSITE_HOST } from "./shared.js";
+const API_BASE = `https://${CURSOR_API_HOST}`;
+export class AuthExchangeError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "AuthExchangeError";
+    }
+}
+export class AuthRefreshError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "AuthRefreshError";
+    }
+}
+export class AuthPollError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "AuthPollError";
+    }
+}
+export class AuthTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthTimeoutError";
+    }
+}
+// ── Helpers ──
+export function isExpiringSoon(jwt, thresholdS = 300) {
+    try {
+        const payload = JSON.parse(atob(jwt.split(".")[1]));
+        return (payload.exp * 1000 - Date.now()) < thresholdS * 1000;
+    }
+    catch {
+        return true;
+    }
+}
+export function decodeJwtPayload(jwt) {
+    try {
+        return JSON.parse(atob(jwt.split(".")[1]));
+    }
+    catch {
+        return null;
+    }
+}
+function base64url(bytes) {
+    return btoa(String.fromCharCode(...bytes))
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+// ── Mode A: pass-through auth token ──
+export function useAuthToken(token) {
+    return { accessToken: token };
+}
+export async function exchangeApiKey(apiKey, baseUrl = API_BASE) {
+    const res = await fetch(`${baseUrl}/auth/exchange_user_api_key`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: "{}",
+    });
+    if (!res.ok) {
+        throw new AuthExchangeError(`API key exchange failed: ${res.status} ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (!body.accessToken || !body.refreshToken) {
+        throw new AuthExchangeError("Exchange response missing tokens");
+    }
+    return { accessToken: body.accessToken, refreshToken: body.refreshToken };
+}
+export async function refreshAccessToken(refreshToken, baseUrl = API_BASE) {
+    const res = await fetch(`${baseUrl}/auth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken }),
+    });
+    if (!res.ok) {
+        throw new AuthRefreshError(`Token refresh failed: ${res.status} ${res.statusText}`);
+    }
+    const body = await res.json();
+    if (!body.accessToken || !body.refreshToken) {
+        throw new AuthRefreshError("Refresh response missing tokens");
+    }
+    return { accessToken: body.accessToken, refreshToken: body.refreshToken };
+}
+// Cache JWTs obtained via API-key exchange so doStream doesn't re-exchange
+// on every turn when the caller only supplied `apiKey`.
+const _apiKeyTokenCache = new Map();
+/** Clear the apiKey→JWT cache (tests). */
+export function clearBearerTokenCache() {
+    _apiKeyTokenCache.clear();
+}
+/**
+ * Resolve a Bearer JWT for Cursor API calls. Prefer an already-exchanged
+ * `accessToken`; otherwise exchange (and cache) from `apiKey`, refreshing
+ * when the cached JWT is near expiry.
+ */
+export async function resolveBearerToken(input) {
+    if (input.accessToken)
+        return input.accessToken;
+    if (!input.apiKey) {
+        throw new Error("Cursor provider: no access token or API key provided");
+    }
+    const baseUrl = input.baseUrl ?? API_BASE;
+    const cached = _apiKeyTokenCache.get(input.apiKey);
+    if (cached && !isExpiringSoon(cached.accessToken)) {
+        return cached.accessToken;
+    }
+    if (cached) {
+        try {
+            const refreshed = await refreshAccessToken(cached.refreshToken, baseUrl);
+            _apiKeyTokenCache.set(input.apiKey, refreshed);
+            return refreshed.accessToken;
+        }
+        catch {
+            // Fall through to a fresh exchange.
+        }
+    }
+    const pair = await exchangeApiKey(input.apiKey, baseUrl);
+    _apiKeyTokenCache.set(input.apiKey, pair);
+    return pair.accessToken;
+}
+// ── Mode C: PKCE browser login ──
+async function sha256(data) {
+    return new Uint8Array(await crypto.subtle.digest("SHA-256", data));
+}
+export function generatePkceParams() {
+    const verifierBytes = new Uint8Array(32);
+    crypto.getRandomValues(verifierBytes);
+    const verifier = base64url(verifierBytes);
+    const uuid = crypto.randomUUID();
+    return { verifier, challenge: "", uuid }; // challenge filled async
+}
+export async function generatePkceChallenge(verifier) {
+    const enc = new TextEncoder();
+    const hash = await sha256(enc.encode(verifier));
+    return base64url(hash);
+}
+export function buildLoginUrl(challenge, uuid, websiteUrl = `https://${CURSOR_WEBSITE_HOST}`) {
+    return `${websiteUrl}/loginDeepControl?challenge=${encodeURIComponent(challenge)}&uuid=${encodeURIComponent(uuid)}&mode=login&redirectTarget=cli`;
+}
+export async function pollForTokens(uuid, verifier, baseUrl = API_BASE, signal, maxAttempts = 150) {
+    let failures = 0;
+    for (let i = 0; i < maxAttempts; i++) {
+        if (signal?.aborted)
+            throw new AuthTimeoutError("Poll cancelled");
+        const delay = Math.min(1000 * Math.pow(1.2, i), 10000);
+        await new Promise((r) => setTimeout(r, delay));
+        try {
+            const url = `${baseUrl}/auth/poll?uuid=${encodeURIComponent(uuid)}&verifier=${encodeURIComponent(verifier)}`;
+            const res = await fetch(url);
+            if (res.status === 404) {
+                failures = 0;
+                continue;
+            }
+            if (!res.ok) {
+                failures++;
+                if (failures >= 3) {
+                    throw new AuthPollError(`Poll failed after ${failures} consecutive errors (last: ${res.status})`);
+                }
+                continue;
+            }
+            const body = await res.json();
+            if (body.accessToken && body.refreshToken) {
+                return { accessToken: body.accessToken, refreshToken: body.refreshToken };
+            }
+            // 200 OK but missing tokens — same fail-fast policy as the other error
+            // paths, otherwise a partial-body server response stalls the full
+            // ~5-minute poll budget with no diagnostic.
+            failures++;
+            if (failures >= 3) {
+                throw new AuthPollError("Poll returned 3 consecutive 200 responses without tokens");
+            }
+        }
+        catch (err) {
+            if (err instanceof AuthPollError)
+                throw err;
+            failures++;
+            if (failures >= 3) {
+                throw new AuthPollError("Poll failed after 3 consecutive network errors", err);
+            }
+        }
+    }
+    throw new AuthTimeoutError(`Poll timed out after ${maxAttempts} attempts (~5 min)`);
+}
+// ── Combined login (Mode C, one-shot) ──
+export async function loginWithBrowser(websiteUrl, apiBaseUrl, signal) {
+    const params = generatePkceParams();
+    const challenge = await generatePkceChallenge(params.verifier);
+    const loginUrl = buildLoginUrl(challenge, params.uuid, websiteUrl);
+    return await pollForTokens(params.uuid, params.verifier, apiBaseUrl, signal);
+}

package/dist/context/agents.d.ts

@@ -0,0 +1,8 @@
+export type CollectedAgent = {
+    fullPath: string;
+    name: string;
+    description: string;
+    prompt: string;
+};
+/** Custom OpenCode agents from `.opencode/agents` and global config. */
+export declare function collectAgents(workspaceRoot: string): Promise<CollectedAgent[]>;

package/dist/context/agents.js

@@ -0,0 +1,76 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { opencodeGlobalConfigDir } from "./paths.js";
+async function exists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseAgentMarkdown(raw, fallbackName) {
+    let name = fallbackName;
+    let description = "";
+    let body = raw;
+    if (raw.startsWith("---")) {
+        const end = raw.indexOf("\n---", 3);
+        if (end >= 0) {
+            const fm = raw.slice(3, end).trim();
+            body = raw.slice(end + 4).replace(/^\n/, "");
+            for (const line of fm.split("\n")) {
+                const m = line.match(/^(\w+):\s*(.*)$/);
+                if (!m)
+                    continue;
+                let val = m[2].trim();
+                if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                    val = val.slice(1, -1);
+                }
+                if (m[1] === "name")
+                    name = val;
+                if (m[1] === "description")
+                    description = val;
+            }
+        }
+    }
+    return { name, description, prompt: body.slice(0, 20_000) };
+}
+async function scanAgentDir(dir, out) {
+    if (!(await exists(dir)))
+        return;
+    let entries;
+    try {
+        entries = await readdir(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        if (!name.endsWith(".md"))
+            continue;
+        const full = path.join(dir, name);
+        try {
+            const raw = await readFile(full, "utf-8");
+            const parsed = parseAgentMarkdown(raw, name.replace(/\.md$/, ""));
+            if (!out.has(parsed.name)) {
+                out.set(parsed.name, {
+                    fullPath: path.resolve(full),
+                    name: parsed.name,
+                    description: parsed.description,
+                    prompt: parsed.prompt,
+                });
+            }
+        }
+        catch {
+            /* skip */
+        }
+    }
+}
+/** Custom OpenCode agents from `.opencode/agents` and global config. */
+export async function collectAgents(workspaceRoot) {
+    const out = new Map();
+    await scanAgentDir(path.join(workspaceRoot, ".opencode", "agents"), out);
+    await scanAgentDir(path.join(opencodeGlobalConfigDir(), "agents"), out);
+    return [...out.values()];
+}

package/dist/context/build.d.ts

@@ -0,0 +1,12 @@
+import { type OpencodeToolDef } from "../protocol/tools.js";
+export type BuildRequestContextInput = {
+    workspaceRoot: string;
+    tools?: OpencodeToolDef[];
+    providerIdentifier?: string;
+};
+/**
+ * Full RequestContext payload for live UMA + exec #10 reply.
+ * Sourced from OpenCode discovery (and .claude/.agents skill fallbacks).
+ * Honors `instructions` globs the same way OpenCode does (including `.cursor/` if listed).
+ */
+export declare function buildRequestContext(input: BuildRequestContextInput): Promise<Record<string, unknown>>;

package/dist/context/build.js

@@ -0,0 +1,83 @@
+import path from "node:path";
+import { toolsToDescriptors, toolsToMcpDescriptors } from "../protocol/tools.js";
+import { collectRules } from "./rules.js";
+import { collectSkills } from "./skills.js";
+import { collectAgents } from "./agents.js";
+import { collectPlugins } from "./plugins.js";
+import { collectGit } from "./git.js";
+import { collectProjectLayout } from "./layout.js";
+import { buildEnv } from "./env.js";
+/**
+ * Full RequestContext payload for live UMA + exec #10 reply.
+ * Sourced from OpenCode discovery (and .claude/.agents skill fallbacks).
+ * Honors `instructions` globs the same way OpenCode does (including `.cursor/` if listed).
+ */
+export async function buildRequestContext(input) {
+    const workspaceRoot = path.resolve(input.workspaceRoot || process.cwd());
+    const providerIdentifier = input.providerIdentifier ?? "opencode";
+    const tools = input.tools ?? [];
+    const { rules, config, worktree } = await collectRules(workspaceRoot);
+    const [skills, agents, plugins, git, layout] = await Promise.all([
+        collectSkills(workspaceRoot, worktree),
+        collectAgents(workspaceRoot),
+        collectPlugins(workspaceRoot, config),
+        collectGit(workspaceRoot),
+        collectProjectLayout(workspaceRoot),
+    ]);
+    const flat = toolsToDescriptors(tools, providerIdentifier);
+    const nested = toolsToMcpDescriptors(tools, providerIdentifier);
+    const permission = config.permission;
+    const autoRun = permission === "allow" ||
+        (typeof permission === "object" &&
+            permission !== null &&
+            permission["*"] === "allow");
+    const ctx = {
+        env: buildEnv(workspaceRoot),
+        tools: flat,
+        rules: rules.map((r) => ({
+            full_path: r.fullPath,
+            content: r.content,
+        })),
+        repository_info: git.repositoryInfo,
+        git_repos: git.gitRepos,
+        project_layouts: [layout],
+        agent_skills: skills.map((s) => ({
+            full_path: s.fullPath,
+            content: s.content,
+            description: s.description,
+        })),
+        custom_subagents: agents.map((a) => ({
+            full_path: a.fullPath,
+            name: a.name,
+            description: a.description,
+            prompt: a.prompt,
+        })),
+        mcp_file_system_options: {
+            enabled: true,
+            workspace_project_dir: workspaceRoot,
+            mcp_descriptors: nested,
+        },
+        mcp_meta_tool_options: {
+            enabled: true,
+            mcp_descriptors: nested,
+        },
+        // Completeness: true only for sections we actually gathered.
+        rules_info_complete: true,
+        env_info_complete: true,
+        repository_info_complete: true,
+        git_repo_info_complete: true,
+        git_status_info_complete: true,
+        agent_skills_info_complete: true,
+        custom_subagents_info_complete: true,
+        mcp_file_system_info_complete: true,
+        mcp_info_complete: true,
+        user_permissions_auto_run: autoRun,
+        project_permissions_auto_run: autoRun,
+    };
+    if (plugins.length > 0) {
+        ctx.hooks_additional_context = plugins
+            .map((p) => `opencode-plugin:${p.source}:${p.id}`)
+            .join("\n");
+    }
+    return ctx;
+}

package/dist/context/env.d.ts

@@ -0,0 +1 @@
+export declare function buildEnv(workspaceRoot: string): Record<string, unknown>;

package/dist/context/env.js

@@ -0,0 +1,29 @@
+import { homedir } from "node:os";
+import path from "node:path";
+export function buildEnv(workspaceRoot) {
+    const cwd = path.resolve(workspaceRoot);
+    let timeZone = "UTC";
+    try {
+        timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    }
+    catch {
+        /* keep UTC */
+    }
+    const home = homedir();
+    const osVersion = (() => {
+        const p = process.platform;
+        const r = process.release?.version;
+        return r ? `${p} ${r}` : p;
+    })();
+    return {
+        os_version: osVersion,
+        workspace_paths: [cwd],
+        shell: process.env.SHELL || "/bin/bash",
+        sandbox_enabled: false,
+        sandbox_supported: false,
+        time_zone: timeZone,
+        project_folder: cwd,
+        process_working_directory: process.cwd(),
+        is_working_dir_home_dir: path.resolve(process.cwd()) === path.resolve(home),
+    };
+}