@opencode-ai/plugin 0.0.0-next-16233 → 0.0.0-next-16273

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

@@ -1,177 +0,0 @@
-import { Agent } from "@opencode-ai/schema/agent";
-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";
-/** A JSON-compatible value. Tool metadata and encoded outputs must be JSON. */
-export type JsonValue = typeof Schema.Json.Type;
-/** Compact JSON metadata for tool-specific UI and client behavior. */
-export type Metadata = Readonly<Record<string, JsonValue>>;
-export interface Context {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly messageID: SessionMessage.ID;
-    readonly callID: string;
-    readonly progress: (update: Progress) => Effect.Effect<void>;
-}
-/** Live replacement metadata for a running tool. */
-export type Progress = Metadata;
-export type StandardSchemaType<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
-export type SchemaType<A = unknown> = Schema.Codec<A, any> | StandardSchemaType<any, A> | JsonSchema.JsonSchema;
-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 : unknown;
-export type OutputValue<S> = IsAny<S> extends true ? any : S extends Schema.Codec<infer A, any> ? A : S extends StandardSchemaV1<infer A, any> ? A : unknown;
-export type EncodedValue<S> = IsAny<S> extends true ? any : S extends Schema.Codec<any, infer A> ? A : S extends StandardSchemaV1<any, infer A> ? A : unknown;
-type ToolDefinition = {
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: JsonSchema.JsonSchema;
-    readonly outputSchema?: JsonSchema.JsonSchema;
-};
-declare const Failure_base: Schema.Class<Failure, Schema.TaggedStruct<"LLM.ToolFailure", {
-    readonly message: Schema.String;
-    readonly error: Schema.optional<Schema.Defect>;
-}>, import("effect/Cause").YieldableError>;
-export declare class Failure extends Failure_base {
-}
-declare const RegistrationError_base: Schema.Class<RegistrationError, Schema.TaggedStruct<"Tool.RegistrationError", {
-    readonly name: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class RegistrationError extends RegistrationError_base {
-}
-export type Content = {
-    readonly type: "text";
-    readonly text: string;
-} | {
-    readonly type: "file";
-    readonly data: string;
-    readonly mime: string;
-    readonly name?: string;
-};
-/** Model-facing tool content: plain text or non-empty rich content. */
-export type ModelOutput = string | readonly [Content, ...Content[]];
-type BaseTool<Input extends SchemaType<any>> = {
-    readonly description: string;
-    readonly input: Input;
-};
-export type Response<Output extends SchemaType<any>> = {
-    readonly output: OutputValue<Output>;
-    readonly content?: ModelOutput;
-    readonly metadata?: Metadata;
-};
-export type ContentResponse = {
-    readonly content: ModelOutput;
-    readonly metadata?: Metadata;
-};
-export type Tool<Input extends SchemaType<any>, Output extends SchemaType<any> | undefined = undefined> = BaseTool<Input> & (Output extends SchemaType<any> ? {
-    readonly output: Output;
-    readonly execute: (input: InputValue<Input>, context: Context) => Effect.Effect<Response<Output>, Failure>;
-} : {
-    readonly output?: undefined;
-    readonly execute: (input: InputValue<Input>, context: Context) => Effect.Effect<ContentResponse, Failure>;
-});
-export type Any = BaseTool<any> & {
-    readonly output?: SchemaType<any>;
-    readonly execute: (input: any, context: Context) => Effect.Effect<Response<any> | ContentResponse, Failure>;
-};
-export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>>(config: Tool<Input, Output>): Tool<Input, Output>;
-export declare function make<Input extends SchemaType<any>>(config: Tool<Input>): Tool<Input>;
-export declare function make(config: Any): Any;
-export interface RegisterOptions {
-    readonly namespace?: string;
-    /** Defaults to true. False exposes the tool directly to the provider. */
-    readonly codemode?: boolean;
-    /** Permission action used for whole-tool visibility filtering. */
-    readonly permission?: string;
-}
-export interface Registration {
-    readonly tool: Any;
-    readonly name: string;
-    readonly namespace?: string;
-    readonly permission: string;
-}
-export declare const validateName: (name: string) => Effect.Effect<void, never, never> | Effect.Effect<never, RegistrationError, never>;
-export declare const registrationEntries: (tools: Readonly<Record<string, Any>>, options?: RegisterOptions) => Array<Registration & {
-    readonly key: string;
-}>;
-export declare const validateNamespace: (namespace: string) => Effect.Effect<void, never, never> | Effect.Effect<never, RegistrationError, never>;
-export declare const toLLMDefinition: (name: string, tool: Any) => ToolDefinition;
-export declare function decodeInput(schema: SchemaType<any>, value: unknown): Effect.Effect<any, Failure>;
-export declare function encodeOutput(schema: SchemaType<any>, value: unknown): Effect.Effect<any, Failure>;
-export interface ToolExecuteBeforeEvent {
-    readonly tool: string;
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly messageID: SessionMessage.ID;
-    readonly callID: string;
-    input: unknown;
-}
-type ToolHookBase = {
-    readonly tool: string;
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly messageID: SessionMessage.ID;
-    readonly callID: string;
-    readonly input: unknown;
-};
-export declare const ExecuteAfterOutcome: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
-    readonly status: Schema.Literal<"completed">;
-    readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly text: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"file">;
-        readonly uri: Schema.String;
-        readonly mime: Schema.String;
-        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>]>>;
-    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly outputPaths: Schema.optional<Schema.$Array<Schema.String>>;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"error">;
-    readonly error: Schema.Struct<{
-        readonly type: Schema.String;
-        readonly message: Schema.String;
-    }>;
-    readonly content: Schema.optional<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly text: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"file">;
-        readonly uri: Schema.String;
-        readonly mime: Schema.String;
-        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>]>>>;
-    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly outputPaths: Schema.optional<Schema.$Array<Schema.String>>;
-}>]>;
-type Mutable<A> = {
-    -readonly [K in keyof A]: A[K];
-};
-type HookOutcome<A extends {
-    readonly status: string;
-}> = Omit<Mutable<A>, "status"> & Pick<A, "status">;
-/** The bounded terminal outcome exposed to tool hooks. */
-export type Outcome = typeof ExecuteAfterOutcome.Type extends infer A ? A extends {
-    readonly status: string;
-} ? HookOutcome<A> : never : never;
-/**
- * The canonical execution outcome as seen by `execute.after` hooks. Hooks
- * observe bounded model content, optional metadata, and managed output paths;
- * they never observe the raw domain output.
- */
-export type ToolExecuteAfterEvent = ToolHookBase & Outcome;
-export interface ToolDraft {
-    add(name: string, tool: Any, options?: RegisterOptions): void;
-}
-export interface ToolHooks {
-    readonly "execute.before": ToolExecuteBeforeEvent;
-    readonly "execute.after": ToolExecuteAfterEvent;
-}
-export interface ToolDomain {
-    readonly transform: Transform<ToolDraft>;
-    readonly hook: Hooks<ToolHooks>;
-}
-export {};

