@getpaseo/server 0.1.58 → 0.1.60

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

@@ -1 +1 @@
-{"version":3,"file":"copilot-acp-agent.js","sourceRoot":"","sources":["../../../../../src/server/agent/providers/copilot-acp-agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"copilot-acp-agent.js","sourceRoot":"","sources":["../../../../../src/server/agent/providers/copilot-acp-agent.ts"],"names":[],"mappings":"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"}

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -0,0 +1,64 @@
+import type { Logger } from "pino";
+import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, ListModesOptions, ListModelsOptions, ListPersistedAgentsOptions, PersistedAgentDescriptor } from "../agent-sdk-types.js";
+export declare const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
+export declare const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
+export declare class MockLoadTestAgentClient implements AgentClient {
+    private readonly logger?;
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    constructor(logger?: Logger | undefined);
+    createSession(config: AgentSessionConfig, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
+    listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
+    listModes(_options: ListModesOptions): Promise<AgentMode[]>;
+    listPersistedAgents(_options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    isAvailable(): Promise<boolean>;
+    getDiagnostic(): Promise<{
+        diagnostic: string;
+    }>;
+}
+export declare class MockLoadTestAgentSession implements AgentSession {
+    readonly provider: AgentProvider;
+    readonly capabilities: AgentCapabilityFlags;
+    readonly features: AgentFeature[];
+    readonly id: string;
+    private readonly listeners;
+    private readonly history;
+    private readonly logger?;
+    private activeTurn;
+    private modeId;
+    private modelId;
+    constructor(options: {
+        config: AgentSessionConfig;
+        sessionId: string;
+        logger?: Logger;
+    });
+    run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+    startTurn(prompt: AgentPromptInput, _options?: AgentRunOptions): Promise<{
+        turnId: string;
+    }>;
+    subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+    streamHistory(): AsyncGenerator<AgentStreamEvent>;
+    getRuntimeInfo(): Promise<AgentRuntimeInfo>;
+    getAvailableModes(): Promise<AgentMode[]>;
+    getCurrentMode(): Promise<string | null>;
+    setMode(modeId: string): Promise<void>;
+    getPendingPermissions(): AgentPermissionRequest[];
+    respondToPermission(_requestId: string, _response: AgentPermissionResponse): Promise<AgentPermissionResult | void>;
+    describePersistence(): AgentPersistenceHandle | null;
+    interrupt(): Promise<void>;
+    close(): Promise<void>;
+    setModel(modelId: string | null): Promise<void>;
+    private schedule;
+    private scheduleLargePayloadTurn;
+    private scheduleStressTurn;
+    private emitStressTurn;
+    private emitLargePayloadTurn;
+    private tick;
+    private emitIteration;
+    private finishTurn;
+    private emitTimeline;
+    private emit;
+    private clearTurnTimer;
+}
+//# sourceMappingURL=mock-load-test-agent.d.ts.map

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-load-test-agent.d.ts","sourceRoot":"","sources":["../../../../../src/server/agent/providers/mock-load-test-agent.ts"],"names":[],"mappings":"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"}

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -0,0 +1,585 @@
+import { randomUUID } from "node:crypto";
+import { getAgentProviderDefinition } from "../provider-manifest.js";
+export const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
+export const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
+const MOCK_LOAD_TEST_MODE_ID = "load-test";
+const MOCK_LOAD_TEST_DURATION_MS = 5 * 60 * 1000;
+const MOCK_LOAD_TEST_INTERVAL_MS = 1000;
+const CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsDynamicModes: false,
+    supportsMcpServers: false,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+};
+const MODELS = [
+    {
+        provider: MOCK_LOAD_TEST_PROVIDER_ID,
+        id: MOCK_LOAD_TEST_DEFAULT_MODEL_ID,
+        label: "Five minute stream",
+        description: "Repeats synthetic markdown and tool-call timeline traffic for five minutes.",
+        isDefault: true,
+        metadata: {
+            durationMs: MOCK_LOAD_TEST_DURATION_MS,
+            intervalMs: MOCK_LOAD_TEST_INTERVAL_MS,
+        },
+    },
+    {
+        provider: MOCK_LOAD_TEST_PROVIDER_ID,
+        id: "one-minute-stream",
+        label: "One minute stream",
+        description: "Shorter synthetic load stream for quick manual checks.",
+        metadata: {
+            durationMs: 60000,
+            intervalMs: 500,
+        },
+    },
+    {
+        provider: MOCK_LOAD_TEST_PROVIDER_ID,
+        id: "ten-second-stream",
+        label: "Ten second stream",
+        description: "Fast synthetic load stream for tests and smoke checks.",
+        metadata: {
+            durationMs: 10000,
+            intervalMs: 250,
+        },
+    },
+];
+function resolveModelProfile(modelId) {
+    const model = MODELS.find((entry) => entry.id === modelId) ?? MODELS[0];
+    const metadata = model.metadata ?? {};
+    return {
+        modelId: model.id,
+        durationMs: typeof metadata.durationMs === "number" ? metadata.durationMs : MOCK_LOAD_TEST_DURATION_MS,
+        intervalMs: typeof metadata.intervalMs === "number" ? metadata.intervalMs : MOCK_LOAD_TEST_INTERVAL_MS,
+    };
+}
+function promptToText(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    return prompt
+        .flatMap((block) => (block.type === "text" ? [block.text] : []))
+        .join("\n")
+        .trim();
+}
+function parseLargeAgentStreamPayloadPrompt(prompt) {
+    const text = promptToText(prompt);
+    const match = /emit\s+(\d+)\s+(?:byte\s+)?(?:large\s+)?(diff|file|image)\s+agent stream (?:update|payload)/i.exec(text);
+    if (!match) {
+        return null;
+    }
+    const bytes = Number(match[1]);
+    if (!Number.isFinite(bytes) || bytes <= 0) {
+        return null;
+    }
+    return {
+        bytes: Math.min(bytes, 1000000),
+        kind: match[2]?.toLowerCase(),
+    };
+}
+function parseAgentStreamStressPrompt(prompt) {
+    const text = promptToText(prompt);
+    const match = /emit\s+(\d+)\s+(coalesced\s+)?agent stream updates/i.exec(text);
+    if (!match) {
+        return null;
+    }
+    const count = Number(match[1]);
+    if (!Number.isFinite(count) || count <= 0) {
+        return null;
+    }
+    return {
+        count: Math.min(count, 5000),
+        coalesced: Boolean(match[2]),
+    };
+}
+function buildRepeatedPayload(bytes, prefix) {
+    const line = `${prefix} ${"x".repeat(96)}\n`;
+    let output = "";
+    while (output.length < bytes) {
+        output += line;
+    }
+    return output.slice(0, bytes);
+}
+function buildMarkdownDocument(iteration, prompt) {
+    const promptPreview = promptToText(prompt).slice(0, 160) || "No prompt text supplied.";
+    return [
+        `## Synthetic Load Cycle ${iteration}`,
+        "",
+        `Prompt preview: ${promptPreview}`,
+        "",
+        "| Signal | Value |",
+        "| --- | --- |",
+        `| cycle | ${iteration} |`,
+        "| stream | markdown + reasoning + tools |",
+        "",
+        "```ts",
+        `const cycle = ${iteration};`,
+        'const purpose = "exercise app parsing and terminal rendering under load";',
+        "```",
+        "",
+        "This paragraph is intentionally stable so repeated cycles produce predictable UI pressure.",
+        "",
+    ].join("\n");
+}
+function splitText(text, chunks) {
+    const size = Math.ceil(text.length / chunks);
+    const parts = [];
+    for (let index = 0; index < text.length; index += size) {
+        parts.push(text.slice(index, index + size));
+    }
+    return parts;
+}
+function createToolCall(input) {
+    return {
+        type: "tool_call",
+        callId: `${input.turnId}:${input.name}:${input.iteration}`,
+        name: input.name,
+        status: input.status,
+        error: null,
+        detail: input.detail,
+    };
+}
+export class MockLoadTestAgentClient {
+    constructor(logger) {
+        this.logger = logger;
+        this.provider = MOCK_LOAD_TEST_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+    }
+    async createSession(config, _launchContext) {
+        return new MockLoadTestAgentSession({
+            config,
+            sessionId: randomUUID(),
+            logger: this.logger,
+        });
+    }
+    async resumeSession(handle, overrides, _launchContext) {
+        const metadata = (handle.metadata ?? {});
+        return new MockLoadTestAgentSession({
+            config: {
+                cwd: String(metadata.cwd ?? overrides?.cwd ?? process.cwd()),
+                ...metadata,
+                ...overrides,
+                provider: MOCK_LOAD_TEST_PROVIDER_ID,
+            },
+            sessionId: handle.sessionId,
+            logger: this.logger,
+        });
+    }
+    async listModels(_options) {
+        return MODELS;
+    }
+    async listModes(_options) {
+        return getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes;
+    }
+    async listPersistedAgents(_options) {
+        return [];
+    }
+    async isAvailable() {
+        return true;
+    }
+    async getDiagnostic() {
+        return {
+            diagnostic: "Mock load-test provider is available in development builds.",
+        };
+    }
+}
+export class MockLoadTestAgentSession {
+    constructor(options) {
+        this.provider = MOCK_LOAD_TEST_PROVIDER_ID;
+        this.capabilities = CAPABILITIES;
+        this.features = [];
+        this.listeners = new Set();
+        this.history = [];
+        this.activeTurn = null;
+        this.id = options.sessionId;
+        this.logger = options.logger;
+        this.modeId = options.config.modeId ?? MOCK_LOAD_TEST_MODE_ID;
+        this.modelId = options.config.model ?? MOCK_LOAD_TEST_DEFAULT_MODEL_ID;
+    }
+    async run(prompt, options) {
+        const { turnId } = await this.startTurn(prompt, options);
+        const turn = this.activeTurn;
+        if (!turn || turn.turnId !== turnId) {
+            throw new Error("Mock load-test turn did not start");
+        }
+        return turn.completed;
+    }
+    async startTurn(prompt, _options) {
+        if (this.activeTurn) {
+            throw new Error("Mock load-test provider already has an active turn");
+        }
+        const profile = resolveModelProfile(this.modelId);
+        const turnId = randomUUID();
+        let resolve;
+        const completed = new Promise((promiseResolve) => {
+            resolve = promiseResolve;
+        });
+        const turn = {
+            turnId,
+            prompt,
+            startedAt: Date.now(),
+            iteration: 0,
+            durationMs: profile.durationMs,
+            intervalMs: profile.intervalMs,
+            timer: null,
+            resolve,
+            completed,
+        };
+        this.activeTurn = turn;
+        const largePayload = parseLargeAgentStreamPayloadPrompt(prompt);
+        const stress = parseAgentStreamStressPrompt(prompt);
+        if (largePayload) {
+            this.scheduleLargePayloadTurn(turn, largePayload);
+        }
+        else if (stress) {
+            this.scheduleStressTurn(turn, stress);
+        }
+        else {
+            this.schedule(turn, 0);
+        }
+        return { turnId };
+    }
+    subscribe(callback) {
+        this.listeners.add(callback);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    async *streamHistory() {
+        for (const event of this.history) {
+            yield event;
+        }
+    }
+    async getRuntimeInfo() {
+        return {
+            provider: this.provider,
+            sessionId: this.id,
+            model: this.modelId,
+            modeId: this.modeId,
+        };
+    }
+    async getAvailableModes() {
+        return getAgentProviderDefinition(MOCK_LOAD_TEST_PROVIDER_ID).modes;
+    }
+    async getCurrentMode() {
+        return this.modeId;
+    }
+    async setMode(modeId) {
+        this.modeId = modeId;
+    }
+    getPendingPermissions() {
+        return [];
+    }
+    async respondToPermission(_requestId, _response) {
+        return undefined;
+    }
+    describePersistence() {
+        return {
+            provider: this.provider,
+            sessionId: this.id,
+            metadata: {
+                model: this.modelId,
+                modeId: this.modeId,
+            },
+        };
+    }
+    async interrupt() {
+        const turn = this.activeTurn;
+        if (!turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.activeTurn = null;
+        const event = {
+            type: "turn_canceled",
+            provider: this.provider,
+            reason: "Interrupted",
+            turnId: turn.turnId,
+        };
+        this.emit(event);
+        turn.resolve({
+            sessionId: this.id,
+            finalText: "",
+            timeline: [],
+            canceled: true,
+        });
+    }
+    async close() {
+        await this.interrupt();
+        this.listeners.clear();
+    }
+    async setModel(modelId) {
+        this.modelId = modelId ?? MOCK_LOAD_TEST_DEFAULT_MODEL_ID;
+    }
+    schedule(turn, delayMs) {
+        turn.timer = setTimeout(() => {
+            this.tick(turn);
+        }, delayMs);
+        turn.timer.unref?.();
+    }
+    scheduleLargePayloadTurn(turn, largePayload) {
+        turn.timer = setTimeout(() => {
+            this.emitLargePayloadTurn(turn, largePayload);
+        }, 0);
+        turn.timer.unref?.();
+    }
+    scheduleStressTurn(turn, stress) {
+        turn.timer = setTimeout(() => {
+            this.emitStressTurn(turn, stress);
+        }, 0);
+        turn.timer.unref?.();
+    }
+    emitStressTurn(turn, stress) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.emit({
+            type: "turn_started",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        for (let index = 0; index < stress.count; index += 1) {
+            this.emitTimeline(turn.turnId, stress.coalesced
+                ? {
+                    type: "assistant_message",
+                    text: `stress-update-${index}`,
+                }
+                : {
+                    type: "todo",
+                    items: [{ text: `stress-update-${index}`, completed: index % 2 === 0 }],
+                });
+        }
+        this.activeTurn = null;
+        const usage = {
+            inputTokens: 1,
+            outputTokens: stress.count,
+            contextWindowUsedTokens: stress.count,
+            contextWindowMaxTokens: 128000,
+        };
+        this.emit({
+            type: "turn_completed",
+            provider: this.provider,
+            turnId: turn.turnId,
+            usage,
+        });
+        turn.resolve({
+            sessionId: this.id,
+            finalText: "Synthetic agent stream stress complete",
+            usage,
+            timeline: [],
+            canceled: false,
+        });
+    }
+    emitLargePayloadTurn(turn, largePayload) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        this.emit({
+            type: "turn_started",
+            provider: this.provider,
+            turnId: turn.turnId,
+        });
+        const payload = buildRepeatedPayload(largePayload.bytes, largePayload.kind);
+        if (largePayload.kind === "diff") {
+            this.emitTimeline(turn.turnId, createToolCall({
+                turnId: turn.turnId,
+                iteration: 0,
+                name: "edit",
+                status: "completed",
+                detail: {
+                    type: "edit",
+                    filePath: "src/large-diff.ts",
+                    unifiedDiff: `diff --git a/src/large-diff.ts b/src/large-diff.ts\n${payload}`,
+                },
+            }));
+        }
+        else if (largePayload.kind === "file") {
+            this.emitTimeline(turn.turnId, createToolCall({
+                turnId: turn.turnId,
+                iteration: 0,
+                name: "read",
+                status: "completed",
+                detail: {
+                    type: "read",
+                    filePath: "src/large-file.txt",
+                    content: payload,
+                },
+            }));
+        }
+        else {
+            this.emitTimeline(turn.turnId, {
+                type: "assistant_message",
+                text: `data:image/png;base64,${payload}`,
+            });
+        }
+        this.activeTurn = null;
+        const usage = {
+            inputTokens: 1,
+            outputTokens: largePayload.bytes,
+            contextWindowUsedTokens: largePayload.bytes,
+            contextWindowMaxTokens: 128000,
+        };
+        this.emit({
+            type: "turn_completed",
+            provider: this.provider,
+            turnId: turn.turnId,
+            usage,
+        });
+        turn.resolve({
+            sessionId: this.id,
+            finalText: "Synthetic large payload complete",
+            usage,
+            timeline: [],
+            canceled: false,
+        });
+    }
+    tick(turn) {
+        if (this.activeTurn !== turn) {
+            return;
+        }
+        this.clearTurnTimer(turn);
+        if (turn.iteration === 0) {
+            this.emit({
+                type: "turn_started",
+                provider: this.provider,
+                turnId: turn.turnId,
+            });
+        }
+        const elapsedMs = Date.now() - turn.startedAt;
+        if (elapsedMs >= turn.durationMs) {
+            this.finishTurn(turn);
+            return;
+        }
+        turn.iteration += 1;
+        this.emitIteration(turn);
+        this.schedule(turn, turn.intervalMs);
+    }
+    emitIteration(turn) {
+        const { turnId, iteration, prompt } = turn;
+        this.emitTimeline(turnId, {
+            type: "reasoning",
+            text: `Thinking chunk ${iteration}: simulate planning pressure before rendering markdown.\n`,
+        });
+        for (const chunk of splitText(buildMarkdownDocument(iteration, prompt), 4)) {
+            this.emitTimeline(turnId, {
+                type: "assistant_message",
+                text: chunk,
+            });
+        }
+        const editDetail = {
+            type: "edit",
+            filePath: `src/load-test-${iteration}.ts`,
+            oldString: "before",
+            newString: "after",
+            unifiedDiff: [
+                `diff --git a/src/load-test-${iteration}.ts b/src/load-test-${iteration}.ts`,
+                "@@",
+                "-before",
+                "+after",
+            ].join("\n"),
+        };
+        this.emitTimeline(turnId, createToolCall({
+            turnId,
+            iteration,
+            name: "edit",
+            status: "running",
+            detail: editDetail,
+        }));
+        this.emitTimeline(turnId, createToolCall({
+            turnId,
+            iteration,
+            name: "edit",
+            status: "completed",
+            detail: editDetail,
+        }));
+        const shellDetail = {
+            type: "shell",
+            command: `printf 'mock load cycle ${iteration}\\n'`,
+            cwd: "/tmp/paseo-mock-load",
+            output: `mock load cycle ${iteration}\n`,
+            exitCode: 0,
+        };
+        this.emitTimeline(turnId, createToolCall({
+            turnId,
+            iteration,
+            name: "bash",
+            status: "running",
+            detail: shellDetail,
+        }));
+        this.emitTimeline(turnId, createToolCall({
+            turnId,
+            iteration,
+            name: "bash",
+            status: "completed",
+            detail: shellDetail,
+        }));
+        this.emit({
+            type: "usage_updated",
+            provider: this.provider,
+            turnId,
+            usage: {
+                inputTokens: iteration * 32,
+                outputTokens: iteration * 128,
+                contextWindowUsedTokens: iteration * 160,
+                contextWindowMaxTokens: 128000,
+            },
+        });
+    }
+    finishTurn(turn) {
+        this.activeTurn = null;
+        this.emitTimeline(turn.turnId, {
+            type: "assistant_message",
+            text: "## Synthetic load test complete\n\nThe mock provider finished its foreground turn.\n",
+        });
+        const usage = {
+            inputTokens: turn.iteration * 32,
+            outputTokens: turn.iteration * 128,
+            contextWindowUsedTokens: turn.iteration * 160,
+            contextWindowMaxTokens: 128000,
+        };
+        this.emit({
+            type: "turn_completed",
+            provider: this.provider,
+            turnId: turn.turnId,
+            usage,
+        });
+        turn.resolve({
+            sessionId: this.id,
+            finalText: "Synthetic load test complete",
+            usage,
+            timeline: [],
+            canceled: false,
+        });
+    }
+    emitTimeline(turnId, item) {
+        this.emit({
+            type: "timeline",
+            provider: this.provider,
+            turnId,
+            item,
+        });
+    }
+    emit(event) {
+        this.history.push(event);
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.logger?.warn({ err: error }, "Mock load-test listener failed");
+            }
+        }
+    }
+    clearTurnTimer(turn) {
+        if (!turn.timer) {
+            return;
+        }
+        clearTimeout(turn.timer);
+        turn.timer = null;
+    }
+}
+//# sourceMappingURL=mock-load-test-agent.js.map