Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
8.2 KB
Raw Blame
import { useEffect, useSyncExternalStore } from 'react';
import { api, ApiError } from './client';

/**
 * A chat's /plan and its queued messages as the host reports them (notes-split-agent6.md, "Backend contract for the ui5 worker"). The plan
 * arrives whole every time it changes, in the chat stream as {type:'plan', event, plan} and as the SSE event 'plan' {chatId, event, plan}; the
 * queue as {type:'queued-message', queue} and the SSE event 'queue' {chatId, queue}. A snapshot replaces what was there; null or an empty
 * list clears it. The host owns both; every button asks it and draws the answer.
 */
export type PlanState = 'proposed' | 'approved' | 'rejected' | 'running' | 'paused' | 'done' | 'stopped';
export type StepState = 'pending' | 'running' | 'done' | 'failed' | 'skipped';
export interface PlanStep { id: string; text: string; detail?: string; summary?: string; state: StepState }
export interface Plan { id: string; title: string; source: 'plan' | 'goal'; state: PlanState; steps: PlanStep[]; /** A plain sentence (an interface string) when the app stopped the planning turn early. */ caution?: string }
export interface QueuedMessage { id: string; text: string; deliverAt: 'step' | 'end' }

const PLAN_STATES = ['proposed', 'approved', 'rejected', 'running', 'paused', 'done', 'stopped'];
const STEP_STATES = ['pending', 'running', 'done', 'failed', 'skipped'];

export function readPlan(raw: unknown): Plan | null {
  if (!raw || typeof raw !== 'object') return null;
  const p = raw as Record<string, unknown>;
  if (typeof p.id !== 'string' || !p.id || !PLAN_STATES.includes(String(p.state)) || !Array.isArray(p.steps)) return null;
  const steps: PlanStep[] = [];
  p.steps.forEach((s, i) => {
    if (!s || typeof s !== 'object') return;
    const r = s as Record<string, unknown>;
    if (typeof r.text !== 'string' || !r.text.trim()) return;
    steps.push({
      id: typeof r.id === 'string' && r.id ? r.id : `s${i + 1}`, text: r.text,
      state: STEP_STATES.includes(String(r.state)) ? r.state as StepState : 'pending',
      ...(typeof r.detail === 'string' && r.detail ? { detail: r.detail } : {}),
      ...(typeof r.summary === 'string' && r.summary ? { summary: r.summary } : {}),
    });
  });
  if (!steps.length) return null;
  return { id: p.id, title: typeof p.title === 'string' ? p.title : '', source: p.source === 'goal' ? 'goal' : 'plan', state: p.state as PlanState, steps };
}

export function readQueue(raw: unknown): QueuedMessage[] {
  if (!Array.isArray(raw)) return [];
  return raw.flatMap((q): QueuedMessage[] => {
    if (!q || typeof q !== 'object') return [];
    const r = q as Record<string, unknown>;
    return typeof r.id === 'string' && r.id && typeof r.text === 'string' && r.text
      ? [{ id: r.id, text: r.text, deliverAt: r.deliverAt === 'end' ? 'end' : 'step' }] : [];
  });
}

const plans = new Map<string, Plan>();
const queues = new Map<string, QueuedMessage[]>();
const listeners = new Set<() => void>();
const emit = () => listeners.forEach(fn => fn());
const subscribe = (fn: () => void) => { listeners.add(fn); return () => { listeners.delete(fn); }; };

export function applyPlanFrame(chatId: string, raw: unknown) {
  const plan = readPlan(raw), before = plans.get(chatId);
  if (!plan) { if (plans.delete(chatId)) emit(); return; }
  if (before && JSON.stringify(before) === JSON.stringify(plan)) return;
  plans.set(chatId, plan);
  emit();
}

export function applyQueueFrame(chatId: string, raw: unknown) {
  const items = readQueue(raw), before = queues.get(chatId) ?? [];
  if (JSON.stringify(before) === JSON.stringify(items)) return;
  if (items.length) queues.set(chatId, items); else queues.delete(chatId);
  emit();
}

const NONE: QueuedMessage[] = [];
export const planOf = (chatId: string | null | undefined): Plan | null => (chatId ? plans.get(chatId) ?? null : null);
export const queueOf = (chatId: string | null | undefined): QueuedMessage[] => (chatId ? queues.get(chatId) ?? NONE : NONE);

