@camerontaylor/paseo-plugin 0.8.0-fork.1

package/dist/server/acp.d.ts

@@ -0,0 +1,112 @@
+import type { JsonValue } from "@camerontaylor/paseo-protocol/agent-types";
+import type { ProviderCatalog, ProviderCommand, ProviderConfigState, ProviderNotice, ProviderRegistration, ProviderTimelineItem } from "./provider.js";
+interface RunAcpProviderBaseOptions {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    acpOptions?: AcpOptions;
+    transformers?: readonly AcpTransformer[];
+}
+export type RunAcpProviderOptions = RunAcpProviderBaseOptions & ({
+    command: readonly [string, ...string[]];
+    connector?: never;
+} | {
+    connector: AcpConnector;
+    command?: never;
+});
+export type AcpStreamMessage = {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: unknown;
+} | {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+} | {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result: unknown;
+} | {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+export interface AcpStream {
+    writable: WritableStream<AcpStreamMessage>;
+    readable: ReadableStream<AcpStreamMessage>;
+}
+export type AcpConnector = () => AcpStream | Promise<AcpStream>;
+export interface AcpOptions {
+    protocol?: "auto" | "v1";
+    startupTimeoutMs?: number;
+    waitForInitialCommands?: boolean;
+    initialCommandsTimeoutMs?: number;
+}
+export interface AcpContext {
+    sessionId: string;
+}
+export interface AcpConfigAccess {
+    read(): Promise<Readonly<Record<string, JsonValue>>>;
+    set(id: string, value: JsonValue): Promise<void>;
+}
+export interface AcpDiscoveryContext extends AcpContext {
+    config: AcpConfigAccess;
+}
+export interface AcpConfigureContext extends AcpContext {
+    config: AcpConfigAccess;
+}
+export type AcpConfigChange = {
+    target: "model";
+    value: string | null;
+} | {
+    target: "mode";
+    value: string | null;
+} | {
+    target: "thinking";
+    value: string | null;
+} | {
+    target: "setting";
+    id: string;
+    value: JsonValue;
+};
+export interface AcpToolCallSnapshot {
+    id: string;
+    name?: string;
+    title: string;
+    kind?: string;
+    status: "pending" | "in_progress" | "completed" | "failed";
+    input: JsonValue;
+    output: JsonValue;
+    locations: readonly string[];
+}
+export type AcpVendorUpdate = {
+    type: "commands";
+    commands: readonly ProviderCommand[];
+} | {
+    type: "config";
+    config: ProviderConfigState;
+} | {
+    type: "timeline";
+    item: ProviderTimelineItem;
+} | {
+    type: "notice";
+    notice: ProviderNotice;
+};
+export interface AcpTransformer {
+    discover?(catalog: ProviderCatalog, context: AcpDiscoveryContext): Promise<ProviderCatalog> | ProviderCatalog;
+    configure?(change: AcpConfigChange, context: AcpConfigureContext): Promise<"handled" | "pass">;
+    notification?(notification: {
+        method: string;
+        params: JsonValue;
+    }, context: AcpContext): AcpVendorUpdate | readonly AcpVendorUpdate[] | null;
+    toolCall?(toolCall: AcpToolCallSnapshot, context: AcpContext): AcpToolCallSnapshot;
+}
+export declare function runAcpProvider(options: RunAcpProviderOptions): ProviderRegistration;
+export {};
+//# sourceMappingURL=acp.d.ts.map

package/dist/server/acp.js

@@ -0,0 +1,21 @@
+import { createAcpProviderConnection } from "./acp-internal/connection.js";
+export function runAcpProvider(options) {
+    const hasCommand = options.command !== undefined;
+    const hasConnector = options.connector !== undefined;
+    if (hasCommand === hasConnector) {
+        throw new Error("ACP provider requires exactly one command or SDK connector");
+    }
+    if (options.command && (options.command.length === 0 || options.command[0].trim().length === 0)) {
+        throw new Error("ACP provider command must contain an executable");
+    }
+    return {
+        id: options.id,
+        label: options.label,
+        description: options.description,
+        icon: options.icon,
+        connect(request) {
+            return createAcpProviderConnection(options, request);
+        },
+    };
+}
+//# sourceMappingURL=acp.js.map

package/dist/server/contracts.d.ts

@@ -0,0 +1,16 @@
+import type { PaseoApi } from "@camerontaylor/paseo-client";
+import type { ZodType, input as ZodInput, output as ZodOutput } from "zod";
+import type { PluginRpcContract } from "../rpc.js";
+import type { PluginCleanup } from "../contracts.js";
+import type { ProviderRegistration } from "./provider.js";
+import type { PluginLifecycleRegistration } from "./lifecycle.js";
+export interface PluginHandlerContext {
+    paseo: PaseoApi;
+}
+export interface PluginServerContext extends PluginLifecycleRegistration {
+    registerSettings<Schema extends ZodType>(definition: import("../settings.js").SettingsDefinition<Schema>): void;
+    handle<InputSchema extends ZodType, OutputSchema extends ZodType>(contract: PluginRpcContract<InputSchema, OutputSchema>, handler: (input: ZodOutput<InputSchema>, context: PluginHandlerContext) => ZodInput<OutputSchema> | Promise<ZodInput<OutputSchema>>): void;
+    registerProvider(provider: ProviderRegistration): void;
+}
+export type PluginServerContribution = (server: PluginServerContext) => PluginCleanup;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/server/contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export type { PluginHandlerContext, PluginServerContext, PluginServerContribution, } from "./contracts.js";
+export type { PluginHookContext, PluginHookWorkspace, PluginHookAgent, PluginSessionOpenRequest, PluginTurnOutcome, PluginLifecycleEvents, PluginBeforeRequests, PluginLifecycleRegistration, } from "./lifecycle.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/server/lifecycle.d.ts

@@ -0,0 +1,92 @@
+import type { AgentPermissionRequest, AgentPermissionResponse, AgentTimelineItem, AgentSessionConfig } from "@camerontaylor/paseo-protocol/agent-types";
+import type { PaseoApi } from "@camerontaylor/paseo-client";
+import type { WorkspaceCreateRequest } from "@camerontaylor/paseo-protocol/messages";
+export interface PluginHookContext {
+    paseo: PaseoApi;
+    signal: AbortSignal;
+}
+export interface PluginHookWorkspace {
+    id: string;
+    projectId: string;
+    cwd: string;
+    name: string | null;
+    archivedAt: string | null;
+}
+export interface PluginHookAgent {
+    id: string;
+    workspaceId: string | null;
+    parentAgentId: string | null;
+    provider: string;
+    cwd: string;
+    title: string | null;
+}
+export interface PluginSessionOpenRequest {
+    agentId: string;
+    workspaceId: string | null;
+    provider: string;
+    cwd: string;
+    reason: "create" | "resume" | "refresh" | "import";
+    purpose: "interactive" | "history";
+    env: Record<string, string>;
+}
+export type PluginTurnOutcome = {
+    kind: "completed";
+} | {
+    kind: "failed";
+    error: {
+        message: string;
+        code?: string;
+    };
+} | {
+    kind: "canceled";
+    reason: string;
+};
+export interface PluginLifecycleEvents {
+    "agent.turn_started": {
+        agent: PluginHookAgent;
+        turnId: string | null;
+    };
+    "agent.turn_ended": {
+        agent: PluginHookAgent;
+        turnId: string | null;
+        outcome: PluginTurnOutcome;
+        timeline: readonly AgentTimelineItem[];
+    };
+    "agent.permission_requested": {
+        agent: PluginHookAgent;
+        request: AgentPermissionRequest;
+    };
+    "agent.permission_resolved": {
+        agent: PluginHookAgent;
+        requestId: string;
+        resolution: AgentPermissionResponse;
+    };
+    "agent.archived": {
+        agent: PluginHookAgent;
+        archivedAt: string;
+    };
+    "agent.created": {
+        agent: PluginHookAgent;
+    };
+    "workspace.created": {
+        workspace: PluginHookWorkspace;
+    };
+    "workspace.archived": {
+        workspace: PluginHookWorkspace;
+    };
+}
+export interface PluginBeforeRequests {
+    "agent.create": {
+        config: AgentSessionConfig;
+        env?: Record<string, string>;
+    };
+    "agent.session_open": PluginSessionOpenRequest;
+    "workspace.create": Omit<WorkspaceCreateRequest, "type" | "requestId">;
+}
+export interface PluginLifecycleRegistration {
+    on<Name extends keyof PluginLifecycleEvents>(name: Name, handler: (event: PluginLifecycleEvents[Name], context: PluginHookContext) => void | Promise<void>): () => void;
+    before<Name extends keyof PluginBeforeRequests>(name: Name, handler: (input: {
+        request: PluginBeforeRequests[Name];
+    }, context: PluginHookContext) => PluginBeforeRequests[Name] | void | Promise<PluginBeforeRequests[Name] | void>): () => void;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/server/lifecycle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lifecycle.js.map