@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/providers/codex-feature-definitions.d.ts

@@ -0,0 +1,11 @@
+import type { AgentFeature, AgentFeatureToggle } from "../agent-sdk-types.js";
+export declare const CODEX_FAST_MODE_FEATURE: Omit<AgentFeatureToggle, "value">;
+export declare const CODEX_PLAN_MODE_FEATURE: Omit<AgentFeatureToggle, "value">;
+export declare function codexModelSupportsFastMode(modelId: string | null | undefined): boolean;
+export declare function buildCodexFeatures(input: {
+    modelId: string | null | undefined;
+    fastModeEnabled: boolean;
+    planModeEnabled: boolean;
+    planModeAvailable?: boolean;
+}): AgentFeature[];
+//# sourceMappingURL=codex-feature-definitions.d.ts.map

package/dist/server/server/agent/providers/codex-feature-definitions.js

@@ -0,0 +1,45 @@
+const CODEX_FAST_MODE_SUPPORTED_MODEL_PREFIXES = ["gpt-5", "gpt-4.1", "o3", "o4-mini"];
+export const CODEX_FAST_MODE_FEATURE = {
+    type: "toggle",
+    id: "fast_mode",
+    label: "Fast",
+    description: "Priority inference at 2x usage",
+    tooltip: "Toggle fast mode",
+    icon: "zap",
+};
+export const CODEX_PLAN_MODE_FEATURE = {
+    type: "toggle",
+    id: "plan_mode",
+    label: "Plan",
+    description: "Switch Codex into planning-only collaboration mode",
+    tooltip: "Toggle plan mode",
+    icon: "list-todo",
+};
+function normalizeCodexModelId(modelId) {
+    const normalized = typeof modelId === "string" ? modelId.trim() : "";
+    return normalized.length > 0 ? normalized : null;
+}
+export function codexModelSupportsFastMode(modelId) {
+    const normalizedModelId = normalizeCodexModelId(modelId);
+    if (!normalizedModelId) {
+        return false;
+    }
+    return CODEX_FAST_MODE_SUPPORTED_MODEL_PREFIXES.some((prefix) => normalizedModelId === prefix || normalizedModelId.startsWith(prefix));
+}
+export function buildCodexFeatures(input) {
+    const features = [];
+    if (codexModelSupportsFastMode(input.modelId)) {
+        features.push({
+            ...CODEX_FAST_MODE_FEATURE,
+            value: input.fastModeEnabled,
+        });
+    }
+    if (input.planModeAvailable !== false) {
+        features.push({
+            ...CODEX_PLAN_MODE_FEATURE,
+            value: input.planModeEnabled,
+        });
+    }
+    return features;
+}
+//# sourceMappingURL=codex-feature-definitions.js.map

package/dist/server/server/agent/providers/copilot-acp-agent.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "pino";
+import type { SessionConfigOption } from "@agentclientprotocol/sdk";
+import type { AgentMode } from "../agent-sdk-types.js";
+import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
+import { ACPAgentClient, type ACPConfigFeatureOption, type ACPBeforeModeWriteResult, type ACPProviderModeWriteResult, type ACPProviderModeWriterContext, type SessionStateResponse } from "./acp-agent.js";
+export declare const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
+export declare const COPILOT_AGENT_FEATURE_OPTION: ACPConfigFeatureOption;
+export declare const COPILOT_MODES: AgentMode[];
+interface CopilotACPAgentClientOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+}
+export declare class CopilotACPAgentClient extends ACPAgentClient {
+    constructor(options: CopilotACPAgentClientOptions);
+    isAvailable(): Promise<boolean>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+}
+export declare function transformCopilotSessionResponse(response: SessionStateResponse): SessionStateResponse;
+export declare function transformCopilotConfigOptions(configOptions: SessionConfigOption[]): SessionConfigOption[];
+export declare function transformCopilotModeId(modeId: string): string | null;
+export declare function writeCopilotProviderMode(context: ACPProviderModeWriterContext): Promise<ACPProviderModeWriteResult>;
+export declare function beforeCopilotModeWriter(context: ACPProviderModeWriterContext): Promise<ACPBeforeModeWriteResult>;
+export {};
+//# sourceMappingURL=copilot-acp-agent.d.ts.map

package/dist/server/server/agent/providers/copilot-acp-agent.js

