Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

5.7 KB
Raw Blame
import type { AssistantSidebarContext } from "./assistant-sidebar";
import type { Agent } from "@earendil-works/pi-agent-core";
import type { TemplateResult, nothing } from "lit";
import type { DensityTier } from "./density";
import type { Attachment } from "@earendil-works/pi-web-ui";
import type {
  ApprovalDecision,
  CoreSession,
  PendingApproval,
  QueuedRun,
  TurnOptions,
  TurnRuntime,
  entriesToMessages,
} from "./core-bridge";
import type { EffortLevel, ModelOption } from "./model-options";
import type { ComposerMenu } from "./composer";

interface PaneState {
  threadRef: string | null;
  sessionId: string | null;
  working: boolean;
}

export interface ConvHost {
  pane: boolean;
  ownsUrl: boolean;
  container(): HTMLElement | null;
  claimContainer(): HTMLElement | null;
  visible(): boolean;
  density(): DensityTier;
  onDensityChange(handler: () => void): void;
  ensureDeliveryStream(): void;
  inbox?: { context(): AssistantSidebarContext };
  onState?(state: PaneState): void;
  onExpand?(): void;
}

export interface ConvCtx extends ConvHost {
  chat: ChatSurface;
  composer: ComposerSurface;
}

interface ChatState {
  pins: import("./core-bridge").SessionPin[];
  agent: Agent | null;
  normalStreamFn: Agent["streamFn"] | null;
  host: HTMLElement | null;
  threadRef: string | null;
  sessionId: string | null;
  scopeId: string | null;
  contextName: string | null;
  rememberedThreadRef: string | null;
  rememberedSessionId: string | null;
  rememberedScopeId: string | null;
  rememberedContextName: string | null;
  pendingSend: string | null;
  resolvingApprovals: Set<string>;
  transcriptAnchorSeq: number | null;
  earlierCount: number;
  loadingEarlier: boolean;
  forkSession: CoreSession | null;
  inheritedMessages: ReturnType<typeof entriesToMessages>;
  inheritedExpanded: boolean;
  inheritedLoaded: boolean;
}

export interface ChatSurface {
  state: ChatState;
  hasLiveRun(): boolean;
  signalLiveRun(
    kind: "abort" | "steer",
    text?: string,
    queuedRunId?: string,
  ): Promise<import("./core-bridge").SignalOutcome>;
  stopLiveRun(): Promise<void>;
  isStopping(): boolean;
  currentTurnOptions(): TurnOptions;
  turnRuntime(): TurnRuntime | null;
  newChat(context?: { scopeId: string; name: string | null }): string;
  teardown(): void;
  resetChatState(): void;
  mountContinuable(
    threadRef: string,
    sessionId: string | null,
    scopeId: string | null,
    messages: ReturnType<typeof entriesToMessages>,
    contextName?: string | null,
    session?: CoreSession,
    inheritedMessages?: ReturnType<typeof entriesToMessages>,
  ): void;
  mountReadOnly(
    s: CoreSession,
    messages: ReturnType<typeof entriesToMessages>,
    earlierCount?: number,
    anchorSeq?: number | null,
    inheritedMessages?: ReturnType<typeof entriesToMessages>,
  ): void;
  attachApprovalsWhenLoaded(sessionId: string, approvals: Promise<{ approvals: PendingApproval[] } | null>): void;
  mountLoadingPane(): () => boolean;
  mountLoadError(retry: () => void): void;
  scrollToBottom(): void;
  revealEntry(seq: number): boolean;
  drawActiveChat(agent?: Agent | null, opts?: { forceScroll?: boolean }): void;
  setTranscriptWindow(anchorSeq: number | null, earlierCount: number, hasEarlier?: boolean): void;
  setPins(pins: import("./core-bridge").SessionPin[]): void;
  setGoal(goal: import("./goal-strip").GoalStripState | null): void;
  setTurnRuntime(runtime: TurnRuntime | null): void;
  requestBackgroundPanel(sessionId: string | null, threadRef: string | null): void;
  activePendingApprovals(): PendingApproval[];
  hasUnresolvedApproval(): boolean;
  resolveCommandApproval(decision: ApprovalDecision): void;
  approvalSummaryView(a: PendingApproval, expanded?: boolean): TemplateResult;
  notePendingSessionOnSend(): void;
  syncPaneState(): void;
  onDelivery(threadRef: string): void;
  resumeIfIdle(): void;
  redraw(): void;
  dispose(): void;
}

interface ComposerState {
  draft: string;
  attachments: Attachment[];
  error: string;
  processingFiles: boolean;
  dragging: boolean;
  openMenu: ComposerMenu | null;
  slashDismissed: boolean;
  effortLevel: EffortLevel;
  fastMode: boolean | undefined;
  pasteView: { id: string; text: string; initial: string; dirty: boolean } | null;
}

export interface ComposerSurface {
  composerApprovalPanel(approvals: PendingApproval[], resolve?: (decision: ApprovalDecision) => void): TemplateResult;
  submit(instruction?: string): Promise<void>;
  restageAttachments(attachments: Attachment[], note: string): void;
  state: ComposerState;
  composerForm(agent: Agent, header?: TemplateResult | typeof nothing): TemplateResult;
  queuedStrip(agent: Agent): TemplateResult | typeof import("lit").nothing;
  waitingSteers(agent: Agent): QueuedRun[];
  queuedRunsFor(threadRef: string | null): QueuedRun[];
  setQueuedRuns(threadRef: string, runs: QueuedRun[]): void;
  resetComposer(): void;
  focusComposerEnd(): void;
  fillSuggestedPrompt(prompt: string, agent: Agent): void;
  addAnnotations(text: string, files: File[], annotationId?: string, remove?: boolean): Promise<boolean>;
  sendSuggestedPrompt(prompt: string, agent: Agent): Promise<void>;
  resizeComposer(): void;
  currentModelOption(): ModelOption | undefined;
  followsDefault(): boolean;
  followScopeDefault(agent: Agent): Promise<void>;
  carryModelPick(fromThreadRef: string | null, toThreadRef: string): void;
  refreshRuntimeSelection(scopeId: string | null, agent?: Agent, refresh?: boolean): Promise<void>;
  onDragEnter(e: DragEvent): void;
  onDragOver(e: DragEvent): void;
  onDragLeave(e: DragEvent): void;
  onDrop(e: DragEvent, agent: Agent): Promise<void>;
  closeMenus(): boolean;
  dispose(): void;
}

export interface Conversation extends ChatSurface {
  composer: ComposerSurface;
}