@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/prompt-attachments.js

@@ -0,0 +1,90 @@
+import { renderFileAttachmentAsText } from "./render-file-attachment.js";
+const REVIEW_LINE_MARKERS = { add: "+", remove: "-", context: " " };
+export function renderPromptAttachmentAsText(attachment) {
+    switch (attachment.type) {
+        case "github_pr": {
+            const lines = [`GitHub PR #${attachment.number}: ${attachment.title}`, attachment.url];
+            if (attachment.baseRefName) {
+                lines.push(`Base: ${attachment.baseRefName}`);
+            }
+            if (attachment.headRefName) {
+                lines.push(`Head: ${attachment.headRefName}`);
+            }
+            if (attachment.body) {
+                lines.push("", attachment.body);
+            }
+            return lines.join("\n");
+        }
+        case "github_issue": {
+            const lines = [`GitHub Issue #${attachment.number}: ${attachment.title}`, attachment.url];
+            if (attachment.body) {
+                lines.push("", attachment.body);
+            }
+            return lines.join("\n");
+        }
+        case "text": {
+            return attachment.text;
+        }
+        case "review": {
+            const lines = [`Paseo review attachment (${attachment.mode})`, `CWD: ${attachment.cwd}`];
+            if (attachment.baseRef) {
+                lines.push(`Base: ${attachment.baseRef}`);
+            }
+            attachment.comments.forEach((comment, index) => {
+                lines.push("", `Comment ${index + 1}: ${comment.filePath}:${comment.side}:${comment.lineNumber}`, comment.body, comment.context.hunkHeader);
+                const target = comment.context.targetLine;
+                for (const line of comment.context.lines) {
+                    const isTarget = line.oldLineNumber === target.oldLineNumber &&
+                        line.newLineNumber === target.newLineNumber &&
+                        line.type === target.type &&
+                        line.content === target.content;
+                    const prefix = isTarget ? "> " : "  ";
+                    const oldLn = padLineNumber(line.oldLineNumber);
+                    const newLn = padLineNumber(line.newLineNumber);
+                    lines.push(`${prefix}${oldLn} ${newLn} ${REVIEW_LINE_MARKERS[line.type]}${line.content}`);
+                }
+            });
+            return lines.join("\n");
+        }
+        case "file": {
+            // Single chokepoint — every provider routes the `file` variant here, and
+            // the format/formatter live only in `./render-file-attachment.js`.
+            return renderFileAttachmentAsText(attachment);
+        }
+        case "uploaded_file": {
+            return [
+                `Uploaded file: ${attachment.fileName}`,
+                `Path: ${attachment.path}`,
+                `MIME: ${attachment.mimeType}`,
+                `Size: ${attachment.size} bytes`,
+            ].join("\n");
+        }
+        default:
+            throw new Error("unreachable");
+    }
+}
+function padLineNumber(lineNumber) {
+    return (lineNumber?.toString() ?? "-").padStart(2);
+}
+export function buildAgentBranchNameSeed(firstAgentContext) {
+    if (!firstAgentContext) {
+        return undefined;
+    }
+    const parts = [];
+    const prompt = firstAgentContext.prompt?.trim();
+    if (prompt) {
+        parts.push(["<user-prompt>", prompt, "</user-prompt>"].join("\n"));
+    }
+    const renderedAttachments = [];
+    for (const attachment of firstAgentContext.attachments ?? []) {
+        const rendered = renderPromptAttachmentAsText(attachment).trim();
+        if (rendered) {
+            renderedAttachments.push(rendered);
+        }
+    }
+    if (renderedAttachments.length > 0) {
+        parts.push(["<attachments>", renderedAttachments.join("\n\n"), "</attachments>"].join("\n"));
+    }
+    return parts.length > 0 ? parts.join("\n\n") : undefined;
+}
+//# sourceMappingURL=prompt-attachments.js.map

package/dist/server/server/agent/provider-config-reload.d.ts

