Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
18.4 KB
Raw Blame
/** @jsxImportSource react */
import { create } from "zustand";
import type { UIMessage } from "ai";
import { transcriptProgress } from "./session-progress";

import { t } from "../../../../i18n";

export type SessionActivityStatus = "idle" | "thinking" | "responding" | "error" | "compacting" | "waiting";

const LIVE_ACTIVITY_STATUSES: SessionActivityStatus[] = [
  "thinking",
  "responding",
  "compacting",
  "waiting",
];

/**
 * Real-time "anything in flight?" signal across all workspaces. The route
 * session lists used for `activeSessions` refresh on a slower cadence, so
 * the SSE-fed activity store is the authoritative gate before disposing the
 * engine: it flips busy on task submit and also covers sessions waiting on
 * permission/question prompts (a dispose would orphan those).
 */
export function hasLiveSessionActivity(
  statusesByWorkspaceId: Record<string, Record<string, SessionActivityStatus>>,
): boolean {
  return Object.values(statusesByWorkspaceId).some((sessions) =>
    Object.values(sessions).some((status) => LIVE_ACTIVITY_STATUSES.includes(status)),
  );
}

type SessionMessageRole = "assistant" | "system" | "user";

type SessionActivityRecord = {
  status: SessionActivityStatus;
  runActive: boolean;
  retrying: boolean;
  runStatusAt: number;
  runStartedAt: number;
  lastProgressAt: number;
  progressRevision: string | null;
  progressParts: Record<string, string>;
  latestActivity: string | null;
  assistantOutput: boolean;
  errorActive: boolean;
  errorMessage: string | null;
  compacting: boolean;
  waitingPermissionIds: string[];
  waitingQuestionIds: string[];
  messageRoles: Record<string, SessionMessageRole>;
  updatedAt: number;
};

type SessionLike = {
  id: string;
  status?: unknown;
  state?: unknown;
  runStatus?: unknown;
};

type SessionActivityStore = {
  recordsByWorkspaceId: Record<string, Record<string, SessionActivityRecord>>;
  statusesByWorkspaceId: Record<string, Record<string, SessionActivityStatus>>;
  getStatus: (workspaceId: string, sessionId: string) => SessionActivityStatus;
  getSessionError: (workspaceId: string, sessionId: string) => string | null;
  seedWorkspaceSessions: (workspaceId: string, sessions: SessionLike[]) => void;
  seedSessionRun: (
    workspaceId: string,
    sessionId: string,
    status: unknown,
    assistantOutput: boolean | undefined,
    options?: { snapshotStartedAt?: number },
  ) => void;
  setRunStatus: (workspaceId: string, sessionId: string, status: unknown) => void;
  observeTranscript: (workspaceId: string, sessionId: string, messages: UIMessage[], snapshot?: boolean) => void;
  markMessageRole: (workspaceId: string, sessionId: string, messageId: string, role: SessionMessageRole) => void;
  markAssistantOutput: (workspaceId: string, sessionId: string, messageId?: string, options?: { allowUnknownMessageRole?: boolean }) => void;
  setWaitingRequest: (workspaceId: string, sessionId: string, kind: "permission" | "question", requestId: string, waiting: boolean) => void;
  replaceWaitingRequests: (workspaceId: string, sessionId: string, kind: "permission" | "question", requestIds: string[]) => void;
  setError: (workspaceId: string, sessionId: string, message?: string) => void;
  clearError: (workspaceId: string, sessionId: string) => void;
  setCompacting: (workspaceId: string, sessionId: string, compacting: boolean) => void;
  removeSession: (workspaceId: string, sessionId: string) => void;
};

const createRecord = (): SessionActivityRecord => ({
  status: "idle",
  runActive: false,
  retrying: false,
  runStatusAt: 0,
  runStartedAt: 0,
  lastProgressAt: 0,
  progressRevision: null,
  progressParts: {},
  latestActivity: null,
  assistantOutput: false,
  errorActive: false,
  errorMessage: null,
  compacting: false,
  waitingPermissionIds: [],
  waitingQuestionIds: [],
  messageRoles: {},
  updatedAt: 0,
});