package/dist/v2/effect/internal/tool.js

@@ -1,108 +0,0 @@
-import { Agent } from "@opencode-ai/schema/agent";
-import { LLM } from "@opencode-ai/schema/llm";
-import { Session } from "@opencode-ai/schema/session";
-import { SessionError } from "@opencode-ai/schema/session-error";
-import { SessionMessage } from "@opencode-ai/schema/session-message";
-import { Effect, JsonSchema, Schema } from "effect";
-export class Failure extends Schema.TaggedErrorClass()("LLM.ToolFailure", {
-    message: Schema.String,
-    error: Schema.optional(Schema.Defect()),
-}) {
-}
-export class RegistrationError extends Schema.TaggedErrorClass()("Tool.RegistrationError", {
-    name: Schema.String,
-    message: Schema.String,
-}) {
-}
-export function make(config) {
-    return config;
-}
-export const validateName = (name) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name)
-    ? Effect.void
-    : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }));
-export const registrationEntries = (tools, options) => Object.entries(tools).map(([name, tool]) => {
-    const normalized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const key = options?.namespace === undefined ? normalized : `${options.namespace.replaceAll(".", "_")}_${normalized}`;
-    return {
-        key,
-        name: normalized,
-        namespace: options?.namespace,
-        tool,
-        permission: options?.permission ?? key,
-    };
-});
-export const validateNamespace = (namespace) => namespace.split(".").every((segment) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(segment))
-    ? Effect.void
-    : Effect.fail(new RegistrationError({ name: namespace, message: `Invalid tool namespace: ${JSON.stringify(namespace)}` }));
-export const toLLMDefinition = (name, tool) => ({
-    name,
-    description: tool.description,
-    inputSchema: inputJsonSchema(tool.input),
-    ...(tool.output === undefined ? {} : { outputSchema: outputJsonSchema(tool.output) }),
-});
-// Schema interpretation
-export 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}` })));
-    if (isStandardSchema(schema))
-        return validateStandard(schema, value, "Invalid tool input");
-    return Effect.succeed(value);
-}
-export 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}` })));
-    if (isStandardSchema(schema))
-        return validateStandard(schema, value, "Tool returned an invalid value for its output schema");
-    return Schema.decodeUnknownEffect(Schema.Json)(value).pipe(Effect.mapError((error) => new Failure({ message: `Tool returned a non-JSON value for its output schema: ${error.message}` })));
-}
-function isStandardSchema(schema) {
-    return "~standard" in 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 (isStandardSchema(schema))
-        return schema["~standard"].jsonSchema.input({ target: "draft-2020-12" });
-    return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
-}
-function outputJsonSchema(schema) {
-    if (isStandardSchema(schema))
-        return schema["~standard"].jsonSchema.output({ target: "draft-2020-12" });
-    return Schema.isSchema(schema) ? toJsonSchema(schema) : schema;
-}
-function toJsonSchema(schema) {
-    const document = Schema.toJsonSchemaDocument(schema);
-    if (Object.keys(document.definitions).length === 0)
-        return document.schema;
-    return { ...document.schema, $defs: document.definitions };
-}
-export const ExecuteAfterOutcome = Schema.Union([
-    Schema.Struct({
-        status: Schema.Literal("completed"),
-        content: Schema.NonEmptyArray(LLM.ToolContent),
-        metadata: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
-        outputPaths: Schema.optional(Schema.Array(Schema.String)),
-    }),
-    Schema.Struct({
-        status: Schema.Literal("error"),
-        error: SessionError.Error,
-        content: Schema.optional(Schema.NonEmptyArray(LLM.ToolContent)),
-        metadata: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
-        outputPaths: Schema.optional(Schema.Array(Schema.String)),
-    }),
-]).pipe(Schema.toTaggedUnion("status"));

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

