@timurproko/a1 0.1.8-dev.ece8cef → 0.2.0

package/dist/integrations/pi/engine/session-integration.js

@@ -0,0 +1,195 @@
+import { AGENT_ENGINE_CONTRACT_VERSION, } from "../../../contracts/agent-engine/index.js";
+/** Routes neutral session commands to Pi while preserving Pi streaming and retry semantics. */
+export class PiSessionCommandIntegration {
+    #lastPrompt = null;
+    // Rationale: Pi's queue restore returns text only, so the attachments of messages queued
+    // during compaction are kept here until the queue is delivered or cleared.
+    #queuedImages = [];
+    session;
+    constructor(session) { this.session = session; }
+    async execute(command) {
+        switch (command.type) {
+            case "prompt":
+                this.#lastPrompt = command.text;
+                await this.session.prompt(command.text, command.images === undefined
+                    ? this.session.isStreaming ? { streamingBehavior: "followUp" } : undefined
+                    : {
+                        ...(this.session.isStreaming ? { streamingBehavior: "followUp" } : {}),
+                        images: [...command.images],
+                    });
+                return { outcome: "completed" };
+            case "steer":
+            case "follow-up": {
+                this.#lastPrompt = command.text;
+                const mode = command.type === "steer" ? "steer" : "followUp";
+                if (this.session.isCompacting && !this.#isExtensionCommand(command.text)) {
+                    // Compatibility: match interactive Pi: prompt() refuses input during manual compaction,
+                    // while the engine queue accepts it at any time and delivers it when compaction ends.
+                    await this.#queue(mode, command.text, command.images);
+                    return { outcome: "completed" };
+                }
+                // Compatibility: match interactive Pi: prompt() owns template/extension expansion and
+                // turns the accepted steering message into the visible user row while
+                // later messages remain in the pending queue.
+                await this.session.prompt(command.text, {
+                    streamingBehavior: mode,
+                    ...(command.images === undefined ? {} : { images: [...command.images] }),
+                });
+                return { outcome: "completed" };
+            }
+            case "abort":
+                if (this.session.isRetrying)
+                    this.session.abortRetry();
+                if (this.session.isCompacting)
+                    this.session.abortCompaction();
+                await this.session.abort();
+                return { outcome: "cancelled" };
+            case "retry":
+                if (this.#lastPrompt === null)
+                    return { outcome: "rejected" };
+                await this.session.prompt(this.#lastPrompt, this.session.isStreaming ? { streamingBehavior: "followUp" } : undefined);
+                return { outcome: "completed" };
+            case "compact":
+                return { outcome: "completed", value: await this.session.compact() };
+            case "bash": {
+                if (!this.session.executeBash)
+                    return { outcome: "rejected" };
+                const value = await this.session.executeBash(command.command, command.onChunk, { excludeFromContext: command.excludeFromContext });
+                if (!value || typeof value !== "object")
+                    throw new TypeError("Pi bash result is malformed");
+                const result = value;
+                if (typeof result.cancelled !== "boolean" || (result.exitCode !== undefined && typeof result.exitCode !== "number"))
+                    throw new TypeError("Pi bash result is malformed");
+                return { outcome: result.cancelled ? "cancelled" : result.exitCode === 0 ? "completed" : "failed", value };
+            }
+        }
+    }
+    /**
+     * Delivers the messages queued during a manual compaction. The session is idle when a manual
+     * compaction ends, so nothing would consume the queue: the first message starts one run
+     * through the ordinary prompt path with its mode, and the rest are re-queued for that run,
+     * whose initial poll injects them in order. Automatic compaction needs no delivery: its
+     * continuing run or pending prompt consumes the queue itself. The run is not awaited; when
+     * the start is refused before the message is accepted, the queue is restored and the error
+     * reported through `onFailure`.
+     */
+    async deliverQueuedAfterCompaction(onFailure) {
+        if (this.session.isStreaming || this.session.isCompacting)
+            return;
+        const { steering, followUp } = this.session.clearQueue();
+        const queued = [
+            ...steering.map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        const [first, ...rest] = queued;
+        if (first === undefined)
+            return;
+        this.#lastPrompt = first.text;
+        let accepted = false;
+        const started = this.session.prompt(first.text, {
+            streamingBehavior: first.mode,
+            preflightResult: success => { accepted = success; },
+            ...(first.images === undefined ? {} : { images: [...first.images] }),
+        });
+        for (const item of rest)
+            await this.#queue(item.mode, item.text, item.images);
+        started.catch(async (error) => {
+            // Security: a run that reached the provider is never resent; only a refused start restores.
+            try {
+                if (!accepted)
+                    await this.#restoreQueue(queued);
+            }
+            finally {
+                onFailure(error);
+            }
+        }).catch(() => undefined);
+    }
+    /** Forgets the attachments kept for queued messages; the queue itself was cleared by the caller. */
+    forgetQueuedImages() {
+        this.#queuedImages = [];
+    }
+    // Rationale: the rest were re-queued before the refused start surfaced, so the queue is rebuilt
+    // in the original order; anything queued in between keeps its place after it.
+    async #restoreQueue(queued) {
+        const { steering, followUp } = this.session.clearQueue();
+        const restored = new Set(queued.map(item => item.text));
+        const extra = [
+            ...steering.filter(text => !restored.has(text)).map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.filter(text => !restored.has(text)).map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        for (const item of [...queued, ...extra])
+            await this.#queue(item.mode, item.text, item.images);
+    }
+    async #queue(mode, text, images) {
+        if (images !== undefined && images.length > 0)
+            this.#queuedImages.push({ text, images: [...images] });
+        if (mode === "steer")
+            await this.session.steer(text, images === undefined ? undefined : [...images]);
+        else
+            await this.session.followUp(text, images === undefined ? undefined : [...images]);
+    }
+    #takeImages(text) {
+        const index = this.#queuedImages.findIndex(item => item.text === text);
+        if (index === -1)
+            return undefined;
+        const [item] = this.#queuedImages.splice(index, 1);
+        return item?.images;
+    }
+    #isExtensionCommand(text) {
+        if (!text.startsWith("/"))
+            return false;
+        const spaceIndex = text.indexOf(" ");
+        const name = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+        return this.session.extensionRunner?.getCommand(name) !== undefined;
+    }
+}
+export function subscribeToPiSessionEvents(session, sessionId, emit, malformed) {
+    let sequence = 0;
+    let disposed = false;
+    const unsubscribe = session.subscribe(event => {
+        if (disposed)
+            return;
+        sequence += 1;
+        try {
+            const converted = convertPiSessionEvent(event, sessionId, sequence);
+            if (converted)
+                emit(converted);
+        }
+        catch (error) {
+            malformed(`Pi session event ${sequence} is malformed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    });
+    return { dispose() { if (disposed)
+            return; disposed = true; unsubscribe(); } };
+}
+export function convertPiSessionEvent(event, sessionId, sequence) {
+    const base = { contractVersion: AGENT_ENGINE_CONTRACT_VERSION, sessionId, sequence };
+    switch (event.type) {
+        case "agent_start": return { ...base, type: "lifecycle", lifecycle: "busy", reason: null };
+        case "agent_settled": return { ...base, type: "lifecycle", lifecycle: "ready", reason: null };
+        case "agent_end": return event.willRetry ? null : { ...base, type: "lifecycle", lifecycle: "ready", reason: null };
+        case "message_start":
+        case "message_update":
+        case "message_end":
+            return { ...base, type: "content", content: toAgentMessage(event.message, event.type === "message_end" ? "final" : "streaming", sequence) };
+        default: return null;
+    }
+}
+function toAgentMessage(value, status, sequence) {
+    if (!value || typeof value !== "object")
+        throw new TypeError("message payload is not an object");
+    const message = value;
+    const role = message.role === "user" || message.role === "assistant" || message.role === "tool" || message.role === "system" ? message.role : "assistant";
+    const source = Array.isArray(message.content) ? message.content : [];
+    const text = source.flatMap(part => part && typeof part === "object" && typeof part.text === "string" ? [part.text] : []).join("");
+    return {
+        id: typeof message.id === "string" ? message.id : `message-${sequence}`,
+        role,
+        status,
+        content: text.length > 0
+            ? [{ kind: "text", text }]
+            : [{ kind: "unknown", sourceType: "pi-message", payload: { role: String(message.role ?? "unknown") } }],
+    };
+}

package/dist/integrations/pi/engine/session-runtime.d.ts

@@ -0,0 +1,98 @@
+import { PiSessionCommandIntegration } from "./session-integration.js";
+import { type AgentSession, type AgentSessionRuntime, type AgentSessionServices } from "../startup-public.js";
+import type { PiProjectTrustPreflightPrompt } from "./project-trust-preflight.js";
+import type { PiSessionForkPrompt, PiSessionSelection } from "./session-selection.js";
+import type { OwnedUiDiagnostics } from "../../../contracts/owned-ui/index.js";
+import type { PiSessionResumeMetadata, PiWorkflowHost } from "./workflows.js";
+import { type PiPullRequestIdentity, type PiPullRequestProbe } from "./repository-pr.js";
+export interface PiEngineRuntimeFactoryInput {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly sessionId: string;
+    readonly sessionPath?: string;
+    readonly sessionSelection?: PiSessionSelection;
+    readonly sessionForkPrompt?: PiSessionForkPrompt;
+    readonly projectTrustPrompt?: PiProjectTrustPreflightPrompt;
+}
+export type PiEngineRuntimeFactory = (input: PiEngineRuntimeFactoryInput) => Promise<AgentSessionRuntime>;
+export type PiEnginePackageUpdateProbe = (settingsManager: AgentSessionServices["settingsManager"]) => Promise<readonly string[]>;
+export interface PiRepositoryContextSelection {
+    readonly cwd: string;
+    readonly branch: string;
+}
+export type PiRepositoryContextReader = (sessionId: string, sessionFile: string, signal: AbortSignal) => Promise<PiRepositoryContextSelection | null>;
+export type PiGitBranchReader = (cwd: string, signal: AbortSignal) => Promise<string | null>;
+export interface PiEngineRuntimeOptions {
+    readonly cwd: string;
+    readonly agentDir: string;
+    readonly sessionId: string;
+    readonly sessionPath: string | undefined;
+    readonly sessionSelection: PiSessionSelection | undefined;
+    readonly sessionForkPrompt: PiSessionForkPrompt | undefined;
+    readonly projectTrustPrompt: PiProjectTrustPreflightPrompt | undefined;
+    readonly createRuntime: PiEngineRuntimeFactory | undefined;
+    readonly checkPackageUpdates: PiEnginePackageUpdateProbe | undefined;
+    readonly pullRequestProbe?: PiPullRequestProbe;
+    readonly pullRequestRefreshMs?: number;
+    readonly repositoryContextPollMs?: number;
+    readonly repositoryContextReader?: PiRepositoryContextReader;
+    readonly gitBranchReader?: PiGitBranchReader;
+    readonly host: PiWorkflowHost;
+}
+export interface PiEngineRuntimePorts {
+    disposed(): boolean;
+    /** The runtime exists and its startup cwd is known; repository metadata resolves after binding. */
+    started(runtime: AgentSessionRuntime): void;
+    /** True while a runtime-initiated rebind must be ignored: delivery overload, stopped admission, or disposal. */
+    rebindBlocked(): boolean;
+    /** The current session is about to be replaced; admitted work that belongs to it is cancelled here. */
+    sessionReplacing(): void;
+    /** A session was bound and subscribed under a new generation; the adapter rebuilds the state it derives from one. */
+    sessionReplaced(session: AgentSession): void;
+    /** A runtime-initiated rebind completed; the adapter publishes the rebuilt view. */
+    rebound(): void;
+    /** A pinned Pi session event for the current generation. */
+    event(event: unknown): void;
+    compactionProgress(percent: number): void;
+    diagnostic(severity: OwnedUiDiagnostics["severity"], code: string, message: string, recoverable: boolean): void;
+    emitView(): void;
+}
+/**
+ * The pinned Pi runtime and the session bound to it: creation through the runtime factory, the
+ * session generation that stamps and invalidates events, the subscription that forwards session
+ * events, compaction progress observation, the queued-input integration, and disposal order. The
+ * adapter derives its view state from the session it is handed and never touches these directly.
+ */
+export declare class PiEngineRuntime {
+    #private;
+    constructor(options: PiEngineRuntimeOptions, ports: PiEngineRuntimePorts);
+    get runtime(): AgentSessionRuntime | undefined;
+    get session(): AgentSession | undefined;
+    /** Bumped on every bind and on overload recovery; events from an earlier generation are invalid. */
+    get generation(): number;
+    /** Actual session replacements, excluding delivery-only invalidation of callbacks. */
+    get bindingGeneration(): number;
+    get cwd(): string;
+    get repositoryCwd(): string;
+    get gitBranch(): string | null;
+    get pullRequest(): PiPullRequestIdentity | null;
+    get sessionCommands(): PiSessionCommandIntegration | undefined;
+    get started(): boolean;
+    /** Create the runtime, bind its first session, and announce the changelog; startup failures propagate. */
+    start(): Promise<AgentSessionRuntime>;
+    /** Probe extension packages for updates after startup and report them as an informational diagnostic. */
+    announcePackageUpdates(): Promise<void>;
+    currentSessionFile(): string | null;
+    currentSessionResumeMetadata(): PiSessionResumeMetadata | null;
+    /** Replace the bound session under a new generation and subscribe to its events. */
+    bindSession(session: AgentSession): void;
+    /** Stop forwarding the current session's events and open a new generation; overload recovery resumes or abandons it. */
+    suspend(): void;
+    /** Forward the current session's events again under the current generation. */
+    resume(): void;
+    compactionStarted(): void;
+    compactionEnded(): void;
+    deliverQueuedAfterCompaction(): void;
+    /** Unsubscribe, stop observing compaction, and dispose the runtime; the session reference is kept for final reads. */
+    dispose(): Promise<void>;
+}