Spaces:
Running
Running
Ribbon logo, copilot layout tools (positions, move_nodes, auto_layout), chats saved to the bucket, linkified copilot messages with media previews, embedded sign-in fix
86da9e3 verified Download src/store/useCopilotStore.ts from mrfakename/flow: direct link, hf CLI and curl.
- Browser
- Download file 24.8 kB
-
https://huggingface.co/spaces/mrfakename/flow/resolve/main/src/store/useCopilotStore.ts
- Command line
-
hf download hf://spaces/mrfakename/flow/src/store/useCopilotStore.ts
-
curl -L -o useCopilotStore.ts https://huggingface.co/spaces/mrfakename/flow/resolve/main/src/store/useCopilotStore.ts
24.8 kB
| import { create } from "zustand"; | |
| import { prefs } from "../lib/prefs"; | |
| import { SYSTEM_PROMPT, TOOL_SPECS, TOOLS, type ToolKind } from "../lib/copilotTools"; | |
| import { chatStream, DEFAULT_MODEL, LLMError, MODEL_PRESETS, validateModel, type ChatMessage, type ModelCheck, type ToolCall } from "../lib/llm"; | |
| import { useAuthStore } from "./useAuthStore"; | |
| import { useCanvasStore } from "./useCanvasStore"; | |
| import type { CanvasEdge, CanvasNode } from "../lib/types"; | |
| const KEY = "gr-canvas-copilot"; | |
| const THREADS_KEY = "gr-canvas-copilot-threads"; | |
| const MAX_THREADS = 500; | |
| export type Approval = "ask" | "auto" | "yolo"; | |
| export const APPROVAL_LABEL: Record<Approval, { label: string; hint: string }> = { | |
| ask: { label: "Ask first", hint: "You approve every change and every run" }, | |
| auto: { label: "Edit freely", hint: "Edits apply right away; asks before spending quota on a run" }, | |
| yolo: { label: "Never ask", hint: "Edits and runs happen without asking" }, | |
| }; | |
| export interface Proposal { | |
| callId: string; | |
| name: string; | |
| kind: ToolKind; | |
| args: Record<string, unknown>; | |
| summary: string; | |
| decision?: "approved" | "rejected"; | |
| status?: "running" | "done" | "error"; | |
| detail?: string; | |
| /** Compact result for the expandable view. */ | |
| result?: string; | |
| } | |
| /** Graph state captured before a turn, so the turn's edits can be reverted. Outputs are dropped to keep storage small. */ | |
| export interface Checkpoint { | |
| nodes: CanvasNode[]; | |
| edges: CanvasEdge[]; | |
| } | |
| export type ChatItem = | |
| | { id: string; kind: "user"; text: string; cp?: Checkpoint; changed?: boolean } | |
| | { id: string; kind: "assistant"; text: string; marks?: number[]; streaming?: boolean } | |
| | { id: string; kind: "tools"; items: Proposal[]; awaiting: boolean } | |
| | { id: string; kind: "error"; text: string }; | |
| /** One timeline. Editing or retrying a message forks a new branch that copies the prefix, so ids stay comparable. */ | |
| export interface Branch { | |
| id: string; | |
| createdAt: number; | |
| items: ChatItem[]; | |
| transcript: ChatMessage[]; | |
| } | |
| export interface Thread { | |
| id: string; | |
| title: string; | |
| createdAt: number; | |
| updatedAt: number; | |
| branches: Branch[]; | |
| active: string; | |
| /** Workflow open when the chat started. */ | |
| workflowId?: string; | |
| /** Listed from the bucket index, not downloaded yet (branches is empty). */ | |
| stub?: boolean; | |
| /** Counts for stubs, from the index. */ | |
| msgCount?: number; | |
| branchCount?: number; | |
| } | |
| /** Where threads are stored (the user's bucket); registered by the sync store. */ | |
| export interface ChatBackend { | |
| load: (id: string) => Promise<Thread | null>; | |
| remove: (id: string) => void; | |
| } | |
| let backend: ChatBackend | null = null; | |
| export const setChatBackend = (b: ChatBackend | null) => { | |
| backend = b; | |
| }; | |
| export const threadMessages = (t: Thread) => (t.stub ? (t.msgCount ?? 0) : activeBranch(t).items.filter((i) => i.kind === "user").length); | |
| export const threadBranches = (t: Thread) => (t.stub ? (t.branchCount ?? 1) : t.branches.length); | |
| export const activeBranch = (t: Thread): Branch => t.branches.find((b) => b.id === t.active) ?? t.branches[0]; | |
| /** Alternative versions of the user message at `index` on the active branch: one representative branch per distinct message. */ | |
| export function versionsAt(t: Thread, index: number): Branch[] { | |
| const cur = activeBranch(t); | |
| const prefix = cur.items.slice(0, index).map((i) => i.id); | |
| const seen = new Map<string, Branch>(); | |
| for (const b of t.branches) { | |
| const it = b.items[index]; | |
| if (!it || it.kind !== "user") continue; | |
| if (prefix.some((id, k) => b.items[k]?.id !== id)) continue; | |
| const prev = seen.get(it.id); | |
| // Prefer the branch the user is on, else the newest fork of this version. | |
| if (!prev || b.id === cur.id || (prev.id !== cur.id && b.createdAt > prev.createdAt)) seen.set(it.id, b); | |
| } | |
| return [...seen.values()].sort((a, b) => a.createdAt - b.createdAt); | |
| } | |
| export interface SavedModel { | |
| id: string; | |
| label: string; | |
| custom?: boolean; | |
| } | |
| export type Layout = "dock" | "sidebar"; | |
| interface CopilotState { | |
| open: boolean; | |
| layout: Layout; | |
| view: "chat" | "history"; | |
| model: string; | |
| models: SavedModel[]; | |
| checks: Record<string, ModelCheck | { pending: true }>; | |
| approval: Approval; | |
| threads: Thread[]; | |
| activeId: string | null; | |
| busy: boolean; | |
| draft: string; | |
| setOpen: (v: boolean) => void; | |
| toggle: () => void; | |
| setLayout: (l: Layout) => void; | |
| setView: (v: "chat" | "history") => void; | |
| setDraft: (v: string) => void; | |
| setModel: (id: string) => void; | |
| addModel: (id: string) => Promise<ModelCheck>; | |
| removeModel: (id: string) => void; | |
| checkModel: (id: string) => Promise<void>; | |
| setApproval: (a: Approval) => void; | |
| newThread: () => void; | |
| openThread: (id: string) => Promise<void>; | |
| /** Id of a chat being downloaded from the bucket. */ | |
| loadingThread: string | null; | |
| deleteThread: (id: string) => void; | |
| send: (text: string) => Promise<void>; | |
| /** Fork at a user message, restore its checkpoint, and resend with new text (retry when text is unchanged). */ | |
| editMessage: (itemId: string, text: string) => Promise<void>; | |
| retry: (itemId: string) => Promise<void>; | |
| restore: (itemId: string) => void; | |
| switchBranch: (branchId: string) => void; | |
| decide: (callId: string, decision: "approved" | "rejected") => void; | |
| decideAll: (decision: "approved" | "rejected") => void; | |
| stop: () => void; | |
| } | |
| function loadPrefs() { | |
| try { | |
| const raw = prefs.get(KEY); | |
| if (raw) { | |
| const p = JSON.parse(raw); | |
| const models: SavedModel[] = Array.isArray(p.models) && p.models.length ? p.models : MODEL_PRESETS.map((m) => ({ id: m.id, label: m.label })); | |
| return { | |
| model: typeof p.model === "string" ? p.model : DEFAULT_MODEL, | |
| models, | |
| approval: (["ask", "auto", "yolo"].includes(p.approval) ? p.approval : "ask") as Approval, | |
| layout: (p.layout === "sidebar" ? "sidebar" : "dock") as Layout, | |
| }; | |
| } | |
| } catch { | |
| /* ignore */ | |
| } | |
| return { model: DEFAULT_MODEL, models: MODEL_PRESETS.map((m) => ({ id: m.id, label: m.label })), approval: "ask" as Approval, layout: "dock" as Layout }; | |
| } | |
| /** Cleans a stored thread: older single-timeline shape, no streaming / awaiting leftovers. */ | |
| export function normaliseThread(x: Thread & { items?: ChatItem[]; transcript?: ChatMessage[] }): Thread { | |
| const branches: Branch[] = x.branches?.length ? x.branches : [{ id: "b0", createdAt: x.createdAt, items: x.items ?? [], transcript: x.transcript ?? [] }]; | |
| return { | |
| id: x.id, | |
| title: x.title, | |
| createdAt: x.createdAt, | |
| updatedAt: x.updatedAt, | |
| workflowId: x.workflowId, | |
| active: x.active && branches.some((b) => b.id === x.active) ? x.active : branches[0].id, | |
| branches: branches.map((b) => ({ ...b, items: b.items.map((i) => (i.kind === "assistant" ? { ...i, marks: undefined, streaming: false } : i.kind === "tools" ? { ...i, awaiting: false } : i)) })), | |
| }; | |
| } | |
| /** Threads that older versions kept inside the preferences blob (migrated to per-chat files). */ | |
| export function legacyThreads(): Thread[] { | |
| try { | |
| const t = JSON.parse(prefs.get(THREADS_KEY) ?? "null"); | |
| if (Array.isArray(t)) return t.map(normaliseThread); | |
| } catch { | |
| /* ignore */ | |
| } | |
| return []; | |
| } | |
| export const LEGACY_THREADS_KEY = THREADS_KEY; | |
| let uid = Date.now() % 100000; | |
| const nid = () => `c${(++uid).toString(36)}`; | |
| let abort: AbortController | null = null; | |
| let waiter: (() => void) | null = null; | |
| const parseArgs = (s: string): Record<string, unknown> => { | |
| try { | |
| const v = JSON.parse(s || "{}"); | |
| return v && typeof v === "object" ? v : {}; | |
| } catch { | |
| return {}; | |
| } | |
| }; | |
| function needsApproval(kind: ToolKind, approval: Approval) { | |
| if (kind === "read") return false; | |
| if (approval === "yolo") return false; | |
| if (approval === "auto") return kind === "run"; | |
| return true; | |
| } | |
| export const useCopilotStore = create<CopilotState>((set, get) => { | |
| const patchThreadRaw = (id: string, fn: (t: Thread) => Partial<Thread>) => set((s) => ({ threads: s.threads.map((t) => (t.id === id ? { ...t, ...fn(t), updatedAt: Date.now() } : t)) })); | |
| /** Patch one branch of a thread. */ | |
| const patchBranch = (tid: string, bid: string, fn: (b: Branch) => Partial<Branch>) => patchThreadRaw(tid, (t) => ({ branches: t.branches.map((b) => (b.id === bid ? { ...b, ...fn(b) } : b)) })); | |
| const patchActive = (tid: string, fn: (b: Branch) => Partial<Branch>) => { | |
| const t = get().threads.find((x) => x.id === tid); | |
| if (t) patchBranch(tid, activeBranch(t).id, fn); | |
| }; | |
| const branch = (tid: string, bid: string) => get().threads.find((t) => t.id === tid)?.branches.find((b) => b.id === bid); | |
| return { | |
| open: false, | |
| view: "chat", | |
| ...loadPrefs(), | |
| checks: {}, | |
| threads: [], | |
| loadingThread: null, | |
| activeId: null, | |
| busy: false, | |
| draft: "", | |
| setOpen: (v) => set({ open: v }), | |
| toggle: () => set((s) => ({ open: !s.open })), | |
| setLayout: (layout) => set({ layout }), | |
| setView: (view) => set({ view }), | |
| setDraft: (v) => set({ draft: v }), | |
| setModel: (id) => { | |
| set({ model: id }); | |
| void get().checkModel(id); | |
| }, | |
| checkModel: async (id) => { | |
| const c = get().checks[id]; | |
| if (c && !("pending" in c)) return; | |
| set((s) => ({ checks: { ...s.checks, [id]: { pending: true } } })); | |
| const r = await validateModel(id, useAuthStore.getState().token()).catch((e) => ({ ok: false, providers: [], error: e instanceof Error ? e.message : String(e) })); | |
| set((s) => ({ checks: { ...s.checks, [id]: r } })); | |
| }, | |
| addModel: async (raw) => { | |
| const id = raw.trim().replace(/^https?:\/\/huggingface\.co\//, ""); | |
| const r = await validateModel(id, useAuthStore.getState().token()); | |
| set((s) => ({ checks: { ...s.checks, [id]: r } })); | |
| if (r.ok) set((s) => ({ models: s.models.some((m) => m.id === id) ? s.models : [...s.models, { id, label: id.split("/")[1], custom: true }], model: id })); | |
| return r; | |
| }, | |
| removeModel: (id) => | |
| set((s) => { | |
| const models = s.models.filter((m) => m.id !== id); | |
| return { models, model: s.model === id ? (models[0]?.id ?? DEFAULT_MODEL) : s.model }; | |
| }), | |
| setApproval: (a) => set({ approval: a }), | |
| newThread: () => set({ activeId: null, view: "chat", draft: "" }), | |
| openThread: async (id) => { | |
| const t = get().threads.find((x) => x.id === id); | |
| if (!t) return; | |
| if (t.stub) { | |
| if (!backend || get().loadingThread) return; | |
| set({ loadingThread: id }); | |
| try { | |
| const full = await backend.load(id); | |
| if (!full) throw new Error("it is missing from your storage"); | |
| set((s) => ({ threads: s.threads.map((x) => (x.id === id ? normaliseThread(full) : x)) })); | |
| } catch (e) { | |
| useCanvasStore.getState().setNotice(`Couldn't open that chat: ${e instanceof Error ? e.message : String(e)}`); | |
| return; | |
| } finally { | |
| set({ loadingThread: null }); | |
| } | |
| } | |
| set({ activeId: id, view: "chat" }); | |
| }, | |
| deleteThread: (id) => { | |
| if (get().activeId === id) get().stop(); | |
| backend?.remove(id); | |
| set((s) => ({ threads: s.threads.filter((t) => t.id !== id), activeId: s.activeId === id ? null : s.activeId })); | |
| }, | |
| restore: (itemId) => { | |
| const t = get().threads.find((x) => x.id === get().activeId); | |
| const it = t && activeBranch(t).items.find((i) => i.id === itemId); | |
| if (!it || it.kind !== "user" || !it.cp) return; | |
| applyCheckpoint(it.cp); | |
| useCanvasStore.getState().setNotice("Canvas restored to checkpoint"); | |
| }, | |
| switchBranch: (branchId) => { | |
| const tid = get().activeId; | |
| if (!tid || get().busy) return; | |
| patchThreadRaw(tid, () => ({ active: branchId })); | |
| }, | |
| editMessage: async (itemId, text) => { | |
| const tid = get().activeId; | |
| const t = get().threads.find((x) => x.id === tid); | |
| if (!tid || !t || get().busy) return; | |
| const cur = activeBranch(t); | |
| const index = cur.items.findIndex((i) => i.id === itemId); | |
| const it = cur.items[index]; | |
| if (!it || it.kind !== "user") return; | |
| const userNo = cur.items.slice(0, index).filter((i) => i.kind === "user").length; | |
| let seen = 0; | |
| let cut = cur.transcript.length; | |
| for (let k = 0; k < cur.transcript.length; k++) { | |
| if (cur.transcript[k].role === "user" && seen++ === userNo) { | |
| cut = k; | |
| break; | |
| } | |
| } | |
| const fork: Branch = { id: nid(), createdAt: Date.now(), items: cur.items.slice(0, index), transcript: cur.transcript.slice(0, cut) }; | |
| patchThreadRaw(tid, (x) => ({ branches: [...x.branches, fork], active: fork.id })); | |
| if (it.cp) applyCheckpoint(it.cp); | |
| await get().send(text.trim() || it.text); | |
| }, | |
| retry: async (itemId) => { | |
| const t = get().threads.find((x) => x.id === get().activeId); | |
| if (!t) return; | |
| const items = activeBranch(t).items; | |
| let index = items.findIndex((i) => i.id === itemId); | |
| // Retrying a reply means retrying the user message that produced it. | |
| while (index >= 0 && items[index].kind !== "user") index--; | |
| if (index < 0) return; | |
| await get().editMessage(items[index].id, (items[index] as { text: string }).text); | |
| }, | |
| send: async (text) => { | |
| const token = useAuthStore.getState().token(); | |
| if (get().busy) return; | |
| let tid = get().activeId; | |
| if (!tid || !get().threads.some((t) => t.id === tid)) { | |
| tid = nid(); | |
| const b0: Branch = { id: nid(), createdAt: Date.now(), items: [], transcript: [] }; | |
| const thread: Thread = { id: tid, title: text.trim().slice(0, 80), createdAt: Date.now(), updatedAt: Date.now(), branches: [b0], active: b0.id, workflowId: useCanvasStore.getState().docId }; | |
| set((s) => ({ threads: [thread, ...s.threads].slice(0, MAX_THREADS), activeId: tid, view: "chat" })); | |
| } | |
| const bid = activeBranch(get().threads.find((t) => t.id === tid)!).id; | |
| const pushItem = (item: ChatItem) => patchBranch(tid!, bid, (b) => ({ items: [...b.items, item] })); | |
| const patchItem = (iid: string, fn: (i: ChatItem) => ChatItem) => patchBranch(tid!, bid, (b) => ({ items: b.items.map((i) => (i.id === iid ? fn(i) : i)) })); | |
| const pushMsg = (m: ChatMessage) => patchBranch(tid!, bid, (b) => ({ transcript: [...b.transcript, m] })); | |
| const userId = nid(); | |
| const cp = takeCheckpoint(); | |
| pushItem({ id: userId, kind: "user", text, cp }); | |
| if (!token) { | |
| pushItem({ id: nid(), kind: "error", text: "Sign in with Hugging Face to use the copilot." }); | |
| return; | |
| } | |
| abort = new AbortController(); | |
| const signal = abort.signal; | |
| set({ busy: true, draft: "" }); | |
| pushMsg({ role: "user", content: text }); | |
| const transcript = () => branch(tid!, bid)?.transcript ?? []; | |
| try { | |
| for (let round = 0; round < 16; round++) { | |
| if (signal.aborted) break; | |
| let msgId: string | null = null; | |
| let len = 0; | |
| const reply = await chatStream({ model: get().model, messages: [{ role: "system", content: SYSTEM_PROMPT }, ...transcript()], tools: TOOL_SPECS, token, signal }, (delta) => { | |
| if (!msgId) { | |
| msgId = nid(); | |
| pushItem({ id: msgId, kind: "assistant", text: "", marks: [], streaming: true }); | |
| } | |
| const at = len; | |
| len += delta.length; | |
| patchItem(msgId, (i) => (i.kind === "assistant" ? { ...i, text: i.text + delta, marks: [...(i.marks ?? []), at].slice(-64) } : i)); | |
| }); | |
| if (msgId) { | |
| const finalText = (reply.content ?? "").trim(); | |
| patchItem(msgId, (i) => (i.kind === "assistant" ? { ...i, text: finalText, streaming: false, marks: undefined } : i)); | |
| if (!finalText) patchBranch(tid, bid, (b) => ({ items: b.items.filter((i) => i.id !== msgId) })); | |
| } | |
| pushMsg(reply); | |
| const calls = reply.tool_calls ?? []; | |
| if (!calls.length) break; | |
| const approval = get().approval; | |
| const proposals: Proposal[] = calls.map((c: ToolCall) => { | |
| const tool = TOOLS[c.function.name]; | |
| const args = parseArgs(c.function.arguments); | |
| return { | |
| callId: c.id, | |
| name: c.function.name, | |
| kind: tool?.kind ?? "read", | |
| args, | |
| summary: tool ? tool.summarise(args) : `Unknown tool ${c.function.name}`, | |
| decision: !tool || !needsApproval(tool.kind, approval) ? "approved" : undefined, | |
| }; | |
| }); | |
| const groupId = nid(); | |
| const awaiting = proposals.some((p) => !p.decision); | |
| pushItem({ id: groupId, kind: "tools", items: proposals, awaiting }); | |
| if (awaiting) { | |
| await new Promise<void>((resolve) => { | |
| waiter = resolve; | |
| signal.addEventListener("abort", () => resolve(), { once: true }); | |
| }); | |
| waiter = null; | |
| if (signal.aborted) break; | |
| } | |
| const current = branch(tid, bid)?.items.find((i) => i.id === groupId); | |
| const decided = current?.kind === "tools" ? current.items : proposals; | |
| const patch = (callId: string, p: Partial<Proposal>) => | |
| patchItem(groupId, (i) => (i.kind === "tools" ? { ...i, awaiting: false, items: i.items.map((x) => (x.callId === callId ? { ...x, ...p } : x)) } : i)); | |
| for (const p of decided) { | |
| if (signal.aborted) break; | |
| const tool = TOOLS[p.name]; | |
| let result: unknown; | |
| if (p.decision !== "approved") { | |
| result = { rejected: true, note: "The user declined this action. Do not retry it; ask what they want instead if needed." }; | |
| patch(p.callId, { status: "done", decision: "rejected" }); | |
| } else if (!tool) { | |
| result = { error: `Unknown tool ${p.name}` }; | |
| patch(p.callId, { status: "error", detail: "Unknown tool" }); | |
| } else { | |
| patch(p.callId, { status: "running" }); | |
| try { | |
| result = await tool.run(p.args, { token, signal }); | |
| // Only a real error value counts: get_node returns `error: undefined` for a healthy node. | |
| const rawErr = result && typeof result === "object" && !Array.isArray(result) ? (result as { error?: unknown }).error : undefined; | |
| const err = rawErr == null || rawErr === "" ? undefined : typeof rawErr === "string" ? rawErr : JSON.stringify(rawErr); | |
| patch(p.callId, { ...(err ? { status: "error", detail: err } : { status: "done", detail: briefResult(p.name, result) }), result: compact(result) }); | |
| } catch (e) { | |
| const msg = (e instanceof Error ? e.message : typeof e === "string" ? e : "") || `${p.name} failed without an error message`; | |
| result = { error: msg }; | |
| patch(p.callId, { status: "error", detail: msg, result: msg }); | |
| } | |
| } | |
| pushMsg({ role: "tool", tool_call_id: p.callId, name: p.name, content: (JSON.stringify(result ?? null) ?? "null").slice(0, 12000) }); | |
| } | |
| } | |
| } catch (e) { | |
| if (!signal.aborted) { | |
| const msg = e instanceof LLMError && e.status === 401 ? "Your Hugging Face session was rejected. Sign in again." : e instanceof Error ? e.message : String(e); | |
| pushItem({ id: nid(), kind: "error", text: msg }); | |
| } | |
| } finally { | |
| // Leave the transcript well-formed: no assistant tool_calls without their tool results. | |
| const changed = !sameGraph(cp, takeCheckpoint()); | |
| patchBranch(tid, bid, (b) => { | |
| const tr = [...b.transcript]; | |
| const last = tr[tr.length - 1]; | |
| if (last?.role === "assistant" && last.tool_calls?.length) { | |
| const answered = new Set(tr.filter((m) => m.role === "tool").map((m) => m.tool_call_id)); | |
| if (!last.tool_calls.every((c) => answered.has(c.id))) tr.pop(); | |
| } | |
| return { | |
| transcript: tr, | |
| items: b.items.map((i) => | |
| i.id === userId && i.kind === "user" ? { ...i, changed } : i.kind === "assistant" && i.streaming ? { ...i, streaming: false, marks: undefined } : i.kind === "tools" && i.awaiting ? { ...i, awaiting: false } : i, | |
| ), | |
| }; | |
| }); | |
| abort = null; | |
| set({ busy: false }); | |
| } | |
| }, | |
| decide: (callId, decision) => { | |
| const tid = get().activeId; | |
| if (!tid) return; | |
| patchActive(tid, (b) => ({ items: b.items.map((i) => (i.kind === "tools" && i.awaiting ? { ...i, items: i.items.map((p) => (p.callId === callId ? { ...p, decision } : p)) } : i)) })); | |
| maybeRelease(get); | |
| }, | |
| decideAll: (decision) => { | |
| const tid = get().activeId; | |
| if (!tid) return; | |
| patchActive(tid, (b) => ({ items: b.items.map((i) => (i.kind === "tools" && i.awaiting ? { ...i, items: i.items.map((p) => (p.decision ? p : { ...p, decision })) } : i)) })); | |
| maybeRelease(get); | |
| }, | |
| stop: () => { | |
| abort?.abort(); | |
| const tid = get().activeId; | |
| if (tid) patchActive(tid, (b) => ({ items: b.items.map((i) => (i.kind === "tools" && i.awaiting ? { ...i, awaiting: false, items: i.items.map((p) => (p.decision ? p : { ...p, decision: "rejected" as const, status: "done" as const })) } : i)) })); | |
| }, | |
| }; | |
| }); | |
| function maybeRelease(get: () => CopilotState) { | |
| const t = get().threads.find((x) => x.id === get().activeId); | |
| const open = t && activeBranch(t).items.find((i) => i.kind === "tools" && i.awaiting); | |
| if (open && open.kind === "tools" && open.items.every((p) => p.decision)) waiter?.(); | |
| } | |
| function takeCheckpoint(): Checkpoint { | |
| const { nodes, edges } = useCanvasStore.getState(); | |
| return { | |
| nodes: nodes.map((n) => { | |
| const { outputs: _o, statusText: _s, error: _e, ...data } = n.data; | |
| return { ...n, selected: false, dragging: false, measured: undefined, data: { ...data, status: "idle", progress: 0 } } as CanvasNode; | |
| }), | |
| edges: edges.map((e) => ({ ...e, selected: false, data: e.data ? { ...e.data, flowing: false } : e.data })), | |
| }; | |
| } | |
| function sameGraph(a: Checkpoint, b: Checkpoint) { | |
| return JSON.stringify(a) === JSON.stringify(b); | |
| } | |
| function applyCheckpoint(cp: Checkpoint) { | |
| const s = useCanvasStore.getState(); | |
| if (s.run.running) s.cancelRun(); | |
| useCanvasStore.setState({ nodes: cp.nodes.map((n) => ({ ...n, data: { ...n.data } })), edges: cp.edges.map((e) => ({ ...e })), dirty: true }); | |
| } | |
| function compact(r: unknown): string { | |
| try { | |
| const s = JSON.stringify(r, null, 1); | |
| return s.length > 1200 ? `${s.slice(0, 1200)}…` : s; | |
| } catch { | |
| return String(r); | |
| } | |
| } | |
| function briefResult(name: string, r: unknown): string | undefined { | |
| if (!r || typeof r !== "object") return undefined; | |
| if (Array.isArray(r)) return `${r.length} result${r.length === 1 ? "" : "s"}`; | |
| const o = r as Record<string, unknown>; | |
| if (name === "add_node" && typeof o.id === "string") return `→ ${o.id}`; | |
| if (name === "add_space" && Array.isArray(o.endpoints)) return `${o.endpoints.length} endpoint${o.endpoints.length === 1 ? "" : "s"}`; | |
| if (name === "get_workflow" && Array.isArray(o.nodes)) return `${o.nodes.length} nodes`; | |
| if ((name === "move_nodes" || name === "auto_layout") && typeof o.moved === "number") return `${o.moved} moved`; | |
| return undefined; | |
| } | |
| /** Re-reads settings (after state.json was loaded). Chats are loaded separately from the bucket. */ | |
| export function rehydrateCopilot() { | |
| useCopilotStore.setState(loadPrefs()); | |
| } | |
| /** Replaces the chat list (after sign-in / sign-out). */ | |
| export function setThreads(threads: Thread[]) { | |
| abort?.abort(); | |
| useCopilotStore.setState({ threads, activeId: null, busy: false, loadingThread: null, view: "chat" }); | |
| } | |
| useCopilotStore.subscribe((s, p) => { | |
| if (s.model === p.model && s.models === p.models && s.approval === p.approval && s.layout === p.layout) return; | |
| prefs.set(KEY, JSON.stringify({ model: s.model, models: s.models, approval: s.approval, layout: s.layout })); | |
| }); | |
| export const useActiveThread = () => useCopilotStore((s) => s.threads.find((t) => t.id === s.activeId) ?? null); | |
| export const useActiveItems = () => useCopilotStore((s) => { | |
| const t = s.threads.find((x) => x.id === s.activeId); | |
| return t ? activeBranch(t).items : EMPTY; | |
| }); | |
| const EMPTY: ChatItem[] = []; | |
| /** Opens the copilot and asks it to explain why a node failed. */ | |
| export const askCopilot = (title: string) => { | |
| const s = useCopilotStore.getState(); | |
| s.setOpen(true); | |
| void s.send(`Why did "${title}" fail? Read its logs and run status, explain the cause in plain words, and fix it if you can.`); | |
| }; | |