@@ -1,6 +0,0 @@
-export interface Location {
-    readonly directory: string;
-    readonly project: {
-        readonly directory: string;
-    };
-}

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

@@ -1,7 +0,0 @@
-import type { Effect } from "effect";
-export interface Npm {
-    add(pkg: string): Effect.Effect<{
-        readonly directory: string;
-        readonly entrypoint?: string;
-    }, unknown>;
-}

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

@@ -1,8 +0,0 @@
-export interface Path {
-    readonly home: string;
-    readonly data: string;
-    readonly cache: string;
-    readonly config: string;
-    readonly state: string;
-    readonly temp: string;
-}

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

@@ -1,2 +0,0 @@
-export * as Tool from "./internal/tool.js";
-export * from "./internal/tool.js";

package/dist/v2/effect/tool.js

@@ -1,2 +0,0 @@
-export * as Tool from "./internal/tool.js";
-export * from "./internal/tool.js";

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

@@ -1,10 +0,0 @@
-import type { AgentApi } from "@opencode-ai/client/promise/api";
-import type { AgentDraft } from "../effect/agent.js";
-import type { Transform } from "./registration.js";
-export type { AgentDraft };
-export interface AgentDomain extends AgentApi {
-    readonly get: (id: string) => Promise<AgentGetOutput | undefined>;
-    readonly transform: Transform<AgentDraft>;
-    readonly reload: () => Promise<void>;
-}
-type AgentGetOutput = Awaited<ReturnType<AgentApi["list"]>>["data"][number];

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

@@ -1,12 +0,0 @@
-import type { CatalogApi } from "@opencode-ai/client/promise/api";
-import type { CatalogDraft, CatalogProviderRecord } from "../effect/catalog.js";
-import type { Transform } from "./registration.js";
-export type { CatalogDraft, CatalogProviderRecord };
-export interface CatalogDomain extends CatalogApi {
-    readonly model: CatalogApi["model"] & {
-        readonly get: (providerID: string, modelID: string) => Promise<ModelGetOutput | undefined>;
-    };
-    readonly transform: Transform<CatalogDraft>;
-    readonly reload: () => Promise<void>;
-}
-type ModelGetOutput = Awaited<ReturnType<CatalogApi["model"]["list"]>>["data"][number];

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

@@ -1,8 +0,0 @@
-import type { CommandApi } from "@opencode-ai/client/promise/api";
-import type { CommandDraft } from "../effect/command.js";
-import type { Transform } from "./registration.js";
-export type { CommandDraft };
-export interface CommandDomain extends CommandApi {
-    readonly transform: Transform<CommandDraft>;
-    readonly reload: () => Promise<void>;
-}

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