@@ -0,0 +1,187 @@
+import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../provider-launch-config.js";
+import { ACPAgentClient, } from "./acp-agent.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, } from "./diagnostic-utils.js";
+const COPILOT_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsSessionListing: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+const COPILOT_AGENT_MODE_ID = "https://agentclientprotocol.com/protocol/session-modes#agent";
+const COPILOT_PLAN_MODE_ID = "https://agentclientprotocol.com/protocol/session-modes#plan";
+const COPILOT_AUTOPILOT_MODE_ID = "https://agentclientprotocol.com/protocol/session-modes#autopilot";
+export const COPILOT_ALLOW_ALL_MODE_ID = "allow-all";
+const COPILOT_ALLOW_ALL_CONFIG_ID = "allow_all";
+const COPILOT_ALLOW_ALL_ON = "on";
+const COPILOT_ALLOW_ALL_OFF = "off";
+export const COPILOT_AGENT_FEATURE_OPTION = {
+    id: "agent",
+    configId: "agent",
+    category: "_agent",
+    label: "Agent",
+    description: "Use a Copilot custom agent profile",
+    tooltip: "Select Copilot agent",
+    emptyOptionLabel: "Default",
+};
+export const COPILOT_MODES = [
+    {
+        id: COPILOT_AGENT_MODE_ID,
+        label: "Agent",
+        description: "Default agent mode for conversational interactions",
+    },
+    {
+        id: COPILOT_PLAN_MODE_ID,
+        label: "Plan",
+        description: "Plan mode for creating and executing multi-step plans",
+    },
+    {
+        id: COPILOT_ALLOW_ALL_MODE_ID,
+        label: "Allow All",
+        description: "Automatically approves all Copilot tool, path, and URL requests.",
+    },
+];
+export class CopilotACPAgentClient extends ACPAgentClient {
+    constructor(options) {
+        super({
+            provider: "copilot",
+            logger: options.logger,
+            runtimeSettings: options.runtimeSettings,
+            defaultCommand: ["copilot", "--acp"],
+            defaultModes: COPILOT_MODES,
+            sessionResponseTransformer: transformCopilotSessionResponse,
+            configOptionsTransformer: transformCopilotConfigOptions,
+            configFeatureOptions: [COPILOT_AGENT_FEATURE_OPTION],
+            modeIdTransformer: transformCopilotModeId,
+            providerModeWriter: writeCopilotProviderMode,
+            beforeModeWriter: beforeCopilotModeWriter,
+            capabilities: COPILOT_CAPABILITIES,
+        });
+    }
+    async isAvailable() {
+        return super.isAvailable();
+    }
+    async getDiagnostic() {
+        try {
+            const launch = await resolveProviderLaunch({
+                commandConfig: this.runtimeSettings?.command,
+                defaultBinary: "copilot",
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            return {
+                diagnostic: formatProviderDiagnostic("Copilot", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["copilot"],
+                    })),
+                    ...(await buildBinaryDiagnosticRows(launch, availability)),
+                ]),
+            };
+        }
+        catch (error) {
+            return {
+                diagnostic: formatProviderDiagnosticError("Copilot", error),
+            };
+        }
+    }
+}
+export function transformCopilotSessionResponse(response) {
+    if (!response.modes) {
+        return response;
+    }
+    const allowAllEnabled = isCopilotAllowAllEnabled(response.configOptions ?? []);
+    return {
+        ...response,
+        modes: {
+            ...response.modes,
+            availableModes: response.modes.availableModes
+                ?.filter((mode) => mode.id !== COPILOT_AUTOPILOT_MODE_ID && mode.id !== COPILOT_ALLOW_ALL_MODE_ID)
+                .concat({
+                id: COPILOT_ALLOW_ALL_MODE_ID,
+                name: "Allow All",
+                description: "Automatically approves all Copilot tool, path, and URL requests.",
+            }),
+            currentModeId: allowAllEnabled
+                ? COPILOT_ALLOW_ALL_MODE_ID
+                : (transformCopilotModeId(response.modes.currentModeId ?? COPILOT_AGENT_MODE_ID) ??
+                    COPILOT_AGENT_MODE_ID),
+        },
+    };
+}
+export function transformCopilotConfigOptions(configOptions) {
+    const allowAllEnabled = isCopilotAllowAllEnabled(configOptions);
+    return configOptions.map((option) => {
+        if (option.type !== "select" || option.category !== "mode") {
+            return option;
+        }
+        // Trust Copilot's allow_all config value as the source of truth when it changes in-process.
+        const options = flattenCopilotModeOptions(option.options)
+            .filter((choice) => choice.value !== COPILOT_AUTOPILOT_MODE_ID && choice.value !== COPILOT_ALLOW_ALL_MODE_ID)
+            .concat({
+            value: COPILOT_ALLOW_ALL_MODE_ID,
+            name: "Allow All",
+            description: "Automatically approves all Copilot tool, path, and URL requests.",
+        });
+        return {
+            ...option,
+            currentValue: allowAllEnabled
+                ? COPILOT_ALLOW_ALL_MODE_ID
+                : (transformCopilotModeId(option.currentValue) ?? COPILOT_AGENT_MODE_ID),
+            options,
+        };
+    });
+}
+function flattenCopilotModeOptions(options) {
+    const flattened = [];
+    for (const option of options) {
+        if ("value" in option) {
+            flattened.push(option);
+            continue;
+        }
+        flattened.push(...option.options);
+    }
+    return flattened;
+}
+export function transformCopilotModeId(modeId) {
+    return modeId === COPILOT_AUTOPILOT_MODE_ID ? COPILOT_AGENT_MODE_ID : modeId;
+}
+export async function writeCopilotProviderMode(context) {
+    // COMPAT(copilotAutopilotMode): added in v0.1.75, remove after 2026-11-12 once old clients no longer send Copilot's old ACP autopilot mode ID.
+    const requestsAllowAll = context.requestedModeId === COPILOT_ALLOW_ALL_MODE_ID ||
+        context.requestedModeId === COPILOT_AUTOPILOT_MODE_ID;
+    if (!requestsAllowAll) {
+        return { handled: false };
+    }
+    const response = await context.connection.setSessionConfigOption({
+        sessionId: context.sessionId,
+        configId: COPILOT_ALLOW_ALL_CONFIG_ID,
+        value: COPILOT_ALLOW_ALL_ON,
+    });
+    return {
+        handled: true,
+        currentModeId: COPILOT_ALLOW_ALL_MODE_ID,
+        configOptions: response.configOptions,
+    };
+}
+export async function beforeCopilotModeWriter(context) {
+    if (context.currentModeId !== COPILOT_ALLOW_ALL_MODE_ID ||
+        context.requestedModeId === COPILOT_ALLOW_ALL_MODE_ID) {
+        return {};
+    }
+    const response = await context.connection.setSessionConfigOption({
+        sessionId: context.sessionId,
+        configId: COPILOT_ALLOW_ALL_CONFIG_ID,
+        value: COPILOT_ALLOW_ALL_OFF,
+    });
+    return { configOptions: response.configOptions };
+}
+function isCopilotAllowAllEnabled(configOptions) {
+    return configOptions.some((option) => option.type === "select" &&
+        option.id === COPILOT_ALLOW_ALL_CONFIG_ID &&
+        option.currentValue === COPILOT_ALLOW_ALL_ON);
+}
+//# sourceMappingURL=copilot-acp-agent.js.map

