@opencode-ai/client 0.0.0-dev-18706 → 0.0.0-dev-18708

package/dist/promise/generated/types.d.ts

@@ -27,6 +27,17 @@ export type PluginSource = {
 } | {
     type: "sdk";
 };
+export type PluginFeatures = {
+    server?: true;
+    tui?: true;
+    rpc?: true;
+};
+export type PluginState = {
+    status: "active";
+} | {
+    status: "failed";
+    error: string;
+};
 export type SessionForkBoundary = {
     type: "before";
     messageID: string;
@@ -504,6 +515,9 @@ export type SkillInfo = {
     location: string;
     content: string;
 };
+export type RpcOutput = {
+    output?: any;
+};
 export type PermissionReply = "once" | "always" | "reject";
 export type Pty = {
     id: string;
@@ -669,16 +683,10 @@ export type PermissionRule = {
     effect: PermissionEffect;
 };
 export type PluginInfo = {
-    id: string;
-    source: PluginSource;
-    status: "active";
-    tui: boolean;
-} | {
     id?: string;
     source: PluginSource;
-    status: "failed";
-    error: string;
-    tui: boolean;
+    features: PluginFeatures;
+    state: PluginState;
 };
 export type SessionMessageLocationSwitched = {
     id: string;
@@ -703,6 +711,18 @@ export type SessionInboxMovePayload = {
     projectID: string;
     subpath?: string;
 };
+export type V2EventRpc = {
+    id: string;
+    created: number;
+    metadata?: {
+        [x: string]: any;
+    } | undefined;
+    type: `${"rpc."}${string}`;
+    location: LocationRef;
+    data: {
+        [x: string]: any;
+    };
+};
 export type V2EventServerConnected = {
     id: string;
     metadata?: {
@@ -3105,7 +3125,7 @@ export type IntegrationInfo = {
     methods: Array<IntegrationMethod>;
     connections: Array<ConnectionInfo>;
 };
-export type V2Event = ModelsDevRefreshed | CredentialUpdated | CredentialSwitched | IntegrationUpdated | CatalogUpdated | AgentUpdated | SessionCreated | SessionAgentSelected | SessionModelSelected | SessionMoved | SessionRenamed | SessionViewed | SessionUsageUpdated | SessionDeleted | SessionForked | SessionInboxDelivered | SessionInboxEnqueued | SessionInboxCancelled | SessionInboxDeliveryChanged | SessionExecutionStarted | SessionExecutionSucceeded | SessionExecutionFailed | SessionExecutionInterrupted | SessionInstructionsUpdated | SessionSynthetic | SessionSkillActivated | SessionShellStarted | SessionShellEnded | SessionStepStarted | SessionStepStreamed | SessionStepEnded | SessionStepFailed | SessionTextStarted | SessionTextDelta | SessionTextEnded | SessionReasoningStarted | SessionReasoningDelta | SessionReasoningEnded | SessionToolInputStarted | SessionToolInputDelta | SessionToolInputEnded | SessionToolCalled | SessionToolProgress | SessionToolSuccess | SessionToolFailed | SessionRetryScheduled | SessionCompactionStarted | SessionCompactionDelta | SessionCompactionEnded | SessionCompactionFailed | SessionRevertStaged | SessionRevertCleared | SessionRevertCommitted | SessionMessageContentUpdated | FilesystemChanged | ReferenceUpdated | PermissionAsked | PermissionReplied | PluginAdded | PluginUpdated | ProjectUpdated | WorktreeUpdated | WorktreeResolved | CommandUpdated | ConfigUpdated | SkillUpdated | PtyCreated | PtyUpdated | PtyExited | PtyDeleted | PersistentPtyAdded | PersistentPtyRemoved | ShellCreated | ShellExited | ShellDeleted | FormCreated | FormReplied | FormCancelled | WebsearchUpdated | SessionStatusUpdated | SessionIdle | TuiPromptAppend | TuiCommandExecute | TuiToastShow | TuiSessionSelect | InstallationUpdated | InstallationUpdateAvailable | VcsBranchUpdated | McpStatusChanged | McpResourcesChanged | V2EventServerConnected;
+export type V2Event = ModelsDevRefreshed | CredentialUpdated | CredentialSwitched | IntegrationUpdated | CatalogUpdated | AgentUpdated | SessionCreated | SessionAgentSelected | SessionModelSelected | SessionMoved | SessionRenamed | SessionViewed | SessionUsageUpdated | SessionDeleted | SessionForked | SessionInboxDelivered | SessionInboxEnqueued | SessionInboxCancelled | SessionInboxDeliveryChanged | SessionExecutionStarted | SessionExecutionSucceeded | SessionExecutionFailed | SessionExecutionInterrupted | SessionInstructionsUpdated | SessionSynthetic | SessionSkillActivated | SessionShellStarted | SessionShellEnded | SessionStepStarted | SessionStepStreamed | SessionStepEnded | SessionStepFailed | SessionTextStarted | SessionTextDelta | SessionTextEnded | SessionReasoningStarted | SessionReasoningDelta | SessionReasoningEnded | SessionToolInputStarted | SessionToolInputDelta | SessionToolInputEnded | SessionToolCalled | SessionToolProgress | SessionToolSuccess | SessionToolFailed | SessionRetryScheduled | SessionCompactionStarted | SessionCompactionDelta | SessionCompactionEnded | SessionCompactionFailed | SessionRevertStaged | SessionRevertCleared | SessionRevertCommitted | SessionMessageContentUpdated | FilesystemChanged | ReferenceUpdated | PermissionAsked | PermissionReplied | PluginAdded | PluginUpdated | ProjectUpdated | WorktreeUpdated | WorktreeResolved | CommandUpdated | ConfigUpdated | SkillUpdated | PtyCreated | PtyUpdated | PtyExited | PtyDeleted | PersistentPtyAdded | PersistentPtyRemoved | ShellCreated | ShellExited | ShellDeleted | FormCreated | FormReplied | FormCancelled | WebsearchUpdated | SessionStatusUpdated | SessionIdle | TuiPromptAppend | TuiCommandExecute | TuiToastShow | TuiSessionSelect | InstallationUpdated | InstallationUpdateAvailable | VcsBranchUpdated | McpStatusChanged | McpResourcesChanged | V2EventRpc | V2EventServerConnected;
 export type SessionLogItem = SessionEventDurable | EventLogSynced;
 export type UnauthorizedError = {
     readonly _tag: "UnauthorizedError";
@@ -3234,6 +3254,20 @@ export type PermissionNotFoundError = {
     readonly message: string;
 };
 export declare const isPermissionNotFoundError: (value: unknown) => value is PermissionNotFoundError;
+export type RpcError = {
+    readonly _tag: "RpcError";
+    readonly type: string;
+    readonly message: string;
+    readonly data?: unknown | undefined;
+};
+export declare const isRpcError: (value: unknown) => value is RpcError;
+export type RpcInternalError = {
+    readonly _tag: "RpcInternalError";
+    readonly type: "rpc.internal" | "rpc.invalid_output";
+    readonly message: string;
+    readonly data?: unknown | undefined;
+};
+export declare const isRpcInternalError: (value: unknown) => value is RpcInternalError;
 export type PtyNotFoundError = {
     readonly _tag: "PtyNotFoundError";
     readonly ptyID: string;
@@ -7637,6 +7671,26 @@ export type SkillListOutput = {
     };
     data: Array<SkillInfo>;
 };
+export type RpcCallInput = {
+    readonly rpcID: {
+        readonly rpcID: string;
+        readonly method: string;
+    }["rpcID"];
+    readonly method: {
+        readonly rpcID: string;
+        readonly method: string;
+    }["method"];
+    readonly location?: {
+        readonly location?: {
+            readonly directory?: string | undefined;
+            readonly workspace?: string | undefined;
+        } | undefined;
+    }["location"];
+    readonly input?: {
+        readonly input: JsonValue;
+    }["input"];
+};
+export type RpcCallOutput = RpcOutput;
 export type EventSubscribeOutput = V2Event;
 export type PtyListInput = {
     readonly location?: {

package/dist/promise/generated/types.js

@@ -22,6 +22,8 @@ export const isFormNotFoundError = (value) => typeof value === "object" && value
 export const isFormAlreadySettledError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormAlreadySettledError";
 export const isFormInvalidAnswerError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormInvalidAnswerError";
 export const isPermissionNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PermissionNotFoundError";
+export const isRpcError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcError";
+export const isRpcInternalError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcInternalError";
 export const isPtyNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PtyNotFoundError";
 export const isForbiddenError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ForbiddenError";
 export const isShellNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError";

package/dist/promise/index.d.ts

@@ -1,4 +1,6 @@
+import type { OpenCode } from "./client.js";
 export * from "./generated/index.js";
-export type { AgentApi, CatalogApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
+export { OpenCode } from "./client.js";
+export type { AgentApi, CatalogApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcCallOptions, RpcClient, RpcEventPayload, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types.js";
-export type OpenCodeClient = ReturnType<typeof import("./generated/client.js").make>;
+export type OpenCodeClient = ReturnType<typeof OpenCode.make>;

package/dist/promise/index.js

@@ -1 +1,2 @@
 export * from "./generated/index.js";
+export { OpenCode } from "./client.js";

package/dist/promise/rpc.d.ts

@@ -0,0 +1,32 @@
+import type { Rpc } from "@opencode-ai/schema/rpc";
+import type { make, RequestOptions } from "./generated/client.js";
+import type { EventSubscribeOutput, LocationGetInput } from "./generated/types.js";
+type RpcEvent = Extract<EventSubscribeOutput, {
+    type: `rpc.${string}`;
+}>;
+export interface RpcCallOptions extends RequestOptions {
+    readonly location?: LocationGetInput["location"];
+}
+export type RpcArguments<Input, Options> = unknown extends Input ? [input: Input, options?: Options] : undefined extends Input ? [input?: Input, options?: Options] : [input: Input, options?: Options];
+export type RpcClient<D extends Rpc.PortableDefinition, Options = RpcCallOptions> = {
+    readonly [Name in keyof D["methods"]]: (...args: RpcArguments<Rpc.Input<D["methods"][Name]["input"]>, Options>) => Promise<Rpc.Output<D["methods"][Name]["output"]>>;
+} & {
+    readonly events: {
+        readonly subscribe: <Name extends keyof D["events"] & string>(name: Name, options?: Pick<RequestOptions, "signal">) => AsyncIterable<RpcEventPayload<D, Name>>;
+        readonly on: <Name extends keyof D["events"] & string>(name: Name, handler: (event: RpcEventPayload<D, Name>) => Promise<void> | void, options?: Pick<RequestOptions, "signal">) => () => void;
+    };
+};
+type RpcEventPayloadFor<D extends Rpc.PortableDefinition, Name extends keyof D["events"] & string> = Omit<RpcEvent, "type" | "data"> & {
+    type: `rpc.${D["id"]}.${Name}`;
+    data: Rpc.EventData<D["events"][Name]["schema"]>;
+};
+export type RpcEventPayload<D extends Rpc.PortableDefinition, Name extends keyof D["events"] & string = keyof D["events"] & string> = {
+    [K in Name]: RpcEventPayloadFor<D, K>;
+}[Name];
+export interface RpcApi<Options = RpcCallOptions> {
+    <D extends Rpc.PortableDefinition>(definition: D): RpcClient<D, Options>;
+}
+export declare function makeRpc(raw: ReturnType<typeof make>, events: {
+    subscribe(options?: Pick<RequestOptions, "signal">): AsyncIterable<EventSubscribeOutput>;
+}): RpcApi;
+export {};

package/dist/promise/rpc.js

@@ -0,0 +1,86 @@
+import { isRpcError, isRpcInternalError } from "./generated/types.js";
+export function makeRpc(raw, events) {
+    return (definition) => {
+        const subscribe = (name, options) => {
+            if (!Object.hasOwn(definition.events, name))
+                throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+            const type = eventType(definition, name);
+            return {
+                [Symbol.asyncIterator]() {
+                    const controller = new AbortController();
+                    const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+                    const iterator = (async function* () {
+                        try {
+                            for await (const published of events.subscribe({ signal })) {
+                                if (signal.aborted)
+                                    return;
+                                if (published.type !== type)
+                                    continue;
+                                // SAFETY: The exact RPC type was selected above; Promise contracts require no client-side transform.
+                                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+                                yield published;
+                            }
+                        }
+                        catch (error) {
+                            if (!signal.aborted)
+                                throw error;
+                        }
+                        finally {
+                            controller.abort();
+                        }
+                    })();
+                    return {
+                        next: () => iterator.next(),
+                        return: () => {
+                            // Interrupt a pending source read before closing the generator.
+                            controller.abort();
+                            return iterator.return();
+                        },
+                    };
+                },
+            };
+        };
+        // SAFETY: Every runtime key comes from this definition's method and event maps, which define RpcClient's mapped keys.
+        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+        return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+            name,
+            async (input, options) => {
+                try {
+                    const result = await raw.rpc.call({
+                        rpcID: definition.id,
+                        method: name,
+                        // SAFETY: The method schema defines the accepted input; this assertion bridges it to the generic JSON transport.
+                        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+                        input: input,
+                        location: options?.location,
+                    }, { signal: options?.signal, headers: options?.headers });
+                    return result.output;
+                }
+                catch (error) {
+                    if (!isRpcError(error) && !isRpcInternalError(error))
+                        throw error;
+                    throw error.data === undefined
+                        ? { type: error.type, message: error.message }
+                        : { type: error.type, message: error.message, data: error.data };
+                }
+            },
+        ])), {
+            events: {
+                subscribe,
+                on: (name, handler, options) => {
+                    const controller = new AbortController();
+                    const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+                    const source = subscribe(name, { signal });
+                    void (async () => {
+                        for await (const event of source)
+                            await handler(event);
+                    })().catch((error) => console.error(error));
+                    return () => controller.abort();
+                },
+            },
+        });
+    };
+}
+function eventType(definition, name) {
+    return `rpc.${definition.id}.${name}`;
+}

package/dist/rpc-runtime.d.ts

@@ -0,0 +1,21 @@
+export * as RpcRuntime from "./rpc-runtime.js";
+import type { Rpc } from "@opencode-ai/schema/rpc";
+import { Effect, Schema } from "effect";
+export declare function read(schema: Rpc.Method["output"], value: unknown): Effect.Effect<unknown, Schema.SchemaError, never>;
+export declare function readError(method: Rpc.Method, error: unknown): Effect.Effect<never, unknown>;
+export declare const event: <D extends Rpc.Definition, Name extends keyof D["events"] & string>(definition: D, name: Name, schema: Rpc.EventDefinition, event: {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly location: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    };
+    readonly data: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: `rpc.${string}`;
+    readonly created: number;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+}) => Effect.Effect<Rpc.EventPayload<D, Name>, unknown, never>;
+export declare function eventType<const D extends Rpc.Definition, const Name extends keyof D["events"] & string>(definition: D, name: Name): `rpc.${D["id"]}.${Name}`;

package/dist/rpc-runtime.js

@@ -0,0 +1,32 @@
+export * as RpcRuntime from "./rpc-runtime.js";
+import { RpcError, RpcInternalError } from "@opencode-ai/protocol/errors";
+import { Effect, Schema } from "effect";
+export function read(schema, value) {
+    // Standard Schema results have already been parsed by the server.
+    return Schema.isSchema(schema) ? Schema.decodeUnknownEffect(schema)(value) : Effect.succeed(value);
+}
+export function readError(method, error) {
+    if (!(error instanceof RpcError) && !(error instanceof RpcInternalError))
+        return Effect.fail(error);
+    if (!method.errors || !Object.hasOwn(method.errors, error.type)) {
+        return Effect.fail(error.data === undefined
+            ? { type: error.type, message: error.message }
+            : { type: error.type, message: error.message, data: error.data });
+    }
+    return read(method.errors[error.type], error.data).pipe(Effect.catch((cause) => Effect.die(cause)), Effect.flatMap((data) => Effect.fail(data === undefined
+        ? { type: error.type, message: error.message }
+        : { type: error.type, message: error.message, data })));
+}
+export const event = Effect.fn("Client.Rpc.event")(function* (definition, name, schema, event) {
+    const data = yield* read(schema.schema, event.data);
+    // SAFETY: The event type was selected by the caller and data was decoded with this event's schema.
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
+    return {
+        ...event,
+        type: eventType(definition, name),
+        data,
+    };
+});
+export function eventType(definition, name) {
+    return `rpc.${definition.id}.${name}`;
+}

package/dist/shared-events.d.ts

@@ -0,0 +1,8 @@
+export * as SharedEvents from "./shared-events.js";
+export declare function make<A extends {
+    readonly type: string;
+}>(connect: (signal: AbortSignal) => AsyncIterable<A>): {
+    subscribe(options?: {
+        readonly signal?: AbortSignal;
+    }): AsyncIterable<A>;
+};

package/dist/shared-events.js

@@ -0,0 +1,133 @@
+export * as SharedEvents from "./shared-events.js";
+export function make(connect) {
+    let current;
+    const delivered = Promise.resolve();
+    function stop(connection) {
+        connection.connected = undefined;
+        connection.controller.abort();
+        if (current === connection)
+            current = undefined;
+    }
+    async function run(connection) {
+        let iterator;
+        let completion = {};
+        try {
+            if (connection.controller.signal.aborted)
+                return;
+            iterator = connect(connection.controller.signal)[Symbol.asyncIterator]();
+            while (!connection.controller.signal.aborted) {
+                const item = await iterator.next();
+                if (item.done || connection.controller.signal.aborted)
+                    break;
+                if (item.value.type === "server.connected")
+                    connection.connected = item.value;
+                await Promise.all(Array.from(connection.subscribers, (subscriber) => subscriber.push(item.value)));
+            }
+        }
+        catch (error) {
+            completion = { error };
+        }
+        finally {
+            stop(connection);
+            try {
+                await iterator?.return?.();
+            }
+            catch (error) {
+                if (!("error" in completion))
+                    completion = { error };
+            }
+            connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+        }
+    }
+    return {
+        subscribe(options) {
+            return {
+                [Symbol.asyncIterator]() {
+                    const pending = [];
+                    let started = false;
+                    let completion;
+                    let connection;
+                    let offered;
+                    function finish(result) {
+                        completion = result;
+                        offered?.accepted.resolve();
+                        offered = undefined;
+                        options?.signal?.removeEventListener("abort", abort);
+                        if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+                            stop(connection);
+                        pending.splice(0).forEach((request) => {
+                            if ("error" in result)
+                                request.reject(result.error);
+                            else
+                                request.resolve({ done: true, value: undefined });
+                        });
+                    }
+                    function abort() {
+                        finish({});
+                    }
+                    const subscriber = {
+                        finish,
+                        push(value) {
+                            if (completion)
+                                return delivered;
+                            const request = pending.shift();
+                            if (request) {
+                                request.resolve({ done: false, value });
+                                return delivered;
+                            }
+                            const accepted = Promise.withResolvers();
+                            offered = { value, accepted };
+                            return accepted.promise;
+                        },
+                    };
+                    function start() {
+                        if (completion)
+                            return;
+                        const fresh = !current;
+                        connection = current ?? {
+                            controller: new AbortController(),
+                            subscribers: new Set(),
+                        };
+                        current = connection;
+                        connection.subscribers.add(subscriber);
+                        if (connection.connected)
+                            void subscriber.push(connection.connected);
+                        if (fresh)
+                            void run(connection);
+                    }
+                    return {
+                        next() {
+                            if (offered) {
+                                const current = offered;
+                                offered = undefined;
+                                current.accepted.resolve();
+                                return Promise.resolve({ done: false, value: current.value });
+                            }
+                            if (completion) {
+                                if ("error" in completion)
+                                    return Promise.reject(completion.error);
+                                return Promise.resolve({ done: true, value: undefined });
+                            }
+                            if (options?.signal?.aborted) {
+                                abort();
+                                return Promise.resolve({ done: true, value: undefined });
+                            }
+                            const request = Promise.withResolvers();
+                            pending.push(request);
+                            if (!started) {
+                                started = true;
+                                options?.signal?.addEventListener("abort", abort, { once: true });
+                                start();
+                            }
+                            return request.promise;
+                        },
+                        return() {
+                            finish({});
+                            return Promise.resolve({ done: true, value: undefined });
+                        },
+                    };
+                },
+            };
+        },
+    };
+}

package/dist/solid/connection.js

@@ -62,7 +62,7 @@ export function createClientConnection(initialApi, options) {
                     return { error: undefined, connectedAt };
                 if (event.done)
                     return { error: new Error("Event stream disconnected"), connectedAt };
-                if ("durable" in event.value)
+                if ("durable" in event.value && event.value.durable)
                     options.log?.debug?.("event", {
                         type: event.value.type,
                         aggregateID: event.value.durable.aggregateID,

package/dist/solid/data.d.ts

@@ -1,13 +1,16 @@
 import type { AgentInfo, CommandInfo, FormCancelInput, FormInfo, FormReplyInput, IntegrationInfo, LocationRef, LocationGetOutput, McpResource, McpServer, ModelInfo, ModelRef, PermissionSavedInfo, PermissionRequest, PermissionReplyInput, Project, ProviderInfo, ReferenceInfo, SessionMessageInfo, SessionInfo, SessionInboxInfo, SessionInboxCompaction, ShellInfo, SkillInfo, VcsInfo, OpenCodeEvent, OpenCodeClient, WebSearchProvider } from "../promise";
 import { type SessionPromptInput } from "../promise";
 export type DataSessionStatus = "idle" | "running";
+type OpenCodeEventMap = {
+    [Type in OpenCodeEvent["type"]]: Extract<OpenCodeEvent, {
+        type: Type;
+    }>;
+};
 export type CreateDataInput = {
     readonly api: () => OpenCodeClient;
     readonly directory: string;
     readonly event: {
-        readonly on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: Extract<OpenCodeEvent, {
-            type: Type;
-        }>) => void) => () => void;
+        readonly on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
         readonly listen: (handler: (event: {
             name: OpenCodeEvent["type"];
             details: OpenCodeEvent;
@@ -25,9 +28,7 @@ type ShellWithLocation = ShellInfo & {
 };
 export declare function locationKey(location: LocationRef): string;
 export declare function createData(config: CreateDataInput): {
-    on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: Extract<OpenCodeEvent, {
-        type: Type;
-    }>) => void) => () => void;
+    on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
     listen: (handler: (event: {
         name: OpenCodeEvent["type"];
         details: OpenCodeEvent;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/client",
-  "version": "0.0.0-dev-18706",
+  "version": "0.0.0-dev-18708",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,8 +57,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/schema": "0.0.0-dev-18706",
-    "@opencode-ai/protocol": "0.0.0-dev-18706"
+    "@opencode-ai/schema": "0.0.0-dev-18708",
+    "@opencode-ai/protocol": "0.0.0-dev-18708"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.112",
@@ -74,11 +74,12 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode-ai/httpapi-codegen": "0.0.0-dev-18706",
+    "@opencode-ai/httpapi-codegen": "0.0.0-dev-18708",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
     "effect": "4.0.0-rc.112",
-    "solid-js": "1.9.15"
+    "solid-js": "1.9.15",
+    "zod": "4.1.8"
   }
 }