@opencode-ai/plugin 0.0.0-fix-build-202511160139 → 0.0.0-next-202606261956

package/dist/example-workspace.d.ts

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

package/dist/example-workspace.js

@@ -0,0 +1,30 @@
+import { mkdir, rm } from "node:fs/promises";
+export const FolderWorkspacePlugin = async ({ experimental_workspace }) => {
+    experimental_workspace.register("folder", {
+        name: "Folder",
+        description: "Create a blank folder",
+        configure(config) {
+            const rand = "" + Math.random();
+            return {
+                ...config,
+                directory: `/tmp/folder/folder-${rand}`,
+            };
+        },
+        async create(config) {
+            if (!config.directory)
+                return;
+            await mkdir(config.directory, { recursive: true });
+        },
+        async remove(config) {
+            await rm(config.directory, { recursive: true, force: true });
+        },
+        target(config) {
+            return {
+                type: "local",
+                directory: config.directory,
+            };
+        },
+    });
+    return {};
+};
+export default FolderWorkspacePlugin;

package/dist/example.d.ts

@@ -1,2 +1,2 @@
-import { Plugin } from "./index";
+import { Plugin } from "./index.js";
 export declare const ExamplePlugin: Plugin;

package/dist/example.js

@@ -1,5 +1,5 @@
-import { tool } from "./tool";
-export const ExamplePlugin = async (ctx) => {
+import { tool } from "./tool.js";
+export const ExamplePlugin = async (_ctx) => {
     return {
         tool: {
             mytool: tool({

package/dist/index.d.ts

@@ -1,16 +1,177 @@
-import type { Event, createOpencodeClient, Project, Model, Provider, Permission, UserMessage, Part, Auth, Config } from "@opencode-ai/sdk";
-import type { BunShell } from "./shell";
-import { type ToolDefinition } from "./tool";
-export * from "./tool";
+import type { Event, createOpencodeClient, Project, Model, Provider, Permission, UserMessage, Message, Part, Config as SDKConfig } from "@opencode-ai/sdk";
+import type { Provider as ProviderV2, Model as ModelV2, Auth } from "@opencode-ai/sdk/v2";
+import type { BunShell } from "./shell.js";
+import { type ToolDefinition } from "./tool.js";
+export * from "./tool.js";
+export type ProviderContext = {
+    source: "env" | "config" | "custom" | "api";
+    info: Provider;
+    options: Record<string, any>;
+};
+export type WorkspaceInfo = {
+    id: string;
+    type: string;
+    name: string;
+    branch: string | null;
+    directory: string | null;
+    extra: unknown | null;
+    projectID: string;
+};
+export type WorkspaceTarget = {
+    type: "local";
+    directory: string;
+} | {
+    type: "remote";
+    url: string | URL;
+    headers?: HeadersInit;
+};
+export type WorkspaceAdapter = {
+    name: string;
+    description: string;
+    configure(config: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>;
+    create(config: WorkspaceInfo, env: Record<string, string | undefined>, from?: WorkspaceInfo): Promise<void>;
+    remove(config: WorkspaceInfo): Promise<void>;
+    target(config: WorkspaceInfo): WorkspaceTarget | Promise<WorkspaceTarget>;
+};
 export type PluginInput = {
     client: ReturnType<typeof createOpencodeClient>;
     project: Project;
     directory: string;
     worktree: string;
+    experimental_workspace: {
+        register(type: string, adapter: WorkspaceAdapter): void;
+    };
+    serverUrl: URL;
     $: BunShell;
 };
-export type Plugin = (input: PluginInput) => Promise<Hooks>;
+export type PluginOptions = Record<string, unknown>;
+export type Config = Omit<SDKConfig, "plugin"> & {
+    plugin?: Array<string | [string, PluginOptions]>;
+};
+export type Plugin = (input: PluginInput, options?: PluginOptions) => Promise<Hooks>;
+export type PluginModule = {
+    id?: string;
+    server: Plugin;
+    tui?: never;
+};
+type Rule = {
+    key: string;
+    op: "eq" | "neq";
+    value: string;
+};
+export type AuthHook = {
+    provider: string;
+    loader?: (auth: () => Promise<Auth>, provider: Provider) => Promise<Record<string, any>>;
+    methods: ({
+        type: "oauth";
+        label: string;
+        prompts?: Array<{
+            type: "text";
+            key: string;
+            message: string;
+            placeholder?: string;
+            validate?: (value: string) => string | undefined;
+            /** @deprecated Use `when` instead */
+            condition?: (inputs: Record<string, string>) => boolean;
+            when?: Rule;
+        } | {
+            type: "select";
+            key: string;
+            message: string;
+            options: Array<{
+                label: string;
+                value: string;
+                hint?: string;
+            }>;
+            /** @deprecated Use `when` instead */
+            condition?: (inputs: Record<string, string>) => boolean;
+            when?: Rule;
+        }>;
+        authorize(inputs?: Record<string, string>): Promise<AuthOAuthResult>;
+    } | {
+        type: "api";
+        label: string;
+        prompts?: Array<{
+            type: "text";
+            key: string;
+            message: string;
+            placeholder?: string;
+            validate?: (value: string) => string | undefined;
+            /** @deprecated Use `when` instead */
+            condition?: (inputs: Record<string, string>) => boolean;
+            when?: Rule;
+        } | {
+            type: "select";
+            key: string;
+            message: string;
+            options: Array<{
+                label: string;
+                value: string;
+                hint?: string;
+            }>;
+            /** @deprecated Use `when` instead */
+            condition?: (inputs: Record<string, string>) => boolean;
+            when?: Rule;
+        }>;
+        authorize?(inputs?: Record<string, string>): Promise<{
+            type: "success";
+            key: string;
+            provider?: string;
+            metadata?: Record<string, string>;
+        } | {
+            type: "failed";
+        }>;
+    })[];
+};
+export type AuthOAuthResult = {
+    url: string;
+    instructions: string;
+} & ({
+    method: "auto";
+    callback(): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+        enterpriseUrl?: string;
+    } | {
+        key: string;
+        metadata?: Record<string, string>;
+    })) | {
+        type: "failed";
+    }>;
+} | {
+    method: "code";
+    callback(code: string): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+        enterpriseUrl?: string;
+    } | {
+        key: string;
+        metadata?: Record<string, string>;
+    })) | {
+        type: "failed";
+    }>;
+});
+export type ProviderHookContext = {
+    auth?: Auth;
+};
+export type ProviderHook = {
+    id: string;
+    models?: (provider: ProviderV2, ctx: ProviderHookContext) => Promise<Record<string, ModelV2>>;
+};
+/** @deprecated Use AuthOAuthResult instead. */
+export type AuthOuathResult = AuthOAuthResult;
 export interface Hooks {
+    dispose?: () => Promise<void>;
     event?: (input: {
         event: Event;
     }) => Promise<void>;
@@ -18,92 +179,8 @@ export interface Hooks {
     tool?: {
         [key: string]: ToolDefinition;
     };
-    auth?: {
-        provider: string;
-        loader?: (auth: () => Promise<Auth>, provider: Provider) => Promise<Record<string, any>>;
-        methods: ({
-            type: "oauth";
-            label: string;
-            prompts?: Array<{
-                type: "text";
-                key: string;
-                message: string;
-                placeholder?: string;
-                validate?: (value: string) => string | undefined;
-                condition?: (inputs: Record<string, string>) => boolean;
-            } | {
-                type: "select";
-                key: string;
-                message: string;
-                options: Array<{
-                    label: string;
-                    value: string;
-                    hint?: string;
-                }>;
-                condition?: (inputs: Record<string, string>) => boolean;
-            }>;
-            authorize(inputs?: Record<string, string>): Promise<{
-                url: string;
-                instructions: string;
-            } & ({
-                method: "auto";
-                callback(): Promise<({
-                    type: "success";
-                    provider?: string;
-                } & ({
-                    refresh: string;
-                    access: string;
-                    expires: number;
-                } | {
-                    key: string;
-                })) | {
-                    type: "failed";
-                }>;
-            } | {
-                method: "code";
-                callback(code: string): Promise<({
-                    type: "success";
-                    provider?: string;
-                } & ({
-                    refresh: string;
-                    access: string;
-                    expires: number;
-                } | {
-                    key: string;
-                })) | {
-                    type: "failed";
-                }>;
-            })>;
-        } | {
-            type: "api";
-            label: string;
-            prompts?: Array<{
-                type: "text";
-                key: string;
-                message: string;
-                placeholder?: string;
-                validate?: (value: string) => string | undefined;
-                condition?: (inputs: Record<string, string>) => boolean;
-            } | {
-                type: "select";
-                key: string;
-                message: string;
-                options: Array<{
-                    label: string;
-                    value: string;
-                    hint?: string;
-                }>;
-                condition?: (inputs: Record<string, string>) => boolean;
-            }>;
-            authorize?(inputs?: Record<string, string>): Promise<{
-                type: "success";
-                key: string;
-                provider?: string;
-            } | {
-                type: "failed";
-            }>;
-        })[];
-    };
+    auth?: AuthHook;
+    provider?: ProviderHook;
     /**
      * Called when a new message is received
      */
@@ -115,6 +192,7 @@ export interface Hooks {
             modelID: string;
         };
         messageID?: string;
+        variant?: string;
     }, output: {
         message: UserMessage;
         parts: Part[];
@@ -126,16 +204,34 @@ export interface Hooks {
         sessionID: string;
         agent: string;
         model: Model;
-        provider: Provider;
+        provider: ProviderContext;
         message: UserMessage;
     }, output: {
         temperature: number;
         topP: number;
+        topK: number;
+        maxOutputTokens: number | undefined;
         options: Record<string, any>;
     }) => Promise<void>;
+    "chat.headers"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        headers: Record<string, string>;
+    }) => Promise<void>;
     "permission.ask"?: (input: Permission, output: {
         status: "ask" | "deny" | "allow";
     }) => Promise<void>;
