@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/prompt-attachments.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAttachment } from "@camerontaylor/paseo-protocol/messages";
+import type { AgentPromptInput } from "./agent-sdk-types.js";
+export declare function buildAgentPrompt(text: string, images?: Array<{
+    data: string;
+    mimeType: string;
+}>, attachments?: AgentAttachment[]): AgentPromptInput;
+export declare function renderPromptAttachmentAsText(attachment: AgentAttachment): string;
+export declare function buildAgentBranchNameSeed(firstAgentContext: {
+    prompt?: string;
+    attachments?: readonly AgentAttachment[];
+} | undefined): string | undefined;
+//# sourceMappingURL=prompt-attachments.d.ts.map

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

@@ -0,0 +1,182 @@
+import { getForgeDefinitionOrNeutral } from "@camerontaylor/paseo-protocol/forge-manifest";
+const REVIEW_LINE_MARKERS = { add: "+", remove: "-", context: " " };
+export function buildAgentPrompt(text, images, attachments) {
+    const normalized = text.trim();
+    const hasImages = (images?.length ?? 0) > 0;
+    const hasAttachments = (attachments?.length ?? 0) > 0;
+    if (!hasImages && !hasAttachments) {
+        return normalized;
+    }
+    const chatHistoryAttachments = [];
+    const otherAttachments = [];
+    for (const attachment of attachments ?? []) {
+        if (attachment.type === "text" && attachment.contextKind === "chat_history") {
+            chatHistoryAttachments.push(attachment);
+        }
+        else {
+            otherAttachments.push(attachment);
+        }
+    }
+    const blocks = [...chatHistoryAttachments];
+    if (normalized.length > 0) {
+        blocks.push({ type: "text", text: normalized });
+    }
+    for (const image of images ?? []) {
+        blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    }
+    blocks.push(...otherAttachments);
+    return blocks;
+}
+export function renderPromptAttachmentAsText(attachment) {
+    switch (attachment.type) {
+        case "forge_change_request": {
+            return renderChangeRequestAttachment({
+                forge: attachment.forge,
+                number: attachment.number,
+                title: attachment.title,
+                url: attachment.url,
+                body: attachment.body,
+                projectPath: attachment.projectPath,
+                baseRefName: attachment.baseRefName,
+                headRefName: attachment.headRefName,
+            });
+        }
+        // COMPAT(githubAttachmentKinds): render legacy wire attachments until
+        // 2027-01-17, when supported client and daemon floors are >= v0.2.0.
+        case "github_pr": {
+            return renderChangeRequestAttachment({
+                forge: "github",
+                number: attachment.number,
+                title: attachment.title,
+                url: attachment.url,
+                body: attachment.body,
+                baseRefName: attachment.baseRefName,
+                headRefName: attachment.headRefName,
+            });
+        }
+        case "forge_issue": {
+            return renderIssueAttachment({
+                forge: attachment.forge,
+                number: attachment.number,
+                title: attachment.title,
+                url: attachment.url,
+                body: attachment.body,
+                projectPath: attachment.projectPath,
+            });
+        }
+        // COMPAT(githubAttachmentKinds): render legacy wire attachments until
+        // 2027-01-17, when supported client and daemon floors are >= v0.2.0.
+        case "github_issue": {
+            return renderIssueAttachment({
+                forge: "github",
+                number: attachment.number,
+                title: attachment.title,
+                url: attachment.url,
+                body: attachment.body,
+            });
+        }
+        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 "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 renderChangeRequestAttachment(input) {
+    const lines = [
+        `${formatForgeLabel(input.forge)} ${formatChangeRequestAbbrev(input.forge)} ${formatChangeRequestNumber(input.forge, input.number)}: ${input.title}`,
+        input.url,
+    ];
+    if (input.projectPath) {
+        lines.push(`Project: ${input.projectPath}`);
+    }
+    if (input.baseRefName) {
+        lines.push(`Base: ${input.baseRefName}`);
+    }
+    if (input.headRefName) {
+        lines.push(`Head: ${input.headRefName}`);
+    }
+    if (input.body) {
+        lines.push("", input.body);
+    }
+    return lines.join("\n");
+}
+function renderIssueAttachment(input) {
+    const lines = [
+        `${formatForgeLabel(input.forge)} Issue ${formatIssueNumber(input.forge, input.number)}: ${input.title}`,
+        input.url,
+    ];
+    if (input.projectPath) {
+        lines.push(`Project: ${input.projectPath}`);
+    }
+    if (input.body) {
+        lines.push("", input.body);
+    }
+    return lines.join("\n");
+}
+function formatForgeLabel(forge) {
+    return getForgeDefinitionOrNeutral(forge).displayName;
+}
+function formatChangeRequestAbbrev(forge) {
+    return getForgeDefinitionOrNeutral(forge).changeRequestAbbrev;
+}
+function formatChangeRequestNumber(forge, number) {
+    return `${getForgeDefinitionOrNeutral(forge).changeRequestNumberPrefix}${number}`;
+}
+function formatIssueNumber(forge, number) {
+    return `${getForgeDefinitionOrNeutral(forge).issueNumberPrefix}${number}`;
+}
+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-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,43 @@
+import { type ProcessEnvRecord } from "../paseo-env.js";
+export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, type AgentProviderRuntimeSettingsMap, type ProviderCommand, type ProviderOverride, type ProviderOverrides, type ProviderProfileModel, type ProviderRuntimeSettings, } from "@camerontaylor/paseo-protocol/provider-config";
+import { type ProviderCommand, type ProviderOverrides, type ProviderRuntimeSettings } from "@camerontaylor/paseo-protocol/provider-config";
+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>;
+}
+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,167 @@
+import { isAbsolute } from "node:path";
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
+import { createExternalProcessEnv } from "../paseo-env.js";
+export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, } from "@camerontaylor/paseo-protocol/provider-config";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, } from "@camerontaylor/paseo-protocol/provider-config";
+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",
+];
+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;
+    }
+    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,4 @@
+import type { AgentProviderNotice } from "./agent-sdk-types.js";
+export declare const MODE_APPLIES_NEXT_TURN_NOTICE: AgentProviderNotice;
+export declare const THINKING_APPLIES_NEXT_TURN_NOTICE: AgentProviderNotice;
+//# sourceMappingURL=provider-notices.d.ts.map

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

