@opencode-ai/plugin 0.0.0-dev-202608272023 → 0.0.0-dev-18430

package/dist/{v2/effect → promise}/reference.d.ts

@@ -1,10 +1,12 @@
-import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/sdk/v2/types";
-import type { Hooks } from "./registration.js";
+import type { ReferenceApi } from "@opencode-ai/client/promise/api";
+import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/client";
+import type { Transform } from "./registration.js";
 export interface ReferenceDraft {
     add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void;
     remove(name: string): void;
     list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[];
 }
-export type ReferenceHooks = Hooks<{
-    transform: ReferenceDraft;
-}>;
+export interface ReferenceDomain extends ReferenceApi {
+    readonly transform: Transform<ReferenceDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/registration.d.ts

@@ -0,0 +1,12 @@
+export interface Registration {
+    readonly dispose: () => Promise<void>;
+}
+export interface ModelHookOptions {
+    /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+    readonly providerID?: string;
+}
+export type Hooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void) => Promise<Registration>;
+export type ModelHooks<Spec> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Promise<void> | void, options?: Spec[Name] extends {
+    readonly model: unknown;
+} ? ModelHookOptions : never) => Promise<Registration>;
+export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>;

package/dist/promise/session.d.ts

@@ -0,0 +1,61 @@
+import type { SessionApi } from "@opencode-ai/client/promise/api";
+import type { GenerationOptionsFields, Message, SystemPart } from "@opencode-ai/ai";
+import type { Agent } from "@opencode-ai/schema/agent";
+import type { Model } from "@opencode-ai/schema/model";
+import type { PromptInput } from "@opencode-ai/schema/prompt-input";
+import type { Session } from "@opencode-ai/schema/session";
+import type { SessionInbox } from "@opencode-ai/schema/session-inbox";
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import type { JsonSchema, Types } from "effect";
+import type { ModelHooks } from "./registration.js";
+export interface SessionPrompt {
+    readonly sessionID: Session.ID;
+    readonly messageID: SessionMessage.ID;
+    prompt: Types.DeepMutable<PromptInput.Prompt>;
+    metadata?: Record<string, unknown>;
+    delivery: SessionInbox.Delivery;
+}
+export interface SessionContext {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    system: Array<SystemPart>;
+    messages: Array<Message>;
+    tools: Record<string, {
+        description: string;
+        input: JsonSchema.JsonSchema;
+    }>;
+    /** Request overrides; unset fields retain route and model defaults. */
+    generation: Types.DeepMutable<GenerationOptionsFields>;
+    providerOptions: Record<string, unknown>;
+}
+export interface SessionModelRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    baseURL?: string;
+    headers: Record<string, string>;
+}
+export interface SessionHttpRequest {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    request: Request;
+}
+export interface SessionHttpResponse {
+    readonly sessionID: Session.ID;
+    readonly agent: Agent.ID;
+    readonly model: Model.Ref;
+    readonly request: Request;
+    response: Response;
+}
+export interface SessionHooks {
+    readonly prompt: SessionPrompt;
+    readonly context: SessionContext;
+    readonly "model.request": SessionModelRequest;
+    readonly "http.request": SessionHttpRequest;
+    readonly "http.response": SessionHttpResponse;
+}
+export type SessionDomain = Pick<SessionApi, "create" | "get" | "switchAgent" | "switchModel" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "move" | "wait" | "context"> & {
+    readonly hook: ModelHooks<SessionHooks>;
+};

package/dist/promise/shell.d.ts

@@ -0,0 +1,14 @@
+import type { Hooks } from "./registration.js";
+export interface ShellCreateBefore {
+    command: string;
+    cwd: string;
+    timeout: number;
+    shell: string;
+    env: Record<string, string | undefined>;
+}
+export interface ShellHooks {
+    readonly "create.before": ShellCreateBefore;
+}
+export interface ShellDomain {
+    readonly hook: Hooks<ShellHooks>;
+}

package/dist/promise/skill.d.ts

@@ -0,0 +1,14 @@
+import type { SkillApi } from "@opencode-ai/client/promise/api";
+import type { Skill } from "@opencode-ai/schema/skill";
+import type { Transform } from "./registration.js";
+import type { DeepMutable } from "./types.js";
+export interface SkillDraft {
+    list(): readonly DeepMutable<Skill.Info>[];
+    add(skill: Skill.Info): void;
+    update(id: string, update: (skill: DeepMutable<Skill.Info>) => void): void;
+    remove(id: string): void;
+}
+export interface SkillDomain extends SkillApi {
+    readonly transform: Transform<SkillDraft>;
+    readonly reload: () => Promise<void>;
+}

package/dist/promise/storage.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from "effect";
+import type { StorageScanOptions, StorageScanResult } from "../storage.js";
+export interface StorageDomain {
+    readonly get: (key: string) => Promise<Schema.Json | undefined>;
+    readonly set: (key: string, value: Schema.Json) => Promise<void>;
+    readonly remove: (key: string) => Promise<void>;
+    readonly scan: (options: StorageScanOptions) => Promise<StorageScanResult>;
+}

package/dist/promise/tool.d.ts

