import { EventEmitter } from "node:events";import {  createAgentSessionFromServices,  createAgentSessionRuntime,  createAgentSessionServices,  SessionManager,  shouldCompact,  type AgentSessionEvent,  type AgentSessionRuntime,} from "@earendil-works/pi-coding-agent";import { Effect } from "effect";import type { AgentImageInput } from "../../../shared/agent/agent-image-input";import {  applyRuntimeEnvInjections,  buildAgentSessionOptionsSync,  runtimeOptionsFingerprint,  resolveAgentCwdEffect,  type RuntimeStartOptions,} from "./pi-runtime-helpers";import { refreshPiModels, resolvePiModelSelection } from "./pi-runtime-models";import { findRuntimeSessionForLookup, piStatusFromEvents } from "./pi-runtime-state";import { findSessionFile } from "./sessions-store";import { getGlobalSingleton } from "./instances";import { connectorsRevisionSync } from "./connectors-service";import type {  LoggedPiEvent,  PiAgentSession,  PiAgentStatus,  PiContextUsage,} from "./pi-runtime-types"; type PiEvent = LoggedPiEvent["event"]; function runtimeFingerprint(  modelId: string,  cwd: string,  piSessionId: string | null,  options: RuntimeStartOptions,) {  return JSON.stringify({    modelId,    cwd,    piSessionId: piSessionId ?? "",    options: runtimeOptionsFingerprint(options),    connectors: connectorsRevisionSync(),  });} export function shouldRestartAfterPromptError(error: unknown): boolean {  return error instanceof Error && /Cannot continue from message role: assistant/i.test(error.message);} type PiResourceDiagnostic = {  type: "info" | "warning" | "error";  message: string;  path?: string;}; function diagnosticsMap(): Map<string, PiResourceDiagnostic[]> {  return getGlobalSingleton(    "piResourceDiagnostics",    () => new Map<string, PiResourceDiagnostic[]>(),  );} export function piResourceDiagnostics(agentDir?: string): PiResourceDiagnostic[] {  const map = diagnosticsMap();  if (agentDir) return map.get(agentDir) ?? [];  return [...map.values()].flat();} class PiSdkSession extends EventEmitter implements PiAgentSession {  private runtime: AgentSessionRuntime | null = null;  private unsubscribe: (() => void) | null = null;  private eventSeq = 0;  private eventLog: LoggedPiEvent[] = [];  private activePromptCount = 0;  private lastError: string | null = null;  private currentFingerprint = "";  private currentPiSessionId: string | null = null;  private currentCwd = "";  private currentModelId = "";  private currentStartOptions: RuntimeStartOptions = {};  private agentDir = "";   ensureStarted(    modelId: string,    cwd?: string,    piSessionId?: string | null,    options: RuntimeStartOptions = {},  ): Promise<void> {    return Effect.runPromise(this.ensureStartedEffect(modelId, cwd, piSessionId, options));  }   private ensureStartedEffect(    modelId: string,    cwd: string | undefined,    piSessionId: string | null | undefined,    options: RuntimeStartOptions,  ): Effect.Effect<void, unknown> {    return Effect.gen(      function* (this: PiSdkSession) {        const resolvedCwd = yield* resolveAgentCwdEffect(cwd);        const desiredSessionId = piSessionId ?? null;        const fingerprint = runtimeFingerprint(modelId, resolvedCwd, desiredSessionId, options);        if (this.runtime && this.currentFingerprint === fingerprint) return;         yield* this.stopEffect();        this.eventSeq = 0;        this.eventLog = [];        this.activePromptCount = 0;        this.lastError = null;         const { models, agentDir } = yield* Effect.tryPromise({          try: () => refreshPiModels(),          catch: (error) => error,        });        const selectedModel = models.find(          (model) => model.id === modelId || model.rawId === modelId || model.name === modelId,        );        if (!selectedModel) {          return yield* Effect.fail(            new Error(`Model '${modelId}' is not available from /v1/models.`),          );        }        const resolvedSelection = resolvePiModelSelection(selectedModel.id);        const providerId = selectedModel.providerId ?? resolvedSelection.providerId;        const backendModelId = selectedModel.rawId ?? resolvedSelection.modelId;         const sessionOptions = buildAgentSessionOptionsSync({ options });        applyRuntimeEnvInjections(sessionOptions.envInjections);        const sessionManager = SessionManager.create(resolvedCwd);        const resumeFile = desiredSessionId ? findSessionFile(resolvedCwd, desiredSessionId) : null;        if (resumeFile) sessionManager.setSessionFile(resumeFile);        const resuming = Boolean(resumeFile);        const runtime = yield* Effect.tryPromise({          try: () =>            createAgentSessionRuntime(              ({ cwd, agentDir, sessionManager, sessionStartEvent }) =>                Effect.runPromise(                  Effect.gen(function* () {                    const services = yield* Effect.tryPromise({                      try: () =>                        createAgentSessionServices({                          cwd,                          agentDir,                          resourceLoaderOptions: {                            noExtensions: true,                            additionalSkillPaths: sessionOptions.skills,                            additionalExtensionPaths: sessionOptions.extensionPaths,                            additionalPromptTemplatePaths: sessionOptions.promptTemplatePaths,                          },                        }),                      catch: (error) => error,                    });                    const model = services.modelRegistry.find(providerId, backendModelId);                    if (!model) {                      return yield* Effect.fail(                        new Error(                          `Model '${providerId}/${backendModelId}' is not available to the SDK runtime.`,                        ),                      );                    }                    const created = yield* Effect.tryPromise({                      try: () =>                        createAgentSessionFromServices({                          services,                          sessionManager,                          sessionStartEvent,                          model,                          thinkingLevel: selectedModel.reasoning ? "high" : undefined,                        }),                      catch: (error) => error,                    });                    const extensionErrors = services.resourceLoader                      .getExtensions()                      .errors.map(({ path, error }) => ({                        type: "error" as const,                        message: `Failed to load extension "${path}": ${error}`,                        path,                      }));                    const diagnostics = [...services.diagnostics, ...extensionErrors];                    diagnosticsMap().set(                      agentDir,                      diagnostics.map((d) => ({                        type: d.type as PiResourceDiagnostic["type"],                        message: d.message,                        path: "path" in d ? (d as { path?: string }).path : undefined,                      })),                    );                    return {                      ...created,                      services,                      diagnostics,                    };                  }),                ),              {                cwd: resolvedCwd,                agentDir,                sessionManager,                sessionStartEvent: {                  type: "session_start",                  reason: resuming ? "resume" : "startup",                },              },            ),          catch: (error) => error,        });         this.runtime = runtime;        this.agentDir = agentDir;        this.currentModelId = modelId;        this.currentCwd = resolvedCwd;        this.currentPiSessionId = runtime.session.sessionId || desiredSessionId;        this.currentFingerprint = fingerprint;        this.currentStartOptions = options;        this.unsubscribe = runtime.session.subscribe((event) => this.recordEvent(event));      }.bind(this),    );  }   prompt(    message: string,    onEvent: (event: PiEvent, seq: number) => void,    options: { streamingBehavior?: "steer" | "followUp"; images?: AgentImageInput[] } = {},  ): Promise<void> {    return Effect.runPromise(this.promptEffect(message, onEvent, options));  }   private promptEffect(    message: string,    onEvent: (event: PiEvent, seq: number) => void,    options: { streamingBehavior?: "steer" | "followUp"; images?: AgentImageInput[] },  ): Effect.Effect<void, unknown> {    const listener = (logged: LoggedPiEvent) => onEvent(logged.event, logged.seq);    this.on("loggedEvent", listener);    this.activePromptCount += 1;    this.lastError = null;    return Effect.tryPromise({      try: () => this.promptSession(message, options),      catch: (error) => error,    }).pipe(      Effect.catch((error) =>        shouldRestartAfterPromptError(error)          ? this.restartPromptEffect(message, options)          : Effect.fail(error),      ),      Effect.catch((error) =>        Effect.sync(() => {          this.lastError = error instanceof Error ? error.message : String(error);        }).pipe(Effect.andThen(Effect.fail(error))),      ),      Effect.ensuring(        Effect.sync(() => {          this.activePromptCount = Math.max(0, this.activePromptCount - 1);          this.off("loggedEvent", listener);        }),      ),    );  }   private promptSession(    message: string,    options: { streamingBehavior?: "steer" | "followUp"; images?: AgentImageInput[] },  ): Promise<void> {    return this.requireSession().prompt(message, {      streamingBehavior: options.streamingBehavior,      images: options.images,    });  }   private restartPromptEffect(    message: string,    options: { streamingBehavior?: "steer" | "followUp"; images?: AgentImageInput[] },  ): Effect.Effect<void, unknown> {    return this.ensureStartedEffect(      this.currentModelId,      this.currentCwd,      null,      this.currentStartOptions,    ).pipe(      Effect.andThen(        Effect.tryPromise({          try: () => this.promptSession(message, options),          catch: (error) => error,        }),      ),    );  }   steer(message: string, images: AgentImageInput[] = []): Promise<void> {    return Effect.runPromise(      Effect.tryPromise({        try: () => this.requireSession().steer(message, images),        catch: (error) => error,      }),    );  }   followUp(message: string, images: AgentImageInput[] = []): Promise<void> {    return Effect.runPromise(      Effect.tryPromise({        try: () => this.requireSession().followUp(message, images),        catch: (error) => error,      }),    );  }   adoptPiSessionId(piSessionId: string | null | undefined): void {    const next = piSessionId?.trim();    if (next && !this.currentPiSessionId) this.currentPiSessionId = next;  }   compact(customInstructions?: string): Promise<unknown> {    return Effect.runPromise(this.compactEffect(customInstructions));  }   private compactEffect(customInstructions?: string): Effect.Effect<unknown, unknown> {    if (this.activePromptCount > 0) {      return Effect.fail(new Error("Cannot compact while the agent is running."));    }    return Effect.tryPromise({      try: () => this.requireSession().compact(customInstructions),      catch: (error) => error,    });  }   abort(): Promise<void> {    return Effect.runPromise(      Effect.tryPromise({        try: () => this.runtime?.session.abort() ?? Promise.resolve(),        catch: () => undefined,      }).pipe(Effect.catch(() => Effect.void)),    );  }   stop(): Promise<void> {    return Effect.runPromise(this.stopEffect());  }   private stopEffect(): Effect.Effect<void> {    this.unsubscribe?.();    this.unsubscribe = null;    const runtime = this.runtime;    this.runtime = null;    if (!runtime) return Effect.void;    return Effect.tryPromise({      try: () => runtime.dispose(),      catch: () => undefined,    }).pipe(Effect.catch(() => Effect.void));  }   get status() {    const sdkSession = this.runtime?.session;    return piStatusFromEvents({      running: Boolean(this.runtime),      activePromptCount: this.activePromptCount,      sdkActive:        Boolean(sdkSession?.isStreaming) ||        Boolean(sdkSession?.isCompacting) ||        (sdkSession?.pendingMessageCount ?? 0) > 0,      modelId: this.currentModelId,      cwd: this.currentCwd,      piSessionId: this.currentPiSessionId,      agentDir: this.agentDir,      eventSeq: this.eventSeq,      lastError: this.lastError,      eventLog: this.eventLog,      contextUsage: this.computeContextUsage(),    });  }   private computeContextUsage() {    const session = this.runtime?.session;    if (!session) return null;    const usage = session.getContextUsage();    if (!usage) return null;    const settings = session.settingsManager.getCompactionSettings();    const tokens = typeof usage.tokens === "number" ? usage.tokens : null;    return {      tokens,      contextWindow: usage.contextWindow,      percent: typeof usage.percent === "number" ? usage.percent : null,      shouldCompact:        tokens !== null && usage.contextWindow > 0          ? shouldCompact(tokens, usage.contextWindow, settings)          : false,    };  }   getEventsAfter(seq: number): LoggedPiEvent[] {    return piEventsAfter(this.eventLog, seq);  }   onLoggedEvent(listener: (event: LoggedPiEvent) => void) {    this.on("loggedEvent", listener);    return () => this.off("loggedEvent", listener);  }   private requireSession() {    const session = this.runtime?.session;    if (!session) throw new Error("pi sdk session is not running");    return session;  }   private recordEvent(event: AgentSessionEvent) {    if (event.type === "session_info_changed" && this.runtime?.session.sessionId) {      this.currentPiSessionId = this.runtime.session.sessionId;    }    const logged: LoggedPiEvent = {      seq: ++this.eventSeq,      event: event as PiEvent,      timestamp: new Date().toISOString(),    };    this.eventLog.push(logged);    if (this.eventLog.length > 2_000) this.eventLog.splice(0, this.eventLog.length - 2_000);    this.emit("loggedEvent", logged);    this.emit("event", event);  }} function piEventsAfter(eventLog: LoggedPiEvent[], seq: number): LoggedPiEvent[] {  const floor = Number.isFinite(seq) ? Math.max(0, Math.trunc(seq)) : 0;  return eventLog.filter((entry) => entry.seq > floor);} const DEFAULT_SESSION_ID = "default"; class PiRuntimeManager {  private sessions = new Map<string, PiAgentSession>();   getSession(sessionId = DEFAULT_SESSION_ID): PiAgentSession {    const existing = this.sessions.get(sessionId);    if (existing) return existing;     const created = new PiSdkSession();    this.sessions.set(sessionId, created);    return created;  }   getSessionForLookup(    sessionId = DEFAULT_SESSION_ID,    piSessionId?: string | null,  ): { sessionId: string; session: PiAgentSession } {    return (      this.findSessionForLookup(sessionId, piSessionId) ?? {        sessionId,        session: this.getSession(sessionId),      }    );  }   findSessionForLookup(    sessionId = DEFAULT_SESSION_ID,    piSessionId?: string | null,  ): { sessionId: string; session: PiAgentSession } | null {    return findRuntimeSessionForLookup(this.listSessions(), sessionId, piSessionId);  }   listSessions(): Array<{ sessionId: string; session: PiAgentSession }> {    return [...this.sessions.entries()].map(([sessionId, session]) => ({ sessionId, session }));  }} export const piRuntimeManager = getGlobalSingleton(  "piRuntimeManager",  () => new PiRuntimeManager(),);