opencode-agy-bridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 raultov
+
+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,138 @@
+# opencode-agy-bridge
+
+OpenCode plugin + provider that routes LLM prompts to `agy` (Google Antigravity CLI).
+
+## How it works
+
+```
+opencode TUI
+  └─ /model → select agy/antigravity
+      └─ you type a prompt
+          └─ provider spawns: agy --add-dir <cwd> [--conversation <id>] -p -
+              └─ agy → Google Antigravity backend → Gemini
+                  └─ stdout (buffered, full response)
+              └─ provider extracts delta vs previous turn
+          └─ text-delta + finish → opencode renders the response
+```
+
+## Prerequisites
+
+1. **`agy` installed and authenticated** — run `agy` standalone at least once to complete OAuth.
+2. **Node.js ≥ 18** or **Bun ≥ 1.0**.
+3. **OpenCode** `>= 1.15.x` (uses Vercel AI SDK v3).
+
+## Installation (local development)
+
+```bash
+git clone <this-repo>
+cd opencode-agy-bridge
+
+# Using Bun (recommended)
+bun install
+bun run build
+bun test       # verify 42 tests pass
+
+# Or using pnpm
+pnpm install
+pnpm run build
+pnpm test
+
+# Or using npm
+npm install
+npm run build
+npm test
+```
+
+## Features
+
+- **Robust Delta Extraction:** Automatically normalizes `\r\n` (CRLF) and `\n` (LF) line endings, tolerates trailing whitespace/newline differences, and implements suffix-based alignment to support seamless recovery during context window truncation.
+
+## Configuration
+
+Add to your `~/.config/opencode/opencode.json`:
+
+```jsonc
+{
+  "plugin": [
+    // ...your existing plugins...
+    "/home/USER/workspace/opencode-agy-bridge/dist/plugin.js"
+  ],
+  "provider": {
+    // ...your existing providers...
+    "agy": {
+      "npm": "/home/USER/workspace/opencode-agy-bridge",
+      "name": "Google Antigravity (via agy CLI)",
+      "options": {
+        "binary": "agy",
+        "timeoutMs": 300000
+      },
+      "models": {
+        "antigravity": {
+          "name": "Antigravity (server-selected Gemini)"
+        }
+      }
+    }
+  }
+}
+```
+
+Then restart OpenCode and run `/model` → select `agy/antigravity`.
+
+## Known limitations
+
+| Limitation | Detail |
+|---|---|
+| **No real streaming** | `agy --print` buffers the full response and emits it on completion. Tokens appear in one batch, not one-by-one. PTY allocation (`script -q`) was tested and does not destrabilize the buffering — agy holds output until the response is complete regardless of whether stdout is a TTY. The provider therefore emits a single `text-delta` per turn instead of faking progressive chunks. |
+| **Single cosmetic model** | `agy` does not accept `--model`. The model is chosen server-side by Antigravity. Declaring extra models in config has no effect. |
+| **Requires authenticated `agy`** | You must run `agy` standalone at least once to authenticate via OAuth. |
+| **No tool-call passthrough** | `agy` CLI does not return structured tool calls to the caller. Tool use happens inside agy's own process. |
+| **Per-turn subprocess** | Each prompt spawns a fresh `agy` process. Context is preserved via `--conversation <id>`. |
+| **Images/file parts omitted** | OpenCode messages with image/file content parts are skipped with a warning — `agy` CLI does not support them. |
+| **Conversation binding heuristic** | The bridge infers `conversation_id` by diffing `~/.gemini/antigravity-cli/conversations/*.pb` before/after each turn. If multiple `.pb` files appear simultaneously, binding is refused and each turn runs in single-turn mode. |
+
+## Project structure
+
+```
+src/
+├── agy-runner.ts           # spawn agy, capture stdout/stderr
+├── conversation-tracker.ts # snapshot .pb files, infer conversation_id
+├── session-store.ts        # persist session→conversation_id mapping
+├── prompt-mapper.ts        # Vercel AI SDK prompt → plain text
+├── provider.ts             # LanguageModelV2 implementation (core)
+└── plugin.ts               # OpenCode plugin entrypoint (hooks)
+```
+
+## Development
+
+Using **Bun**:
+```bash
+bun run build
+bun test
+```
+
+Using **pnpm**:
+```bash
+pnpm run build
+pnpm test
+```
+
+Using **npm**:
+```bash
+npm run build
+npm test
+```
+
+## CI/CD (GitHub Actions)
+
+The project includes two GitHub Actions workflows:
+
+- **CI (`ci.yml`):** Runs on push and pull requests to `main` or `master` to compile the project and execute all unit tests using Bun.
+- **Release (`release.yml`):** Runs when a new GitHub Release is created. It automatically installs dependencies, builds, tests, and publishes the package to the public npm registry.
+
+Note that both `npm` and `pnpm` share the same public registry (`registry.npmjs.org`), so a single publish step makes the package installable by both package managers.
+
+### Setup
+
+To enable automated releases:
+1. Generate an Access Token with publish permissions on [npmjs.com](https://www.npmjs.com/).
+2. Add the token as a repository secret named `NPM_TOKEN` in your GitHub repository settings under **Settings** → **Secrets and variables** → **Actions**.

package/dist/agy-runner.d.ts

@@ -0,0 +1,14 @@
+export interface RunAgyInput {
+    prompt: string;
+    cwd: string;
+    conversationId?: string;
+    binary?: string;
+    extraArgs?: string[];
+    timeoutMs?: number;
+}
+export interface RunAgyResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function runAgy(input: RunAgyInput): Promise<RunAgyResult>;

package/dist/agy-runner.js

@@ -0,0 +1,50 @@
+import { spawn } from "node:child_process";
+export async function runAgy(input) {
+    const binary = input.binary ?? "agy";
+    const timeoutMs = input.timeoutMs ?? 300_000;
+    const extraArgs = input.extraArgs ?? [];
+    const args = [
+        "--add-dir",
+        input.cwd,
+        ...extraArgs,
+    ];
+    if (input.conversationId) {
+        args.push("--conversation", input.conversationId);
+    }
+    args.push("-p", "-");
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            cwd: input.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        child.stdin.write(input.prompt);
+        child.stdin.end();
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error("agy timed out"));
+        }, timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+            const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+            const exitCode = code ?? 1;
+            if (stderr.trim()) {
+                console.error("[agy-bridge] agy stderr:", stderr.trimEnd());
+            }
+            if (exitCode !== 0 && !stdout.trim()) {
+                const msg = stderr.trim() || `agy exited with status ${exitCode}`;
+                reject(new Error(msg));
+                return;
+            }
+            resolve({ stdout, stderr, exitCode });
+        });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new Error(`failed to spawn agy: ${err.message}`));
+        });
+    });
+}