@@ -0,0 +1,9 @@
+export const MODE_APPLIES_NEXT_TURN_NOTICE = {
+    type: "warning",
+    message: "Permission mode applies next turn",
+};
+export const THINKING_APPLIES_NEXT_TURN_NOTICE = {
+    type: "warning",
+    message: "Thinking level applies next turn",
+};
+//# sourceMappingURL=provider-notices.js.map

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

@@ -0,0 +1,19 @@
+import type { ProviderOptions } from "@camerontaylor/paseo-protocol/agent-types";
+import type { z } from "zod";
+export interface ProviderOptionIssue {
+    path: Array<string | number>;
+    message: string;
+}
+export declare class ProviderOptionsValidationError extends Error {
+    readonly provider: string;
+    readonly issues: ProviderOptionIssue[];
+    readonly code: "provider_options_invalid";
+    constructor(provider: string, issues: ProviderOptionIssue[]);
+}
+export declare class ToolPolicyUnsupportedError extends Error {
+    readonly provider: string;
+    readonly code: "tool_policy_unsupported";
+    constructor(provider: string, reason?: string);
+}
+export declare function validateProviderOptions(provider: string, schema: z.ZodType<ProviderOptions>, options: ProviderOptions | undefined): ProviderOptions | undefined;
+//# sourceMappingURL=provider-options.d.ts.map

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

@@ -0,0 +1,53 @@
+export class ProviderOptionsValidationError extends Error {
+    constructor(provider, issues) {
+        const details = issues
+            .map((issue) => `${formatProviderOptionPath(issue.path)}: ${issue.message}`)
+            .join("; ");
+        super(`Invalid providerOptions for '${provider}': ${details}`);
+        this.provider = provider;
+        this.issues = issues;
+        this.code = "provider_options_invalid";
+        this.name = "ProviderOptionsValidationError";
+    }
+}
+export class ToolPolicyUnsupportedError extends Error {
+    constructor(provider, reason) {
+        super(reason ??
+            `Provider '${provider}' cannot preapprove exact MCP tools for unattended execution; select Claude, Codex, or OpenCode`);
+        this.provider = provider;
+        this.code = "tool_policy_unsupported";
+        this.name = "ToolPolicyUnsupportedError";
+    }
+}
+export function validateProviderOptions(provider, schema, options) {
+    if (options === undefined)
+        return undefined;
+    const parsed = schema.safeParse(options);
+    if (parsed.success)
+        return parsed.data;
+    throw new ProviderOptionsValidationError(provider, flattenZodIssues(parsed.error.issues));
+}
+function flattenZodIssues(issues, prefix = []) {
+    return issues.flatMap((issue) => {
+        const path = [...prefix, ...issue.path];
+        if (issue.code === "invalid_union") {
+            return flattenZodIssues(issue.errors.flat(), path);
+        }
+        return [
+            {
+                path: path.map((segment) => typeof segment === "symbol" ? (segment.description ?? String(segment)) : segment),
+                message: issue.message,
+            },
+        ];
+    });
+}
+function formatProviderOptionPath(path) {
+    return path.reduce((formatted, segment) => {
+        if (typeof segment === "number")
+            return `${formatted}[${segment}]`;
+        return /^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(segment)
+            ? `${formatted}.${segment}`
+            : `${formatted}[${JSON.stringify(segment)}]`;
+    }, "providerOptions");
+}
+//# sourceMappingURL=provider-options.js.map

package/dist/server/server/agent/provider-refresh-deadline.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderRefreshContext } from "./agent-sdk-types.js";
+interface RunProviderRefreshOptions<T> {
+    label: string;
+    timeoutMs: number;
+    operation: (context: ProviderRefreshContext) => Promise<T>;
+}
+export declare function runProviderRefreshActivity<T>(context: ProviderRefreshContext | undefined, name: string, operation: () => Promise<T>): Promise<T>;
+export declare function raceProviderRefreshAbort<T>(signal: AbortSignal | undefined, operation: Promise<T>): Promise<T>;
+export declare function runProviderRefreshWithDeadline<T>(options: RunProviderRefreshOptions<T>): Promise<T>;
+export {};
+//# sourceMappingURL=provider-refresh-deadline.d.ts.map