package/dist/server/server/agent/providers/cursor-acp-agent.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "pino";
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+interface CursorACPAgentClientOptions {
+    logger: Logger;
+    command: [string, ...string[]];
+    env?: Record<string, string>;
+    providerId?: string;
+    label?: string;
+    providerParams?: unknown;
+}
+export declare class CursorACPAgentClient extends GenericACPAgentClient {
+    constructor(options: CursorACPAgentClientOptions);
+}
+export {};
+//# sourceMappingURL=cursor-acp-agent.d.ts.map

package/dist/server/server/agent/providers/cursor-acp-agent.js

@@ -0,0 +1,18 @@
+import { GenericACPAgentClient } from "./generic-acp-agent.js";
+const CURSOR_INITIAL_COMMANDS_WAIT_TIMEOUT_MS = 10000;
+export class CursorACPAgentClient extends GenericACPAgentClient {
+    constructor(options) {
+        super({
+            logger: options.logger,
+            command: options.command,
+            env: options.env,
+            providerId: options.providerId,
+            label: options.label,
+            providerParams: options.providerParams,
+            // cursor-agent publishes slash commands asynchronously via available_commands_update.
+            waitForInitialCommands: true,
+            initialCommandsWaitTimeoutMs: CURSOR_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,
+        });
+    }
+}
+//# sourceMappingURL=cursor-acp-agent.js.map

package/dist/server/server/agent/providers/diagnostic-utils.d.ts

@@ -0,0 +1,36 @@
+import { type ProviderLaunchAvailability, type ProviderRuntimeSettings, type ResolvedProviderLaunch } from "../provider-launch-config.js";
+export interface DiagnosticEntry {
+    label: string;
+    value: string;
+}
+export declare function formatProviderDiagnostic(providerName: string, entries: DiagnosticEntry[]): string;
+export declare function formatProviderDiagnosticError(providerName: string, error: unknown): string;
+export declare function formatAvailabilityStatus(available: boolean): string;
+export declare function formatDiagnosticStatus(available: boolean, error?: {
+    source: string;
+    cause: unknown;
+}): string;
+export declare function truncateForDiagnostic(value: string): string;
+export declare function toDiagnosticErrorMessage(error: unknown): string;
+export declare function resolveBinaryVersion(binaryPath: string): Promise<string>;
+export interface BinaryDiagnosticVersionCommand {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+}
+export interface BinaryDiagnosticRowsOptions {
+    binaryLabel?: string;
+    versionCommand?: BinaryDiagnosticVersionCommand;
+}
+export interface CommandResolutionDiagnosticRowsOptions {
+    knownBinaryNames: readonly string[];
+    includeCommandProbes?: boolean;
+    pathValue?: string;
+    pathext?: string;
+    platform?: NodeJS.Platform;
+    shell?: string;
+}
+export declare function buildCommandResolutionDiagnosticRows(launch: ResolvedProviderLaunch, options: CommandResolutionDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
+export declare function buildBinaryDiagnosticRows(launch: ResolvedProviderLaunch, availability: ProviderLaunchAvailability, options?: BinaryDiagnosticRowsOptions): Promise<DiagnosticEntry[]>;
+export declare function formatConfiguredCommand(defaultArgv: readonly string[], runtimeSettings?: ProviderRuntimeSettings): string;
+//# sourceMappingURL=diagnostic-utils.d.ts.map