package/dist/conversation-tracker.d.ts

@@ -0,0 +1,3 @@
+export declare function defaultConversationsDir(): string;
+export declare function snapshot(dir: string): Promise<Set<string>>;
+export declare function findNewConversation(before: Set<string>, dir: string): Promise<string | null>;

package/dist/conversation-tracker.js

@@ -0,0 +1,38 @@
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function defaultConversationsDir() {
+    return join(homedir(), ".gemini", "antigravity-cli", "conversations");
+}
+export async function snapshot(dir) {
+    try {
+        const entries = await readdir(dir);
+        const stems = new Set();
+        for (const entry of entries) {
+            if (entry.endsWith(".pb")) {
+                stems.add(entry.slice(0, -3));
+            }
+        }
+        return stems;
+    }
+    catch {
+        return new Set();
+    }
+}
+export async function findNewConversation(before, dir) {
+    const after = await snapshot(dir);
+    const created = [];
+    for (const stem of after) {
+        if (!before.has(stem)) {
+            created.push(stem);
+        }
+    }
+    if (created.length === 0) {
+        return null;
+    }
+    if (created.length > 1) {
+        console.error("[agy-bridge] WARN: multiple new agy conversation files appeared; refusing to bind");
+        return null;
+    }
+    return created[0];
+}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugin.js

@@ -0,0 +1,10 @@
+const plugin = async () => ({
+    "chat.headers": async (incoming, output) => {
+        // Only inject for our own provider
+        if (incoming.model.providerID !== "agy")
+            return;
+        // Pass the stable OpenCode session ID so agy can reuse conversations
+        output.headers["x-agy-session-id"] = incoming.sessionID;
+    },
+});
+export default plugin;

package/dist/prompt-mapper.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModelV2Prompt } from "@ai-sdk/provider";
+export declare function flattenPrompt(prompt: LanguageModelV2Prompt): string;

package/dist/prompt-mapper.js

