feat(ui/chat): run the Vue chat on the archie binary (#2023)
Sessions, turns, streamed replies, thinking and tool cards, held-action approvals and resume now use modules/chat; /api/stream forwards the chat topic. Sub-features the binary can't back yet stay hidden. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
15 files changed
+481
-267
No files matched your search
@@ -7,6 +7,7 @@ import (
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/buildinfo"
|
||||
"github.com/samcharles93/archie-core/internal/platform/httpapi"
|
||||
"github.com/samcharles93/archie-core/internal/platform/hub"
|
||||
"github.com/samcharles93/archie-core/modules/approvals"
|
||||
"github.com/samcharles93/archie-core/modules/chat"
|
||||
"github.com/samcharles93/archie-core/modules/connectors"
|
||||
@@ -34,6 +35,7 @@ type apiModules struct {
|
||||
engine *runs.Engine
|
||||
chat *chat.Module
|
||||
drafts *drafts.Module
|
||||
live *hub.Hub
|
||||
}
|
||||
|
||||
func (m apiModules) register(api huma.API) {
|
||||
@@ -50,7 +52,7 @@ func (m apiModules) register(api huma.API) {
|
||||
m.engine.Register(api, orgID, m.hear, m.judge, m.allow)
|
||||
m.drafts.Register(api)
|
||||
m.chat.Register(api)
|
||||
dashboard.Register(api)
|
||||
dashboard.Register(api, m.live)
|
||||
}
|
||||
|
||||
// Document returns the API's OpenAPI document as YAML. It makes the same
|
||||
@@ -63,7 +65,7 @@ func Document() ([]byte, error) {
|
||||
settings: settings, conns: &connectors.Module{}, system: &system.Module{},
|
||||
tell: &deliveries.Module{}, allow: &approvals.Module{}, classes: &judgement.Classes{},
|
||||
policies: &judgement.Policies{}, hear: &events.Module{}, judge: &judgement.Module{},
|
||||
engine: &runs.Engine{}, chat: &chat.Module{}, drafts: &drafts.Module{},
|
||||
engine: &runs.Engine{}, chat: &chat.Module{}, drafts: &drafts.Module{}, live: hub.New(),
|
||||
}.register(api)
|
||||
return api.OpenAPI().YAML()
|
||||
}
|
||||
@@ -115,6 +115,7 @@ func Run(ctx context.Context, configPath string) error {
|
||||
apiModules{
|
||||
settings: settings, conns: conns, system: sys, tell: tell, allow: allow, classes: classes, policies: policies,
|
||||
hear: hear, judge: judge, engine: engine, chat: talk, drafts: drafts.NewModule(db, log.With("module", "drafts"), orgID, hear, engine, policies),
|
||||
live: live,
|
||||
}.register(api)
|
||||
dashboard.Routes(mux, ui.DistDirFS)
|
||||
|
||||
|
||||
+55
-29
@@ -9,18 +9,27 @@ import (
|
||||
"github.com/danielgtaylor/huma/v2"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/platform/httpapi"
|
||||
"github.com/samcharles93/archie-core/internal/platform/hub"
|
||||
"github.com/samcharles93/archie-core/modules/governance"
|
||||
)
|
||||
|
||||
// keepalive is how often an idle stream writes a comment, so proxies keep
|
||||
// the connection open and the browser notices one that died.
|
||||
const keepalive = 25 * time.Second
|
||||
|
||||
// chatTopic is the hub topic the chat module publishes when an action a
|
||||
// conversation held settles after its turn ended.
|
||||
const chatTopic = "chat"
|
||||
|
||||
// chatOutcome is the frame the dashboard re-reads the open conversation on.
|
||||
const chatOutcome = `data: {"topic":"tasks","data":{"kind":"chat_outcome"}}` + "\n\n"
|
||||
|
||||
// Register adds the dashboard's live stream: the one EventSource the SPA
|
||||
// keeps open, framing each update as `data: {"topic":…,"data":…}`. Nothing
|
||||
// this binary publishes has a dashboard reader yet, so the stream carries
|
||||
// only keepalives; it still tells the connection indicator the server is
|
||||
// up, and a reconnect still makes every mounted page re-read.
|
||||
func Register(api huma.API) {
|
||||
// keeps open, framing each update as `data: {"topic":…,"data":…}`. A settled
|
||||
// chat action is the only update with a dashboard reader; a turn's own reply
|
||||
// streams from the chat API. Keepalives tell the connection indicator the
|
||||
// server is up, and a reconnect makes every mounted page re-read.
|
||||
func Register(api huma.API, h *hub.Hub) {
|
||||
huma.Register(api, httpapi.SignedIn(huma.Operation{
|
||||
OperationID: "stream-dashboard", Method: http.MethodGet, Path: "/api/stream",
|
||||
Summary: "Stream live dashboard updates", Tags: []string{"Dashboard"},
|
||||
@@ -28,33 +37,50 @@ func Register(api huma.API) {
|
||||
Description: "Server-sent events: one data frame of {\"topic\", \"data\"} per update, and a keepalive comment while idle",
|
||||
Content: map[string]*huma.MediaType{"text/event-stream": {Schema: &huma.Schema{Type: huma.TypeString}}},
|
||||
}},
|
||||
}), stream)
|
||||
}), func(ctx context.Context, _ *struct{}) (*huma.StreamResponse, error) {
|
||||
// Chat is an administrator's; nobody else hears that it changed.
|
||||
var chat <-chan hub.Note
|
||||
stop := func() {}
|
||||
if p, _ := governance.PrincipalFromContext(ctx); p.InstanceAdmin() {
|
||||
chat, stop = h.Subscribe(chatTopic)
|
||||
}
|
||||
return &huma.StreamResponse{Body: func(hc huma.Context) {
|
||||
defer stop()
|
||||
serve(hc, chat)
|
||||
}}, nil
|
||||
})
|
||||
}
|
||||
|
||||
func stream(_ context.Context, _ *struct{}) (*huma.StreamResponse, error) {
|
||||
return &huma.StreamResponse{Body: func(hc huma.Context) {
|
||||
w := hc.BodyWriter()
|
||||
flusher, ok := w.(http.Flusher)
|
||||
if !ok {
|
||||
hc.SetStatus(http.StatusInternalServerError)
|
||||
func serve(hc huma.Context, chat <-chan hub.Note) {
|
||||
w := hc.BodyWriter()
|
||||
flusher, ok := w.(http.Flusher)
|
||||
if !ok {
|
||||
hc.SetStatus(http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
hc.SetHeader("Content-Type", "text/event-stream")
|
||||
hc.SetHeader("Cache-Control", "no-store")
|
||||
hc.SetStatus(http.StatusOK)
|
||||
flusher.Flush()
|
||||
tick := time.NewTicker(keepalive)
|
||||
defer tick.Stop()
|
||||
for {
|
||||
frame := ": keepalive\n\n"
|
||||
select {
|
||||
case <-hc.Context().Done():
|
||||
return
|
||||
case <-tick.C:
|
||||
case _, ok := <-chat:
|
||||
if !ok {
|
||||
// The hub dropped a reader that fell behind; it reconnects
|
||||
// and re-reads.
|
||||
return
|
||||
}
|
||||
frame = chatOutcome
|
||||
}
|
||||
if _, err := fmt.Fprint(w, frame); err != nil {
|
||||
return
|
||||
}
|
||||
hc.SetHeader("Content-Type", "text/event-stream")
|
||||
hc.SetHeader("Cache-Control", "no-store")
|
||||
hc.SetStatus(http.StatusOK)
|
||||
flusher.Flush()
|
||||
tick := time.NewTicker(keepalive)
|
||||
defer tick.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-hc.Context().Done():
|
||||
return
|
||||
case <-tick.C:
|
||||
if _, err := fmt.Fprint(w, ": keepalive\n\n"); err != nil {
|
||||
return
|
||||
}
|
||||
flusher.Flush()
|
||||
}
|
||||
}
|
||||
}}, nil
|
||||
}
|
||||
}
|
||||
@@ -610,12 +610,12 @@ func (m *Module) capabilities(ctx context.Context, _ *struct{}) (*httpapi.Reply[
|
||||
p, _ := PrincipalFromContext(ctx)
|
||||
sections := map[string]bool{}
|
||||
for _, name := range []string{
|
||||
"settings", "events", "workflows", "runs", "credentials", "extensions", "secret_engines", "models", "controls",
|
||||
"settings", "events", "workflows", "runs", "credentials", "extensions", "secret_engines", "models", "controls", "chat",
|
||||
} {
|
||||
sections[name] = p.InstanceAdmin()
|
||||
}
|
||||
for _, name := range []string{
|
||||
"home", "tasks", "work_requests", "chat", "logs", "skills", "curators", "channels",
|
||||
"home", "tasks", "work_requests", "logs", "skills", "curators", "channels",
|
||||
"captures", "mappings", "bindings", "workflow_editor", "extension_catalogue", "model_aliases",
|
||||
"system_status", "task_execution", "organisations", "tools", "plugins", "container_runtime", "agent_profiles",
|
||||
"org", "org_members", "org_agents", "org_workspaces", "org_policies", "org_denials", "org_audit", "org_usage", "org_config",
|
||||
|
||||
+2
-2
@@ -121,7 +121,7 @@ watch(() => accounts.status?.user, (user) => {
|
||||
<ConnectionPill />
|
||||
<CommandPalette :hidden="hidden" @new-task="newTaskOpen = true" />
|
||||
<NewTaskDialog v-if="session.sections?.work_requests !== false" v-model:open="newTaskOpen" />
|
||||
<ChatTopbarButton />
|
||||
<ChatTopbarButton v-if="session.sections?.chat !== false" />
|
||||
<AlertsBell />
|
||||
<span><AccountMenu /></span>
|
||||
</div>
|
||||
@@ -146,7 +146,7 @@ watch(() => accounts.status?.user, (user) => {
|
||||
</RouterView>
|
||||
</div>
|
||||
</SidebarInset>
|
||||
<ChatDock />
|
||||
<ChatDock v-if="session.sections?.chat !== false" />
|
||||
</SidebarProvider>
|
||||
<Toaster position="bottom-right" rich-colors close-button />
|
||||
</TooltipProvider>
|
||||
|
||||
@@ -7,9 +7,9 @@ import { Input } from "@/components/ui/input";
|
||||
import { Item, ItemActions, ItemContent, ItemDescription, ItemMedia, ItemTitle } from "@/components/ui/item";
|
||||
import { ReadError } from "@/components/ui/read-error";
|
||||
import ChatQuestionnaire from "./ChatQuestionnaire.vue";
|
||||
import { answerAsk, askError, type ChatAsk } from "./state";
|
||||
import { answerAsk, askError, askErrorID, type ChatAsk } from "./state";
|
||||
|
||||
defineProps<{ ask: ChatAsk }>();
|
||||
const props = defineProps<{ ask: ChatAsk }>();
|
||||
|
||||
const reply = ref("");
|
||||
// The last answer tried, so a failed send can be retried from the error.
|
||||
@@ -17,7 +17,7 @@ const lastAnswer = ref("");
|
||||
|
||||
async function answer(value: string): Promise<boolean> {
|
||||
lastAnswer.value = value;
|
||||
return answerAsk(value);
|
||||
return answerAsk(value, props.ask);
|
||||
}
|
||||
|
||||
async function sendReply(): Promise<void> {
|
||||
@@ -33,7 +33,7 @@ function retry(): void {
|
||||
</script>
|
||||
|
||||
<template>
|
||||
<ReadError v-if="askError" :message="askError" retry-label="Retry answer" class="mt-2" @retry="retry" />
|
||||
<ReadError v-if="askError && askErrorID === ask.id" :message="askError" retry-label="Retry answer" class="mt-2" @retry="retry" />
|
||||
|
||||
<ChatQuestionnaire v-if="ask.kind === 'questionnaire'" :ask="ask" :send="answer" />
|
||||
|
||||
@@ -45,7 +45,7 @@ function retry(): void {
|
||||
</ItemContent>
|
||||
<ItemActions class="flex-wrap">
|
||||
<Button size="sm" variant="outline" @click="answer('deny')">Deny</Button>
|
||||
<Button size="sm" variant="outline" @click="answer('always')">Always this session</Button>
|
||||
<Button v-if="ask.via !== 'approvals'" size="sm" variant="outline" @click="answer('always')">Always this session</Button>
|
||||
<Button size="sm" @click="answer('approve')">Approve</Button>
|
||||
</ItemActions>
|
||||
</Item>
|
||||
|
||||
@@ -7,6 +7,7 @@ import {
|
||||
Pencil,
|
||||
RotateCw,
|
||||
Shrink,
|
||||
Trash2,
|
||||
Undo2,
|
||||
} from "@lucide/vue";
|
||||
import { ref } from "vue";
|
||||
@@ -33,7 +34,10 @@ import { describeError } from "@/lib/api";
|
||||
import ChatSettings from "./ChatSettings.vue";
|
||||
import {
|
||||
currentSession,
|
||||
deleteSession,
|
||||
hasCommand,
|
||||
messages,
|
||||
renameSession,
|
||||
runSessionCommand,
|
||||
useEscapeLayer,
|
||||
} from "./state";
|
||||
@@ -99,7 +103,21 @@ function prompt(command: string, message: string): void {
|
||||
function submitPrompt(): void {
|
||||
const value = promptValue.value.trim();
|
||||
promptOpen.value = false;
|
||||
if (value) void runSessionCommand(`${promptCommand.value} ${value}`);
|
||||
if (!value) return;
|
||||
// Renaming is the chat API's own; other prompts are server commands.
|
||||
if (promptCommand.value === "/title") void renameSession(value);
|
||||
else void runSessionCommand(`${promptCommand.value} ${value}`);
|
||||
}
|
||||
|
||||
const confirmDelete = ref(false);
|
||||
useEscapeLayer(confirmDelete);
|
||||
function askDelete(): void {
|
||||
open.value = false;
|
||||
confirmDelete.value = true;
|
||||
}
|
||||
function remove(): void {
|
||||
confirmDelete.value = false;
|
||||
void deleteSession();
|
||||
}
|
||||
</script>
|
||||
|
||||
@@ -129,6 +147,7 @@ function submitPrompt(): void {
|
||||
<PopoverContent align="end" class="grid w-64 gap-0.5 p-1">
|
||||
<template v-if="currentSession">
|
||||
<Button
|
||||
v-if="hasCommand('/retry')"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
class="justify-start"
|
||||
@@ -136,6 +155,7 @@ function submitPrompt(): void {
|
||||
><RotateCw data-icon="inline-start" />Retry</Button
|
||||
>
|
||||
<Button
|
||||
v-if="hasCommand('/undo')"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
class="justify-start"
|
||||
@@ -150,6 +170,7 @@ function submitPrompt(): void {
|
||||
><Pencil data-icon="inline-start" />Rename</Button
|
||||
>
|
||||
<Button
|
||||
v-if="hasCommand('/branch')"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
class="justify-start"
|
||||
@@ -157,6 +178,7 @@ function submitPrompt(): void {
|
||||
><GitBranch data-icon="inline-start" />Branch</Button
|
||||
>
|
||||
<Button
|
||||
v-if="hasCommand('/compress')"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
class="justify-start"
|
||||
@@ -170,6 +192,13 @@ function submitPrompt(): void {
|
||||
@click="copyMarkdown"
|
||||
><Copy data-icon="inline-start" />Copy as Markdown</Button
|
||||
>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
class="justify-start text-destructive"
|
||||
@click="askDelete"
|
||||
><Trash2 data-icon="inline-start" />Delete</Button
|
||||
>
|
||||
<Separator class="my-1" />
|
||||
</template>
|
||||
<ChatSettings />
|
||||
@@ -185,4 +214,13 @@ function submitPrompt(): void {
|
||||
</DialogFooter>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
<Dialog :open="confirmDelete" @update:open="(v: boolean) => (confirmDelete = v)">
|
||||
<DialogContent>
|
||||
<DialogHeader><DialogTitle>Delete this conversation?</DialogTitle></DialogHeader>
|
||||
<DialogFooter>
|
||||
<Button variant="ghost" @click="confirmDelete = false">Cancel</Button>
|
||||
<Button variant="destructive" @click="remove">Delete</Button>
|
||||
</DialogFooter>
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
</template>
|
||||
@@ -34,12 +34,16 @@ const groups = computed(() => {
|
||||
? entries
|
||||
: [["", selectorData.value.models || []] as [string, string[]]];
|
||||
});
|
||||
// The model is chosen here only when the server offers a choice.
|
||||
const choosable = computed(() => groups.value.some(([, models]) => models.length));
|
||||
</script>
|
||||
|
||||
<template>
|
||||
<div class="grid gap-1 p-1">
|
||||
<span v-if="statusText !== 'Ready'" class="text-caption text-fg-subtle">{{ statusText }}</span>
|
||||
<span v-if="selectorData.model_error" class="text-caption text-destructive">{{ selectorData.model_error }}</span>
|
||||
<Select
|
||||
v-if="choosable"
|
||||
:model-value="modelValue"
|
||||
@update:model-value="setModel($event === DEFAULT ? '' : String($event ?? ''))"
|
||||
>
|
||||
|
||||
@@ -51,6 +51,7 @@ function parts(message: ChatMessage, index: number) {
|
||||
update: message.update,
|
||||
choose: message.choose,
|
||||
error: !!message.error,
|
||||
approvals: message.approvals || [],
|
||||
};
|
||||
}
|
||||
|
||||
@@ -84,6 +85,7 @@ const rows = computed(() => {
|
||||
update: undefined,
|
||||
choose: undefined,
|
||||
error: turn.isError,
|
||||
approvals: turn.approvals || [],
|
||||
live: true,
|
||||
reasoning: turn.reasoning ?? "",
|
||||
// Nothing said and nothing reasoned yet: the turn may still be thinking,
|
||||
@@ -133,6 +135,7 @@ const rows = computed(() => {
|
||||
:thinking-pending="row.thinkingPending"
|
||||
:error="row.error"
|
||||
>
|
||||
<ChatAskCard v-for="ask in row.approvals" :key="ask.id" :ask="ask" />
|
||||
<template v-if="row.live && streamingTurn">
|
||||
<Button
|
||||
v-if="streamingTurn.isError && streamingTurn.turn"
|
||||
|
||||
+247
-164
@@ -1,10 +1,9 @@
|
||||
import { computed, onMounted, onUnmounted, ref, watch, type Ref } from "vue";
|
||||
|
||||
import { errors } from "@/copy/errors";
|
||||
import { api, describeError } from "@/lib/api";
|
||||
import { api, describeError, type ChatTurnRecord } from "@/lib/api";
|
||||
import { router } from "@/router";
|
||||
import { randomUUID } from "@/lib/uuid";
|
||||
import { channelID } from "./channel";
|
||||
import { useSessionStore } from "@/stores/session";
|
||||
import { commandCompletions, detectTrigger, taskCompletions, type Completion, type Trigger } from "./commands";
|
||||
import {
|
||||
resolveTurn,
|
||||
@@ -111,6 +110,8 @@ export interface ChatMessage {
|
||||
choose?: "model";
|
||||
/** A reply standing in for a turn that failed; the bubble shows it as an error. */
|
||||
error?: boolean;
|
||||
/** Actions the turn held for approval that nobody has answered yet. */
|
||||
approvals?: ChatAsk[];
|
||||
}
|
||||
|
||||
/** The update snapshot /update shows, and whether this host can install it. */
|
||||
@@ -131,6 +132,8 @@ export interface StreamingTurn {
|
||||
reasoning?: string;
|
||||
/** A question the turn waits on until the operator answers it. */
|
||||
ask?: ChatAsk;
|
||||
/** Actions the turn held for approval so far. */
|
||||
approvals?: ChatAsk[];
|
||||
}
|
||||
|
||||
/** An approval, clarify or picker question from a running turn. */
|
||||
@@ -141,6 +144,8 @@ export interface ChatAsk {
|
||||
detail?: string;
|
||||
choices?: { id: string; label: string }[];
|
||||
questions?: ChatQuestion[];
|
||||
/** Answered through the approvals API: approve or deny, nothing session-wide. */
|
||||
via?: "approvals";
|
||||
}
|
||||
|
||||
/** One question of a questionnaire ask. */
|
||||
@@ -163,6 +168,8 @@ export interface ChatSelectorData {
|
||||
active_model?: string;
|
||||
commands?: Array<ChatCommandSpec | string>;
|
||||
voice_available?: boolean;
|
||||
/** Why no model can answer, when none can. */
|
||||
model_error?: string;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -171,10 +178,13 @@ export interface ChatSelectorData {
|
||||
* string "undefined" into the transcript on a turn whose reply is empty.
|
||||
*/
|
||||
interface ChatStreamFrame extends ChatToolCall {
|
||||
seq?: number;
|
||||
type?: string;
|
||||
text: string;
|
||||
session_id?: string;
|
||||
ask?: ChatAsk;
|
||||
// An approval frame: an action the turn held for people to answer.
|
||||
request_id?: string;
|
||||
action?: string;
|
||||
}
|
||||
|
||||
/** A turn that never settles must not hold the composer closed forever. */
|
||||
@@ -183,6 +193,8 @@ let rearmTimeout: (() => void) | null = null;
|
||||
|
||||
// A failed answer keeps the question card up; the failure shows on the card.
|
||||
export const askError = ref("");
|
||||
/** The question askError belongs to. */
|
||||
export const askErrorID = ref("");
|
||||
|
||||
/**
|
||||
* answerAsk sends the operator's answer to the question the turn waits on.
|
||||
@@ -190,15 +202,25 @@ export const askError = ref("");
|
||||
* then, and only then. On failure the question stays, askError carries the
|
||||
* message for the card, and the caller's answer stays filled in for a retry.
|
||||
*/
|
||||
export async function answerAsk(answer: string): Promise<boolean> {
|
||||
const ask = streamingTurn.value?.ask;
|
||||
export async function answerAsk(answer: string, ask = streamingTurn.value?.ask): Promise<boolean> {
|
||||
if (!ask) return false;
|
||||
try {
|
||||
await api.chatAnswer(ask.id, answer);
|
||||
if (ask.via !== "approvals") throw new Error(errors.chat.ask.unsupported);
|
||||
await api.answerApproval(ask.id, answer === "approve");
|
||||
} catch (err) {
|
||||
askError.value = describeError(err, errors.chat.ask.answer);
|
||||
askErrorID.value = ask.id;
|
||||
return false;
|
||||
}
|
||||
if (ask.via === "approvals") {
|
||||
// The answered card leaves; what the action did comes back with the turn.
|
||||
const answered = (asks?: ChatAsk[]) => asks?.filter((a) => a.id !== ask.id);
|
||||
messages.value = messages.value.map((m) => (m.approvals ? { ...m, approvals: answered(m.approvals) } : m));
|
||||
if (streamingTurn.value) streamingTurn.value = { ...streamingTurn.value, approvals: answered(streamingTurn.value.approvals) };
|
||||
askError.value = "";
|
||||
void reloadTranscript();
|
||||
return true;
|
||||
}
|
||||
streamingTurn.value = streamingTurn.value ? { ...streamingTurn.value, ask: undefined } : null;
|
||||
askError.value = "";
|
||||
rearmTimeout?.();
|
||||
@@ -301,6 +323,8 @@ export function escapeOwnedByLayer(): boolean {
|
||||
}
|
||||
|
||||
let activeController: AbortController | null = null;
|
||||
// The turn the active controller is reading, once the server has it.
|
||||
let activeTurnID = "";
|
||||
|
||||
// Bumped on every conversation switch: a turn started in an earlier
|
||||
// conversation is detached and must not write into the one now open.
|
||||
@@ -313,9 +337,7 @@ function abortActiveTurn(): void {
|
||||
}
|
||||
|
||||
async function refreshSessions(): Promise<void> {
|
||||
const data = await api.chatSessions<
|
||||
ChatSelectorData & { sessions?: ChatSession[] }
|
||||
>();
|
||||
const data: ChatSelectorData & { sessions?: ChatSession[] } = await api.chatSessions();
|
||||
const sessionList = data.sessions || [];
|
||||
sessions.value = sessionList;
|
||||
selectorData.value = data;
|
||||
@@ -328,36 +350,57 @@ async function refreshSessions(): Promise<void> {
|
||||
: item,
|
||||
);
|
||||
|
||||
if (!currentSession.value && sessionList[0]) {
|
||||
if (!currentSession.value && sessionList[0] && !startedFresh) {
|
||||
// The assignment above is readable here immediately, so the first
|
||||
// conversation is selected from the shared state with no data passed in.
|
||||
await selectSession(sessionList[0].session_id);
|
||||
}
|
||||
}
|
||||
|
||||
/** Whether the server accepts a slash command; the controls for one it doesn't are hidden. */
|
||||
export function hasCommand(command: string): boolean {
|
||||
return commandSpecs.value.some((spec) => spec.command === command);
|
||||
}
|
||||
|
||||
// Set by "New chat": the conversation is created with its first message, so
|
||||
// until then nothing reopens an older one.
|
||||
let startedFresh = false;
|
||||
|
||||
/** The open conversation, created on the server when there is none yet. */
|
||||
async function ensureSession(): Promise<string> {
|
||||
if (currentSession.value) return currentSession.value;
|
||||
const created = await api.chatCreateSession();
|
||||
// The unsent text and tags typed into the new chat stay with it.
|
||||
drafts.value = { ...drafts.value, [created.session_id]: drafts.value[""] ?? "" };
|
||||
tagDrafts.value = { ...tagDrafts.value, [created.session_id]: tagDrafts.value[""] ?? [] };
|
||||
currentSession.value = created.session_id;
|
||||
startedFresh = false;
|
||||
sessions.value = [created, ...sessions.value];
|
||||
return created.session_id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a server command over the chat stream, the same path as any message,
|
||||
* and reads the stream to its end. Resolves with the reply and the session the
|
||||
* server reports.
|
||||
* Reads a turn's recorded events from the server-sent stream until it ends,
|
||||
* handing each frame to onFrame. Resolves with the last frame: done, error or
|
||||
* cancelled. A stream that closes before one of those is a failure.
|
||||
*/
|
||||
async function sendCommand(
|
||||
text: string,
|
||||
): Promise<{ reply: string; session_id: string }> {
|
||||
const response = await api.chatStream({
|
||||
channel_id: channelID(),
|
||||
source_id: randomUUID(),
|
||||
text,
|
||||
page: sentPage(),
|
||||
});
|
||||
if (!response.body) throw new Error(errors.chat.stream.noBody);
|
||||
const reader = response.body.getReader();
|
||||
async function readTurn(
|
||||
turnID: string,
|
||||
signal: AbortSignal | undefined,
|
||||
onFrame: (frame: ChatStreamFrame) => void,
|
||||
onBytes: () => void = () => {},
|
||||
): Promise<ChatStreamFrame> {
|
||||
const response = await api.chatTurnEvents(turnID, 0, { signal });
|
||||
const body = response.body;
|
||||
if (!body) throw new Error(errors.chat.stream.noBody);
|
||||
const reader = body.getReader();
|
||||
const decoder = new TextDecoder();
|
||||
let buffer = "";
|
||||
let reply = "";
|
||||
let session = "";
|
||||
let finished = false;
|
||||
// Drained to completion: a turn that ends without a terminal frame is a
|
||||
// failed turn rather than a short one.
|
||||
for (;;) {
|
||||
const { value, done } = await reader.read();
|
||||
if (!done) onBytes();
|
||||
buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
|
||||
const frames = buffer.split("\n\n");
|
||||
buffer = frames.pop() || "";
|
||||
@@ -365,18 +408,32 @@ async function sendCommand(
|
||||
const line = frame.split("\n").find((part) => part.startsWith("data: "));
|
||||
if (!line) continue;
|
||||
const event = JSON.parse(line.slice(6)) as ChatStreamFrame;
|
||||
if (event.session_id) session = event.session_id;
|
||||
if (event.type === "error") throw new Error(event.text);
|
||||
if (event.type === "delta") reply += event.text;
|
||||
if (event.type === "done") {
|
||||
finished = true;
|
||||
if (!reply) reply = event.text || "";
|
||||
onFrame(event);
|
||||
if (event.type === "done" || event.type === "error" || event.type === "cancelled") {
|
||||
await reader.cancel().catch(() => {});
|
||||
return event;
|
||||
}
|
||||
}
|
||||
if (done) break;
|
||||
if (done) throw new Error(errors.chat.stream.endedEarly);
|
||||
}
|
||||
if (!finished) throw new Error(errors.chat.stream.endedEarly);
|
||||
return { reply, session_id: session };
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a server command as a message of the open conversation and reads its
|
||||
* reply. Only commands the server lists are offered, so this runs only against
|
||||
* a server that answers them.
|
||||
*/
|
||||
async function sendCommand(
|
||||
text: string,
|
||||
): Promise<{ reply: string; session_id: string }> {
|
||||
const session = await ensureSession();
|
||||
const turn = await api.chatSend(session, { text, page: sentPage() });
|
||||
let reply = "";
|
||||
const last = await readTurn(turn.id, undefined, (event) => {
|
||||
if (event.type === "delta") reply += event.text;
|
||||
});
|
||||
if (last.type === "error") throw new Error(last.text);
|
||||
return { reply: reply || last.text || "", session_id: session };
|
||||
}
|
||||
|
||||
export async function selectSession(id: string): Promise<void> {
|
||||
@@ -386,6 +443,7 @@ export async function selectSession(id: string): Promise<void> {
|
||||
sessionEpoch++;
|
||||
abortActiveTurn();
|
||||
currentSession.value = id;
|
||||
startedFresh = false;
|
||||
messages.value = [];
|
||||
streamingTurn.value = null;
|
||||
queuedMessages.value = [];
|
||||
@@ -394,11 +452,16 @@ export async function selectSession(id: string): Promise<void> {
|
||||
askError.value = "";
|
||||
|
||||
try {
|
||||
// Resuming is the server's own command, so the transcript read below is of
|
||||
// a conversation the server considers current rather than a stale one.
|
||||
await sendCommand(`/resume ${id}`);
|
||||
const transcript = await readTranscript(id);
|
||||
if (isCurrentSession(id)) messages.value = transcript;
|
||||
const turns = await api.chatTurns(id);
|
||||
if (!isCurrentSession(id)) return;
|
||||
const last = turns.at(-1);
|
||||
const open = last && (last.state === "queued" || last.state === "running") ? last : undefined;
|
||||
// A turn still being answered is followed live rather than shown half done.
|
||||
messages.value = transcriptOf(open ? turns.slice(0, -1) : turns);
|
||||
if (open) {
|
||||
messages.value = [...messages.value, { from: "web", text: open.text, message_id: `${open.id}:in` }];
|
||||
void sendMessage({ follow: open.id, textOverride: open.text });
|
||||
}
|
||||
} catch (err) {
|
||||
if (isCurrentSession(id))
|
||||
sessionError.value = describeError(err, errors.chat.session.loadMessages);
|
||||
@@ -407,44 +470,74 @@ export async function selectSession(id: string): Promise<void> {
|
||||
}
|
||||
}
|
||||
|
||||
// readTranscript reads a conversation's messages with each reply's tool calls.
|
||||
// Tool calls belong to the turn, not the message, so a reopened conversation
|
||||
// gets its transcript back with the evidence in place.
|
||||
async function readTranscript(id: string): Promise<ChatMessage[]> {
|
||||
const [msgs, turns] = await Promise.all([
|
||||
api.chatMessages<ChatMessage[]>(id),
|
||||
api.chatTurns<ChatTurnView[]>(id),
|
||||
/** The turns as the transcript shows them: each message, then what answered it. */
|
||||
function transcriptOf(turns: ChatTurnRecord[]): ChatMessage[] {
|
||||
return turns.flatMap((turn): ChatMessage[] => [
|
||||
{ from: "web", text: turn.text, message_id: `${turn.id}:in` },
|
||||
replyOf(turn),
|
||||
]);
|
||||
const byAssistantMessage = new Map<string, ChatTurnView>();
|
||||
// A failed or stopped turn records no reply, so what happened follows the
|
||||
// message it was answering.
|
||||
const failedByInput = new Map<string, ChatTurnView>();
|
||||
for (const turn of turns || []) {
|
||||
const assistantID = turn.assistant_message_id || turn.AssistantMessageID;
|
||||
if (assistantID) byAssistantMessage.set(assistantID, turn);
|
||||
else if ((turn.status === "failed" || turn.status === "cancelled") && turn.input_message_id)
|
||||
failedByInput.set(turn.input_message_id, turn);
|
||||
}
|
||||
|
||||
function replyOf(turn: ChatTurnRecord): ChatMessage {
|
||||
const end = Array.from(turn.reply).length;
|
||||
const settled = new Map(turn.actions.map((a) => [a.request_id, a]));
|
||||
const tools: ChatToolCall[] = [
|
||||
...turn.tool_calls,
|
||||
// Pages opened and answered approvals carry no offset; they follow the reply.
|
||||
...turn.navigate.map((n) => ({ ...n, text_offset: end })),
|
||||
...turn.approvals.flatMap((a) => {
|
||||
const done = settled.get(a.request_id);
|
||||
if (!done) return [];
|
||||
return [{
|
||||
name: a.action,
|
||||
text: done.result ? `${done.state}: ${done.result}` : done.state,
|
||||
failed: !["approved", "running", "succeeded"].includes(done.state),
|
||||
text_offset: end,
|
||||
}];
|
||||
}),
|
||||
];
|
||||
const message: ChatMessage = {
|
||||
from: "assistant",
|
||||
message_id: `${turn.id}:out`,
|
||||
text: turn.reply,
|
||||
tool_calls: tools,
|
||||
approvals: turn.approvals.filter((a) => !settled.has(a.request_id)).map(askOf),
|
||||
};
|
||||
if (turn.state === "failed") return { ...message, text: turn.reply || turn.error || errors.chat.turn.failed, error: !turn.reply };
|
||||
if (turn.state === "cancelled") return { ...message, text: turn.reply || "Stopped before replying." };
|
||||
return message;
|
||||
}
|
||||
|
||||
function askOf(a: { request_id?: string; action?: string; summary?: string }): ChatAsk {
|
||||
return { id: a.request_id ?? "", kind: "approval", prompt: a.action ?? "", detail: a.summary, via: "approvals" };
|
||||
}
|
||||
|
||||
/** Renames the open conversation. */
|
||||
export async function renameSession(title: string): Promise<void> {
|
||||
const id = currentSession.value;
|
||||
if (!id) return;
|
||||
try {
|
||||
const renamed = await api.chatRenameSession(id, title);
|
||||
sessions.value = sessions.value.map((s) => (s.session_id === id ? renamed : s));
|
||||
} catch (err) {
|
||||
sessionError.value = describeError(err, errors.chat.session.command);
|
||||
}
|
||||
return (msgs || []).flatMap((message) => {
|
||||
const messageID = message.message_id || message.MessageID;
|
||||
const turn = messageID ? byAssistantMessage.get(messageID) : undefined;
|
||||
const failed = messageID ? failedByInput.get(messageID) : undefined;
|
||||
if (failed)
|
||||
return [
|
||||
message,
|
||||
{
|
||||
from: "assistant",
|
||||
text:
|
||||
failed.status === "cancelled"
|
||||
? "Stopped before replying."
|
||||
: failed.error || errors.chat.turn.failed,
|
||||
error: failed.status !== "cancelled",
|
||||
tool_calls: failed.tool_calls || [],
|
||||
},
|
||||
];
|
||||
return turn
|
||||
? { ...message, tool_calls: turn.tool_calls || turn.ToolCalls || [] }
|
||||
: message;
|
||||
}
|
||||
|
||||
/** Deletes the open conversation and opens the next one. */
|
||||
export async function deleteSession(): Promise<void> {
|
||||
const id = currentSession.value;
|
||||
if (!id) return;
|
||||
try {
|
||||
await api.chatDeleteSession(id);
|
||||
} catch (err) {
|
||||
sessionError.value = describeError(err, errors.chat.session.delete);
|
||||
return;
|
||||
}
|
||||
newChat();
|
||||
startedFresh = false;
|
||||
await refreshSessions().catch((err) => {
|
||||
sessionError.value = errors.chat.session.refreshList(describeError(err, errors.common.unknown));
|
||||
});
|
||||
}
|
||||
|
||||
@@ -459,7 +552,7 @@ export async function reloadTranscript(): Promise<void> {
|
||||
const stopped = streamingTurn.value?.text === "Turn stopped.";
|
||||
if (!id || (streamingTurn.value && !stopped)) return;
|
||||
try {
|
||||
const transcript = await readTranscript(id);
|
||||
const transcript = transcriptOf(await api.chatTurns(id));
|
||||
if (isCurrentSession(id) && (!streamingTurn.value || streamingTurn.value.text === "Turn stopped.")) {
|
||||
messages.value = transcript;
|
||||
if (stopped) streamingTurn.value = null;
|
||||
@@ -475,17 +568,6 @@ function isCurrentSession(id: string): boolean {
|
||||
return currentSession.value === id;
|
||||
}
|
||||
|
||||
/** One recorded turn, as GET /api/chat/sessions/{id}/turns returns it. */
|
||||
interface ChatTurnView {
|
||||
input_message_id?: string;
|
||||
status?: string;
|
||||
error?: string;
|
||||
assistant_message_id?: string;
|
||||
AssistantMessageID?: string;
|
||||
tool_calls?: ChatToolCall[];
|
||||
ToolCalls?: ChatToolCall[];
|
||||
}
|
||||
|
||||
export async function runSessionCommand(command: string): Promise<void> {
|
||||
if (!currentSession.value) return;
|
||||
try {
|
||||
@@ -527,8 +609,17 @@ export function setTurnHooks(hooks: typeof turnHooks): void {
|
||||
turnHooks = hooks;
|
||||
}
|
||||
|
||||
/** Opens an empty conversation; the server creates it with its first message. */
|
||||
export function newChat(): void {
|
||||
void sendMessage({ textOverride: "/new" });
|
||||
sessionEpoch++;
|
||||
abortActiveTurn();
|
||||
startedFresh = true;
|
||||
currentSession.value = "";
|
||||
messages.value = [];
|
||||
streamingTurn.value = null;
|
||||
queuedMessages.value = [];
|
||||
sessionError.value = "";
|
||||
askError.value = "";
|
||||
}
|
||||
|
||||
/** Messages sent while a turn runs, oldest first; each goes when the turn before it ends. */
|
||||
@@ -595,6 +686,7 @@ export function syncCommandMenu(value: string, caret: number): void {
|
||||
// The list is read when # is first typed, so it is never older than the
|
||||
// moment the operator reached for it.
|
||||
if (
|
||||
tasksBacked() &&
|
||||
detectTrigger(value, caret)?.trigger === "#" &&
|
||||
(!isCommandMenuOpen.value || menuTrigger.value !== "#")
|
||||
) {
|
||||
@@ -604,8 +696,15 @@ export function syncCommandMenu(value: string, caret: number): void {
|
||||
renderMenu();
|
||||
}
|
||||
|
||||
// # attaches a task, which needs the server's task list; without one the
|
||||
// trigger is plain text.
|
||||
function tasksBacked(): boolean {
|
||||
return useSessionStore().sections?.tasks !== false;
|
||||
}
|
||||
|
||||
function renderMenu(): void {
|
||||
const found = detectTrigger(lastInput.value, lastInput.caret);
|
||||
const trigger = detectTrigger(lastInput.value, lastInput.caret);
|
||||
const found = trigger?.trigger === "#" && !tasksBacked() ? null : trigger;
|
||||
let matches: Completion[] = [];
|
||||
if (found?.trigger === "/") {
|
||||
matches = commandCompletions(commandSpecs.value, found.query);
|
||||
@@ -691,7 +790,9 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
: typed;
|
||||
const { text, turn, isRetry } = resolveTurn(retryOpts, rawValue);
|
||||
if (!text) return;
|
||||
if (isSending.value) {
|
||||
const follow = retryOpts?.follow;
|
||||
// Following a turn already sent never queues: it is the turn being waited on.
|
||||
if (isSending.value && !follow) {
|
||||
// A message typed during a turn waits for it; a retry has nothing to
|
||||
// wait for. A voice clip queues too, so it is not dropped.
|
||||
if (isRetry) return;
|
||||
@@ -709,15 +810,15 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
isSending.value = true;
|
||||
statusText.value = isRetry ? "Retrying…" : "Thinking…";
|
||||
|
||||
if (!isRetry) {
|
||||
if (!isRetry && !follow) {
|
||||
messages.value = [...messages.value, { from: "web", text }];
|
||||
// A queued or command send must not clear what is being typed.
|
||||
if (explicitText === undefined) clearDraft();
|
||||
}
|
||||
|
||||
// A bare /model offers its choices as buttons, as Telegram does; with an
|
||||
// argument it goes to the gateway like any command.
|
||||
if (!isRetry && text.trim() === "/model") {
|
||||
// argument it goes to the server like any command.
|
||||
if (!isRetry && !follow && text.trim() === "/model" && hasCommand("/model")) {
|
||||
messages.value = [...messages.value, { from: "assistant", text: "", choose: "model" }];
|
||||
isSending.value = false;
|
||||
statusText.value = "Ready";
|
||||
@@ -725,7 +826,7 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
}
|
||||
|
||||
// /update answers here, where the panel can offer Install like Telegram does.
|
||||
if (!isRetry && text.trim() === "/update") {
|
||||
if (!isRetry && !follow && text.trim() === "/update" && hasCommand("/update")) {
|
||||
try {
|
||||
const update = await api.updateSnapshot<ChatUpdate>();
|
||||
messages.value = [...messages.value, { from: "assistant", text: "", update }];
|
||||
@@ -743,12 +844,12 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
}
|
||||
|
||||
let activeTools: ChatToolCall[] = [];
|
||||
let approvals: ChatAsk[] = [];
|
||||
streamingTurn.value = { text: "", tools: [], isError: false, turn, isRetry, reasoning: "" };
|
||||
askError.value = "";
|
||||
|
||||
let streamedText = "";
|
||||
let streamedReasoning = "";
|
||||
let finished = false;
|
||||
let timedOut = false;
|
||||
let detached = false;
|
||||
let timeoutId: ReturnType<typeof setTimeout> | undefined;
|
||||
@@ -758,6 +859,7 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
const ctrl = new AbortController();
|
||||
controller = ctrl;
|
||||
activeController = ctrl;
|
||||
activeTurnID = follow ?? "";
|
||||
const arm = () => {
|
||||
clearTimeout(timeoutId);
|
||||
timeoutId = setTimeout(() => {
|
||||
@@ -768,51 +870,25 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
arm();
|
||||
// The clock stops while a question waits on the operator.
|
||||
rearmTimeout = arm;
|
||||
await turnHooks.before?.();
|
||||
|
||||
const response = await api.chatStream(
|
||||
{
|
||||
channel_id: channelID(),
|
||||
source_id: turn.sourceID,
|
||||
text: turn.text,
|
||||
page: sentPage(),
|
||||
voice: turn.voice,
|
||||
},
|
||||
{ signal: ctrl.signal },
|
||||
);
|
||||
const body = response.body;
|
||||
if (!body) throw new Error(errors.chat.stream.noBody);
|
||||
|
||||
const reader = body.getReader();
|
||||
const decoder = new TextDecoder();
|
||||
let buffer = "";
|
||||
|
||||
// Drained to completion: the stream is read until the reader reports done,
|
||||
// and a turn that ends without a `done` frame is a failed turn rather than
|
||||
// a short one. Reading only some frames leaves the producer writing into a
|
||||
// stream nobody collects.
|
||||
for (;;) {
|
||||
const { value, done } = await reader.read();
|
||||
if (epoch !== sessionEpoch) {
|
||||
// Detached by a conversation switch mid-turn: stop reading and write
|
||||
// nothing into the conversation now open.
|
||||
detached = true;
|
||||
await reader.cancel().catch(() => {});
|
||||
return;
|
||||
if (!follow) {
|
||||
await turnHooks.before?.();
|
||||
const session = await ensureSession();
|
||||
const sent = await api.chatSend(session, { text: turn.text, page: sentPage(), page_label: pageTag.value?.label });
|
||||
if (activeController === ctrl) activeTurnID = sent.id;
|
||||
// Stopped while the message was on its way: the turn exists now, so stop it.
|
||||
if (ctrl.signal.aborted) {
|
||||
void api.chatCancelTurn(sent.id).catch(() => {});
|
||||
throw new DOMException("stopped", "AbortError");
|
||||
}
|
||||
// Any bytes, including the server's keepalive, show the turn is alive;
|
||||
// a question waiting on the operator stops the clock until answered.
|
||||
if (!done && !streamingTurn.value?.ask) arm();
|
||||
buffer += decoder.decode(value || new Uint8Array(), { stream: !done });
|
||||
const frames = buffer.split("\n\n");
|
||||
buffer = frames.pop() || "";
|
||||
for (const frame of frames) {
|
||||
const line = frame
|
||||
.split("\n")
|
||||
.find((part) => part.startsWith("data: "));
|
||||
if (!line) continue;
|
||||
const event = JSON.parse(line.slice(6)) as ChatStreamFrame;
|
||||
if (event.session_id) currentSession.value = event.session_id;
|
||||
}
|
||||
|
||||
const last = await readTurn(
|
||||
activeTurnID,
|
||||
ctrl.signal,
|
||||
(event) => {
|
||||
// Detached by a conversation switch mid-turn: write nothing into the
|
||||
// conversation now open.
|
||||
if (epoch !== sessionEpoch) throw new DOMException("detached", "AbortError");
|
||||
if (event.type === "delta") {
|
||||
streamedText += event.text;
|
||||
streamingTurn.value = streamingTurn.value
|
||||
@@ -832,28 +908,29 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
// is one more thing the turn did, and it renders as a chip rather than
|
||||
// a tool line.
|
||||
if (event.type === "tool" || event.type === "navigate") {
|
||||
activeTools = [...activeTools, event];
|
||||
const at = event.type === "navigate" ? { text_offset: Array.from(streamedText).length } : {};
|
||||
activeTools = [...activeTools, { ...event, ...at }];
|
||||
streamingTurn.value = streamingTurn.value
|
||||
? { ...streamingTurn.value, tools: activeTools }
|
||||
: null;
|
||||
}
|
||||
if (event.type === "ask" && event.ask) {
|
||||
clearTimeout(timeoutId);
|
||||
askError.value = "";
|
||||
// A held action does not stop the turn: its card waits in the reply.
|
||||
if (event.type === "approval" && event.request_id) {
|
||||
approvals = [...approvals, askOf(event)];
|
||||
streamingTurn.value = streamingTurn.value
|
||||
? { ...streamingTurn.value, ask: event.ask }
|
||||
? { ...streamingTurn.value, approvals }
|
||||
: null;
|
||||
}
|
||||
if (event.type === "done") {
|
||||
finished = true;
|
||||
if (!streamedText) streamedText = event.text || "";
|
||||
}
|
||||
if (event.type === "error") throw new Error(event.text);
|
||||
}
|
||||
if (done) break;
|
||||
}
|
||||
|
||||
if (!finished) throw new Error(errors.chat.stream.endedEarly);
|
||||
},
|
||||
() => {
|
||||
// Any bytes, including the server's keepalive, show the turn is alive.
|
||||
if (epoch === sessionEpoch) arm();
|
||||
},
|
||||
);
|
||||
if (epoch !== sessionEpoch) throw new DOMException("detached", "AbortError");
|
||||
if (last.type === "error") throw new Error(last.text);
|
||||
if (last.type === "cancelled") throw new DOMException("stopped", "AbortError");
|
||||
if (!streamedText) streamedText = last.text || "";
|
||||
|
||||
if (epoch === sessionEpoch) {
|
||||
// /new opens an empty conversation, so the window clears instead of
|
||||
@@ -863,7 +940,7 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
? []
|
||||
: [
|
||||
...messages.value,
|
||||
{ from: "assistant", text: streamedText, tool_calls: activeTools },
|
||||
{ from: "assistant", text: streamedText, tool_calls: activeTools, approvals },
|
||||
];
|
||||
streamingTurn.value = null;
|
||||
}
|
||||
@@ -884,7 +961,7 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
if (streamedText) {
|
||||
messages.value = [
|
||||
...messages.value,
|
||||
{ from: "assistant", text: streamedText, tool_calls: activeTools },
|
||||
{ from: "assistant", text: streamedText, tool_calls: activeTools, approvals },
|
||||
];
|
||||
activeTools = [];
|
||||
}
|
||||
@@ -921,6 +998,7 @@ export async function sendMessage(retryOpts?: RetryOptions): Promise<void> {
|
||||
// the conversation now open.
|
||||
if (controller && activeController === controller) {
|
||||
activeController = null;
|
||||
activeTurnID = "";
|
||||
isSending.value = false;
|
||||
if (detached) statusText.value = "Ready";
|
||||
}
|
||||
@@ -935,12 +1013,17 @@ function lastStep(tools: ChatToolCall[]): string {
|
||||
|
||||
export function stopTurn(): void {
|
||||
statusText.value = "Stopping…";
|
||||
if (currentSession.value) {
|
||||
void api.chatCancel(currentSession.value).catch((err) => {
|
||||
sessionError.value = errors.chat.turn.stop(describeError(err, errors.common.unknown));
|
||||
});
|
||||
const id = activeTurnID;
|
||||
// Without a turn yet, the abort stops the send; with one, the server stops
|
||||
// it and the stream ends on its cancelled event, keeping what was said.
|
||||
if (!id) {
|
||||
abortActiveTurn();
|
||||
return;
|
||||
}
|
||||
abortActiveTurn();
|
||||
void api.chatCancelTurn(id).catch((err) => {
|
||||
sessionError.value = errors.chat.turn.stop(describeError(err, errors.common.unknown));
|
||||
abortActiveTurn();
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -24,6 +24,8 @@ export interface RetryOptions {
|
||||
textOverride?: string;
|
||||
turn?: ChatTurn;
|
||||
voice?: ChatTurn["voice"];
|
||||
/** A turn the server already has: follow its stream instead of sending. */
|
||||
follow?: string;
|
||||
}
|
||||
|
||||
// resolveTurn decides what to send: a real retry descriptor's original turn,
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
export const chat = {
|
||||
ask: {
|
||||
answer: "Could not send the answer",
|
||||
unsupported: "This question can't be answered here",
|
||||
},
|
||||
composer: {
|
||||
microphoneUnavailable: (detail: string) => `Microphone unavailable: ${detail}`,
|
||||
@@ -12,6 +13,7 @@ export const chat = {
|
||||
loadMessages: "Could not load session messages",
|
||||
refreshList: (detail: string) => `Could not refresh the session list: ${detail}`,
|
||||
command: "Session action failed",
|
||||
delete: "Could not delete the conversation",
|
||||
model: (detail: string) => `Model update failed: ${detail}`,
|
||||
nothingToCopy: "Nothing to copy",
|
||||
copyFailed: (detail: string) => `Not copied: ${detail}`,
|
||||
|
||||
+65
-22
@@ -515,34 +515,77 @@ export const api = {
|
||||
request<T>(`/api/sources/${encodeURIComponent(path)}/secret`, {
|
||||
method: "POST",
|
||||
}),
|
||||
chatSessions: <T = unknown>() => request<T>("/api/chat/sessions"),
|
||||
chatAnswer: (id: string, answer: string) =>
|
||||
request("/api/chat/answer", { method: "POST", body: { id, answer } }),
|
||||
chatMessages: <T = unknown>(id: string) =>
|
||||
request<T>(`/api/chat/sessions/${encodeURIComponent(id)}/messages`),
|
||||
chatTurns: <T = unknown>(id: string) =>
|
||||
request<T>(`/api/chat/sessions/${encodeURIComponent(id)}/turns`),
|
||||
chatCancel: <T = unknown>(sessionID: string) =>
|
||||
request<T>("/api/chat/cancel", {
|
||||
method: "POST",
|
||||
body: { session_id: sessionID },
|
||||
}),
|
||||
chatSessions: () => request<ChatSessions>("/api/chat/sessions"),
|
||||
chatCreateSession: () => request<ChatSessionView>("/api/chat/sessions", { method: "POST" }),
|
||||
chatRenameSession: (id: string, title: string) =>
|
||||
request<ChatSessionView>(`/api/chat/sessions/${encodeURIComponent(id)}`, { method: "PATCH", body: { title } }),
|
||||
chatDeleteSession: (id: string) =>
|
||||
request<void>(`/api/chat/sessions/${encodeURIComponent(id)}`, { method: "DELETE", parse: false }),
|
||||
chatTurns: (id: string) => request<ChatTurnRecord[]>(`/api/chat/sessions/${encodeURIComponent(id)}/turns`),
|
||||
chatSend: (id: string, body: { text: string; page?: string; page_label?: string }) =>
|
||||
request<ChatTurnRecord>(`/api/chat/sessions/${encodeURIComponent(id)}/turns`, { method: "POST", body }),
|
||||
chatCancelTurn: (id: string) =>
|
||||
request<ChatTurnRecord>(`/api/chat/turns/${encodeURIComponent(id)}/cancel`, { method: "POST" }),
|
||||
// A server-sent event stream cannot be parsed as JSON and outlives a normal
|
||||
// request, so the caller owns the abort controller and the timeout, and
|
||||
// reads the body itself. Only the URL, headers, and failure shape are shared.
|
||||
chatStream: (payload: unknown, opts: { signal?: AbortSignal } = {}) =>
|
||||
send("/api/chat/stream", {
|
||||
method: "POST",
|
||||
headers: {
|
||||
Accept: "text/event-stream",
|
||||
"Content-Type": "application/json",
|
||||
"X-Archie-CSRF": "1",
|
||||
},
|
||||
body: JSON.stringify(payload),
|
||||
// reads the body itself. `after` is the last event seq already read.
|
||||
chatTurnEvents: (id: string, after: number, opts: { signal?: AbortSignal } = {}) =>
|
||||
send(`/api/chat/turns/${encodeURIComponent(id)}/events${after ? qs({ after }) : ""}`, {
|
||||
headers: { Accept: "text/event-stream" },
|
||||
signal: opts.signal,
|
||||
}),
|
||||
};
|
||||
|
||||
/** GET /api/chat/sessions: the conversations and the model that answers. */
|
||||
export interface ChatSessions {
|
||||
sessions: ChatSessionView[];
|
||||
active_model?: string;
|
||||
model_error?: string;
|
||||
}
|
||||
|
||||
export interface ChatSessionView {
|
||||
session_id: string;
|
||||
title: string;
|
||||
created_at: string;
|
||||
updated_at: string;
|
||||
}
|
||||
|
||||
/** One turn of a conversation, with what it did, as the chat API records it. */
|
||||
export interface ChatTurnRecord {
|
||||
id: string;
|
||||
session_id: string;
|
||||
seq: number;
|
||||
state: "queued" | "running" | "succeeded" | "failed" | "cancelled";
|
||||
text: string;
|
||||
page?: string;
|
||||
page_label?: string;
|
||||
reply: string;
|
||||
reasoning?: string;
|
||||
error?: string;
|
||||
tool_calls: { id: string; name: string; parameters: string; text: string; failed?: boolean; duration_ms: number; text_offset: number }[];
|
||||
approvals: ChatApprovalRecord[];
|
||||
actions: ChatActionRecord[];
|
||||
navigate: { path: string; label: string }[];
|
||||
created_at: string;
|
||||
finished_at?: string;
|
||||
}
|
||||
|
||||
/** An action judgement held in a chat turn and put to people. */
|
||||
export interface ChatApprovalRecord {
|
||||
request_id: string;
|
||||
action: string;
|
||||
summary: string;
|
||||
level: string;
|
||||
deadline: string;
|
||||
}
|
||||
|
||||
/** What became of a held action once its approval was answered. */
|
||||
export interface ChatActionRecord {
|
||||
request_id: string;
|
||||
state: string;
|
||||
result?: string;
|
||||
}
|
||||
|
||||
export interface Run {
|
||||
id: string;
|
||||
workflow: string;
|
||||
|
||||
@@ -27,15 +27,12 @@ const PAGE_MOCK = `(() => {
|
||||
const url = typeof input === "string" ? input : input.url;
|
||||
const json = (body, type = "application/json") =>
|
||||
Promise.resolve(new Response(typeof body === "string" ? body : JSON.stringify(body), { status: 200, headers: { "Content-Type": type } }));
|
||||
if (url.includes("/api/chat/stream")) {
|
||||
window.__archieSent.push(JSON.parse(init.body).text);
|
||||
return json('data: {"type":"delta","text":"ok","session_id":"s1"}\\n\\ndata: {"type":"done","text":"ok","session_id":"s1"}\\n\\n', "text/event-stream");
|
||||
}
|
||||
if (url.includes("/api/chat/")) window.__archieSent.push((init?.method || "GET") + " " + url.replace(location.origin, "") + (init?.body ? " " + init.body : ""));
|
||||
if (url.includes("/api/auth/status"))
|
||||
return json({ setup_required: false, user: { id: "u1", display_name: "Operator", kind: "operator" }, oidc: false, public_url: location.origin + "/", instance: "archie" });
|
||||
if (url.includes("/api/chat/sessions"))
|
||||
return json({ providers: ["test"], models: ["test-model"], models_by_provider: { test: ["test-model"] }, active_provider: "test", active_model: "test-model", commands: ["/retry", "/undo", "/title", "/branch", "/compress"], voice_available: false, sessions: [{ session_id: "s1", title: "Test session", created_at: "2026-01-01T00:00:00Z" }] });
|
||||
if (url.includes("/turns")) return json({ turns: [] });
|
||||
return json({ active_model: "test-model", sessions: [{ session_id: "s1", title: "Test session", created_at: "2026-01-01T00:00:00Z", updated_at: "2026-01-01T00:00:00Z" }] });
|
||||
if (url.includes("/turns")) return json([]);
|
||||
if (url.includes("/health")) return json({ status: "ok" });
|
||||
if (url.includes("/api/")) return json({});
|
||||
return realFetch(input, init);
|
||||
@@ -203,8 +200,8 @@ test("chat More menu opens on screen and its items run", { timeout: 90000 }, asy
|
||||
return false;
|
||||
})()`).then((expanded: unknown) => assert.equal(expanded, true, "the chat dock expanded and rendered the More button"));
|
||||
|
||||
// Pick the open conversation first, so the menu's commands have a
|
||||
// session to act on (selectSession itself streams /resume s1).
|
||||
// Pick the open conversation first, so the menu's actions have a
|
||||
// session to act on.
|
||||
await cdp.evaluate(`(() => {
|
||||
document.querySelector('button[aria-label="Conversations"]').click();
|
||||
})()`);
|
||||
@@ -215,9 +212,10 @@ test("chat More menu opens on screen and its items run", { timeout: 90000 }, asy
|
||||
})()`);
|
||||
await cdp.evaluate(`(async () => {
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
for (let i = 0; i < 40 && !window.__archieSent.includes("/resume s1"); i++) await sleep(250);
|
||||
return window.__archieSent.includes("/resume s1");
|
||||
})()`).then((selected: unknown) => assert.equal(selected, true, "selecting the conversation opened it on the server"));
|
||||
const read = () => window.__archieSent.includes("GET /api/chat/sessions/s1/turns");
|
||||
for (let i = 0; i < 40 && !read(); i++) await sleep(250);
|
||||
return read();
|
||||
})()`).then((selected: unknown) => assert.equal(selected, true, "selecting the conversation read its turns"));
|
||||
|
||||
// Hover the More button: the tooltip keeps its accessible name.
|
||||
const moreBox = await cdp.evaluate(`(() => { const r = document.querySelector('button[aria-label="More"]').getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 }; })()`);
|
||||
@@ -249,22 +247,20 @@ test("chat More menu opens on screen and its items run", { timeout: 90000 }, asy
|
||||
assert.equal(opened.exists, true, "clicking More opens the popover");
|
||||
assert.equal(opened.ariaExpanded, "true");
|
||||
assert.equal(opened.inViewport, true, `the menu must render on screen, got ${JSON.stringify(opened.rect)}`);
|
||||
for (const item of ["Retry", "Undo", "Rename", "Branch", "Preview compression", "Copy as Markdown"]) {
|
||||
for (const item of ["Rename", "Copy as Markdown", "Delete"]) {
|
||||
assert.ok(opened.text.includes(item), `the menu lists ${item}`);
|
||||
}
|
||||
// A server that lists no slash commands gets none of their buttons.
|
||||
for (const item of ["Retry", "Undo", "Branch", "Preview compression"]) {
|
||||
assert.ok(!opened.text.includes(item), `the menu hides ${item}`);
|
||||
}
|
||||
|
||||
// Run Retry from the menu: the command goes over the chat stream and
|
||||
// the menu closes.
|
||||
// Run Copy as Markdown from the menu: the menu closes.
|
||||
await cdp.evaluate(`(() => {
|
||||
const retry = [...document.querySelectorAll('[data-slot="popover-content"] button')].find((el) => el.innerText.includes("Retry"));
|
||||
if (retry) retry.click();
|
||||
const copy = [...document.querySelectorAll('[data-slot="popover-content"] button')].find((el) => el.innerText.includes("Copy as Markdown"));
|
||||
if (copy) copy.click();
|
||||
})()`);
|
||||
await cdp.evaluate(`(async () => {
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
for (let i = 0; i < 40 && !window.__archieSent.includes("/retry"); i++) await sleep(250);
|
||||
return window.__archieSent.includes("/retry");
|
||||
})()`).then((sent: unknown) => assert.equal(sent, true, `Retry sends /retry over the chat stream, got ${JSON.stringify(sent)}`));
|
||||
const afterRetry = await cdp.evaluate(`(async () => {
|
||||
const afterCopy = await cdp.evaluate(`(async () => {
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
for (let i = 0; i < 40; i++) {
|
||||
const pop = document.querySelector('[data-slot="popover-content"]');
|
||||
@@ -277,9 +273,9 @@ test("chat More menu opens on screen and its items run", { timeout: 90000 }, asy
|
||||
dockStillThere: !!document.querySelector('button[aria-label="More"]'),
|
||||
};
|
||||
})()`);
|
||||
assert.equal(afterRetry.popoverClosed, true, "running a command closes the menu");
|
||||
assert.equal(afterRetry.ariaExpanded, "false");
|
||||
assert.equal(afterRetry.dockStillThere, true);
|
||||
assert.equal(afterCopy.popoverClosed, true, "running an action closes the menu");
|
||||
assert.equal(afterCopy.ariaExpanded, "false");
|
||||
assert.equal(afterCopy.dockStillThere, true);
|
||||
|
||||
// Reopen and use Rename: the labelled dialog opens from the menu.
|
||||
await cdp.evaluate(`(() => { document.querySelector('button[aria-label="More"]').click(); })()`);
|
||||
@@ -295,12 +291,26 @@ test("chat More menu opens on screen and its items run", { timeout: 90000 }, asy
|
||||
})()`);
|
||||
assert.ok(dialog && dialog.includes("Session title"), `Rename opens the session-title dialog, got ${JSON.stringify(dialog)}`);
|
||||
|
||||
// Cancel the dialog, reopen the menu, then Escape: it dismisses the menu
|
||||
// but leaves the conversation open.
|
||||
// Submit a title: it is saved through the chat API.
|
||||
await cdp.evaluate(`(() => {
|
||||
const cancel = [...document.querySelectorAll('[role="dialog"] button')].find((el) => el.innerText.trim() === "Cancel");
|
||||
if (cancel) cancel.click();
|
||||
const input = document.querySelector('[role="dialog"] input');
|
||||
input.value = "Renamed";
|
||||
input.dispatchEvent(new Event("input", { bubbles: true }));
|
||||
})()`);
|
||||
await new Promise((r) => setTimeout(r, 300));
|
||||
await cdp.evaluate(`(() => {
|
||||
const ok = [...document.querySelectorAll('[role="dialog"] button')].find((el) => el.innerText.trim() === "OK");
|
||||
if (ok) ok.click();
|
||||
})()`);
|
||||
await cdp.evaluate(`(async () => {
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
const sent = () => window.__archieSent.includes('PATCH /api/chat/sessions/s1 {"title":"Renamed"}');
|
||||
for (let i = 0; i < 40 && !sent(); i++) await sleep(250);
|
||||
return sent();
|
||||
})()`).then((sent: unknown) => assert.equal(sent, true, "Rename saves the title through the chat API"));
|
||||
|
||||
// Reopen the menu, then Escape: it dismisses the menu but leaves the
|
||||
// conversation open.
|
||||
await new Promise((r) => setTimeout(r, 800));
|
||||
await cdp.evaluate(`(() => { document.querySelector('button[aria-label="More"]').click(); })()`);
|
||||
await new Promise((r) => setTimeout(r, 1000));
|
||||
|
||||
@@ -15,6 +15,8 @@ const apiStub =
|
||||
"export const api = new Proxy({}, { get: (_, p) => globalThis.__archieChatTestApi[p] });" +
|
||||
"export function describeError(err, fallback) { return err instanceof Error && err.message ? err.message : fallback; }",
|
||||
);
|
||||
const sessionStub =
|
||||
"data:text/javascript," + encodeURIComponent("export function useSessionStore() { return { sections: null }; }");
|
||||
const routerStub =
|
||||
"data:text/javascript," +
|
||||
encodeURIComponent(
|
||||
@@ -26,6 +28,7 @@ register(
|
||||
const SRC = ${JSON.stringify(pathToFileURL(srcRoot + "/").href)};
|
||||
export async function resolve(specifier, context, next) {
|
||||
if (specifier === "@/lib/api") return { url: ${JSON.stringify(apiStub)}, shortCircuit: true };
|
||||
if (specifier === "@/stores/session") return { url: ${JSON.stringify(sessionStub)}, shortCircuit: true };
|
||||
if (specifier === "@/router") return { url: ${JSON.stringify(routerStub)}, shortCircuit: true };
|
||||
if (specifier === "@/copy/errors") return { url: SRC + "copy/errors/index.ts", shortCircuit: true };
|
||||
if (specifier.startsWith("@/")) return { url: SRC + specifier.slice(2) + ".ts", shortCircuit: true };
|
||||
@@ -40,7 +43,6 @@ register(
|
||||
interface Frame {
|
||||
type: string;
|
||||
text?: string;
|
||||
session_id?: string;
|
||||
}
|
||||
|
||||
/** One SSE body: each frame as the server writes it, `data: {...}\n\n`. */
|
||||
@@ -55,14 +57,14 @@ function sseBody(frames: Frame[]): ReadableStream<Uint8Array> {
|
||||
});
|
||||
}
|
||||
|
||||
const started = { type: "started", session_id: "s1" };
|
||||
|
||||
// The stream stub: chatStream answers with the given frames, sessions reads
|
||||
// back an empty list so the finished turn does not trigger a reload.
|
||||
// The stream stub: the turn's events answer with the given frames, sessions
|
||||
// reads back an empty list so the finished turn does not trigger a reload.
|
||||
function stubApi(frames: Frame[]): void {
|
||||
(globalThis as Record<string, unknown>).__archieChatTestApi = {
|
||||
chatStream: () => ({ body: sseBody(frames) }),
|
||||
chatSessions: () => ({ sessions: [], commands: [] }),
|
||||
chatCreateSession: () => ({ session_id: "s1", title: "" }),
|
||||
chatSend: () => ({ id: "t1" }),
|
||||
chatTurnEvents: () => ({ body: sseBody(frames) }),
|
||||
chatSessions: () => ({ sessions: [] }),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -70,7 +72,6 @@ const state = await import("../src/chat/state.ts");
|
||||
|
||||
test("reasoning frames accumulate on the live turn as its thinking", async () => {
|
||||
stubApi([
|
||||
started,
|
||||
{ type: "reasoning", text: "considering " },
|
||||
{ type: "reasoning", text: "the request" },
|
||||
{ type: "error", text: "provider exploded" },
|
||||
@@ -84,10 +85,9 @@ test("reasoning frames accumulate on the live turn as its thinking", async () =>
|
||||
|
||||
test("reasoning never leaks into the reply text", async () => {
|
||||
stubApi([
|
||||
started,
|
||||
{ type: "reasoning", text: "secret chain of thought" },
|
||||
{ type: "delta", text: "Hello" },
|
||||
{ type: "done", text: "Hello", session_id: "s1" },
|
||||
{ type: "done", text: "Hello" },
|
||||
]);
|
||||
await state.sendMessage({ textOverride: "hi" });
|
||||
assert.equal(state.streamingTurn.value, null);
|
||||
@@ -97,7 +97,7 @@ test("reasoning never leaks into the reply text", async () => {
|
||||
});
|
||||
|
||||
test("a turn without reasoning frames completes normally", async () => {
|
||||
stubApi([started, { type: "delta", text: "Hi" }, { type: "done", text: "Hi", session_id: "s1" }]);
|
||||
stubApi([{ type: "delta", text: "Hi" }, { type: "done", text: "Hi" }]);
|
||||
await state.sendMessage({ textOverride: "hey" });
|
||||
assert.equal(state.streamingTurn.value, null);
|
||||
assert.equal(state.messages.value.at(-1)?.text, "Hi");
|
||||
|
||||
Reference in new issue
Block a user