export function usePlan(chatId: string | null | undefined): Plan | null {
  const plan = useSyncExternalStore(subscribe, () => planOf(chatId), () => null);
  useEffect(() => { if (chatId) void loadPlan(chatId); }, [chatId]);
  return plan;
}

export function useQueue(chatId: string | null | undefined): QueuedMessage[] {
  const items = useSyncExternalStore(subscribe, () => queueOf(chatId), () => NONE);
  useEffect(() => { if (chatId) void loadQueue(chatId); }, [chatId]);
  return items;
}

export async function loadPlan(chatId: string) {
  try { applyPlanFrame(chatId, (await api.get<{ plan: unknown }>(`/api/plan?sessionId=${encodeURIComponent(chatId)}`)).plan); }
  catch { /* an older host has no plan route: no plan */ }
}

/** The waiting messages. Without `release` this only reads; the host never sends them from here. */
export async function loadQueue(chatId: string) {
  try { applyQueueFrame(chatId, (await api.get<{ queue: unknown }>(`/api/chat/queue?sessionId=${encodeURIComponent(chatId)}`)).queue); }
  catch { /* an older host has no queue route: nothing queued */ }
}

/** Save the edited steps. Each step keeps its grey detail line when its words did not change. */
export async function planEdit(chatId: string, plan: Plan, texts: string[]) {
  const steps = texts.map((text, i) => { const was = plan.steps[i]; return was && was.text === text && was.detail ? { text, detail: was.detail } : text; });
  const result = await api.post<{ plan: unknown }>('/api/plan/edit', { sessionId: chatId, planId: plan.id, steps });
  applyPlanFrame(chatId, result.plan);
}

export async function planReject(chatId: string, planId: string) {
  const result = await api.post<{ plan: unknown }>('/api/plan/reject', { sessionId: chatId, planId });
  applyPlanFrame(chatId, result.plan);
}

/** Approve: the host answers with the plan and the message that carries it out; the caller sends that message as an ordinary turn. */
export async function planApprove(chatId: string, planId: string): Promise<{ prompt: string }> {
  const result = await api.post<{ plan: unknown; prompt: string }>('/api/plan/approve', { sessionId: chatId, planId });
  applyPlanFrame(chatId, result.plan);
  return { prompt: String(result.prompt ?? '') };
}

/** Put a message behind the running goal. Returns false when no goal is running (409), so the caller can send it the normal way. */
export async function queueMessage(chatId: string, message: string): Promise<boolean> {
  try {
    const result = await api.post<{ queue: unknown }>('/api/chat/queue', { sessionId: chatId, message });
    applyQueueFrame(chatId, result.queue);
    return true;
  } catch (e) {
    if (e instanceof ApiError && e.status === 409) return false;
    throw e;
  }
}

/** Take a queued message back before it is sent. */
export async function cancelQueued(chatId: string, id: string) {
  const result = await api.post<{ queue: unknown }>('/api/chat/queue/cancel', { sessionId: chatId, id });
  applyQueueFrame(chatId, result.queue);
}

/** The step the queued message waits for: the one running now, or the next that has not started. 1-based, 0 if there is none. */
export function currentStep(plan: Plan | null): number {
  if (!plan) return 0;
  const running = plan.steps.findIndex(s => s.state === 'running');
  if (running >= 0) return running + 1;
  const next = plan.steps.findIndex(s => s.state === 'pending');
  return next >= 0 ? next + 1 : 0;
}

/** The words under a queued message: when it will be sent. The first one goes out after the current step, the next ones after that. */
export function queuedWhen(item: QueuedMessage, index: number, plan: Plan | null): { id: string; args?: unknown[] } {
  if (item.deliverAt === 'end') return { id: 'Queued — sends when the goal finishes' };
  if (index > 0) return { id: 'Queued — sends after that' };
  const step = currentStep(plan);
  return step > 0 ? { id: 'Queued — sends when step {0} finishes', args: [step] } : { id: 'Queued — sends when the goal finishes' };
}

export const stepsDone = (plan: Plan) => plan.steps.filter(s => s.state === 'done').length;

/** The stored plan of a chat without asking the host (the one that asks is usePlan, used once per chat). */
export function usePlanQuiet(chatId: string | null | undefined): Plan | null {
  return useSyncExternalStore(subscribe, () => planOf(chatId), () => null);
}