package/dist/server/server/agent/provider-refresh-deadline.js

@@ -0,0 +1,65 @@
+export function runProviderRefreshActivity(context, name, operation) {
+    return context ? context.runActivity(name, operation) : operation();
+}
+export async function raceProviderRefreshAbort(signal, operation) {
+    if (!signal)
+        return await operation;
+    signal.throwIfAborted();
+    let handleAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        handleAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", handleAbort, { once: true });
+    });
+    try {
+        return await Promise.race([operation, aborted]);
+    }
+    finally {
+        if (handleAbort)
+            signal.removeEventListener("abort", handleAbort);
+    }
+}
+export async function runProviderRefreshWithDeadline(options) {
+    const controller = new AbortController();
+    const activityCounts = new Map();
+    let timeoutError;
+    const context = {
+        signal: controller.signal,
+        async runActivity(name, operation) {
+            controller.signal.throwIfAborted();
+            activityCounts.set(name, (activityCounts.get(name) ?? 0) + 1);
+            try {
+                const result = await operation();
+                controller.signal.throwIfAborted();
+                return result;
+            }
+            finally {
+                const remaining = (activityCounts.get(name) ?? 1) - 1;
+                if (remaining === 0) {
+                    activityCounts.delete(name);
+                }
+                else {
+                    activityCounts.set(name, remaining);
+                }
+            }
+        },
+    };
+    const timer = setTimeout(() => {
+        const pending = Array.from(activityCounts.keys());
+        const suffix = pending.length > 0 ? `; pending: ${pending.join(", ")}` : "";
+        timeoutError = new Error(`Timed out refreshing ${options.label} after ${options.timeoutMs}ms${suffix}`);
+        controller.abort(timeoutError);
+    }, options.timeoutMs);
+    try {
+        const result = await options.operation(context);
+        if (timeoutError)
+            throw timeoutError;
+        return result;
+    }
+    catch (error) {
+        throw timeoutError ?? error;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=provider-refresh-deadline.js.map

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

@@ -0,0 +1,72 @@
+import type { Logger } from "pino";
+import type { ProviderOptions, ToolPolicy } from "@camerontaylor/paseo-protocol/agent-types";
+import { z } from "zod";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentProvider, AgentSession, FetchCatalogOptions, ProviderRefreshContext, ProviderCatalog, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult, AgentSessionConfig } 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, ProviderRuntimeSettings } from "./provider-launch-config.js";
+import type { OpenCodeBridge } from "./providers/opencode/bridge.js";
+import type { OmpRuntime } from "./providers/omp/runtime.js";
+import { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, type AgentProviderDefinition } from "@camerontaylor/paseo-protocol/provider-manifest";
+export type { AgentProviderDefinition };
+export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
+export interface ProviderDefinition extends AgentProviderDefinition {
+    /** Effective inputs after overrides and inheritance; plugin registrations are owned separately. */
+    configuration: Omit<ResolvedProvider, "createBaseClient" | "contract"> | null;
+    iconSvg?: string;
+    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;
+    optionsSchema: z.ZodType<ProviderOptions>;
+    supportsExactMcpPreapproval: boolean;
+    validateOptions: (options: ProviderOptions | undefined) => ProviderOptions | undefined;
+    applyOptions: (config: AgentSessionConfig, options: ProviderOptions | undefined) => AgentSessionConfig;
+    applyToolPolicy: (config: AgentSessionConfig, toolPolicy: ToolPolicy | undefined) => AgentSessionConfig;
+    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, context?: ProviderRefreshContext) => Promise<ProviderCatalog>;
+}
+export interface BuildProviderRegistryOptions {
+    runtimeSettings?: AgentProviderRuntimeSettingsMap;
+    providerOverrides?: Record<string, ProviderOverride>;
+    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    managedProcesses?: ManagedProcessRegistry;
+    isDev?: boolean;
+    ompRuntime?: OmpRuntime;
+    openCodeBridge?: OpenCodeBridge;
+}
+interface ResolvedProvider {
+    definition: AgentProviderDefinition;
+    runtimeSettings?: ProviderRuntimeSettings;
+    profileModels: ProviderProfileModel[];
+    additionalModels: ProviderProfileModel[];
+    profileModelsAreAdditive: boolean;
+    enabled: boolean;
+    derivedFromProviderId: string | null;
+    providerParams?: unknown;
+    createBaseClient: (logger: Logger) => AgentClient;
+    contract: ProviderContract;
+}
+interface ProviderContract {
+    optionsSchema: z.ZodType<ProviderOptions>;
+    supportsExactMcpPreapproval: boolean;
+    applyToolPolicy?: (provider: string, toolPolicy: ToolPolicy) => ToolPolicy;
+}
+export declare function wrapSessionProvider(provider: AgentProvider, inner: AgentSession): AgentSession;
+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