@opencode/plugin 2.0.27 → 2.0.29

package/dist/effect/permission.d.ts

@@ -2,6 +2,9 @@ import type { PermissionApi } from "@opencode/client/effect/api";
 import type { Agent } from "@opencode/schema/agent";
 import type { Permission } from "@opencode/schema/permission";
 import type { Session } from "@opencode/schema/session";
+import type { Tool } from "@opencode/schema/tool";
+import type { Effect } from "effect";
+import type { AssertInput } from "../permission.js";
 import type { Hooks } from "./registration.js";
 export interface PermissionEvaluation {
     readonly sessionID: Session.ID;
@@ -18,4 +21,10 @@ export interface PermissionHooks {
 }
 export type PermissionDomain = Pick<PermissionApi<unknown>, "list" | "get" | "reply"> & {
     readonly hook: Hooks<PermissionHooks>;
+    /**
+     * Evaluates the session's permission rules and, when approval is required, prompts the user and
+     * waits for the reply. Succeeds when allowed. A deny rule or a rejection with feedback fails with a
+     * `Tool.Error` carrying the reason; a plain rejection ends the current step.
+     */
+    readonly assert: (input: AssertInput) => Effect.Effect<void, Tool.Error>;
 };

package/dist/effect/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { ExperimentalApi, GenerateApi, PluginApi } from "@opencode/client/effect/api";
+import type { CredentialApi, ExperimentalApi, GenerateApi, PluginApi } from "@opencode/client/effect/api";
 import type { Location } from "@opencode/schema/location";
 import type { Effect, Scope } from "effect";
 import type { PluginOptions } from "../options.js";
@@ -29,6 +29,7 @@ export interface Context {
     readonly agent: AgentDomain;
     readonly aisdk: AISDKDomain;
     readonly command: CommandDomain;
+    readonly credential: Pick<CredentialApi<unknown>, "activate">;
     readonly event: EventDomain;
     readonly experimental: {
         readonly terminal: Pick<ExperimentalApi<unknown>["persistentPty"], "read">;

package/dist/permission.d.ts

@@ -0,0 +1,23 @@
+import { Schema } from "effect";
+export declare const AssertInput: Schema.Struct<{
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly agent: Schema.optional<Schema.brand<Schema.String, "Agent.ID">>;
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly id: Schema.String;
+    }>]>>, never, never>;
+}>;
+export interface AssertInput extends Schema.Schema.Type<typeof AssertInput> {
+}

package/dist/permission.js

@@ -0,0 +1,12 @@
+import { Agent } from "@opencode/schema/agent";
+import { Permission } from "@opencode/schema/permission";
+import { Schema } from "effect";
+export const AssertInput = Schema.Struct({
+    sessionID: Permission.Request.fields.sessionID,
+    agent: Agent.ID.pipe(Schema.optional),
+    action: Permission.Request.fields.action,
+    resources: Permission.Request.fields.resources,
+    save: Permission.Request.fields.save,
+    metadata: Permission.Request.fields.metadata,
+    source: Permission.Request.fields.source,
+});

package/dist/promise/adapter.js

@@ -2,6 +2,7 @@ import { Tool } from "@opencode/schema/tool";
 import { Effect, Schema, SchemaAST, Stream } from "effect";
 import { HttpApiEndpoint, HttpApiSchema } from "effect/http-api";
 import { define } from "../effect/plugin.js";
+import { AssertInput } from "../permission.js";
 const compiledEndpoints = new WeakMap();
 const JsonInput = Schema.fromJsonString(Schema.Unknown);
 class ReturnedRpcError extends Error {
@@ -157,6 +158,7 @@ export function fromPromise(plugin) {
             const [{ ClientApi }, { OpenCodeEvent }] = yield* Effect.promise(() => Promise.all([import("@opencode/protocol/client"), import("@opencode/protocol/groups/event")]));
             const AgentEndpoints = ClientApi.groups["server.agent"].endpoints;
             const CommandEndpoints = ClientApi.groups["server.command"].endpoints;
+            const CredentialEndpoints = ClientApi.groups["server.credential"].endpoints;
             const ExperimentalEndpoints = ClientApi.groups["server.experimental"].endpoints;
             const GenerateEndpoints = ClientApi.groups["server.generate"].endpoints;
             const IntegrationEndpoints = ClientApi.groups["server.integration"].endpoints;
@@ -220,6 +222,9 @@ export function fromPromise(plugin) {
                     }))),
                     reload: () => run(host.command.reload()),
                 },
+                credential: {
+                    activate: adaptApiMethod(CredentialEndpoints["credential.activate"], host.credential.activate),
+                },
                 event: {
                     subscribe: (options) => streams(host.event.subscribe().pipe(Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)), Stream.map((event) => event)), options),
                 },