function normalizeRunStatus(status: unknown): "idle" | "running" | "retry" {
  if (typeof status === "string") {
    if (status === "busy" || status === "running") return "running";
    if (status === "retry") return "retry";
    return "idle";
  }

  if (!status || typeof status !== "object") return "idle";
  const type = "type" in status ? status.type : undefined;
  if (type === "busy" || type === "running") return "running";
  if (type === "retry") return "retry";
  return "idle";
}

function sessionRunStatus(session: SessionLike) {
  return session.status ?? session.state ?? session.runStatus;
}

function statusForRecord(record: SessionActivityRecord): SessionActivityStatus {
  if (record.errorActive) return "error";
  if (record.waitingPermissionIds.length > 0 || record.waitingQuestionIds.length > 0) return "waiting";
  if (record.compacting) return "compacting";
  if (!record.runActive) return "idle";
  return record.assistantOutput ? "responding" : "thinking";
}

function updateWorkspaceStatus(
  statusesByWorkspaceId: Record<string, Record<string, SessionActivityStatus>>,
  workspaceId: string,
  sessionId: string,
  status: SessionActivityStatus,
) {
  const current = statusesByWorkspaceId[workspaceId] ?? {};
  if (current[sessionId] === status) return statusesByWorkspaceId;
  return {
    ...statusesByWorkspaceId,
    [workspaceId]: {
      ...current,
      [sessionId]: status,
    },
  };
}

function sameStrings(left: string[], right: string[]): boolean {
  return left.length === right.length && left.every((value, index) => value === right[index]);
}

function sameMessageRoles(
  left: Record<string, SessionMessageRole>,
  right: Record<string, SessionMessageRole>,
): boolean {
  const leftEntries = Object.entries(left);
  return leftEntries.length === Object.keys(right).length
    && leftEntries.every(([messageId, role]) => right[messageId] === role);
}

function sameActivityRecord(
  current: SessionActivityRecord,
  next: SessionActivityRecord,
  status: SessionActivityStatus,
): boolean {
  return current.status === status
    && current.runActive === next.runActive
    && current.retrying === next.retrying
    && current.runStatusAt === next.runStatusAt
    && current.runStartedAt === next.runStartedAt
    && current.lastProgressAt === next.lastProgressAt
    && current.progressRevision === next.progressRevision
    && current.latestActivity === next.latestActivity
    && current.assistantOutput === next.assistantOutput
    && current.errorActive === next.errorActive
    && current.errorMessage === next.errorMessage
    && current.compacting === next.compacting
    && sameStrings(current.waitingPermissionIds, next.waitingPermissionIds)
    && sameStrings(current.waitingQuestionIds, next.waitingQuestionIds)
    && sameMessageRoles(current.messageRoles, next.messageRoles);
}

function updateRecord(
  state: Pick<SessionActivityStore, "recordsByWorkspaceId" | "statusesByWorkspaceId">,
  workspaceId: string,
  sessionId: string,
  updater: (record: SessionActivityRecord) => SessionActivityRecord,
) {
  const workspaceRecords = state.recordsByWorkspaceId[workspaceId] ?? {};
  const currentRecord = workspaceRecords[sessionId];
  const nextRecord = updater(currentRecord ?? createRecord());
  const status = statusForRecord(nextRecord);
  if (currentRecord && sameActivityRecord(currentRecord, nextRecord, status)) return state;
  const recordWithStatus = { ...nextRecord, status, updatedAt: Date.now() };
  return {
    recordsByWorkspaceId: {
      ...state.recordsByWorkspaceId,
      [workspaceId]: {
        ...workspaceRecords,
        [sessionId]: recordWithStatus,
      },
    },
    statusesByWorkspaceId: updateWorkspaceStatus(state.statusesByWorkspaceId, workspaceId, sessionId, status),
  };
}

// Message roles are only consulted while a run is active to decide whether a
// streaming part belongs to an assistant message. Without a cap the dict grows
// by one entry per message for a session's whole lifetime, so keep only the
// most recently marked messages.
export const MAX_TRACKED_MESSAGE_ROLES = 200;

function withMessageRole(
  roles: Record<string, SessionMessageRole>,
  messageId: string,
  role: SessionMessageRole,
): Record<string, SessionMessageRole> {
  if (roles[messageId] === role) return roles;
  const next: Record<string, SessionMessageRole> = { ...roles, [messageId]: role };
  const ids = Object.keys(next);
  const overflow = ids.length - MAX_TRACKED_MESSAGE_ROLES;
  if (overflow <= 0) return next;
  for (const id of ids.slice(0, overflow)) {
    delete next[id];
  }
  return next;
}