@@ -0,0 +1,42 @@
+export function flattenPrompt(prompt) {
+    const nonSystem = prompt.filter((msg) => msg.role !== "system");
+    if (nonSystem.length === 0)
+        return "";
+    if (nonSystem.length === 1) {
+        return extractText(nonSystem[0]).trim();
+    }
+    const parts = [];
+    const history = nonSystem.slice(0, -1);
+    const current = nonSystem[nonSystem.length - 1];
+    parts.push("[Contexto previo de la conversación]");
+    for (const msg of history) {
+        const text = extractText(msg);
+        if (text.trim()) {
+            const label = msg.role === "user" ? "User" : "Assistant";
+            parts.push(`${label}: ${text}`);
+        }
+    }
+    parts.push("[Fin del contexto]");
+    const currentText = extractText(current).trim();
+    if (currentText) {
+        parts.push("");
+        parts.push("Petición actual:");
+        parts.push(currentText);
+    }
+    return parts.join("\n");
+}
+function extractText(msg) {
+    if (typeof msg.content === "string") {
+        return msg.content;
+    }
+    if (Array.isArray(msg.content)) {
+        const texts = [];
+        for (const part of msg.content) {
+            if (part.type === "text") {
+                texts.push(part.text);
+            }
+        }
+        return texts.join("\n");
+    }
+    return "";
+}

package/dist/provider.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderV2 } from "@ai-sdk/provider";
+export interface AgyProviderOptions {
+    binary?: string;
+    conversationsDir?: string;
+    stateFile?: string;
+    extraArgs?: string[];
+    timeoutMs?: number;
+}
+export declare function extractDelta(prevOutput: string, fullText: string, conversationBound: boolean): string;
+export declare function createAgyProvider(opts?: AgyProviderOptions): ProviderV2;
+export default function defaultFactory(opts?: AgyProviderOptions): ProviderV2;

package/dist/provider.js