@@ -0,0 +1,27 @@
+import { type LoggerLike } from "../persisted-config.js";
+import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
+export interface ProviderOverridesFromDisk {
+    providerOverrides: Record<string, ProviderOverride> | undefined;
+    runtimeSettings: AgentProviderRuntimeSettingsMap | undefined;
+}
+/** What a reload changed, relative to the overrides the daemon was holding. */
+export interface ProviderOverridesDiff {
+    added: string[];
+    updated: string[];
+    removed: string[];
+    unchanged: string[];
+}
+export declare function isProviderOverridesDiffEmpty(diff: ProviderOverridesDiff): boolean;
+/**
+ * Read `agents.providers` out of `$PASEO_HOME/config.json` and derive both maps
+ * the registry needs. Mirrors what `resolveConfig` does at bootstrap so a
+ * reloaded daemon lands in the same state a freshly started one would.
+ */
+export declare function readProviderOverridesFromDisk(paseoHome: string, logger?: LoggerLike): ProviderOverridesFromDisk;
+/**
+ * Structural diff of two override maps. Compared by value, not identity: a
+ * reload that reads back an unchanged file reports every provider as
+ * `unchanged`, so `provider reload` is safely idempotent.
+ */
+export declare function diffProviderOverrides(previous: Record<string, ProviderOverride> | undefined, next: Record<string, ProviderOverride> | undefined): ProviderOverridesDiff;
+//# sourceMappingURL=provider-config-reload.d.ts.map

package/dist/server/server/agent/provider-config-reload.js

@@ -0,0 +1,65 @@
+/**
+ * Re-reading `$PASEO_HOME/config.json` into the live provider registry.
+ *
+ * The daemon already rebuilds its provider registry without a restart whenever
+ * the *mutable* daemon config changes (`DaemonConfigStore.onChange` ->
+ * `ProviderSnapshotManager.applyMutableProviderConfig`). What it never did was
+ * re-read the config *file*: `providerOverrides` and `agentProviderSettings`
+ * were resolved once at bootstrap, so a hand-edited `agents.providers` block
+ * only took effect after `paseo daemon restart`.
+ *
+ * This module owns the file half of that reload: read config.json, re-derive
+ * both override maps, and diff old vs new so callers can report what actually
+ * changed. It deliberately holds no daemon state — the manager applies it.
+ *
+ * NOTE ON REMOVAL: a mutable-config *patch* deep-merges and therefore can only
+ * add or update. Removing a provider requires replacing the base override map
+ * wholesale, which is why this path exists separately from the patch path.
+ */
+import { extractAgentProviderSettings, extractProviderOverrides } from "../config.js";
+import { loadPersistedConfig } from "../persisted-config.js";
+export function isProviderOverridesDiffEmpty(diff) {
+    return diff.added.length === 0 && diff.updated.length === 0 && diff.removed.length === 0;
+}
+/**
+ * Read `agents.providers` out of `$PASEO_HOME/config.json` and derive both maps
+ * the registry needs. Mirrors what `resolveConfig` does at bootstrap so a
+ * reloaded daemon lands in the same state a freshly started one would.
+ */
+export function readProviderOverridesFromDisk(paseoHome, logger) {
+    const persisted = loadPersistedConfig(paseoHome, logger);
+    const providerOverrides = extractProviderOverrides(persisted.agents?.providers);
+    return {
+        providerOverrides,
+        runtimeSettings: extractAgentProviderSettings(providerOverrides),
+    };
+}
+/**
+ * Structural diff of two override maps. Compared by value, not identity: a
+ * reload that reads back an unchanged file reports every provider as
+ * `unchanged`, so `provider reload` is safely idempotent.
+ */
+export function diffProviderOverrides(previous, next) {
+    const before = previous ?? {};
+    const after = next ?? {};
+    const diff = { added: [], updated: [], removed: [], unchanged: [] };
+    for (const providerId of Object.keys(after).sort()) {
+        if (!Object.hasOwn(before, providerId)) {
+            diff.added.push(providerId);
+            continue;
+        }
+        if (JSON.stringify(before[providerId]) === JSON.stringify(after[providerId])) {
+            diff.unchanged.push(providerId);
+        }
+        else {
+            diff.updated.push(providerId);
+        }
+    }
+    for (const providerId of Object.keys(before).sort()) {
+        if (!Object.hasOwn(after, providerId)) {
+            diff.removed.push(providerId);
+        }
+    }
+    return diff;
+}
+//# sourceMappingURL=provider-config-reload.js.map

package/dist/server/server/agent/provider-history-timestamps.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeProviderReplayTimestamp(value: unknown): string | null;
+//# sourceMappingURL=provider-history-timestamps.d.ts.map

