@opencode-ai/client 0.0.0-dev-17471

package/dist/effect/service.js

@@ -0,0 +1,286 @@
+import { ServiceStatus } from "@opencode-ai/protocol/groups/health";
+import { Effect, FileSystem, Option, Schedule, Schema } from "effect";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { contenderFailure, contenderFinished, spawnServiceContender, } from "../service-contender.js";
+import { defaultEnsureTiming, ensureTiming } from "../service-timing.js";
+import { matchesVersion } from "../service-version.js";
+export * from "../service.js";
+// Find, start, and stop the local opencode background service.
+//
+// The service daemon advertises itself through a registration file in the
+// user's state directory: url, pid, version, and the private password, with
+// 0600 permissions. That file is the complete discovery contract — reading it
+// is all a client needs to connect. The daemon's own configuration (port,
+// persisted password) is CLI-owned and never read here.
+// Read-only lookup: registration file plus health check and version gate.
+// Never spawns; escalation to ensure() is the caller's policy.
+/** Discover a healthy, compatible local service without starting one. */
+export const discover = Effect.fn("service.discover")(function* (options = {}) {
+    return (yield* discoverLocal(options))?.endpoint;
+});
+/** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
+export const incumbent = Effect.fn("service.incumbent")(function* (options) {
+    const info = yield* read(options.file);
+    const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url });
+    if (found === undefined || found.legacy)
+        return undefined;
+    if (!matchesVersion(found.version, options))
+        return undefined;
+    return { endpoint: found.endpoint, state: found.state };
+});
+const discoverLocal = Effect.fnUntraced(function* (options) {
+    const found = (yield* registered(options.file)).service;
+    if (found?.state !== "ready")
+        return undefined;
+    if (!matchesVersion(found.version, options))
+        return undefined;
+    return found;
+});
+// Idempotent ensure-running: reuses a healthy compatible server, replaces a
+// version-mismatched one, and otherwise spawns small contenders until a server
+// becomes discoverable. A contender is never killed merely for slow startup.
+/** Ensure a healthy, compatible local service is running. */
+export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
+    const timing = ensureTiming(options);
+    const contenders = new Set();
+    let timeouts;
+    let announced = false;
+    let lastSpawn = 0;
+    let spawnDelay = timing.spawnDelay;
+    const announce = (reason, previousVersion) => Effect.sync(() => {
+        if (announced)
+            return;
+        announced = true;
+        options.onStart?.(reason, previousVersion);
+    });
+    const spawnContender = Effect.gen(function* () {
+        const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+        if (command === undefined)
+            return yield* Effect.fail(new Error("Missing service command"));
+        return yield* Effect.try({
+            try: () => {
+                return spawnServiceContender(command, args);
+            },
+            catch: (cause) => new Error("Failed to start server", { cause }),
+        });
+    });
+    const found = yield* Effect.gen(function* () {
+        const registration = yield* registered(options.file, true, timing.requestTimeout);
+        const info = registration.info;
+        const service = registration.service;
+        if (registration.timedOut && info !== undefined) {
+            timeouts = {
+                info,
+                count: timeouts !== undefined && same(timeouts.info, info) ? timeouts.count + 1 : 1,
+            };
+            if (timeouts.count >= 3) {
+                yield* announce("missing");
+                yield* evict(info, options, timing);
+                timeouts = undefined;
+                lastSpawn = Date.now() - spawnDelay;
+            }
+        }
+        else
+            timeouts = undefined;
+        if (service !== undefined) {
+            spawnDelay = timing.spawnDelay;
+            const compatible = !service.legacy && matchesVersion(service.version, options);
+            if (compatible && service.state === "ready")
+                return Option.some(service);
+            if (compatible && service.state === "failed")
+                return yield* Effect.fail(new Error("Background service failed to start"));
+            if (compatible)
+                return Option.none();
+            yield* announce("version-mismatch", service.version);
+            yield* kill(service, options, timing).pipe(Effect.ignore);
+            lastSpawn = 0;
+            return Option.none();
+        }
+        else if (lastSpawn === 0 && info !== undefined)
+            lastSpawn = Date.now();
+        const finished = [...contenders].filter(contenderFinished);
+        const failure = finished.map(contenderFailure).find((error) => error !== undefined);
+        if (finished.some((item) => item.child.exitCode === 0)) {
+            spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
+        }
+        finished.forEach((item) => contenders.delete(item));
+        if (failure !== undefined && contenders.size === 0)
+            return yield* Effect.fail(failure);
+        // Keep one candidate plus one lock probe so a pre-lock stall cannot block recovery.
+        if (contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay) {
+            yield* announce("missing");
+            contenders.add(yield* spawnContender);
+            lastSpawn = Date.now();
+        }
+        return Option.none();
+    }).pipe(Effect.repeat({
+        until: Option.isSome,
+        schedule: Schedule.max([Schedule.spaced(timing.pollInterval), Schedule.recurs(timing.attempts)]),
+    }), Effect.ensuring(Effect.sync(() => contenders.forEach((contender) => contender.release()))));
+    if (Option.isNone(found))
+        return yield* Effect.fail(new Error("Timed out waiting for the background service to start"));
+    return found.value.endpoint;
+});
+/** Stop the registered local service. */
+export const stop = Effect.fn("service.stop")(function* (options = {}) {
+    const existing = yield* find(options);
+    if (existing !== undefined)
+        yield* kill(existing, options, defaultEnsureTiming);
+});
+function fallback() {
+    const state = process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state");
+    return join(state, "opencode", "service.json");
+}
+/** Create HTTP authentication headers for a service endpoint. */
+export function headers(endpoint) {
+    if (endpoint.auth === undefined)
+        return undefined;
+    return { authorization: "Basic " + btoa(endpoint.auth.username + ":" + endpoint.auth.password) };
+}
+/** Schema for the local service registration file. */
+export const Info = Schema.Struct({
+    id: Schema.optional(Schema.String),
+    version: Schema.optional(Schema.String),
+    url: Schema.String,
+    pid: Schema.Int.check(Schema.isGreaterThan(0)),
+    password: Schema.optional(Schema.String),
+});
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info));
+const decodeHealth = Schema.decodeUnknownOption(ServiceStatus.Health);
+const decodeLegacyHealth = Schema.decodeUnknownOption(Schema.Struct({ healthy: Schema.Literal(true) }));
+// A missing or corrupt file means no valid info; callers treat both
+// the same (the registering server self-evicts, clients rediscover).
+const read = Effect.fnUntraced(function* (file) {
+    const fs = yield* FileSystem.FileSystem;
+    const text = yield* fs.readFileString(file ?? fallback()).pipe(Effect.option);
+    if (Option.isNone(text))
+        return undefined;
+    return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined));
+});
+const probe = Effect.fnUntraced(function* (info, allowLegacy = false) {
+    return (yield* probeResult(info, allowLegacy)).service;
+});
+const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false, timeout = defaultEnsureTiming.requestTimeout) {
+    const endpoint = {
+        url: info.url,
+        auth: info.password === undefined
+            ? undefined
+            : { type: "basic", username: "opencode", password: info.password },
+    };
+    const signal = AbortSignal.timeout(timeout);
+    const result = yield* Effect.promise(() => fetch(new URL("/api/health", info.url), {
+        headers: headers(endpoint),
+        signal,
+    })
+        .then(async (response) => ({ response, body: (await response.json()) }))
+        .then((value) => ({ value }), (cause) => ({ cause })));
+    if ("cause" in result)
+        return { service: undefined, timedOut: signal.aborted };
+    const response = result.value.response;
+    const body = result.value.body;
+    const health = decodeHealth(body);
+    if (Option.isSome(health)) {
+        if (health.value.pid !== info.pid)
+            return { service: undefined, timedOut: false };
+        if (info.version !== undefined && health.value.version !== info.version)
+            return { service: undefined, timedOut: false };
+        return {
+            service: {
+                info,
+                endpoint,
+                version: health.value.version,
+                state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+                legacy: false,
+            },
+            timedOut: false,
+        };
+    }
+    if (!allowLegacy ||
+        Option.isNone(decodeLegacyHealth(body)) ||
+        (typeof body === "object" && body !== null && ("version" in body || "pid" in body)))
+        return { service: undefined, timedOut: false };
+    return {
+        service: { info, endpoint, state: "ready", legacy: true },
+        timedOut: false,
+    };
+});
+const registered = Effect.fnUntraced(function* (file, allowLegacy = false, timeout) {
+    const info = yield* read(file);
+    if (info === undefined)
+        return { info: undefined, service: undefined, timedOut: false };
+    return { info, ...(yield* probeResult(info, allowLegacy, timeout)) };
+});
+// Health-checked lookup without the version gate: lifecycle operations must be
+// able to see (and replace or stop) a server from a different version.
+const find = Effect.fnUntraced(function* (options) {
+    return (yield* registered(options.file, true)).service;
+});
+// 50ms cadence bounded at ~5s, shared by stop escalation and each ensure
+// discovery window.
+const poll = (timing) => Schedule.max([Schedule.spaced(timing.stopPollInterval), Schedule.recurs(timing.stopPollAttempts)]);
+const signal = (pid, name) => Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore);
+const stopped = Effect.fnUntraced(function* (pid) {
+    const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(Effect.orElseSucceed(() => false));
+    if (!running)
+        return true;
+    return yield* Effect.fail(new Error(`Server process ${pid} is still running`));
+});
+function same(left, right) {
+    return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+const evict = Effect.fnUntraced(function* (info, options, timing) {
+    const current = yield* read(options.file);
+    if (current === undefined || !same(current, info))
+        return;
+    yield* signal(info.pid, "SIGTERM");
+    const done = yield* stopped(info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
+    if (Option.isSome(done))
+        return;
+    const latest = yield* read(options.file);
+    if (latest === undefined || !same(latest, info))
+        return;
+    yield* signal(info.pid, "SIGKILL");
+    yield* stopped(info.pid).pipe(Effect.retry(poll(timing)));
+});
+const kill = Effect.fnUntraced(function* (service, options, timing) {
+    const requested = yield* requestStop(service, timing.requestTimeout);
+    if (requested === "rejected")
+        return;
+    if (requested === "unsupported") {
+        // A stale registration may point at a reused PID. Authenticate again
+        // immediately before the legacy signal fallback.
+        const current = yield* find(options);
+        if (current === undefined || !same(current.info, service.info))
+            return;
+        yield* signal(service.info.pid, "SIGTERM");
+    }
+    const done = yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)), Effect.option);
+    if (Option.isSome(done))
+        return;
+    const latest = yield* find(options);
+    if (latest === undefined || !same(latest.info, service.info))
+        return;
+    yield* signal(service.info.pid, "SIGKILL");
+    yield* stopped(service.info.pid).pipe(Effect.retry(poll(timing)));
+});
+const decodeStopResponse = Schema.decodeUnknownOption(ServiceStatus.StopResponse);
+const requestStop = Effect.fnUntraced(function* (service, timeout = defaultEnsureTiming.requestTimeout) {
+    if (service.info.id === undefined || service.legacy)
+        return "unsupported";
+    const response = yield* Effect.tryPromise(() => fetch(new URL("/api/service/stop", service.info.url), {
+        method: "POST",
+        headers: { ...headers(service.endpoint), "content-type": "application/json" },
+        body: JSON.stringify({ instanceID: service.info.id }),
+        signal: AbortSignal.timeout(timeout),
+    })).pipe(Effect.option, Effect.map(Option.getOrUndefined));
+    if (response === undefined || response.status === 404 || response.status === 405)
+        return "unsupported";
+    const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.option, Effect.map(Option.getOrUndefined));
+    const decoded = decodeStopResponse(body);
+    if (!response.ok || Option.isNone(decoded) || !decoded.value.accepted)
+        return "rejected";
+    return "accepted";
+});
+/** Effect-based local service lifecycle operations. */
+export const Service = { discover, incumbent, ensure, stop, headers, Info };

