@opencode-ai/plugin 0.0.0-next-15632 → 0.0.0-next-15634

package/dist/v2/effect/tool.d.ts

@@ -3,6 +3,7 @@ import { Agent } from "@opencode-ai/schema/agent";
 import type { LLM } from "@opencode-ai/schema/llm";
 import { Session } from "@opencode-ai/schema/session";
 import { SessionMessage } from "@opencode-ai/schema/session-message";
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from "@standard-schema/spec";
 import { Effect, JsonSchema, Schema } from "effect";
 import type { Hooks, Transform } from "./registration.js";
 export interface Context {
@@ -16,7 +17,12 @@ export interface Progress {
     readonly structured: Readonly<Record<string, unknown>>;
     readonly content?: ReadonlyArray<Content>;
 }
-export type SchemaType<A> = Schema.Codec<A, any>;
+export type StandardSchemaType<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+export type SchemaType<A> = Schema.Codec<A, any> | StandardSchemaType<any, A>;
+type IsAny<A> = 0 extends 1 & A ? true : false;
+export type InputValue<S> = IsAny<S> extends true ? any : S extends Schema.Codec<infer A, any> ? A : S extends StandardSchemaV1<any, infer A> ? A : never;
+export type OutputValue<S> = IsAny<S> extends true ? any : S extends Schema.Codec<infer A, any> ? A : S extends StandardSchemaV1<infer A, any> ? A : never;
+export type EncodedValue<S> = IsAny<S> extends true ? any : S extends Schema.Codec<any, infer A> ? A : S extends StandardSchemaV1<any, infer A> ? A : never;
 type ToolDefinition = {
     readonly name: string;
     readonly description: string;
@@ -44,14 +50,6 @@ type ToolOutput = {
     readonly structured: unknown;
     readonly content: ReadonlyArray<LLM.ToolContent>;
 };
-declare const TypeId: unique symbol;
-export interface Definition<Input extends SchemaType<any>, Output extends SchemaType<any>> {
-    readonly [TypeId]: {
-        readonly _Input: Input;
-        readonly _Output: Output;
-    };
-}
-export type AnyTool = Definition<any, any>;
 declare const Failure_base: Schema.Class<Failure, Schema.TaggedStruct<"LLM.ToolFailure", {
     readonly message: Schema.String;
     readonly error: Schema.optional<Schema.Defect>;
@@ -74,19 +72,20 @@ export type Content = {
     readonly mime: string;
     readonly name?: string;
 };
-type Config<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output> = {
+export type Definition<Input extends SchemaType<any>, Structured extends SchemaType<any>, Output extends SchemaType<any> = any> = {
     readonly description: string;
     readonly input: Input;
     readonly output: Output;
     readonly structured?: Structured;
+    readonly permission?: string;
     readonly toStructuredOutput?: (input: {
-        readonly input: Schema.Schema.Type<Input>;
-        readonly output: Output["Encoded"];
-    }) => Schema.Schema.Type<Structured>;
-    readonly execute: (input: Schema.Schema.Type<Input>, context: Context) => Effect.Effect<Schema.Schema.Type<Output>, Failure>;
+        readonly input: InputValue<Input>;
+        readonly output: EncodedValue<Output>;
+    }) => OutputValue<Structured>;
+    readonly execute: (input: InputValue<Input>, context: Context) => Effect.Effect<OutputValue<Output>, Failure>;
     readonly toModelOutput?: (input: {
-        readonly input: Schema.Schema.Type<Input>;
-        readonly output: Output["Encoded"];
+        readonly input: InputValue<Input>;
+        readonly output: EncodedValue<Output>;
     }) => ReadonlyArray<Content>;
 };
 export type DynamicOutput = {
@@ -98,14 +97,17 @@ export type DynamicOutput = {
  * time (MCP servers, plugin manifests). Input is passed through as `unknown`;
  * `execute` returns the already-projected structured value and model content.
  */
-type DynamicConfig = {
+export type DynamicDefinition = {
     readonly description: string;
     readonly jsonSchema: JsonSchema.JsonSchema;
     readonly outputSchema?: JsonSchema.JsonSchema;
+    readonly permission?: string;
     readonly execute: (input: unknown, context: Context) => Effect.Effect<DynamicOutput, Failure>;
 };
-export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output>(config: Config<Input, Output, Structured>): Definition<Input, Structured>;
-export declare function make(config: DynamicConfig): AnyTool;
+export type AnyTool = Definition<any, any> | DynamicDefinition;
+export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output>(config: Definition<Input, Structured, Output>): Definition<Input, Structured, Output>;
+export declare function make(config: DynamicDefinition): DynamicDefinition;
+export declare function make(config: AnyTool): AnyTool;
 export declare const validateName: (name: string) => Effect.Effect<void, never, never> | Effect.Effect<never, RegistrationError, never>;
 export declare const registrationEntries: (tools: Readonly<Record<string, AnyTool>>, group?: string) => {
     key: string;
@@ -113,10 +115,12 @@ export declare const registrationEntries: (tools: Readonly<Record<string, AnyToo
     group: string | undefined;
     tool: AnyTool;
 }[];
-export declare const withPermission: <Input extends SchemaType<any>, Output extends SchemaType<any>>(tool: Definition<Input, Output>, permission: string) => Definition<Input, Output>;
+export declare const withPermission: <T extends AnyTool>(tool: T, permission: string) => Omit<T, "permission"> & {
+    readonly permission: string;
+};
 export declare const permission: (tool: AnyTool, name: string) => string;
 export declare const definition: (name: string, tool: AnyTool) => ToolDefinition;
-export declare const settle: (tool: AnyTool, call: ToolCall, context: Context) => Effect.Effect<ToolOutput, Failure, never>;
+export declare const settle: (tool: AnyTool, call: ToolCall, context: Context) => Effect.Effect<ToolOutput, Failure>;
 export interface ToolExecuteBeforeEvent {
     readonly tool: string;
     readonly sessionID: Session.ID;

package/dist/v2/effect/tool.js

@@ -14,65 +14,8 @@ export class RegistrationError extends Schema.TaggedErrorClass()("Tool.Registrat
     message: Schema.String,
 }) {
 }
-const runtimes = new WeakMap();
 export function make(config) {
-    if ("jsonSchema" in config)
-        return makeDynamic(config);
-    return makeTyped(config);
-}
-function makeTyped(config) {
-    const tool = Object.freeze({});
-    const definitions = new Map();
-    runtimes.set(tool, {
-        definition: (name) => {
-            const cached = definitions.get(name);
-            if (cached)
-                return cached;
-            const definition = {
-                name,
-                description: config.description,
-                inputSchema: toJsonSchema(config.input),
-                outputSchema: toJsonSchema(config.structured ?? config.output),
-            };
-            definitions.set(name, definition);
-            return definition;
-        },
-        settle: (call, context) => Schema.decodeUnknownEffect(config.input)(call.input).pipe(Effect.mapError((error) => new Failure({ message: `Invalid tool input: ${error.message}` })), Effect.flatMap((input) => config.execute(input, context).pipe(Effect.flatMap((output) => Schema.encodeEffect(config.output)(output).pipe(Effect.flatMap((output) => {
-            if (!config.structured || !config.toStructuredOutput)
-                return Effect.succeed({ output, structured: output });
-            return Schema.encodeEffect(config.structured)(config.toStructuredOutput({ input, output })).pipe(Effect.map((structured) => ({ output, structured })));
-        }), Effect.mapError((error) => new Failure({
-            message: `Tool returned an invalid value for its output schema: ${error.message}`,
-        })))), Effect.map(({ output, structured }) => ({
-            structured,
-            content: config.toModelOutput?.({ input, output }).map(toModelContent) ??
-                (typeof output === "string" ? [{ type: "text", text: output }] : []),
-        }))))),
-    });
-    return tool;
-}
-function makeDynamic(config) {
-    const tool = Object.freeze({});
-    const definitions = new Map();
-    runtimes.set(tool, {
-        definition: (name) => {
-            const cached = definitions.get(name);
-            if (cached)
-                return cached;
-            const definition = {
-                name,
-                description: config.description,
-                inputSchema: config.jsonSchema,
-                outputSchema: config.outputSchema,
-            };
-            definitions.set(name, definition);
-            return definition;
-        },
-        settle: (call, context) => config
-            .execute(call.input, context)
-            .pipe(Effect.map((output) => ({ structured: output.structured, content: output.content.map(toModelContent) }))),
-    });
-    return tool;
+    return config;
 }
 function toModelContent(part) {
     if (part.type === "text")
@@ -92,19 +35,74 @@ export const registrationEntries = (tools, group) => Object.entries(tools).map((
         tool,
     };
 });
-export const withPermission = (tool, permission) => {
-    const decorated = Object.freeze({});
-    runtimes.set(decorated, { ...runtimeOf(tool), permission });
-    return decorated;
-};
-export const permission = (tool, name) => runtimeOf(tool).permission ?? name;
-export const definition = (name, tool) => runtimeOf(tool).definition(name);
-export const settle = (tool, call, context) => runtimeOf(tool).settle(call, context);
-function runtimeOf(tool) {
-    const runtime = runtimes.get(tool);
-    if (!runtime)
-        throw new TypeError("Invalid Tool value");
-    return runtime;
+export const withPermission = (tool, permission) => ({ ...tool, permission });
+export const permission = (tool, name) => tool.permission ?? name;
+export const definition = (name, tool) => "jsonSchema" in tool
+    ? {
+        name,
+        description: tool.description,
+        inputSchema: tool.jsonSchema,
+        outputSchema: tool.outputSchema,
+    }
+    : {
+        name,
+        description: tool.description,
+        inputSchema: inputJsonSchema(tool.input),
+        outputSchema: outputJsonSchema(tool.structured ?? tool.output),
+    };
+export const settle = (tool, call, context) => Effect.gen(function* () {
+    if ("jsonSchema" in tool) {
+        const output = yield* tool.execute(call.input, context);
+        return { structured: output.structured, content: output.content.map(toModelContent) };
+    }
+    const input = yield* decodeInput(tool.input, call.input);
+    const value = yield* tool.execute(input, context);
+    const output = yield* encodeOutput(tool.output, value);
+    const structured = tool.structured && tool.toStructuredOutput
+        ? yield* encodeOutput(tool.structured, tool.toStructuredOutput({ input, output }))
+        : output;
+    return {
+        structured,
+        content: tool.toModelOutput?.({ input, output }).map(toModelContent) ??
+            (typeof output === "string" ? [{ type: "text", text: output }] : []),
+    };
+});
+function decodeInput(schema, value) {
+    if (Schema.isSchema(schema))
+        return Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new Failure({ message: `Invalid tool input: ${error.message}` })));
+    return validateStandard(schema, value, "Invalid tool input");
+}
+function encodeOutput(schema, value) {
+    if (Schema.isSchema(schema))
+        return Schema.encodeEffect(schema)(value).pipe(Effect.mapError((error) => new Failure({ message: `Tool returned an invalid value for its output schema: ${error.message}` })));
+    return validateStandard(schema, value, "Tool returned an invalid value for its output schema");
+}
+function validateStandard(schema, value, prefix) {
+    return Effect.gen(function* () {
+        const pending = yield* Effect.try({
+            try: () => schema["~standard"].validate(value),
+            catch: (error) => standardFailure(prefix, error),
+        });
+        const result = pending instanceof Promise
+            ? yield* Effect.tryPromise({ try: () => pending, catch: (error) => standardFailure(prefix, error) })
+            : pending;
+        if (result.issues)
+            return yield* Effect.fail(new Failure({ message: `${prefix}: ${result.issues.map((issue) => issue.message).join(", ")}` }));
+        return result.value;
+    });
+}
+function standardFailure(prefix, error) {
+    return new Failure({ message: `${prefix}: ${error instanceof Error ? error.message : String(error)}` });
+}
+function inputJsonSchema(schema) {
+    if (!Schema.isSchema(schema))
+        return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+    return toJsonSchema(schema);
+}
+function outputJsonSchema(schema) {
+    if (!Schema.isSchema(schema))
+        return schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+    return toJsonSchema(schema);
 }
 function toJsonSchema(schema) {
     const document = Schema.toJsonSchemaDocument(schema);

package/dist/v2/promise/tool.d.ts

@@ -1,8 +1,4 @@
 import type { Tool } from "../effect/tool.js";
-import type { Agent } from "@opencode-ai/schema/agent";
-import type { Session } from "@opencode-ai/schema/session";
-import type { SessionMessage } from "@opencode-ai/schema/session-message";
-import type { JsonSchema, Schema } from "effect";
 import type { Hooks, Transform } from "./registration.js";
 export type Context = Omit<Tool.Context, "progress"> & {
     readonly progress: (update: Tool.Progress) => Promise<void>;
@@ -10,56 +6,20 @@ export type Context = Omit<Tool.Context, "progress"> & {
 export type SchemaType<A> = Tool.SchemaType<A>;
 export type Content = Tool.Content;
 export type DynamicOutput = Tool.DynamicOutput;
-export type Definition<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output> = {
+export type Definition<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output> = Omit<Tool.Definition<Input, Structured, Output>, "execute" | "permission"> & {
     readonly name: string;
     readonly options?: RegisterOptions;
-    readonly description: string;
-    readonly input: Input;
-    readonly output: Output;
-    readonly structured?: Structured;
-    readonly toStructuredOutput?: (input: {
-        readonly input: Schema.Schema.Type<Input>;
-        readonly output: Output["Encoded"];
-    }) => Schema.Schema.Type<Structured>;
-    readonly execute: (input: Schema.Schema.Type<Input>, context: Context) => Promise<Schema.Schema.Type<Output>>;
-    readonly toModelOutput?: (input: {
-        readonly input: Schema.Schema.Type<Input>;
-        readonly output: Output["Encoded"];
-    }) => ReadonlyArray<Content>;
+    readonly execute: (input: Tool.InputValue<Input>, context: Context) => Promise<Tool.OutputValue<Output>>;
 };
-export type DynamicDefinition = {
+export type DynamicDefinition = Omit<Tool.DynamicDefinition, "execute" | "permission"> & {
     readonly name: string;
     readonly options?: RegisterOptions;
-    readonly description: string;
-    readonly jsonSchema: JsonSchema.JsonSchema;
-    readonly outputSchema?: JsonSchema.JsonSchema;
     readonly execute: (input: unknown, context: Context) => Promise<DynamicOutput>;
 };
 export type AnyTool = Definition<any, any, any> | DynamicDefinition;
-export interface ToolExecuteBeforeEvent {
-    readonly tool: string;
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly messageID: SessionMessage.ID;
-    readonly callID: string;
-    input: unknown;
-}
-export interface ToolExecuteAfterEvent {
-    readonly tool: string;
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly messageID: SessionMessage.ID;
-    readonly callID: string;
-    readonly input: unknown;
-    result: Tool.ToolExecuteAfterEvent["result"];
-    output?: Tool.ToolExecuteAfterEvent["output"];
-    outputPaths?: ReadonlyArray<string>;
-}
-export interface RegisterOptions {
-    readonly group?: string;
-    /** Defaults to true. False exposes the tool directly to the provider. */
-    readonly codemode?: boolean;
-}
+export type ToolExecuteBeforeEvent = Tool.ToolExecuteBeforeEvent;
+export type ToolExecuteAfterEvent = Tool.ToolExecuteAfterEvent;
+export type RegisterOptions = Tool.RegisterOptions;
 export interface ToolDraft {
     add<Input extends SchemaType<any>, Output extends SchemaType<any>, Structured extends SchemaType<any> = Output>(tool: Definition<Input, Output, Structured>): void;
     add(tool: DynamicDefinition): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/plugin",
-  "version": "0.0.0-next-15632",
+  "version": "0.0.0-next-15634",
   "type": "module",
   "license": "MIT",
   "scripts": {
@@ -52,10 +52,11 @@
   ],
   "dependencies": {
     "@ai-sdk/provider": "3.0.8",
-    "@opencode-ai/ai": "0.0.0-next-15632",
-    "@opencode-ai/client": "0.0.0-next-15632",
-    "@opencode-ai/schema": "0.0.0-next-15632",
-    "@opencode-ai/sdk": "0.0.0-next-15632",
+    "@opencode-ai/ai": "0.0.0-next-15634",
+    "@opencode-ai/client": "0.0.0-next-15634",
+    "@opencode-ai/schema": "0.0.0-next-15634",
+    "@opencode-ai/sdk": "0.0.0-next-15634",
+    "@standard-schema/spec": "^1.1.0",
     "effect": "4.0.0-beta.83",
     "zod": "4.1.8"
   },