@camerontaylor/paseo-client 0.8.0-fork.1

package/dist/index.d.ts

@@ -0,0 +1,383 @@
+import type { DaemonClientConfig } from "./daemon-client.js";
+import type { AgentPermissionResponse } from "@camerontaylor/paseo-protocol/agent-types";
+import type { AgentSnapshotPayload, CreationSnapshot, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListCommandsResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ProjectListRequestMessage, ProjectListResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, ProjectPlacementPayload, WorkspaceProjectDescriptorPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@camerontaylor/paseo-protocol/messages";
+import { DaemonClient } from "./daemon-client.js";
+import { type PaseoTerminalActions, type PaseoWorkspaceTerminalActions } from "./terminals/index.js";
+export type { PaseoTerminal, PaseoTerminalActions, PaseoTerminalHandle, PaseoTerminalCreateOptions, PaseoTerminalListOptions, PaseoTerminalListResult, PaseoTerminalCaptureOptions, PaseoTerminalCaptureResult, PaseoWorkspaceTerminalActions, } from "./terminals/index.js";
+import type { PluginTimelineItem } from "@camerontaylor/paseo-protocol/agent-types";
+import type { FetchAgentsEntry, FetchAgentsOptions, FetchAgentsPageInfo, FetchAgentTimelineCursor, FetchAgentTimelineDirection, FetchAgentTimelinePayload, FetchAgentTimelineProjection, WaitForFinishResult } from "./daemon-client.js";
+export type ConnectionState = {
+    status: "idle";
+} | {
+    status: "connecting";
+    attempt: number;
+} | {
+    status: "connected";
+} | {
+    status: "disconnected";
+    reason?: string;
+} | {
+    status: "disposed";
+};
+export interface PaseoLogger {
+    debug(obj: object, msg?: string): void;
+    info(obj: object, msg?: string): void;
+    warn(obj: object, msg?: string): void;
+    error(obj: object, msg?: string): void;
+}
+export interface PaseoClientConfig {
+    capabilities?: DaemonClientConfig["capabilities"];
+    url: string;
+    clientId?: string;
+    appVersion?: string;
+    runtimeGeneration?: number | null;
+    password?: string;
+    authHeader?: string;
+    suppressSendErrors?: boolean;
+    logger?: PaseoLogger;
+    connectTimeoutMs?: number;
+    e2ee?: {
+        enabled?: boolean;
+        daemonPublicKeyB64?: string;
+    };
+    reconnect?: {
+        enabled?: boolean;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+    runtimeMetricsIntervalMs?: number;
+    runtimeMetricsWindowMs?: number;
+}
+export type PaseoWorkspace = WorkspaceDescriptorPayload;
+export type PaseoAgent = AgentSnapshotPayload;
+export type PaseoAgentListOptions = FetchAgentsOptions;
+export type PaseoProject = WorkspaceProjectDescriptorPayload;
+export type PaseoProjectListOptions = Omit<ProjectListRequestMessage, "type" | "requestId"> & {
+    requestId?: string;
+};
+export type PaseoProjectListResult = ProjectListResponseMessage["payload"];
+export type PaseoProjectUpdate = Extract<SessionOutboundMessage, {
+    type: "project.update";
+}>["payload"];
+export type PaseoProjectUpdateHandler = (update: PaseoProjectUpdate) => void;
+export interface PaseoAgentListResult {
+    requestId: string;
+    subscriptionId?: string | null;
+    entries: FetchAgentsEntry[];
+    pageInfo: FetchAgentsPageInfo;
+}
+export type PaseoWorkspaceListOptions = Omit<FetchWorkspacesRequestMessage, "type" | "requestId"> & {
+    requestId?: string;
+};
+export interface PaseoWorkspaceListResult {
+    requestId: string;
+    subscriptionId?: string | null;
+    entries: PaseoWorkspace[];
+    pageInfo: FetchWorkspacesResponseMessage["payload"]["pageInfo"];
+}
+export interface PaseoWorkspaceOpenOptions {
+    cwd: string;
+    requestId?: string;
+}
+export type PaseoWorkspaceCreateOptions = Omit<WorkspaceCreateRequest, "type" | "requestId" | "agent" | "subscribe"> & {
+    requestId?: string;
+    agent?: Omit<PaseoAgentCreateOptions, "worktree" | "git" | "onEvent" | "idempotencyKey" | "requestId">;
+    onEvent?: (snapshot: CreationSnapshot) => void;
+};
+export interface PaseoWorkspaceArchiveResult {
+    requestId: string;
+    workspaceId: string;
+    archivedAt: string | null;
+    error: string | null;
+}
+export type PaseoWorkspaceUpdate = Extract<SessionOutboundMessage, {
+    type: "workspace_update";
+}>["payload"];
+export type PaseoWorkspaceUpdateHandler = (update: PaseoWorkspaceUpdate) => void;
+export interface PaseoWorkspaceHandle {
+    readonly id: string;
+    readonly projectId: string | null;
+    readonly directory: string | null;
+    readonly name: string | null;
+    readonly status: PaseoWorkspace["status"] | null;
+    readonly agents: {
+        create(options: PaseoWorkspaceAgentCreateOptions): Promise<PaseoAgentHandle>;
+    };
+    readonly terminals: PaseoWorkspaceTerminalActions;
+    current(): PaseoWorkspace | null;
+    refresh(options?: {
+        requestId?: string;
+    }): Promise<PaseoWorkspace | null>;
+    setTitle(title: string | null, requestId?: string): Promise<{
+        title: string | null;
+    }>;
+    archive(requestId?: string): Promise<PaseoWorkspaceArchiveResult>;
+    /**
+     * Subscribes to already-emitted daemon workspace_update events for this id.
+     * This returns a local unsubscribe function; it does not own app cache state or
+     * send a daemon unsubscribe RPC. Call `workspaces.list({ subscribe: {} })` when
+     * the daemon should start streaming workspace directory updates.
+     */
+    subscribe(handler: (update: PaseoWorkspaceUpdate) => void): () => void;
+}
+export interface PaseoProjectActions {
+    list(options?: PaseoProjectListOptions): Promise<PaseoProjectListResult>;
+    subscribe(handler: PaseoProjectUpdateHandler): () => void;
+}
+export interface PaseoWorkspaceActions {
+    list(options?: PaseoWorkspaceListOptions): Promise<PaseoWorkspaceListResult>;
+    ref(workspace: string | PaseoWorkspace): PaseoWorkspaceHandle;
+    open(input: string | PaseoWorkspaceOpenOptions, requestId?: string): Promise<PaseoWorkspaceHandle>;
+    create(options: PaseoWorkspaceCreateOptions): Promise<PaseoWorkspaceHandle>;
+    archive(workspace: string | PaseoWorkspaceHandle, requestId?: string): Promise<PaseoWorkspaceArchiveResult>;
+    /**
+     * Local event subscription over the low-level driver's workspace_update stream.
+     * The returned function only removes this SDK listener.
+     */
+    subscribe(handler: PaseoWorkspaceUpdateHandler): () => void;
+}
+type PaseoAgentSessionConfig = CreateAgentRequestMessage["config"];
+export type PaseoAgentProvider = PaseoAgentSessionConfig["provider"];
+export type PaseoProviderFeatureValues = Record<string, unknown>;
+export interface PaseoAgentConfig {
+    /** Provider and model in `provider/model` format. */
+    provider: string;
+    modeId?: PaseoAgentSessionConfig["modeId"];
+    thinkingOptionId?: PaseoAgentSessionConfig["thinkingOptionId"];
+    featureValues?: PaseoProviderFeatureValues;
+    /** JSON-safe provider-native settings, validated by the selected provider. */
+    options?: PaseoAgentSessionConfig["providerOptions"];
+    systemPrompt?: PaseoAgentSessionConfig["systemPrompt"];
+    toolPolicy?: PaseoAgentSessionConfig["toolPolicy"];
+    mcpServers?: PaseoAgentSessionConfig["mcpServers"];
+}
+export interface PaseoAgentCreateOptions {
+    idempotencyKey?: string;
+    agentId?: string;
+    onEvent?: (snapshot: CreationSnapshot) => void;
+    config: PaseoAgentConfig;
+    cwd: string;
+    parent?: string | PaseoAgentHandle;
+    title?: PaseoAgentSessionConfig["title"];
+    env?: CreateAgentRequestMessage["env"];
+    prompt?: string;
+    clientMessageId?: string;
+    outputSchema?: Record<string, unknown>;
+    images?: CreateAgentRequestMessage["images"];
+    attachments?: CreateAgentRequestMessage["attachments"];
+    git?: CreateAgentRequestMessage["git"];
+    worktree?: CreateAgentRequestMessage["worktree"];
+    autoArchive?: CreateAgentRequestMessage["autoArchive"];
+    requestId?: string;
+    labels?: Record<string, string>;
+}
+export type PaseoWorkspaceAgentCreateOptions = Omit<PaseoAgentCreateOptions, "cwd">;
+export interface PaseoAgentRefetchResult {
+    agent: PaseoAgent;
+    project: ProjectPlacementPayload | null;
+}
+export interface PaseoAgentTimelineRefetchOptions {
+    direction?: FetchAgentTimelineDirection;
+    cursor?: FetchAgentTimelineCursor;
+    limit?: number;
+    projection?: FetchAgentTimelineProjection;
+    requestId?: string;
+}
+export interface PaseoAgentSendOptions {
+    messageId?: string;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    attachments?: SendAgentMessageRequest["attachments"];
+}
+export interface PaseoAgentRunOptions extends PaseoAgentSendOptions {
+    timeoutMs?: number;
+}
+export type PaseoAgentRunResult = WaitForFinishResult;
+export type PaseoAgentPermissionResponse = AgentPermissionResponse;
+export interface PaseoAgentRespondToPermissionOptions {
+    requestId: string;
+    response: PaseoAgentPermissionResponse;
+}
+export interface PaseoAgentCommandsOptions {
+    requestId?: string;
+}
+export type PaseoAgentCommandsResult = ListCommandsResponse["payload"];
+export type PaseoAgentUpdate = Extract<SessionOutboundMessage, {
+    type: "agent_update";
+}>["payload"];
+export type PaseoAgentStream = Extract<SessionOutboundMessage, {
+    type: "agent_stream";
+}>["payload"];
+export type PaseoAgentUpdateHandler = (update: PaseoAgentUpdate) => void;
+export type PaseoAgentTimelineEvent = PaseoAgentStream | {
+    agentId: string;
+    event: {
+        type: "replacement";
+        epoch: string;
+    };
+};
+export type PaseoAgentTimelineSubscription = ReturnType<DaemonClient["subscribeAgentTimeline"]>;
+export interface PaseoAgentTimelineHandle {
+    append(item: Omit<PluginTimelineItem, "pluginId">): Promise<{
+        seq: number;
+        epoch: string;
+    }>;
+    /**
+     * Fetches a fresh timeline page through the existing daemon RPC. If the daemon
+     * includes an agent snapshot in the response, the parent handle is updated to
+     * that value.
+     */
+    refetch(options?: PaseoAgentTimelineRefetchOptions): Promise<FetchAgentTimelinePayload>;
+    /**
+     * Subscribe to this agent and restore demand after reconnect. A replacement
+     * event invalidates previously fetched history; refetch the page you need.
+     * Await the returned unsubscribe function's `ready` promise before starting
+     * work that must be observed. It rejects if establishment fails.
+     */
+    subscribe(handler: (event: PaseoAgentTimelineEvent) => void): PaseoAgentTimelineSubscription;
+}
+export interface PaseoAgentHandle {
+    readonly id: string;
+    /**
+     * `workspaceId` through `archivedAt` mirror the last snapshot this handle
+     * observed. A handle from `ref()` reads `null` for all of them until
+     * `refresh()`, `run()`, `waitForFinish()`, a timeline refetch, or
+     * `subscribe()` delivers a snapshot. Optional snapshot values also read as
+     * `null`; use `current()` when you need to distinguish those states.
+     */
+    readonly workspaceId: string | null;
+    readonly cwd: string | null;
+    readonly status: PaseoAgent["status"] | null;
+    readonly capabilities: PaseoAgent["capabilities"] | null;
+    readonly availableModes: PaseoAgent["availableModes"] | null;
+    readonly pendingPermissions: PaseoAgent["pendingPermissions"] | null;
+    readonly activeTurn: NonNullable<PaseoAgent["activeTurn"]> | null;
+    readonly lastUsage: NonNullable<PaseoAgent["lastUsage"]> | null;
+    readonly lastError: NonNullable<PaseoAgent["lastError"]> | null;
+    readonly features: NonNullable<PaseoAgent["features"]> | null;
+    readonly runtimeInfo: NonNullable<PaseoAgent["runtimeInfo"]> | null;
+    readonly archivedAt: NonNullable<PaseoAgent["archivedAt"]> | null;
+    readonly timeline: PaseoAgentTimelineHandle;
+    current(): PaseoAgent | null;
+    refresh(requestId?: string): Promise<PaseoAgentRefetchResult | null>;
+    send(text: string, options?: PaseoAgentSendOptions): Promise<void>;
+    respondToPermission(options: PaseoAgentRespondToPermissionOptions): Promise<void>;
+    /** Sends a prompt and resolves when that turn finishes or needs attention. */
+    run(text: string, options?: PaseoAgentRunOptions): Promise<PaseoAgentRunResult>;
+    /** Waits for the current turn, including one started with `prompt`. */
+    waitForFinish(timeoutMs?: number): Promise<PaseoAgentRunResult>;
+    /**
+     * Asks the running session for the slash commands and skills it actually
+     * loaded. Providers answer from the live session, so this sees built-in and
+     * bundled entries that no directory scan can find. The payload carries its own
+     * `error` string; a provider that cannot answer reports it there rather than
+     * rejecting.
+     */
+    commands(options?: PaseoAgentCommandsOptions): Promise<PaseoAgentCommandsResult>;
+    archive(): Promise<{
+        archivedAt: string;
+    }>;
+    detach(): Promise<void>;
+    subscribe(handler: (update: PaseoAgentUpdate) => void): () => void;
+}
+export interface PaseoAgentActions {
+    list(options?: PaseoAgentListOptions): Promise<PaseoAgentListResult>;
+    ref(agent: string | PaseoAgent): PaseoAgentHandle;
+    create(options: PaseoAgentCreateOptions): Promise<PaseoAgentHandle>;
+    /**
+     * Local event subscription over the low-level driver's agent_update stream.
+     * The returned function only removes this SDK listener.
+     */
+    subscribe(handler: PaseoAgentUpdateHandler): () => void;
+}
+export type PaseoProviderModelsResult = ListProviderModelsResponseMessage["payload"];
+export type PaseoProviderModesResult = ListProviderModesResponseMessage["payload"];
+type PaseoProviderFeaturesDraft = ListProviderFeaturesRequestMessage["draftConfig"];
+export interface PaseoProviderFeaturesInput extends Omit<PaseoProviderFeaturesDraft, "provider" | "model"> {
+    /** Provider and model in `provider/model` format. */
+    provider: string;
+}
+export type PaseoProviderFeaturesResult = ListProviderFeaturesResponseMessage["payload"];
+export type PaseoProviderAvailabilityResult = ListAvailableProvidersResponse["payload"];
+export type PaseoProviderSnapshotResult = GetProvidersSnapshotResponseMessage["payload"];
+export type PaseoProviderSnapshotUpdate = Extract<SessionOutboundMessage, {
+    type: "providers_snapshot_update";
+}>["payload"];
+export type PaseoProviderRefreshResult = RefreshProvidersSnapshotResponseMessage["payload"];
+export type PaseoProviderDiagnosticResult = ProviderDiagnosticResponseMessage["payload"];
+export type PaseoProviderUsageResult = ProviderUsageListResponseMessage["payload"];
+export interface PaseoProviderUsageOptions {
+    requestId?: string;
+}
+export interface PaseoProviderListOptions {
+    cwd?: string;
+    requestId?: string;
+}
+export interface PaseoProviderRefreshOptions {
+    cwd?: string;
+    providers?: PaseoAgentProvider[];
+    requestId?: string;
+}
+export interface PaseoProviderWaitOptions extends PaseoProviderListOptions {
+    timeoutMs?: number;
+}
+export interface PaseoProviderActions {
+    listModels(provider: PaseoAgentProvider, options?: PaseoProviderListOptions): Promise<PaseoProviderModelsResult>;
+    listModes(provider: PaseoAgentProvider, options?: PaseoProviderListOptions): Promise<PaseoProviderModesResult>;
+    listFeatures(draftConfig: PaseoProviderFeaturesInput, options?: {
+        requestId?: string;
+    }): Promise<PaseoProviderFeaturesResult>;
+    listAvailable(options?: {
+        requestId?: string;
+    }): Promise<PaseoProviderAvailabilityResult>;
+    snapshot(options?: PaseoProviderListOptions): Promise<PaseoProviderSnapshotResult>;
+    /** Resolves after the daemon's lazy provider discovery has finished. */
+    waitForReady(options?: PaseoProviderWaitOptions): Promise<PaseoProviderSnapshotResult>;
+    refresh(options?: PaseoProviderRefreshOptions): Promise<PaseoProviderRefreshResult>;
+    diagnostic(provider: PaseoAgentProvider, options?: {
+        requestId?: string;
+    }): Promise<PaseoProviderDiagnosticResult>;
+    listUsage(options?: PaseoProviderUsageOptions): Promise<PaseoProviderUsageResult>;
+    subscribe(handler: (update: PaseoProviderSnapshotUpdate) => void): () => void;
+}
+export interface PaseoConfigActions {
+    /**
+     * Reads daemon config through the existing config RPC. Provider profiles,
+     * custom provider entries, keys/env, custom binaries, and provider enablement
+     * are currently config-file-shaped daemon state, so the SDK exposes this raw
+     * typed surface instead of pretending there are higher-level provider-settings
+     * RPCs.
+     */
+    get(requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+    /**
+     * Patches daemon config through the existing config RPC. The daemon validates
+     * and persists supported fields; unsupported provider/settings workflows remain
+     * daemon gaps until first-class RPCs exist.
+     */
+    patch(config: MutableDaemonConfigPatch, requestId?: string): Promise<{
+        requestId: string;
+        config: MutableDaemonConfig;
+    }>;
+}
+export interface PaseoApi {
+    readonly terminals: PaseoTerminalActions;
+    readonly workspaces: PaseoWorkspaceActions;
+    readonly projects: PaseoProjectActions;
+    readonly agents: PaseoAgentActions;
+    readonly providers: PaseoProviderActions;
+    readonly config: PaseoConfigActions;
+}
+export interface PaseoClient extends PaseoApi {
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    ensureConnected(): void;
+    getConnectionState(): ConnectionState;
+}
+export declare function createPaseoClient(config: PaseoClientConfig): PaseoClient;
+export declare function createPaseoApi(daemonClient: DaemonClient): PaseoApi;
+//# sourceMappingURL=index.d.ts.map