package/dist/promise/api.d.ts

@@ -0,0 +1,18 @@
+type Client = ReturnType<typeof import("./generated/client.js").make>;
+export type AgentApi = Client["agent"];
+export type CommandApi = Client["command"];
+export type ConfigApi = Client["config"];
+export type EventApi = Client["event"];
+export type IntegrationApi = Client["integration"];
+export type ModelApi = Client["model"];
+export type PluginApi = Client["plugin"];
+export type ProviderApi = Client["provider"];
+export type ReferenceApi = Client["reference"];
+export type WebSearchApi = Client["websearch"];
+export type SessionApi = Client["session"];
+export type SkillApi = Client["skill"];
+export interface CatalogApi {
+    readonly provider: ProviderApi;
+    readonly model: ModelApi;
+}
+export {};

package/dist/promise/generated/client-error.d.ts

@@ -0,0 +1,6 @@
+export type ClientErrorReason = "Transport" | "UnexpectedStatus" | "UnsupportedContentType" | "MalformedResponse" | "SseEventTooLarge";
+export declare class ClientError extends Error {
+    readonly reason: ClientErrorReason;
+    readonly name = "ClientError";
+    constructor(reason: ClientErrorReason, options?: ErrorOptions);
+}

package/dist/promise/generated/client-error.js