+    "command.execute.before"?: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Part[];
+    }) => Promise<void>;
     "tool.execute.before"?: (input: {
         tool: string;
         sessionID: string;
@@ -143,13 +239,84 @@ export interface Hooks {
     }, output: {
         args: any;
     }) => Promise<void>;
+    "shell.env"?: (input: {
+        cwd: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
     "tool.execute.after"?: (input: {
         tool: string;
         sessionID: string;
         callID: string;
+        args: any;
     }, output: {
         title: string;
         output: string;
         metadata: any;
     }) => Promise<void>;
+    "experimental.chat.messages.transform"?: (input: {}, output: {
+        messages: {
+            info: Message;
+            parts: Part[];
+        }[];
+    }) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: {
+        sessionID?: string;
+        model: Model;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+    "experimental.provider.small_model"?: (input: {
+        provider: ProviderV2;
+    }, output: {
+        model?: ModelV2;
+    }) => Promise<void>;
+    /**
+     * Called before session compaction starts. Allows plugins to customize
+     * the compaction prompt.
+     *
+     * - `context`: Additional context strings appended to the default prompt
+     * - `prompt`: If set, replaces the default compaction prompt entirely
+     */
+    "experimental.session.compacting"?: (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+        prompt?: string;
+    }) => Promise<void>;
+    /**
+     * Called after compaction succeeds and before a synthetic user
+     * auto-continue message is added.
+     *
+     * - `enabled`: Defaults to `true`. Set to `false` to skip the synthetic
+     *   user "continue" turn.
+     */
+    "experimental.compaction.autocontinue"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+        overflow: boolean;
+    }, output: {
+        enabled: boolean;
+    }) => Promise<void>;
+    "experimental.text.complete"?: (input: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+    /**
+     * Modify tool definitions (description and parameters) sent to LLM
+     */
+    "tool.definition"?: (input: {
+        toolID: string;
+    }, output: {
+        description: string;
+        parameters: any;
+    }) => Promise<void>;
 }

package/dist/index.js

@@ -1 +1 @@
-export * from "./tool";
+export * from "./tool.js";

package/dist/shell.js

@@ -0,0 +1 @@
+export {};

package/dist/tool.d.ts

@@ -3,18 +3,58 @@ export type ToolContext = {
     sessionID: string;
     messageID: string;
     agent: string;
+    /**
+     * Current project directory for this session.
+     * Prefer this over process.cwd() when resolving relative paths.
+     */
+    directory: string;
+    /**
+     * Project worktree root for this session.
+     * Useful for generating stable relative paths (e.g. path.relative(worktree, absPath)).
+     */
+    worktree: string;
     abort: AbortSignal;
+    metadata(input: {
+        title?: string;
+        metadata?: {
+            [key: string]: any;
+        };
+    }): void;
+    ask(input: AskInput): Promise<void>;
+};
+type AskInput = {
+    permission: string;
+    patterns: string[];
+    always: string[];
+    metadata: {
+        [key: string]: any;
+    };
+};
+export type ToolAttachment = {
+    type: "file";
+    mime: string;
+    url: string;
+    filename?: string;
+};
+export type ToolResult = string | {
+    title?: string;
+    output: string;
+    metadata?: {
+        [key: string]: any;
+    };
+    attachments?: ToolAttachment[];
 };
 export declare function tool<Args extends z.ZodRawShape>(input: {
     description: string;
     args: Args;
-    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>;
+    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<ToolResult>;
 }): {
     description: string;
     args: Args;
-    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<string>;
+    execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<ToolResult>;
 };
 export declare namespace tool {
     var schema: typeof z;
 }
 export type ToolDefinition = ReturnType<typeof tool>;
+export {};