@@ -1,24 +0,0 @@
-import type { IntegrationApi } from "@opencode-ai/client/promise/api";
-import type { IntegrationDraft, IntegrationMethodRegistration } from "../effect/integration.js";
-import type { CredentialOAuth, CredentialValue } from "@opencode-ai/sdk/v2/types";
-import type { Transform } from "./registration.js";
-export type { IntegrationDraft, IntegrationMethodRegistration };
-export type IntegrationOAuthAuthorization = {
-    readonly url: string;
-    readonly instructions: string;
-    readonly expiresAt?: number;
-} & ({
-    readonly mode: "auto";
-    readonly callback: Promise<CredentialOAuth>;
-} | {
-    readonly mode: "code";
-    readonly callback: (code: string) => Promise<CredentialOAuth>;
-});
-export interface IntegrationDomain extends Omit<IntegrationApi, "wellknown"> {
-    readonly transform: Transform<IntegrationDraft>;
-    readonly reload: () => Promise<void>;
-    readonly connection: {
-        readonly active: (integrationID: string) => Promise<import("@opencode-ai/sdk/v2/types").ConnectionInfo | undefined>;
-        readonly resolve: (connection: import("@opencode-ai/sdk/v2/types").ConnectionInfo) => Promise<CredentialValue | undefined>;
-    };
-}

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

@@ -1,32 +0,0 @@
-import type { Hooks, Transform } from "../registration.js";
-export type Context = Omit<import("../../effect/internal/tool.js").Context, "progress"> & {
-    readonly progress: (update: import("../../effect/internal/tool.js").Progress) => Promise<void>;
-};
-export type SchemaType<A> = import("../../effect/internal/tool.js").SchemaType<A>;
-export type Content = import("../../effect/internal/tool.js").Content;
-export type Metadata = import("../../effect/internal/tool.js").Metadata;
-export type ModelOutput = import("../../effect/internal/tool.js").ModelOutput;
-export type Tool<Input extends SchemaType<any>, Output extends SchemaType<any> | undefined = undefined> = Omit<import("../../effect/internal/tool.js").Tool<Input, Output>, "execute"> & {
-    readonly execute: (input: import("../../effect/internal/tool.js").InputValue<Input>, context: Context) => Promise<Output extends SchemaType<any> ? import("../../effect/internal/tool.js").Response<Output> : import("../../effect/internal/tool.js").ContentResponse>;
-};
-export type Any = Omit<import("../../effect/internal/tool.js").Any, "execute"> & {
-    readonly execute: (input: any, context: Context) => Promise<import("../../effect/internal/tool.js").Response<any> | import("../../effect/internal/tool.js").ContentResponse>;
-};
-export declare function make<Input extends SchemaType<any>, Output extends SchemaType<any>>(tool: Tool<Input, Output>): Tool<Input, Output>;
-export declare function make<Input extends SchemaType<any>>(tool: Tool<Input>): Tool<Input>;
-export declare function make(tool: Any): Any;
-export type ToolExecuteBeforeEvent = import("../../effect/internal/tool.js").ToolExecuteBeforeEvent;
-export type ToolExecuteAfterEvent = import("../../effect/internal/tool.js").ToolExecuteAfterEvent;
-export type RegisterOptions = import("../../effect/internal/tool.js").RegisterOptions;
-export interface ToolDraft {
-    add<Input extends SchemaType<any>, Output extends SchemaType<any>>(name: string, tool: Tool<Input, Output>, options?: RegisterOptions): void;
-    add<Input extends SchemaType<any>>(name: string, tool: Tool<Input>, options?: RegisterOptions): void;
-}
-export interface ToolHooks {
-    readonly "execute.before": ToolExecuteBeforeEvent;
-    readonly "execute.after": ToolExecuteAfterEvent;
-}
-export interface ToolDomain {
-    readonly transform: Transform<ToolDraft>;
-    readonly hook: Hooks<ToolHooks>;
-}

package/dist/v2/promise/internal/tool.js

@@ -1,3 +0,0 @@
-export function make(tool) {
-    return tool;
-}

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

@@ -1,8 +0,0 @@
-import type { ReferenceApi } from "@opencode-ai/client/promise/api";
-import type { ReferenceDraft } from "../effect/reference.js";
-import type { Transform } from "./registration.js";
-export type { ReferenceDraft };
-export interface ReferenceDomain extends ReferenceApi {
-    readonly transform: Transform<ReferenceDraft>;
-    readonly reload: () => Promise<void>;
-}

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

@@ -1,2 +0,0 @@
-export * as Tool from "./internal/tool.js";
-export * from "./internal/tool.js";

package/dist/v2/promise/tool.js

@@ -1,2 +0,0 @@
-export * as Tool from "./internal/tool.js";
-export * from "./internal/tool.js";