function removeValue(values: string[], value: string) {
  return values.filter((item) => item !== value);
}

function addValue(values: string[], value: string) {
  return values.includes(value) ? values : [...values, value];
}

export const useSessionActivityStore = create<SessionActivityStore>((set, get) => ({
  recordsByWorkspaceId: {},
  statusesByWorkspaceId: {},
  getStatus: (workspaceId, sessionId) => (
    get().statusesByWorkspaceId[workspaceId]?.[sessionId] ?? "idle"
  ),
  getSessionError: (workspaceId, sessionId) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();

    if (!workspace || !session) {
      return null;
    }

    const record = get().recordsByWorkspaceId[workspace]?.[session];

    if (!record?.errorActive) {
      return null;
    }

    return record.errorMessage;
  },
  seedWorkspaceSessions: (workspaceId, sessions) => {
    const id = workspaceId.trim();
    if (!id) return;
    set((state) => {
      let nextState: Pick<SessionActivityStore, "recordsByWorkspaceId" | "statusesByWorkspaceId"> = state;
      for (const session of sessions) {
        const sessionId = session.id.trim();
        if (!sessionId) continue;
        const status = sessionRunStatus(session);
        if (status === undefined || status === null) continue;
        nextState = updateRecord(nextState, id, sessionId, (record) => {
          const normalized = normalizeRunStatus(status);
          const runActive = normalized === "running" || normalized === "retry";
          if (!runActive && record.status !== "idle") return record;
          return {
            ...record,
            runActive,
            retrying: normalized === "retry",
            runStartedAt: runActive && !record.runActive ? Date.now() : record.runStartedAt,
            assistantOutput: runActive && record.runActive ? record.assistantOutput : false,
            errorActive: runActive ? false : record.errorActive,
            errorMessage: runActive ? null : record.errorMessage,
            compacting: runActive ? record.compacting : false,
            waitingPermissionIds: runActive ? record.waitingPermissionIds : [],
            waitingQuestionIds: runActive ? record.waitingQuestionIds : [],
          };
        });
      }
      if (nextState === state) return state;
      return { ...state, ...nextState };
    });
  },
  seedSessionRun: (workspaceId, sessionId, status, assistantOutput, options) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => {
      const normalized = normalizeRunStatus(status);
      const runActive = normalized === "running" || normalized === "retry";
      const snapshotStartedAt = options?.snapshotStartedAt;
      // Order snapshot seeds against live writes so stale idle cannot kill a
      // live spinner and stale busy cannot resurrect a run that already ended.
      if (typeof snapshotStartedAt === "number" && snapshotStartedAt < record.runStatusAt) return record;
      if (typeof snapshotStartedAt !== "number" && !runActive && record.status !== "idle") return record;
      return {
        ...record,
        runActive,
        runStatusAt: snapshotStartedAt ?? record.runStatusAt,
        retrying: normalized === "retry",
        runStartedAt: runActive && !record.runActive ? Date.now() : record.runStartedAt,
        assistantOutput: runActive && (assistantOutput ?? record.assistantOutput),
        errorActive: runActive ? false : record.errorActive,
        errorMessage: runActive ? null : record.errorMessage,
        compacting: runActive ? record.compacting : false,
        waitingPermissionIds: runActive ? record.waitingPermissionIds : [],
        waitingQuestionIds: runActive ? record.waitingQuestionIds : [],
      };
    }));
  },
  setRunStatus: (workspaceId, sessionId, status) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => {
      const normalized = normalizeRunStatus(status);
      const runActive = normalized === "running" || normalized === "retry";
      return {
        ...record,
        runActive,
        runStatusAt: Date.now(),
        retrying: normalized === "retry",
        runStartedAt: runActive && !record.runActive ? Date.now() : record.runStartedAt,
        assistantOutput: runActive && record.runActive ? record.assistantOutput : false,
        errorActive: runActive ? false : record.errorActive,
        errorMessage: runActive ? null : record.errorMessage,
        compacting: runActive ? record.compacting : false,
        waitingPermissionIds: runActive ? record.waitingPermissionIds : [],
        waitingQuestionIds: runActive ? record.waitingQuestionIds : [],
      };
    }));
  },
  observeTranscript: (workspaceId, sessionId, messages, snapshot = false) => {
    set((state) => updateRecord(state, workspaceId, sessionId, (record) => {
      const progress = transcriptProgress(messages, record.progressParts);
      if (record.progressRevision === progress.revision) return record;
      return {
        ...record,
        progressRevision: progress.revision,
        progressParts: progress.parts,
        latestActivity: progress.label ?? record.latestActivity,
        lastProgressAt: progress.label
          ? Math.max(record.lastProgressAt, snapshot && record.progressRevision === null ? progress.timestamp : Date.now())
          : record.lastProgressAt,
      };
    }));
  },
  markMessageRole: (workspaceId, sessionId, messageId, role) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    const message = messageId.trim();
    if (!workspace || !session || !message) return;
    set((state) => updateRecord(state, workspace, session, (record) => ({
      ...record,
      messageRoles: withMessageRole(record.messageRoles, message, role),
    })));
  },
  markAssistantOutput: (workspaceId, sessionId, messageId, options) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    const message = messageId?.trim() ?? "";
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => {
      if (!record.runActive) return record;
      if (message && record.messageRoles[message] && record.messageRoles[message] !== "assistant") return record;
      if (message && !record.messageRoles[message] && options?.allowUnknownMessageRole !== true) return record;
      return { ...record, assistantOutput: true };
    }));
  },
  setWaitingRequest: (workspaceId, sessionId, kind, requestId, waiting) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    const request = requestId.trim();
    if (!workspace || !session || !request) return;
    set((state) => updateRecord(state, workspace, session, (record) => {
      const key = kind === "permission" ? "waitingPermissionIds" : "waitingQuestionIds";
      return {
        ...record,
        [key]: waiting ? addValue(record[key], request) : removeValue(record[key], request),
      };
    }));
  },
  replaceWaitingRequests: (workspaceId, sessionId, kind, requestIds) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    const ids = Array.from(new Set(requestIds.map((requestId) => requestId.trim()).filter(Boolean)));
    set((state) => updateRecord(state, workspace, session, (record) => ({
      ...record,
      [kind === "permission" ? "waitingPermissionIds" : "waitingQuestionIds"]: ids,
    })));
  },
  setError: (workspaceId, sessionId, message) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => ({
      ...record,
      errorActive: true,
      errorMessage: message ? message : "Session failed",
      runActive: false,
      retrying: false,
      runStatusAt: Date.now(),
      assistantOutput: false,
      compacting: false,
    })));
  },
  clearError: (workspaceId, sessionId) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => ({
      ...record,
      errorActive: false,
      errorMessage: null,
    })));
  },
  setCompacting: (workspaceId, sessionId, compacting) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => updateRecord(state, workspace, session, (record) => ({
      ...record,
      compacting,
      errorActive: compacting ? false : record.errorActive,
      errorMessage: compacting ? null : record.errorMessage,
    })));
  },
  removeSession: (workspaceId, sessionId) => {
    const workspace = workspaceId.trim();
    const session = sessionId.trim();
    if (!workspace || !session) return;
    set((state) => {
      const workspaceRecords = state.recordsByWorkspaceId[workspace];
      const workspaceStatuses = state.statusesByWorkspaceId[workspace];
      if (!workspaceRecords?.[session] && !workspaceStatuses?.[session]) return state;
      const nextRecords = { ...(workspaceRecords ?? {}) };
      const nextStatuses = { ...(workspaceStatuses ?? {}) };
      delete nextRecords[session];
      delete nextStatuses[session];
      return {
        ...state,
        recordsByWorkspaceId: {
          ...state.recordsByWorkspaceId,
          [workspace]: nextRecords,
        },
        statusesByWorkspaceId: {
          ...state.statusesByWorkspaceId,
          [workspace]: nextStatuses,
        },
      };
    });
  },
}));

export function getSessionActivityStatusLabel(status: SessionActivityStatus) {
  if (status === "thinking") return t("session.assistant_thinking");
  if (status === "responding") return t("session.assistant_responding");
  if (status === "waiting") return t("session.assistant_waiting");
  if (status === "compacting") return t("session.assistant_compacting");
  if (status === "error") return t("session.assistant_error");
  return t("session.assistant_idle");
}