@@ -308,6 +313,7 @@ export function fromPromise(plugin) {
                     list: adaptApiMethod(PermissionEndpoints["session.permission.list"], host.permission.list),
                     get: adaptApiMethod(PermissionEndpoints["session.permission.get"], host.permission.get),
                     reply: adaptApiMethod(PermissionEndpoints["session.permission.reply"], host.permission.reply),
+                    assert: (input) => run(Schema.decodeUnknownEffect(AssertInput)(input).pipe(Effect.flatMap(host.permission.assert))),
                 },
                 plugin: {
                     list: adaptApiMethod(PluginEndpoints["plugin.list"], host.plugin.list),
@@ -357,7 +363,7 @@ export function fromPromise(plugin) {
                         }),
                         remove: editor.remove,
                     }))),
-                    hook: (name, callback) => register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+                    hook: (name, callback) => register(host.tool.hook(name, (event) => toolHook[name](() => Promise.resolve(callback(event))))),
                 },
                 vcs: {
                     get: adaptApiMethod(VcsEndpoints["vcs.get"], host.vcs.get),
@@ -447,8 +453,19 @@ export function fromPromise(plugin) {
 function attempt(evaluate) {
     return Effect.tryPromise({ try: evaluate, catch: (cause) => cause });
 }
-const executePromiseTool = (tool, input, context) => Effect.promise((signal) => tool.execute(input, {
-    ...context,
-    signal,
-    progress: (update) => Effect.runPromise(context.progress(update), { signal }),
-}));
+const toolError = (error) => error instanceof Tool.Error
+    ? error
+    : new Tool.Error({ message: error instanceof Error ? error.message : String(error), error });
+// Only execute.before may reject a call; a rejection fails that call alone, like an Effect hook.
+const toolHook = {
+    "execute.before": (run) => Effect.tryPromise({ try: run, catch: toolError }),
+    "execute.after": (run) => Effect.promise(run),
+};
+const executePromiseTool = (tool, input, context) => Effect.tryPromise({
+    try: (signal) => tool.execute(input, {
+        ...context,
+        signal,
+        progress: (update) => Effect.runPromise(context.progress(update), { signal }),
+    }),
+    catch: toolError,
+});

package/dist/promise/permission.d.ts

@@ -2,6 +2,7 @@ import type { PermissionApi } from "@opencode/client/promise/api";
 import type { Agent } from "@opencode/schema/agent";
 import type { Permission } from "@opencode/schema/permission";
 import type { Session } from "@opencode/schema/session";
+import type { AssertInput } from "../permission.js";
 import type { Hooks } from "./registration.js";
 export interface PermissionEvaluation {
     readonly sessionID: Session.ID;
@@ -18,4 +19,11 @@ export interface PermissionHooks {
 }
 export type PermissionDomain = Pick<PermissionApi, "list" | "get" | "reply"> & {
     readonly hook: Hooks<PermissionHooks>;
+    /**
+     * Evaluates the session's permission rules and, when approval is required, prompts the user and
+     * waits for the reply. Resolves when allowed. A deny rule or a rejection with feedback rejects with
+     * a `Tool.Error` carrying the reason. A plain rejection rejects with an error that ends the current
+     * step; rethrow it rather than returning it as tool output.
+     */
+    readonly assert: (input: typeof AssertInput.Encoded) => Promise<void>;
 };

package/dist/promise/plugin.d.ts

@@ -1,5 +1,5 @@
 import type { OpenCodeClient } from "@opencode/client";
-import type { GenerateApi, PluginApi } from "@opencode/client/promise/api";
+import type { CredentialApi, GenerateApi, PluginApi } from "@opencode/client/promise/api";
 import type { Location } from "@opencode/schema/location";
 import type { PluginOptions } from "../options.js";
 import type { App } from "../app.js";
@@ -29,6 +29,7 @@ export interface Context {
     readonly agent: AgentDomain;
     readonly aisdk: AISDKDomain;
     readonly command: CommandDomain;
+    readonly credential: Pick<CredentialApi, "activate">;
     readonly event: EventDomain;
     readonly experimental: {
         readonly terminal: Pick<OpenCodeClient["experimental"]["persistentPty"], "read">;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/plugin",
-  "version": "2.0.27",
+  "version": "2.0.29",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -47,15 +47,15 @@
   ],
   "dependencies": {
     "@ai-sdk/provider": "3.0.8",
-    "@opencode/ai": "2.0.27",
-    "@opencode/client": "2.0.27",
-    "@opencode/protocol": "2.0.27",
-    "@opencode/schema": "2.0.27",
-    "@opencode/util": "2.0.27",
+    "@opencode/ai": "2.0.29",
+    "@opencode/client": "2.0.29",
+    "@opencode/protocol": "2.0.29",
+    "@opencode/schema": "2.0.29",
+    "@opencode/util": "2.0.29",
     "effect": "4.0.1"
   },
   "peerDependencies": {
-    "@opencode/theme": "2.0.27",
+    "@opencode/theme": "2.0.29",
     "@opentui/core": ">=0.5.17",
     "@opentui/solid": ">=0.5.17",
     "solid-js": ">=1.9.0"
@@ -75,7 +75,7 @@
     }
   },
   "devDependencies": {
-    "@opencode/theme": "2.0.27",
+    "@opencode/theme": "2.0.29",
     "@opentui/core": "0.5.17",
     "@opentui/solid": "0.5.17",
     "@tsconfig/bun": "1.0.9",