package/dist/server/server/agent/provider-history-timestamps.js

@@ -0,0 +1,16 @@
+export function normalizeProviderReplayTimestamp(value) {
+    if (typeof value === "string") {
+        const timestamp = value.trim();
+        if (!timestamp || Number.isNaN(Date.parse(timestamp))) {
+            return null;
+        }
+        return timestamp;
+    }
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    const timestampMs = value > 1000000000000 ? value : value * 1000;
+    const date = new Date(timestampMs);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+//# sourceMappingURL=provider-history-timestamps.js.map

package/dist/server/server/agent/provider-launch-config.d.ts

@@ -0,0 +1,51 @@
+import { type ProcessEnvRecord } from "../paseo-env.js";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, type AgentProviderRuntimeSettingsMap, type ProviderCommand, type ProviderOverride, type ProviderOverrides, type ProviderRuntimeSettings, type ProviderProfileModel } from "@hyperdrive.bot/fleet-protocol/provider-config";
+export { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, };
+export type { AgentProviderRuntimeSettingsMap, ProviderCommand, ProviderOverride, ProviderOverrides, ProviderRuntimeSettings, ProviderProfileModel, };
+export interface ProviderCommandPrefix {
+    command: string;
+    args: string[];
+}
+export type ProviderLaunchSource = "default" | "append" | "override";
+export interface ResolvedProviderLaunch {
+    command: string;
+    args: string[];
+    source: ProviderLaunchSource;
+}
+export interface ProviderLaunchAvailability {
+    available: boolean;
+    resolvedPath: string | null;
+}
+export interface ProviderLaunchDefault {
+    command: string;
+    resolvePath?: () => Promise<string | null>;
+}
+export interface ResolveProviderLaunchOptions {
+    commandConfig?: ProviderCommand;
+    defaultBinary?: string | ProviderLaunchDefault;
+}
+export declare function resolveProviderLaunch({ commandConfig, defaultBinary, }: ResolveProviderLaunchOptions): Promise<ResolvedProviderLaunch>;
+export declare function checkProviderLaunchAvailable(launch: ResolvedProviderLaunch, defaultBinary?: ProviderLaunchDefault): Promise<ProviderLaunchAvailability>;
+export declare function resolveProviderCommandPrefix(commandConfig: ProviderCommand | undefined, resolveDefaultCommand: () => string | Promise<string>): Promise<ProviderCommandPrefix>;
+export declare function resolveShellEnv(): Record<string, string>;
+export declare function migrateProviderSettings(raw: Record<string, unknown>, builtinProviderIds: string[]): ProviderOverrides;
+export interface ProviderEnvOptions {
+    baseEnv?: ProcessEnvRecord;
+    runtimeSettings?: ProviderRuntimeSettings;
+    overlays?: Array<ProcessEnvRecord | undefined>;
+    /**
+     * Extra env keys to remove from the child on top of PARENT_SESSION_ENV_VARS.
+     * The PTY transport passes ANTHROPIC_API_KEY/ANTHROPIC_BASE_URL here so the
+     * interactive claude falls back to keychain OAuth (Max plan) instead of the
+     * daemon's API-key routing (Agent-SDK credit pool).
+     */
+    extraScrubKeys?: string[];
+}
+export interface ProviderEnvSpec {
+    baseEnv?: ProcessEnvRecord;
+    envOverlay: ProcessEnvRecord;
+}
+export declare function createProviderEnvSpec(options?: ProviderEnvOptions): ProviderEnvSpec;
+export declare function createProviderEnv(options?: ProviderEnvOptions): NodeJS.ProcessEnv;
+export declare function isProviderCommandAvailable(commandConfig: ProviderCommand | undefined, resolveDefaultCommand: () => string | Promise<string>): Promise<boolean>;
+//# sourceMappingURL=provider-launch-config.d.ts.map

package/dist/server/server/agent/provider-launch-config.js