@@ -0,0 +1,213 @@
+import { runAgy } from "./agy-runner";
+import { snapshot, findNewConversation, defaultConversationsDir } from "./conversation-tracker";
+import { SessionStore } from "./session-store";
+import { flattenPrompt } from "./prompt-mapper";
+import { randomUUID } from "node:crypto";
+const prevOutputs = new Map();
+export function extractDelta(prevOutput, fullText, conversationBound) {
+    if (!conversationBound || !prevOutput) {
+        return fullText;
+    }
+    const normalize = (str) => str.replace(/\r\n/g, "\n");
+    const normPrev = normalize(prevOutput);
+    const normFull = normalize(fullText);
+    if (normFull.startsWith(normPrev)) {
+        return normFull.slice(normPrev.length).replace(/^\n+/, "");
+    }
+    const normPrevTrimmed = normPrev.trimEnd();
+    if (normFull.startsWith(normPrevTrimmed)) {
+        return normFull.slice(normPrevTrimmed.length).replace(/^\s+/, "");
+    }
+    const idx = normFull.indexOf(normPrevTrimmed);
+    if (idx !== -1) {
+        return normFull.slice(idx + normPrevTrimmed.length).replace(/^\s+/, "");
+    }
+    const lines = normPrevTrimmed.split("\n").filter((l) => l.trim());
+    if (lines.length > 0) {
+        const lastLine = lines[lines.length - 1].trim();
+        if (lastLine.length >= 10) {
+            const lastLineIdx = normFull.indexOf(lastLine);
+            if (lastLineIdx !== -1) {
+                return normFull.slice(lastLineIdx + lastLine.length).replace(/^\s+/, "");
+            }
+        }
+    }
+    const tailLength = 150;
+    const tail = normPrevTrimmed.length > tailLength
+        ? normPrevTrimmed.slice(-tailLength)
+        : normPrevTrimmed;
+    if (tail.length >= 20) {
+        const tailIdx = normFull.lastIndexOf(tail);
+        if (tailIdx !== -1) {
+            return normFull.slice(tailIdx + tail.length).replace(/^\s+/, "");
+        }
+    }
+    console.error("[agy-bridge] WARN: agy stdout was not append-only; sending full output and resetting delta baseline");
+    return fullText;
+}
+function buildLanguageModel(modelId, opts) {
+    const store = new SessionStore(opts.stateFile);
+    const conversationsDir = opts.conversationsDir ?? defaultConversationsDir();
+    const doGenerate = async (callOpts) => {
+        // Use the stable OpenCode session ID injected via plugin chat.headers hook.
+        // Falls back to providerMetadata or a random UUID for standalone/testing.
+        const sessionId = callOpts.headers?.["x-agy-session-id"] ??
+            callOpts.providerOptions?.agy
+                ?.sessionId ??
+            randomUUID();
+        const entry = await store.getEntry(sessionId);
+        let conversationId = entry?.conversationId ?? null;
+        const processedMessages = entry?.processedMessages ?? 0;
+        // On first turn (no conversation yet), acquire a global lock before
+        // spawning agy so we can safely diff *.pb files without races from
+        // another concurrent OpenCode instance.
+        let releaseBindingLock = null;
+        if (!conversationId) {
+            releaseBindingLock = await SessionStore.acquireBindingLock();
+        }
+        let before = null;
+        try {
+            before = conversationId ? null : await snapshot(conversationsDir);
+            // Only send new messages when conversation is already bound.
+            // agy preserves context internally via --conversation, so sending
+            // the full history each turn confuses it and causes hallucination.
+            const newMessages = conversationId
+                ? callOpts.prompt.slice(processedMessages)
+                : callOpts.prompt;
+            const prompt = flattenPrompt(newMessages);
+            const result = await runAgy({
+                prompt,
+                cwd: process.cwd(),
+                conversationId: conversationId ?? undefined,
+                binary: opts.binary,
+                extraArgs: opts.extraArgs,
+                timeoutMs: opts.timeoutMs,
+            });
+            if (!conversationId && before) {
+                const newId = await findNewConversation(before, conversationsDir);
+                if (newId) {
+                    conversationId = newId;
+                }
+            }
+            // Restore prevOutput from persisted store (survives restarts).
+            // In-memory cache takes priority (faster, has latest turn data).
+            let prevOutput = prevOutputs.get(sessionId) ?? "";
+            if (!prevOutput && entry?.prevOutput) {
+                prevOutput = entry.prevOutput;
+                prevOutputs.set(sessionId, prevOutput);
+            }
+            const delta = extractDelta(prevOutput, result.stdout, !!conversationId);
+            if (conversationId) {
+                prevOutputs.set(sessionId, result.stdout);
+            }
+            else {
+                prevOutputs.delete(sessionId);
+            }
+            // Persist state so it survives process restarts.
+            await store.set(sessionId, conversationId, conversationId ? callOpts.prompt.length : 0, conversationId ? result.stdout : "");
+            return {
+                content: [{ type: "text", text: delta }],
+                finishReason: "stop",
+                usage: {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    totalTokens: 0,
+                },
+                providerMetadata: {
+                    agy: {
+                        sessionId,
+                        conversationId: conversationId ?? null,
+                    },
+                },
+                response: {
+                    id: randomUUID(),
+                    timestamp: new Date(),
+                    modelId,
+                },
+                warnings: [],
+            };
+        }
+        finally {
+            if (releaseBindingLock) {
+                await releaseBindingLock();
+            }
+        }
+    };
+    const doStream = async (callOpts) => {
+        const generatePromise = doGenerate(callOpts);
+        let aborted = false;
+        callOpts.abortSignal?.addEventListener("abort", () => {
+            aborted = true;
+        });
+        const stream = new ReadableStream({
+            async start(controller) {
+                try {
+                    controller.enqueue({
+                        type: "stream-start",
+                        warnings: [],
+                    });
+                    const result = await generatePromise;
+                    if (aborted) {
+                        controller.close();
+                        return;
+                    }
+                    const textContent = result.content.find((c) => c.type === "text");
+                    const text = textContent && "text" in textContent ? textContent.text : "";
+                    if (text) {
+                        controller.enqueue({
+                            type: "text-start",
+                            id: "agy-1",
+                        });
+                        controller.enqueue({
+                            type: "text-delta",
+                            id: "agy-1",
+                            delta: text,
+                        });
+                        controller.enqueue({
+                            type: "text-end",
+                            id: "agy-1",
+                        });
+                    }
+                    controller.enqueue({
+                        type: "finish",
+                        finishReason: result.finishReason,
+                        usage: result.usage,
+                    });
+                    controller.close();
+                }
+                catch (err) {
+                    controller.enqueue({ type: "error", error: String(err) });
+                    controller.close();
+                }
+            },
+            cancel() {
+                // agy is one-shot; no real cancellation possible here
+            },
+        });
+        return { stream };
+    };
+    return {
+        specificationVersion: "v2",
+        provider: "agy",
+        modelId,
+        supportedUrls: {},
+        doGenerate,
+        doStream,
+    };
+}
+export function createAgyProvider(opts) {
+    const resolvedOpts = opts ?? {};
+    const languageModel = (modelId) => buildLanguageModel(modelId, resolvedOpts);
+    return {
+        languageModel,
+        textEmbeddingModel() {
+            throw new Error("agy bridge does not support text embeddings");
+        },
+        imageModel() {
+            throw new Error("agy bridge does not support image generation");
+        },
+    };
+}
+export default function defaultFactory(opts) {
+    return createAgyProvider(opts);
+}