@@ -0,0 +1,8 @@
+export class ClientError extends Error {
+    reason;
+    name = "ClientError";
+    constructor(reason, options) {
+        super(reason, options);
+        this.reason = reason;
+    }
+}

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

@@ -0,0 +1,228 @@
+import type { HealthStopInput, ServerGetOutput, LocationGetInput, LocationGetOutput, AgentListInput, AgentListOutput, AgentGetInput, AgentGetOutput, PluginListInput, PluginListOutput, SessionListInput, SessionCreateInput, SessionImportInput, SessionExportInput, SessionGetInput, SessionRemoveInput, SessionForkInput, SessionSwitchAgentInput, SessionSwitchModelInput, SessionRenameInput, SessionMoveInput, SessionPromptInput, SessionCommandInput, SessionSkillInput, SessionSyntheticInput, SessionShellInput, SessionCompactInput, SessionWaitInput, SessionRevertStageInput, SessionRevertClearInput, SessionRevertCommitInput, SessionContextInput, SessionInboxListInput, SessionInboxCancelInput, SessionInboxSteerInput, SessionInboxQueueInput, SessionInstructionsEntryListInput, SessionInstructionsEntryPutInput, SessionInstructionsEntryRemoveInput, SessionGenerateInput, SessionLogInput, SessionLogOutput, SessionInterruptInput, SessionBackgroundInput, SessionMessageInput, MessageListInput, ModelListInput, ModelListOutput, ModelDefaultInput, ModelDefaultOutput, GenerateTextInput, ProviderListInput, ProviderListOutput, ProviderGetInput, ProviderGetOutput, IntegrationListInput, IntegrationListOutput, IntegrationGetInput, IntegrationGetOutput, IntegrationWellknownAddInput, IntegrationConnectKeyInput, IntegrationOauthConnectInput, IntegrationOauthConnectOutput, IntegrationOauthStatusInput, IntegrationOauthStatusOutput, IntegrationOauthCompleteInput, IntegrationOauthCancelInput, IntegrationCommandConnectInput, IntegrationCommandConnectOutput, IntegrationCommandStatusInput, IntegrationCommandStatusOutput, IntegrationCommandCancelInput, McpListInput, McpListOutput, McpAddInput, McpRemoveInput, McpConnectInput, McpDisconnectInput, McpResourceCatalogInput, McpResourceCatalogOutput, CredentialUpdateInput, CredentialRemoveInput, ProjectListOutput, ProjectCurrentInput, FormRequestListInput, FormRequestListOutput, FormListInput, FormCreateInput, FormGetInput, FormStateInput, FormReplyInput, FormCancelInput, PermissionRequestListInput, PermissionRequestListOutput, PermissionSavedListInput, PermissionSavedRemoveInput, PermissionCreateInput, PermissionListInput, PermissionGetInput, PermissionReplyInput, FileReadInput, FileReadOutput, FileListInput, FileListOutput, FileFindInput, FileFindOutput, CommandListInput, CommandListOutput, SkillListInput, SkillListOutput, EventSubscribeOutput, PtyListInput, PtyListOutput, PtyCreateInput, PtyCreateOutput, PtyGetInput, PtyGetOutput, PtyUpdateInput, PtyUpdateOutput, PtyRemoveInput, ShellListInput, ShellListOutput, ShellCreateInput, ShellCreateOutput, ShellGetInput, ShellGetOutput, ShellTimeoutInput, ShellTimeoutOutput, ShellOutputInput, ShellOutputOutput, ShellRemoveInput, ReferenceListInput, ReferenceListOutput, WorktreeListInput, WorktreeCreateInput, WorktreeRemoveInput, WorktreeRefreshInput, VcsGetInput, VcsGetOutput, VcsStatusInput, VcsStatusOutput, VcsDiffInput, VcsDiffOutput, DebugLocationListOutput, DebugLocationEvictInput, MigrationV1StatusOutput, WebsearchProvidersInput, WebsearchProvidersOutput, WebsearchQueryInput, WebsearchQueryOutput, ConfigGetInput, ConfigGetOutput } from "./types.js";
+export interface ClientOptions {
+    readonly baseUrl: string;
+    readonly fetch?: typeof globalThis.fetch;
+    readonly headers?: RequestInit["headers"];
+}
+export interface RequestOptions {
+    readonly signal?: AbortSignal;
+    readonly headers?: RequestInit["headers"];
+}
+export declare function make(options: ClientOptions): {
+    health: {
+        get: (requestOptions?: RequestOptions) => Promise<import("./types.js").ServiceHealth>;
+        stop: (input: HealthStopInput, requestOptions?: RequestOptions) => Promise<import("./types.js").ServiceStopResponse>;
+    };
+    server: {
+        get: (requestOptions?: RequestOptions) => Promise<ServerGetOutput>;
+    };
+    location: {
+        get: (input?: LocationGetInput, requestOptions?: RequestOptions) => Promise<LocationGetOutput>;
+    };
+    agent: {
+        list: (input?: AgentListInput, requestOptions?: RequestOptions) => Promise<AgentListOutput>;
+        get: (input: AgentGetInput, requestOptions?: RequestOptions) => Promise<AgentGetOutput>;
+    };
+    plugin: {
+        list: (input?: PluginListInput, requestOptions?: RequestOptions) => Promise<PluginListOutput>;
+    };
+    session: {
+        list: (input?: SessionListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionsResponse>;
+        create: (input?: SessionCreateInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInfo>;
+        import: (input: SessionImportInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInfo>;
+        export: (input: SessionExportInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionTransferData>;
+        active: (requestOptions?: RequestOptions) => Promise<{
+            [x: string]: import("./types.js").SessionActive;
+        }>;
+        get: (input: SessionGetInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInfo>;
+        remove: (input: SessionRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+        fork: (input: SessionForkInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInfo>;
+        switchAgent: (input: SessionSwitchAgentInput, requestOptions?: RequestOptions) => Promise<void>;
+        switchModel: (input: SessionSwitchModelInput, requestOptions?: RequestOptions) => Promise<void>;
+        rename: (input: SessionRenameInput, requestOptions?: RequestOptions) => Promise<void>;
+        move: (input: SessionMoveInput, requestOptions?: RequestOptions) => Promise<void>;
+        prompt: (input: SessionPromptInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInboxUser>;
+        command: (input: SessionCommandInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInboxUser>;
+        skill: (input: SessionSkillInput, requestOptions?: RequestOptions) => Promise<void>;
+        synthetic: (input: SessionSyntheticInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInboxSynthetic>;
+        shell: (input: SessionShellInput, requestOptions?: RequestOptions) => Promise<void>;
+        compact: (input: SessionCompactInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInboxCompaction>;
+        wait: (input: SessionWaitInput, requestOptions?: RequestOptions) => Promise<void>;
+        revert: {
+            stage: (input: SessionRevertStageInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionRevert>;
+            clear: (input: SessionRevertClearInput, requestOptions?: RequestOptions) => Promise<void>;
+            commit: (input: SessionRevertCommitInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        context: (input: SessionContextInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionMessageInfo[]>;
+        inbox: {
+            list: (input: SessionInboxListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionInboxInfo[]>;
+            cancel: (input: SessionInboxCancelInput, requestOptions?: RequestOptions) => Promise<void>;
+            steer: (input: SessionInboxSteerInput, requestOptions?: RequestOptions) => Promise<void>;
+            queue: (input: SessionInboxQueueInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        instructions: {
+            entry: {
+                list: (input: SessionInstructionsEntryListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").InstructionEntryInfo[]>;
+                put: (input: SessionInstructionsEntryPutInput, requestOptions?: RequestOptions) => Promise<void>;
+                remove: (input: SessionInstructionsEntryRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+            };
+        };
+        generate: (input: SessionGenerateInput, requestOptions?: RequestOptions) => Promise<{
+            text: string;
+        }>;
+        log: (input: SessionLogInput, requestOptions?: RequestOptions) => AsyncIterable<SessionLogOutput>;
+        interrupt: (input: SessionInterruptInput, requestOptions?: RequestOptions) => Promise<void>;
+        background: (input: SessionBackgroundInput, requestOptions?: RequestOptions) => Promise<void>;
+        message: (input: SessionMessageInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionMessageAgentSelected | import("./types.js").SessionMessageSynthetic | import("./types.js").SessionMessageSystem | import("./types.js").SessionMessageSkill | import("./types.js").SessionMessageShell | import("./types.js").SessionMessageCompactionRunning | import("./types.js").SessionMessageCompactionCompleted | import("./types.js").SessionMessageModelSelected | import("./types.js").SessionMessageLocationSwitched | import("./types.js").SessionMessageCompactionFailed | import("./types.js").SessionMessageUser | import("./types.js").SessionMessageAssistant>;
+    };
+    message: {
+        list: (input: MessageListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").SessionMessagesResponse>;
+    };
+    model: {
+        list: (input?: ModelListInput, requestOptions?: RequestOptions) => Promise<ModelListOutput>;
+        default: (input?: ModelDefaultInput, requestOptions?: RequestOptions) => Promise<ModelDefaultOutput>;
+    };
+    generate: {
+        text: (input: GenerateTextInput, requestOptions?: RequestOptions) => Promise<{
+            text: string;
+        }>;
+    };
+    provider: {
+        list: (input?: ProviderListInput, requestOptions?: RequestOptions) => Promise<ProviderListOutput>;
+        get: (input: ProviderGetInput, requestOptions?: RequestOptions) => Promise<ProviderGetOutput>;
+    };
+    integration: {
+        list: (input?: IntegrationListInput, requestOptions?: RequestOptions) => Promise<IntegrationListOutput>;
+        get: (input: IntegrationGetInput, requestOptions?: RequestOptions) => Promise<IntegrationGetOutput>;
+        wellknown: {
+            add: (input: IntegrationWellknownAddInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        connect: {
+            key: (input: IntegrationConnectKeyInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        oauth: {
+            connect: (input: IntegrationOauthConnectInput, requestOptions?: RequestOptions) => Promise<IntegrationOauthConnectOutput>;
+            status: (input: IntegrationOauthStatusInput, requestOptions?: RequestOptions) => Promise<IntegrationOauthStatusOutput>;
+            complete: (input: IntegrationOauthCompleteInput, requestOptions?: RequestOptions) => Promise<void>;
+            cancel: (input: IntegrationOauthCancelInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        command: {
+            connect: (input: IntegrationCommandConnectInput, requestOptions?: RequestOptions) => Promise<IntegrationCommandConnectOutput>;
+            status: (input: IntegrationCommandStatusInput, requestOptions?: RequestOptions) => Promise<IntegrationCommandStatusOutput>;
+            cancel: (input: IntegrationCommandCancelInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+    };
+    mcp: {
+        list: (input?: McpListInput, requestOptions?: RequestOptions) => Promise<McpListOutput>;
+        add: (input: McpAddInput, requestOptions?: RequestOptions) => Promise<void>;
+        remove: (input: McpRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+        connect: (input: McpConnectInput, requestOptions?: RequestOptions) => Promise<void>;
+        disconnect: (input: McpDisconnectInput, requestOptions?: RequestOptions) => Promise<void>;
+        resource: {
+            catalog: (input?: McpResourceCatalogInput, requestOptions?: RequestOptions) => Promise<McpResourceCatalogOutput>;
+        };
+    };
+    credential: {
+        update: (input: CredentialUpdateInput, requestOptions?: RequestOptions) => Promise<void>;
+        remove: (input: CredentialRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    project: {
+        list: (requestOptions?: RequestOptions) => Promise<ProjectListOutput>;
+        current: (input?: ProjectCurrentInput, requestOptions?: RequestOptions) => Promise<import("./types.js").ProjectCurrent>;
+    };
+    form: {
+        request: {
+            list: (input?: FormRequestListInput, requestOptions?: RequestOptions) => Promise<FormRequestListOutput>;
+        };
+        list: (input: FormListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").FormInfo[]>;
+        create: (input: FormCreateInput, requestOptions?: RequestOptions) => Promise<import("./types.js").FormInfo>;
+        get: (input: FormGetInput, requestOptions?: RequestOptions) => Promise<import("./types.js").FormInfo>;
+        state: (input: FormStateInput, requestOptions?: RequestOptions) => Promise<{
+            status: "pending";
+        } | {
+            status: "answered";
+            answer: import("./types.js").FormAnswer;
+        } | {
+            status: "cancelled";
+        }>;
+        reply: (input: FormReplyInput, requestOptions?: RequestOptions) => Promise<void>;
+        cancel: (input: FormCancelInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    permission: {
+        request: {
+            list: (input?: PermissionRequestListInput, requestOptions?: RequestOptions) => Promise<PermissionRequestListOutput>;
+        };
+        saved: {
+            list: (input?: PermissionSavedListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").PermissionSavedInfo[]>;
+            remove: (input: PermissionSavedRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+        create: (input: PermissionCreateInput, requestOptions?: RequestOptions) => Promise<{
+            id: string;
+            effect: import("./types.js").PermissionEffect;
+        }>;
+        list: (input: PermissionListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").PermissionRequest[]>;
+        get: (input: PermissionGetInput, requestOptions?: RequestOptions) => Promise<import("./types.js").PermissionRequest>;
+        reply: (input: PermissionReplyInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    file: {
+        read: (input: FileReadInput, requestOptions?: RequestOptions) => Promise<FileReadOutput>;
+        list: (input?: FileListInput, requestOptions?: RequestOptions) => Promise<FileListOutput>;
+        find: (input: FileFindInput, requestOptions?: RequestOptions) => Promise<FileFindOutput>;
+    };
+    command: {
+        list: (input?: CommandListInput, requestOptions?: RequestOptions) => Promise<CommandListOutput>;
+    };
+    skill: {
+        list: (input?: SkillListInput, requestOptions?: RequestOptions) => Promise<SkillListOutput>;
+    };
+    event: {
+        subscribe: (requestOptions?: RequestOptions) => AsyncIterable<EventSubscribeOutput>;
+    };
+    pty: {
+        list: (input?: PtyListInput, requestOptions?: RequestOptions) => Promise<PtyListOutput>;
+        create: (input?: PtyCreateInput, requestOptions?: RequestOptions) => Promise<PtyCreateOutput>;
+        get: (input: PtyGetInput, requestOptions?: RequestOptions) => Promise<PtyGetOutput>;
+        update: (input: PtyUpdateInput, requestOptions?: RequestOptions) => Promise<PtyUpdateOutput>;
+        remove: (input: PtyRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    shell: {
+        list: (input?: ShellListInput, requestOptions?: RequestOptions) => Promise<ShellListOutput>;
+        create: (input: ShellCreateInput, requestOptions?: RequestOptions) => Promise<ShellCreateOutput>;
+        get: (input: ShellGetInput, requestOptions?: RequestOptions) => Promise<ShellGetOutput>;
+        timeout: (input: ShellTimeoutInput, requestOptions?: RequestOptions) => Promise<ShellTimeoutOutput>;
+        output: (input: ShellOutputInput, requestOptions?: RequestOptions) => Promise<ShellOutputOutput>;
+        remove: (input: ShellRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    reference: {
+        list: (input?: ReferenceListInput, requestOptions?: RequestOptions) => Promise<ReferenceListOutput>;
+    };
+    worktree: {
+        list: (input: WorktreeListInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeList>;
+        create: (input: WorktreeCreateInput, requestOptions?: RequestOptions) => Promise<import("./types.js").WorktreeInfo>;
+        remove: (input: WorktreeRemoveInput, requestOptions?: RequestOptions) => Promise<void>;
+        refresh: (input: WorktreeRefreshInput, requestOptions?: RequestOptions) => Promise<void>;
+    };
+    vcs: {
+        get: (input?: VcsGetInput, requestOptions?: RequestOptions) => Promise<VcsGetOutput>;
+        status: (input?: VcsStatusInput, requestOptions?: RequestOptions) => Promise<VcsStatusOutput>;
+        diff: (input: VcsDiffInput, requestOptions?: RequestOptions) => Promise<VcsDiffOutput>;
+    };
+    debug: {
+        location: {
+            list: (requestOptions?: RequestOptions) => Promise<DebugLocationListOutput>;
+            evict: (input?: DebugLocationEvictInput, requestOptions?: RequestOptions) => Promise<void>;
+        };
+    };
+    migration: {
+        v1: {
+            status: (requestOptions?: RequestOptions) => Promise<MigrationV1StatusOutput>;
+        };
+    };
+    websearch: {
+        providers: (input?: WebsearchProvidersInput, requestOptions?: RequestOptions) => Promise<WebsearchProvidersOutput>;
+        query: (input: WebsearchQueryInput, requestOptions?: RequestOptions) => Promise<WebsearchQueryOutput>;
+    };
+    config: {
+        get: (input?: ConfigGetInput, requestOptions?: RequestOptions) => Promise<ConfigGetOutput>;
+    };
+};