@@ -0,0 +1,55 @@
+export { CallID, Error } from "@opencode-ai/schema/tool";
+export type { Metadata, Options, Result } from "@opencode-ai/schema/tool";
+import { Tool } from "@opencode-ai/schema/tool";
+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 { Types } from "effect";
+import type { Hooks, Transform } from "./registration.js";
+export interface ToolContext extends Omit<Tool.Context, "progress"> {
+    readonly progress: (update: Tool.Metadata) => Promise<void>;
+}
+export type Info<Input extends Tool.ValueSchema<any> = Tool.ValueSchema<any>, Output extends Tool.ValueSchema<any> | undefined = Tool.ValueSchema<any> | undefined> = Omit<Tool.Info<Input, Output>, "execute"> & {
+    readonly execute: (input: Parameters<Tool.Info<Input, Output>["execute"]>[0], context: ToolContext) => Promise<Tool.Result<Output>>;
+};
+interface ToolDraft {
+    list(): readonly (Info & {
+        readonly id: string;
+    })[];
+    get(id: string): (Info & {
+        readonly id: string;
+    }) | undefined;
+    add<Input extends Tool.ValueSchema<any>, Output extends Tool.ValueSchema<any> | undefined>(tool: Info<Input, Output>): void;
+    /** Updates an existing tool; missing IDs are ignored. */
+    update(id: string, update: (tool: Types.Mutable<Info>) => void): void;
+    remove(id: string): void;
+}
+interface ToolHooks {
+    readonly "execute.before": {
+        tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        input: unknown;
+    };
+    readonly "execute.after": {
+        readonly tool: string;
+        readonly sessionID: Session.ID;
+        readonly agent: Agent.ID;
+        readonly messageID: SessionMessage.ID;
+        readonly id: Tool.CallID;
+        readonly input: unknown;
+    } & ({
+        readonly status: "completed";
+        result: Tool.Result;
+    } | {
+        readonly status: "error";
+        error: Tool.Error;
+    });
+}
+export interface ToolDomain {
+    readonly transform: Transform<ToolDraft>;
+    readonly reload: () => Promise<void>;
+    readonly hook: Hooks<ToolHooks>;
+}

package/dist/promise/tool.js

@@ -0,0 +1,2 @@
+export { CallID, Error } from "@opencode-ai/schema/tool";
+import { Tool } from "@opencode-ai/schema/tool";

package/dist/promise/types.d.ts

@@ -0,0 +1,3 @@
+export type DeepMutable<A> = A extends (...args: never[]) => unknown ? A : A extends ReadonlyMap<infer K, infer V> ? Map<DeepMutable<K>, DeepMutable<V>> : A extends ReadonlyArray<infer I> ? DeepMutable<I>[] : A extends object ? {
+    -readonly [K in keyof A]: DeepMutable<A[K]>;
+} : A;

package/dist/promise/vcs.d.ts

@@ -0,0 +1,46 @@
+import type { VcsApi } from "@opencode-ai/client/promise/api";
+import type { FileDiff } from "@opencode-ai/schema/file-diff";
+import type { Vcs } from "@opencode-ai/schema/vcs";
+import type { Transform } from "./registration.js";
+export interface VcsScope {
+    readonly directory: string;
+    readonly worktree: string;
+    readonly canonical: string;
+    readonly store?: string;
+}
+export interface VcsBranchesInput extends VcsScope {
+    readonly search?: string;
+    readonly limit?: number;
+}
+export interface VcsDiffInput extends VcsScope {
+    readonly mode: Vcs.Mode;
+    readonly context: number;
+    readonly maxOutputBytes: number;
+}
+export interface VcsDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly info: (input: VcsScope, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<Vcs.Info>;
+    readonly branches: (input: VcsBranchesInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<Vcs.BranchList>;
+    readonly status: (input: VcsScope, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly Vcs.FileStatus[]>;
+    readonly diff: (input: VcsDiffInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly FileDiff.Info[]>;
+}
+export interface VcsDomain extends VcsApi {
+    readonly transform: Transform<VcsDraft>;
+    readonly reload: () => Promise<void>;
+}
+export interface VcsDraft {
+    add(definition: VcsDefinition): void;
+    readonly default: {
+        get(): string | undefined;
+        set(selection: string): void;
+    };
+}

package/dist/promise/websearch.d.ts

@@ -0,0 +1,21 @@
+import type { WebSearch } from "@opencode-ai/schema/websearch";
+import type { WebSearchApi } from "@opencode-ai/client/promise/api";
+import type { Transform } from "./registration.js";
+export interface WebSearchDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly execute: (input: WebSearch.ProviderInput, context: {
+        readonly signal: AbortSignal;
+    }) => Promise<readonly WebSearch.Result[]>;
+}
+export interface WebSearchDomain extends WebSearchApi {
+    readonly transform: Transform<WebSearchDraft>;
+    readonly reload: () => Promise<void>;
+}
+export interface WebSearchDraft {
+    add(definition: WebSearchDefinition): void;
+    readonly default: {
+        get(): string | false | undefined;
+        set(selection: string | false): void;
+    };
+}

package/dist/storage.d.ts

@@ -0,0 +1,14 @@
+import type { Schema } from "effect";
+export interface StorageEntry {
+    readonly key: string;
+    readonly value: Schema.Json;
+}
+export interface StorageScanOptions {
+    readonly prefix: string;
+    readonly after?: string;
+    readonly limit?: number;
+}
+export interface StorageScanResult {
+    readonly entries: readonly StorageEntry[];
+    readonly next?: string;
+}