package/dist/session-store.d.ts

@@ -0,0 +1,19 @@
+interface StoreEntry {
+    conversationId: string | null;
+    processedMessages: number;
+    prevOutput: string;
+}
+export declare class SessionStore {
+    private stateFile;
+    constructor(stateFile?: string);
+    /**
+     * Acquires a global lock for the bind-while-running phase.
+     * Prevents concurrent agy instances from creating ambiguous .pb files.
+     */
+    static acquireBindingLock(): Promise<() => Promise<void>>;
+    getEntry(sessionId: string): Promise<StoreEntry | null>;
+    set(sessionId: string, conversationId: string | null, processedMessages?: number, prevOutput?: string): Promise<void>;
+    private loadStore;
+    private loadStoreUnlocked;
+}
+export {};

package/dist/session-store.js

@@ -0,0 +1,108 @@
+import { readFile, writeFile, rename, mkdir, open, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function defaultStateFile() {
+    return join(homedir(), ".opencode-agy-bridge", "sessions.json");
+}
+function defaultBindingLockPath() {
+    return join(homedir(), ".opencode-agy-bridge", "binding.lock");
+}
+async function acquireLock(lockPath) {
+    const lockDir = dirname(lockPath);
+    await mkdir(lockDir, { recursive: true });
+    const startTime = Date.now();
+    const staleTimeoutMs = 30_000;
+    let backoff = 1;
+    const maxBackoff = 500;
+    while (true) {
+        try {
+            const fh = await open(lockPath, "wx");
+            await fh.close();
+            return () => releaseLock(lockPath);
+        }
+        catch {
+            if (Date.now() - startTime > staleTimeoutMs) {
+                try {
+                    const stats = await stat(lockPath);
+                    if (Date.now() - stats.mtimeMs > staleTimeoutMs) {
+                        await releaseLock(lockPath);
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            await new Promise((r) => setTimeout(r, backoff));
+            backoff = Math.min(backoff * 2, maxBackoff);
+        }
+    }
+}
+async function releaseLock(lockPath) {
+    try {
+        const { unlink } = await import("node:fs/promises");
+        await unlink(lockPath);
+    }
+    catch {
+        // best effort
+    }
+}
+export class SessionStore {
+    stateFile;
+    constructor(stateFile) {
+        this.stateFile = stateFile ?? defaultStateFile();
+    }
+    /**
+     * Acquires a global lock for the bind-while-running phase.
+     * Prevents concurrent agy instances from creating ambiguous .pb files.
+     */
+    static acquireBindingLock() {
+        return acquireLock(defaultBindingLockPath());
+    }
+    async getEntry(sessionId) {
+        const store = await this.loadStore();
+        return store.sessions[sessionId] ?? null;
+    }
+    async set(sessionId, conversationId, processedMessages = 0, prevOutput = "") {
+        const stateDir = dirname(this.stateFile);
+        await mkdir(stateDir, { recursive: true });
+        const lockPath = this.stateFile + ".lock";
+        const release = await acquireLock(lockPath);
+        try {
+            const store = await this.loadStoreUnlocked();
+            store.sessions[sessionId] = {
+                conversationId,
+                processedMessages,
+                prevOutput,
+            };
+            const tmpPath = this.stateFile + ".tmp";
+            await writeFile(tmpPath, JSON.stringify(store, null, 2), "utf-8");
+            await rename(tmpPath, this.stateFile);
+        }
+        finally {
+            await release();
+        }
+    }
+    async loadStore() {
+        const stateDir = dirname(this.stateFile);
+        await mkdir(stateDir, { recursive: true });
+        const lockPath = this.stateFile + ".lock";
+        const release = await acquireLock(lockPath);
+        try {
+            return await this.loadStoreUnlocked();
+        }
+        finally {
+            await release();
+        }
+    }
+    async loadStoreUnlocked() {
+        try {
+            const raw = await readFile(this.stateFile, "utf-8");
+            const parsed = JSON.parse(raw);
+            return { sessions: parsed.sessions ?? {} };
+        }
+        catch {
+            return { sessions: {} };
+        }
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "opencode-agy-bridge",
+  "version": "0.1.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "OpenCode plugin + provider that routes LLM prompts to agy (Google Antigravity CLI)",
+  "exports": {
+    ".": "./dist/provider.js",
+    "./plugin": "./dist/plugin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^3.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.15.12",
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  }
+}