@@ -0,0 +1,183 @@
+import { isAbsolute } from "node:path";
+// Single import+export block: imports schemas/types for local use AND re-exports
+// them for downstream consumers (claude/agent.ts, config.ts, session.ts,
+// persisted-config.ts, provider-registry.ts, opencode-agent.ts, bootstrap.ts,
+// exports.ts, and all per-provider files in agent/providers/). Combining the
+// two avoids the TS2459 "declares X locally but is not exported" trap that
+// hits when a separate `import { type X }` shadows an `export type { X } from`.
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
+import { createExternalProcessEnv } from "../paseo-env.js";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, } from "@hyperdrive.bot/fleet-protocol/provider-config";
+export { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, AgentProviderRuntimeSettingsMapSchema, ProviderProfileModelSchema, };
+function normalizeLaunchDefault(defaultBinary) {
+    if (typeof defaultBinary === "string") {
+        return { command: defaultBinary };
+    }
+    return defaultBinary;
+}
+async function resolveLaunchPath(command) {
+    const found = await findExecutable(command);
+    if (found) {
+        return found;
+    }
+    if (isAbsolute(command)) {
+        return executableExists(command);
+    }
+    return null;
+}
+async function resolveDefaultLaunchPath(defaultBinary) {
+    return defaultBinary.resolvePath
+        ? await defaultBinary.resolvePath()
+        : await resolveLaunchPath(defaultBinary.command);
+}
+export async function resolveProviderLaunch({ commandConfig, defaultBinary, }) {
+    if (commandConfig?.mode === "replace") {
+        const command = commandConfig.argv[0];
+        return {
+            command,
+            args: commandConfig.argv.slice(1),
+            source: "override",
+        };
+    }
+    if (defaultBinary === undefined) {
+        throw new Error("defaultBinary is required when provider command is not replaced");
+    }
+    const normalizedDefault = normalizeLaunchDefault(defaultBinary);
+    const args = commandConfig?.mode === "append" ? [...(commandConfig.args ?? [])] : [];
+    return {
+        command: normalizedDefault.command,
+        args,
+        source: commandConfig?.mode === "append" ? "append" : "default",
+    };
+}
+export async function checkProviderLaunchAvailable(launch, defaultBinary) {
+    const resolvedPath = defaultBinary && launch.source !== "override"
+        ? await resolveDefaultLaunchPath(defaultBinary)
+        : await resolveLaunchPath(launch.command);
+    return {
+        available: resolvedPath !== null,
+        resolvedPath,
+    };
+}
+export async function resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand) {
+    if (commandConfig?.mode === "replace") {
+        const launch = await resolveProviderLaunch({
+            commandConfig,
+        });
+        return {
+            command: launch.command,
+            args: launch.args,
+        };
+    }
+    const defaultCommand = await resolveDefaultCommand();
+    const launch = await resolveProviderLaunch({
+        commandConfig,
+        defaultBinary: {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        },
+    });
+    return {
+        command: launch.command,
+        args: launch.args,
+    };
+}
+let cachedShellEnv = null;
+export function resolveShellEnv() {
+    if (cachedShellEnv) {
+        return cachedShellEnv;
+    }
+    cachedShellEnv = { ...process.env };
+    return cachedShellEnv;
+}
+export function migrateProviderSettings(raw, builtinProviderIds) {
+    const migrated = {};
+    const builtinProviderIdSet = new Set(builtinProviderIds);
+    for (const [providerId, value] of Object.entries(raw)) {
+        const parsedNew = ProviderOverrideSchema.safeParse(value);
+        if (parsedNew.success) {
+            migrated[providerId] = parsedNew.data;
+            continue;
+        }
+        const parsedOld = ProviderRuntimeSettingsSchema.safeParse(value);
+        if (!parsedOld.success) {
+            continue;
+        }
+        const nextEntry = {};
+        const command = parsedOld.data.command;
+        if (command?.mode === "append") {
+            continue;
+        }
+        if (command?.mode === "replace") {
+            nextEntry.command = command.argv;
+        }
+        if (parsedOld.data.env) {
+            nextEntry.env = parsedOld.data.env;
+        }
+        if (!builtinProviderIdSet.has(providerId) && nextEntry.extends === undefined) {
+            delete nextEntry.extends;
+        }
+        migrated[providerId] = nextEntry;
+    }
+    return ProviderOverridesSchema.parse(migrated);
+}
+// Env vars that indicate a running Claude Code session. If the daemon itself is
+// launched from inside Claude Code (e.g. by a Paseo agent), these leak into
+// child processes and cause "cannot be launched inside another session" errors.
+const PARENT_SESSION_ENV_VARS = [
+    "CLAUDECODE",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_SSE_PORT",
+    "CLAUDE_AGENT_SDK_VERSION",
+    // A claude child that inherits these treats itself as a NESTED child session and
+    // does NOT persist its own transcript under ~/.claude/projects — which breaks the
+    // PTY transport's transcript reconstruction (it reads that JSONL). Scrub them so
+    // every spawned claude is a clean top-level `entrypoint:cli` session. Safe for the
+    // SDK path too: it binds sessions via query options (resume/sessionId), not env.
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDE_CODE_SESSION_ID",
+];
+function collectProviderEnvOverlays(runtimeSettings, overlays) {
+    return [runtimeSettings?.env, ...overlays].filter((overlay) => !!overlay);
+}
+export function createProviderEnvSpec(options = {}) {
+    const overlays = collectProviderEnvOverlays(options.runtimeSettings, options.overlays ?? []);
+    const envOverlay = Object.assign({}, ...overlays);
+    for (const key of PARENT_SESSION_ENV_VARS) {
+        envOverlay[key] = undefined;
+    }
+    for (const key of options.extraScrubKeys ?? []) {
+        envOverlay[key] = undefined;
+    }
+    return {
+        ...(options.baseEnv ? { baseEnv: options.baseEnv } : {}),
+        envOverlay,
+    };
+}
+export function createProviderEnv(options = {}) {
+    const spec = createProviderEnvSpec(options);
+    return createExternalProcessEnv(spec.baseEnv ?? process.env, spec.envOverlay);
+}
+export async function isProviderCommandAvailable(commandConfig, resolveDefaultCommand) {
+    try {
+        if (commandConfig?.mode === "replace") {
+            const launch = await resolveProviderLaunch({
+                commandConfig,
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            return availability.available;
+        }
+        const defaultCommand = await resolveDefaultCommand();
+        const defaultBinary = {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        };
+        const launch = await resolveProviderLaunch({ commandConfig, defaultBinary });
+        const availability = await checkProviderLaunchAvailable(launch, defaultBinary);
+        return availability.available;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=provider-launch-config.js.map

package/dist/server/server/agent/provider-notices.d.ts

@@ -0,0 +1,3 @@
+import type { AgentProviderNotice } from "./agent-sdk-types.js";
+export declare const SETTING_APPLIES_NEXT_TURN_NOTICE: AgentProviderNotice;
+//# sourceMappingURL=provider-notices.d.ts.map

package/dist/server/server/agent/provider-notices.js

@@ -0,0 +1,5 @@
+export const SETTING_APPLIES_NEXT_TURN_NOTICE = {
+    type: "info",
+    message: "This change applies next turn.",
+};
+//# sourceMappingURL=provider-notices.js.map

package/dist/server/server/agent/provider-registry-contract.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Compile-time guard: every optional method on `AgentSession` must be forwarded by
+ * `wrapSessionProvider`.
+ *
+ * WHY THIS FILE EXISTS, rather than living next to the wrapper's tests.
+ *
+ * An identical guard already existed in `provider-registry-wrap.test.ts` and never once
+ * fired, because nothing compiles it: `tsconfig.server.json` excludes `src/**\/*.test.ts`,
+ * so `npm run typecheck` skips it, and vitest transpiles with esbuild, which strips types
+ * without checking them. A type-level assertion in a test file is decoration.
+ *
+ * Five methods drifted past it before this was noticed -- the four background-task methods,
+ * and `resolveTranscriptTurnId`, whose loss broke "edit a message" on every `pool-*`
+ * provider while the undecorated `claude` provider worked, which is exactly the shape that
+ * makes this class of bug survive review.
+ *
+ * This file is ordinary source, so the typecheck job compiles it and the assertion below is
+ * a real build failure. Adding an optional method to `AgentSession` breaks the build until
+ * it is listed here AND forwarded in `wrapSessionProvider`.
+ */
+import type { AgentSession } from "./agent-sdk-types.js";
+/** Every optional, function-valued member of AgentSession. */
+type OptionalAgentSessionMethodName = {
+    [K in keyof AgentSession]-?: undefined extends AgentSession[K] ? NonNullable<AgentSession[K]> extends (...args: never[]) => unknown ? K : never : never;
+}[keyof AgentSession];
+/**
+ * The names `wrapSessionProvider` forwards. Keep in sync with that object literal --
+ * the runtime half of this contract lives in `provider-registry-wrap.test.ts` and asserts
+ * each of these actually survives wrapping.
+ */
+export declare const FORWARDED_OPTIONAL_SESSION_METHODS: readonly ["getActiveBackgroundTaskCount", "listBackgroundTasks", "readBackgroundTaskOutput", "dismissBackgroundTask", "listCommands", "setModel", "setThinkingOption", "setFeature", "revertConversation", "revertFiles", "revertBoth", "tryHandleOutOfBand", "resolveTranscriptTurnId", "capturePane"];
+type UnforwardedOptionalSessionMethod = Exclude<OptionalAgentSessionMethodName, (typeof FORWARDED_OPTIONAL_SESSION_METHODS)[number]>;
+/**
+ * Fails to compile when an optional AgentSession method is not listed above. The error
+ * reads `Type 'true' is not assignable to type 'never'`; the fix is to add the method to
+ * the list AND to `wrapSessionProvider`.
+ */
+export declare const _allOptionalSessionMethodsForwarded: UnforwardedOptionalSessionMethod extends never ? true : never;
+export {};
+//# sourceMappingURL=provider-registry-contract.d.ts.map

package/dist/server/server/agent/provider-registry-contract.js

@@ -0,0 +1,28 @@
+/**
+ * The names `wrapSessionProvider` forwards. Keep in sync with that object literal --
+ * the runtime half of this contract lives in `provider-registry-wrap.test.ts` and asserts
+ * each of these actually survives wrapping.
+ */
+export const FORWARDED_OPTIONAL_SESSION_METHODS = [
+    "getActiveBackgroundTaskCount",
+    "listBackgroundTasks",
+    "readBackgroundTaskOutput",
+    "dismissBackgroundTask",
+    "listCommands",
+    "setModel",
+    "setThinkingOption",
+    "setFeature",
+    "revertConversation",
+    "revertFiles",
+    "revertBoth",
+    "tryHandleOutOfBand",
+    "resolveTranscriptTurnId",
+    "capturePane",
+];
+/**
+ * Fails to compile when an optional AgentSession method is not listed above. The error
+ * reads `Type 'true' is not assignable to type 'never'`; the fix is to add the method to
+ * the list AND to `wrapSessionProvider`.
+ */
+export const _allOptionalSessionMethodsForwarded = true;
+//# sourceMappingURL=provider-registry-contract.js.map

package/dist/server/server/agent/provider-registry.d.ts

@@ -0,0 +1,97 @@
+import type { Logger } from "pino";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentProvider, AgentSession, FetchCatalogOptions, ProviderCatalog, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+import type { WorkspaceGitService } from "../workspace-git-service.js";
+import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
+import type { AgentProviderRuntimeSettingsMap, ProviderOverride, ProviderProfileModel } from "./provider-launch-config.js";
+import { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, type AgentProviderDefinition } from "@hyperdrive.bot/fleet-protocol/provider-manifest";
+export declare function resolveClaudeTransport(setting: "sdk" | "pty" | "auto" | undefined, deps?: {
+    requireNodePty?: () => unknown;
+    probeClaudeBinary?: () => void;
+}): "sdk" | "pty";
+/**
+ * Internal agents (session-digest and auto-title generation) are headless,
+ * one-shot, `persistSession: false` runs. They have no TUI to drive: they are
+ * handed a prompt and asked for one structured answer.
+ *
+ * `resolveClaudeTransport` returns "pty" whenever node-pty and the `claude`
+ * binary are both present, which on a developer box is always, so these runs
+ * were being given a full interactive terminal and their prompt written through
+ * the PTY's bracketed-paste path. That path can refuse the write when the TUI
+ * is not in an input-accepting state, and the caller sees:
+ *
+ *   "Your message did not reach the agent: the terminal would not accept it."
+ *
+ * Measured on 2026-08-04: 187 of 191 structured-generation failures (98%) were
+ * exactly that error, across claude/pool/pool-tu and across haiku, opus-5 and
+ * opus-4-8, so it is neither provider- nor model-specific. Each failure burned
+ * a provider attempt until the digest's 120s budget expired, losing ~46% of all
+ * digests (116 DigestGenerationTimeoutError against 113 successful digests that
+ * day). Every lost digest also silently costs a Jarvis judgement, because the
+ * judge only wakes on the `onSettled` hook that a completed digest fires.
+ *
+ * Two cheaper explanations were tested and rejected before this one: prompt
+ * size (2 KB / 8 KB / 32 KB pastes all delivered fine) and a spawn/readiness
+ * race (three spawn-then-immediately-send probes all delivered fine).
+ *
+ * So internal agents default to the SDK transport, which needs no terminal. An
+ * EXPLICIT `transport` setting still wins: this only redirects the "auto" case,
+ * so anyone deliberately pinning "pty" keeps it.
+ */
+export declare function resolveInternalAgentTransportSetting(internal: boolean | undefined, setting: "sdk" | "pty" | "auto" | undefined): "sdk" | "pty" | "auto" | undefined;
+export declare const NODE_PTY_UNAVAILABLE_REASON = "node-pty native module not built. Run 'npm rebuild node-pty' in packages/server.";
+export declare function isNodePtyAvailable(deps?: {
+    requireNodePty?: () => unknown;
+}): boolean;
+export type { AgentProviderDefinition };
+export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
+export interface ProviderDefinition extends AgentProviderDefinition {
+    enabled: boolean;
+    /**
+     * The id of another *registered* provider this one extends (e.g. a Z.AI
+     * profile that extends "claude"). null for built-in providers and for
+     * generic ACP providers (which only extend the literal "acp" sentinel).
+     */
+    derivedFromProviderId: string | null;
+    createClient: (logger: Logger) => AgentClient;
+    resolveCreateConfig: (input: ResolveAgentCreateConfigInput) => ResolveAgentCreateConfigResult;
+    isCreateConfigUnattended: (input: AgentCreateConfigUnattendedInput) => boolean;
+    /**
+     * Single catalog discovery call used by ProviderSnapshotManager. Should spawn
+     * at most one provider runtime process and return both models and modes.
+     */
+    fetchCatalog: (options: FetchCatalogOptions, client?: AgentClient) => Promise<ProviderCatalog>;
+}
+/**
+ * A custom provider that could not be resolved out of `agents.providers` and was
+ * therefore left out of the registry. `reason` is the underlying error message,
+ * e.g. "Custom provider 'zai' requires a label". Ids and reasons only - never the
+ * resolved `env`, which routinely holds API keys.
+ */
+export interface SkippedProvider {
+    provider: string;
+    reason: string;
+}
+export interface BuildProviderRegistryOptions {
+    runtimeSettings?: AgentProviderRuntimeSettingsMap;
+    providerOverrides?: Record<string, ProviderOverride>;
+    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    managedProcesses?: ManagedProcessRegistry;
+    isDev?: boolean;
+    /**
+     * Out-param: populated with every custom provider the build had to skip. An
+     * out-param rather than a widened return type because `buildProviderRegistry`
+     * returns the registry record itself to a dozen call sites, most of which do
+     * not care why a provider is missing.
+     */
+    skipped?: SkippedProvider[];
+}
+export declare function wrapSessionProvider(provider: AgentProvider, inner: AgentSession): AgentSession;
+export declare function wrapClientProvider(provider: AgentProvider, inner: AgentClient, profileModels: ProviderProfileModel[], additionalModels: ProviderProfileModel[], profileModelsAreAdditive: boolean): AgentClient;
+export declare function buildProviderRegistry(logger: Logger, options?: BuildProviderRegistryOptions): Record<AgentProvider, ProviderDefinition>;
+export declare function getProviderIds(registry: Record<AgentProvider, ProviderDefinition>): AgentProvider[];
+export declare const PROVIDER_REGISTRY: Record<AgentProvider, ProviderDefinition>;
+export declare function createAllClients(logger: Logger, options?: BuildProviderRegistryOptions): Record<AgentProvider, AgentClient>;
+export declare function createClientsFromRegistry(registry: Record<AgentProvider, ProviderDefinition>, logger: Logger): Record<AgentProvider, AgentClient>;
+export declare function shutdownProviders(logger: Logger, options?: BuildProviderRegistryOptions): Promise<void>;
+export declare function shutdownAgentClients(clients: Iterable<AgentClient>, logger: Logger): Promise<void>;
+//# sourceMappingURL=provider-registry.d.ts.map