@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/mock-slow-provider.d.ts

@@ -0,0 +1,14 @@
+import type { AgentCapabilityFlags, AgentClient, AgentLaunchContext, AgentPersistenceHandle, AgentProvider, AgentSession, AgentSessionConfig, FetchCatalogOptions, ProviderRefreshContext, ProviderCatalog } from "../agent-sdk-types.js";
+export declare const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+export declare class MockSlowProviderClient implements AgentClient {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    isAvailable(): Promise<boolean>;
+    fetchCatalog(_options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<ProviderCatalog>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    createSession(_config: AgentSessionConfig, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(_handle: AgentPersistenceHandle, _overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+}
+//# sourceMappingURL=mock-slow-provider.d.ts.map

package/dist/server/server/agent/providers/mock-slow-provider.js

@@ -0,0 +1,40 @@
+export const MOCK_SLOW_PROVIDER_ID = "mock-slow";
+const CAPABILITIES = {
+    supportsStreaming: false,
+    supportsSessionPersistence: false,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: false,
+    supportsToolInvocations: false,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: false,
+};
+export class MockSlowProviderClient {
+    constructor() {
+        this.provider = MOCK_SLOW_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+    }
+    async isAvailable() {
+        return process.env.PASEO_ENABLE_MOCK_SLOW === "true";
+    }
+    async fetchCatalog(_options, context) {
+        return await (context?.runActivity("mock.catalog", () => new Promise((_resolve, reject) => {
+            context.signal.addEventListener("abort", () => reject(context.signal.reason), {
+                once: true,
+            });
+        })) ?? new Promise(() => { }));
+    }
+    async getDiagnostic() {
+        return {
+            diagnostic: "Mock slow provider: dev-only. fetchCatalog() never resolves so the snapshot manager will time out.",
+        };
+    }
+    createSession(_config, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+    resumeSession(_handle, _overrides, _launchContext) {
+        throw new Error("Mock slow provider is dev-only; sessions are not supported.");
+    }
+}
+//# sourceMappingURL=mock-slow-provider.js.map

package/dist/server/server/agent/providers/omp/advisor-message.d.ts

@@ -0,0 +1,11 @@
+import type { AgentTimelineItem } from "../../agent-sdk-types.js";
+import type { OmpAgentMessage } from "./rpc-types.js";
+type OmpCustomMessage = Extract<OmpAgentMessage, {
+    role: "custom";
+}>;
+type OmpAdvisorToolCallItem = Extract<AgentTimelineItem, {
+    type: "tool_call";
+}>;
+export declare function mapOmpAdvisorMessageToToolCall(message: OmpCustomMessage, text: string): OmpAdvisorToolCallItem | null;
+export {};
+//# sourceMappingURL=advisor-message.d.ts.map

package/dist/server/server/agent/providers/omp/advisor-message.js

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+const ADVISOR_SEVERITIES = {
+    nit: true,
+    concern: true,
+    blocker: true,
+};
+function readOptionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readAdvisorNotes(message) {
+    const details = Reflect.get(message, "details");
+    if (!details || typeof details !== "object")
+        return [];
+    const notes = Reflect.get(details, "notes");
+    if (!Array.isArray(notes))
+        return [];
+    return notes.flatMap((value) => {
+        if (!value || typeof value !== "object")
+            return [];
+        const note = readOptionalString(Reflect.get(value, "note"));
+        if (!note)
+            return [];
+        const rawSeverity = Reflect.get(value, "severity");
+        const severity = typeof rawSeverity === "string" && rawSeverity in ADVISOR_SEVERITIES
+            ? rawSeverity
+            : undefined;
+        const advisor = readOptionalString(Reflect.get(value, "advisor"));
+        return [{ note, ...(severity ? { severity } : {}), ...(advisor ? { advisor } : {}) }];
+    });
+}
+function formatAdvisorNote(note) {
+    const prefix = [
+        note.severity ? `[${note.severity}]` : null,
+        note.advisor ? `[${note.advisor}]` : null,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return prefix ? `${prefix} ${note.note}` : note.note;
+}
+function buildAdvisorLabel(noteCount, blockerCount) {
+    if (noteCount === 0)
+        return "Advisor";
+    const label = `Advisor · ${noteCount} ${noteCount === 1 ? "note" : "notes"}`;
+    return blockerCount > 0
+        ? `${label} · ${blockerCount} ${blockerCount === 1 ? "blocker" : "blockers"}`
+        : label;
+}
+function buildAdvisorCallId(message, text) {
+    const id = readOptionalString(Reflect.get(message, "id"));
+    if (id)
+        return `omp-advisor:${id}`;
+    const digest = createHash("sha1").update(text.trim()).digest("hex").slice(0, 12);
+    return `omp-advisor:${digest}`;
+}
+export function mapOmpAdvisorMessageToToolCall(message, text) {
+    if (Reflect.get(message, "customType") !== "advisor")
+        return null;
+    const notes = readAdvisorNotes(message);
+    const blockerCount = notes.filter((note) => note.severity === "blocker").length;
+    return {
+        type: "tool_call",
+        callId: buildAdvisorCallId(message, text),
+        name: "advisor",
+        status: "completed",
+        detail: {
+            type: "plain_text",
+            label: buildAdvisorLabel(notes.length, blockerCount),
+            text: notes.length > 0 ? notes.map(formatAdvisorNote).join("\n\n") : text,
+            icon: "brain",
+        },
+        metadata: {
+            synthetic: true,
+            source: "omp_advisor",
+            noteCount: notes.length,
+            blockerCount,
+        },
+        error: null,
+    };
+}
+//# sourceMappingURL=advisor-message.js.map

package/dist/server/server/agent/providers/omp/agent.d.ts

@@ -0,0 +1,178 @@
+import type { Logger } from "pino";
+import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentProviderNotice, type AgentPersistenceHandle, type AgentPromptInput, type AgentProvider, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog, type ProviderRefreshContext } from "../../agent-sdk-types.js";
+import type { PaseoToolCatalog } from "../../tools/types.js";
+import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
+export { formatOmpVersionSupport, resolveOmpDiagnosticPaths } from "./provider-config.js";
+import { type OmpSubagentCardScheduler } from "./subagent-card-tracker.js";
+import type { OmpRuntime, OmpRuntimeSession } from "./runtime.js";
+import type { OmpSessionState } from "./rpc-types.js";
+import { type OmpUsagePollScheduler } from "./usage-poller.js";
+export interface OmpAgentClientOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    providerParams?: unknown;
+    runtime?: OmpRuntime;
+    subagentCardScheduler?: OmpSubagentCardScheduler;
+    providerIdleScheduler?: OmpProviderIdleScheduler;
+    noTurnScheduler?: OmpNoTurnScheduler;
+    usagePollScheduler?: OmpUsagePollScheduler;
+}
+export interface OmpProviderIdleScheduler {
+    waitForRetry(): Promise<void>;
+}
+export interface OmpNoTurnScheduler {
+    waitForSettle(signal: AbortSignal): Promise<void>;
+}
+interface StartTurnResult {
+    turnId: string;
+}
+interface OmpAgentSessionOptions {
+    runtimeSession: OmpRuntimeSession;
+    config: AgentSessionConfig;
+    initialState: OmpSessionState;
+    currentModeId?: string | null;
+    logger: Logger;
+    subagentCardScheduler?: OmpSubagentCardScheduler;
+    providerIdleScheduler?: OmpProviderIdleScheduler;
+    noTurnScheduler?: OmpNoTurnScheduler;
+    usagePollScheduler?: OmpUsagePollScheduler;
+    paseoTools?: PaseoToolCatalog;
+    /**
+     * When false (resumed sessions), replayed session events are dropped until
+     * the first prompt or agent_start so history is not re-emitted as live
+     * timeline items.
+     */
+    live?: boolean;
+}
+export declare function transformOmpModels(models: AgentModelDefinition[]): AgentModelDefinition[];
+export declare class OmpAgentSession implements AgentSession {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    private readonly subscribers;
+    private readonly activeToolCalls;
+    private readonly pendingExtensionUiRequests;
+    private activeAskUserDialog;
+    private pendingCombinedAskUserResponse;
+    private activeTurnId;
+    private activeClientMessageId;
+    private activeAssistantMessageId;
+    private activeTurnTerminalAssistantMessage;
+    private activeTurnStarted;
+    private activeTurnHasUserMessage;
+    private activeNoTurnPromptText;
+    private readonly pendingNoTurnOutputs;
+    private activePromptRequestId;
+    private activePromptAgentInvoked;
+    private readonly pendingPromptResults;
+    private pendingNoTurnCompletionAbort;
+    private lastKnownThinkingOptionId;
+    private outOfBandCompactionEmit;
+    private outOfBandCompactionStarted;
+    private outOfBandCompactionCompleted;
+    private commandCache;
+    private readonly subagentIndex;
+    private readonly subagentCardTracker;
+    private lastTodoItem;
+    private state;
+    private readonly currentModeId;
+    private readonly providerIdleScheduler;
+    private readonly noTurnScheduler;
+    private readonly usagePoller;
+    private closed;
+    private live;
+    private readonly emittedUserMessageIds;
+    constructor(options: OmpAgentSessionOptions);
+    private readonly runtimeSession;
+    private readonly config;
+    private readonly logger;
+    private readonly paseoTools?;
+    get id(): string | null;
+    run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+    startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<StartTurnResult>;
+    subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+    streamHistory(): AsyncGenerator<AgentStreamEvent>;
+    getRuntimeInfo(): Promise<AgentRuntimeInfo>;
+    getAvailableModes(): Promise<AgentMode[]>;
+    getCurrentMode(): Promise<string | null>;
+    setMode(modeId: string): Promise<void | AgentProviderNotice>;
+    getPendingPermissions(): AgentPermissionRequest[];
+    respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
+    describePersistence(): AgentPersistenceHandle | null;
+    interrupt(): Promise<void>;
+    revertConversation(input: {
+        messageId: string;
+    }): Promise<void>;
+    close(): Promise<void>;
+    private clearOmpSessionState;
+    private clearOmpTurnState;
+    private terminalizeActiveWork;
+    listCommands(): Promise<AgentSlashCommand[]>;
+    tryHandleOutOfBand(prompt: AgentPromptInput): {
+        run(ctx: {
+            emit: (event: AgentStreamEvent) => void;
+        }): Promise<void>;
+    } | null;
+    setModel(modelId: string | null): Promise<void>;
+    setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    private emit;
+    private currentTurnIdForEvent;
+    private scheduleNoTurnPromptCompletion;
+    private cancelNoTurnPromptCompletion;
+    private completeNoTurnPrompt;
+    private clearNoTurnBuffers;
+    private emitBufferedNoTurnOutputs;
+    private bufferNoTurnOutput;
+    private parseSlashCommandInput;
+    private executeCompactCommand;
+    private executeAutoCompactCommand;
+    private executeHandoffCommand;
+    private handleExtensionUiRequest;
+    private mapExtensionUiSideEffect;
+    private respondToCombinedAskUserFollowUp;
+    private handleCommandOutput;
+    private handleExtraRuntimeEvent;
+    private emitActiveToolCall;
+    private emitTodoItem;
+    private handleRuntimeEvent;
+    private handleProcessExit;
+    private handleSessionEvent;
+    private handleToolExecutionEnd;
+    private emitCompactionTimeline;
+    private handleMessageUpdate;
+    private handleMessageStart;
+    private handleMessageEnd;
+    private emitToolCallEvent;
+    private mapToolDetail;
+    private completeTurn;
+    private completeTurnAfterProviderIdle;
+    private refreshState;
+    private refreshAfterTurn;
+}
+export declare class OmpAgentClient implements AgentClient {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    private readonly logger;
+    private readonly runtimeSettings?;
+    private readonly providerParams;
+    private readonly modelRoleParams;
+    private readonly subagentCardScheduler?;
+    private readonly providerIdleScheduler?;
+    private readonly noTurnScheduler?;
+    private readonly usagePollScheduler?;
+    private readonly runtime;
+    constructor(options: OmpAgentClientOptions);
+    private configureNativePaseoTools;
+    createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    fetchCatalog(options: FetchCatalogOptions, context?: ProviderRefreshContext): Promise<ProviderCatalog>;
+    listFeatures(_config: AgentSessionConfig): Promise<AgentFeature[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
+    isAvailable(): Promise<boolean>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+    private resolveLaunchMode;
+    private resolveOmpLaunch;
+}
+//# sourceMappingURL=agent.d.ts.map