@g9tm/aiassistant-svelte 0.0.0-stage → 1.1.0

package/dist/pages/RoutineWizard.svelte

@@ -0,0 +1,197 @@
+<script lang="ts">
+  // The routine wizard: the routines the person may run; choosing one asks for its slots (entity slots through a
+  // searchable picker, the rest typed and checked by the core's slotValue), then "Preview". A read-only routine answers
+  // with its report; one that changes things returns its card, confirmed here (with the code its method asks for) and
+  // run bound to the preview's run and hash.
+  import { ApiError, arr, needsCode, num, obj, planView, str, type PlanView } from "@g9tm/aiassistant";
+  import { missingSlots, pageCalls, readRoutines, slotValue, type Routine, type RoutineSlot } from "@g9tm/aiassistant/pages";
+  import { cls, override, useUi } from "../context.js";
+  import BlockView from "../blocks/BlockView.svelte";
+  import PinPad from "../slots/PinPad.svelte";
+  import SlotPicker from "./SlotPicker.svelte";
+  import { pageTexts } from "./texts.js";
+
+  // The same props as the other pages (a routine opens no conversation).
+  let {}: { onopen?: ((conversationId: string) => void) | undefined } = $props();
+  const ui = useUi();
+  const texts = pageTexts(ui.texts);
+  const t = texts.t;
+  const api = ui.assistant.api;
+  const Picker = $derived(override(ui, "SlotPicker") ?? SlotPicker);
+  const Pin = $derived(override(ui, "PinPad") ?? PinPad);
+
+  type Card = { plan: PlanView; routineRunId: string; hash: string };
+  let routines = $state<Routine[]>([]);
+  let loadFailed = $state(false);
+  let chosen = $state<Routine | null>(null);
+  let typed = $state<Record<string, string>>({});
+  let picks = $state<Record<string, { id: string; label: string }>>({});
+  let tried = $state(false);
+  let serverMissing = $state<string[]>([]);
+  let report = $state<unknown[] | null>(null);
+  let card = $state<Card | null>(null);
+  let code = $state("");
+  let busy = $state(false);
+  let failure = $state<string | null>(null);
+  let triesLeft = $state<number | null>(null);
+  let result = $state<string | null>(null);
+
+  $effect(() => {
+    pageCalls.routines(api).then((raw) => { routines = readRoutines(raw); loadFailed = false; }, () => { loadFailed = true; });
+  });
+
+  const has = (o: Record<string, unknown>, k: string): boolean => Object.prototype.hasOwnProperty.call(o, k);
+  const textOf = (name: string): string => (has(typed, name) ? String(new Map(Object.entries(typed)).get(name) ?? "") : "");
+  const pickOf = (name: string): { id: string; label: string } | null => new Map(Object.entries(picks)).get(name) ?? null;
+  const valueOf = (slot: RoutineSlot): string | null => (slot.field === "pick" ? pickOf(slot.name)?.id ?? null : slotValue(slot, textOf(slot.name)));
+  const values = $derived(Object.fromEntries((chosen?.slots ?? []).flatMap((s) => { const v = valueOf(s); return v === null ? [] : [[s.name, v]]; })) as Record<string, string>);
+  const missing = $derived(chosen ? missingSlots(chosen.slots, values).map((s) => s.name) : []);
+  /** A slot's state: filled, missing (shown once the person asked for the preview, or the server said so) or not right. */
+  function stateOf(slot: RoutineSlot): "ok" | "missing" | "invalid" {
+    if (slot.field !== "pick" && textOf(slot.name).trim().length > 0 && valueOf(slot) === null) return "invalid";
+    if (serverMissing.includes(slot.name)) return "missing";
+    return tried && missing.includes(slot.name) ? "missing" : "ok";
+  }
+  function labelOf(slot: RoutineSlot): string {
+    const key = "slot." + slot.name;
+    const v = t(key);
+    return v === key ? slot.name : v;
+  }
+  const say = (key: string, args: Record<string, string>): string => {
+    const text = t(key, args);
+    return text === key ? Object.values(args).join(" ") || key : text;
+  };
+
+  function choose(r: Routine | null): void {
+    chosen = r;
+    typed = {};
+    picks = {};
+    tried = false;
+    serverMissing = [];
+    report = null;
+    card = null;
+    code = "";
+    failure = null;
+    triesLeft = null;
+    result = null;
+  }
+
+  function failed(e: unknown): void {
+    failure = e instanceof ApiError ? e.code : "error.network";
+    const left = e instanceof ApiError ? obj(e.body)["triesLeft"] : undefined;
+    triesLeft = typeof left === "number" ? left : null;
+  }
+
+  async function preview(): Promise<void> {
+    tried = true;
+    failure = null;
+    serverMissing = [];
+    const r0 = chosen;
+    if (!r0 || missing.length > 0 || chosen?.slots.some((s) => stateOf(s) === "invalid")) return;
+    busy = true;
+    try {
+      const r = obj(await pageCalls.preview(api, r0.id, values, ui.assistant.snapshot().conversationId ?? undefined));
+      const state = str(r["state"]);
+      if (state === "report") report = arr(r["blocks"]);
+      else if (state === "missing" || !r["card"]) serverMissing = arr(r["missing"]).filter((m): m is string => typeof m === "string");
+      else {
+        const plan = planView(r["card"]);
+        card = { plan, routineRunId: str(r["routineRunId"]), hash: str(r["hash"], plan.hash) };
+      }
+    } catch (e) {
+      failed(e);
+    }
+    busy = false;
+  }
+
+  async function run(): Promise<void> {
+    const r0 = chosen;
+    const c = card;
+    if (!r0 || !c) return;
+    busy = true;
+    failure = null;
+    triesLeft = null;
+    try {
+      const r = obj(await pageCalls.run(api, r0.id, c.routineRunId, c.hash, needsCode(c.plan.method) ? code : undefined));
+      if (r["ok"] === false) {
+        failure = str(obj(r["error"])["code"], "routine.failed");
+        triesLeft = typeof r["triesLeft"] === "number" ? num(r["triesLeft"]) : null;
+      } else {
+        result = str(r["text"]) || t("routine.done");
+        card = null;
+      }
+    } catch (e) {
+      failed(e);
+    }
+    code = "";
+    busy = false;
+  }
+</script>
+
+<div class={cls(ui, "panel.body") + " g9a-routines"} data-page="routines">
+  {#if loadFailed}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+  {#if !chosen}
+    <h4>{t("routine.list")}</h4>
+    <ul class="g9a-routines__list">
+      {#each routines as r (r.id)}
+        <li><button type="button" class="g9a-routines__choose" data-id={r.id} onclick={() => choose(r)}>{r.title || r.id}</button></li>
+      {:else}
+        <li class="g9a-note">{t("routine.empty")}</li>
+      {/each}
+    </ul>
+  {:else}
+    <div class="g9a-row"><button type="button" class="g9a-routines__back" onclick={() => choose(null)}>{t("routine.back")}</button></div>
+    <h4>{chosen.title || chosen.id}</h4>
+    {#if result !== null}
+      <p class="g9a-note g9a-routines__result" role="status">{result}</p>
+    {:else if report}
+      <div class="g9a-routines__report">{#each report as b, i (i)}<BlockView block={b} />{/each}</div>
+    {:else if card}
+      {@const plan = card.plan}
+      <div class={cls(ui, "card.approval")} data-routine-card={plan.id}>
+        <h3>{plan.readOnly ? t("card.readonly_routine") : plan.title}</h3>
+        {#if plan.warning}<p class="g9a-warning" role="note">{t("card.tainted")}</p>{/if}
+        <ol>
+          {#each plan.steps as s (s.index)}
+            <li class={cls(ui, "card.approval.step")}>
+              {s.text}{#if !s.undoable}<span class="g9a-irreversible"> ({t("card.irreversible")})</span>{/if}
+              {#each s.facts as f, i (i)}<div class={cls(ui, "card.approval.fact")}>{say(f.key, f.args)}</div>{/each}
+              {#each s.diff as d, i (i)}<div class={cls(ui, "card.approval.fact")}>{say(d.name, d.args)}: {d.before ?? "—"} ← {d.after ?? "—"}</div>{/each}
+            </li>
+          {/each}
+        </ol>
+        {#if needsCode(plan.method)}<Pin bind:value={code} label={t("card.code")} />{/if}
+        {#if failure}
+          <p class="g9a-note" role="alert" data-code={failure}>{failure === "confirm.waiting" ? t("card.waiting") : t("routine.failed")}{#if triesLeft !== null} · {t("card.tries_left", { count: triesLeft })}{/if}</p>
+        {/if}
+        <div class="g9a-row">
+          <button type="button" class={cls(ui, "card.approval.confirm")} disabled={busy || (needsCode(plan.method) && code.length === 0)} onclick={run}>{t("card.confirm")}</button>
+          <button type="button" class={cls(ui, "card.approval.refuse")} disabled={busy} onclick={() => { card = null; failure = null; }}>{t("card.refuse")}</button>
+        </div>
+      </div>
+    {:else}
+      <form class="g9a-routines__form" onsubmit={(e) => { e.preventDefault(); void preview(); }} novalidate>
+        {#each chosen.slots as slot (slot.name)}
+          {@const st = stateOf(slot)}
+          <div class="g9a-routines__slot" data-slot={slot.name} data-field={slot.field} data-state={st}>
+            {#if slot.field === "pick"}
+              <span class="g9a-routines__label">{labelOf(slot)}</span>
+              <Picker {slot} label={labelOf(slot)} picked={pickOf(slot.name)} onpick={(p: { id: string; label: string } | null) => {
+                const next = { ...picks };
+                if (p) next[slot.name] = p; else delete next[slot.name];
+                picks = next;
+              }} />
+            {:else}
+              <label for={"g9a-slot-" + slot.name}>{labelOf(slot)}</label>
+              <input id={"g9a-slot-" + slot.name} value={textOf(slot.name)} inputmode={slot.field === "number" || slot.field === "money" ? "decimal" : undefined}
+                aria-invalid={st !== "ok"} oninput={(e) => { typed = { ...typed, [slot.name]: e.currentTarget.value }; }} />
+            {/if}
+            {#if st !== "ok"}<span class="g9a-note" data-bad="true">{t(st === "missing" ? "routine.missing" : "routine.invalid")}</span>{/if}
+          </div>
+        {/each}
+        {#if failure}<p class="g9a-note" role="alert" data-code={failure}>{t("routine.failed")}</p>{/if}
+        <div class="g9a-row"><button type="submit" class="g9a-routines__preview" disabled={busy}>{t("routine.preview")}</button></div>
+      </form>
+    {/if}
+  {/if}
+</div>

package/dist/pages/RoutineWizard.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    onopen?: ((conversationId: string) => void) | undefined;
+};
+declare const RoutineWizard: import("svelte").Component<$$ComponentProps, {}, "">;
+type RoutineWizard = ReturnType<typeof RoutineWizard>;
+export default RoutineWizard;

package/dist/pages/SlotPicker.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+  // A routine's entity slot: a searchable picker over the host's things of the slot's kind (`GET pick`), asked a short
+  // while after the person stops typing; an answer that came after a newer question is dropped.
+  import { pageCalls, readPicks, type RoutineSlot } from "@g9tm/aiassistant/pages";
+  import { useUi } from "../context.js";
+  import { pageTexts } from "./texts.js";
+
+  let { slot, label, picked = null, onpick, delay = 250 }: {
+    slot: RoutineSlot; label: string; picked?: { id: string; label: string } | null; onpick: (pick: { id: string; label: string } | null) => void; delay?: number;
+  } = $props();
+  const ui = useUi();
+  const t = pageTexts(ui.texts).t;
+  let q = $state("");
+  let found = $state<{ id: string; label: string }[]>([]);
+  let asked = $state(false);
+  let failed = $state(false);
+  let handle: ReturnType<typeof setTimeout> | undefined;
+  let seq = 0;
+
+  function ask(text: string): void {
+    if (handle !== undefined) clearTimeout(handle);
+    const mine = ++seq;
+    handle = setTimeout(() => {
+      pageCalls.pick(ui.assistant.api, slot.kind, text.trim()).then((raw) => {
+        if (mine !== seq) return;
+        found = readPicks(raw);
+        asked = true;
+        failed = false;
+      }, () => {
+        if (mine === seq) failed = true;
+      });
+    }, delay);
+  }
+  $effect(() => () => { if (handle !== undefined) clearTimeout(handle); });
+</script>
+
+<div class="g9a-picker" data-slot={slot.name}>
+  {#if picked}
+    <span class="g9a-picker__chosen">{picked.label}</span>
+    <button type="button" class="g9a-picker__change" onclick={() => { onpick(null); q = ""; found = []; asked = false; }}>{t("routine.change")}</button>
+  {:else}
+    <input type="search" value={q} aria-label={label} placeholder={t("routine.search")}
+      oninput={(e) => { q = e.currentTarget.value; ask(q); }} onfocus={() => { if (!asked) ask(q); }} />
+    {#if failed}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+    {#if found.length > 0}
+      <ul class="g9a-picker__list" role="listbox" aria-label={label}>
+        {#each found as p (p.id)}
+          <li role="option" aria-selected="false"><button type="button" onclick={() => onpick(p)}>{p.label}</button></li>
+        {/each}
+      </ul>
+    {:else if asked}
+      <p class="g9a-note">{t("routine.none_found")}</p>
+    {/if}
+  {/if}
+</div>

package/dist/pages/SlotPicker.svelte.d.ts

@@ -0,0 +1,17 @@
+import { type RoutineSlot } from "@g9tm/aiassistant/pages";
+type $$ComponentProps = {
+    slot: RoutineSlot;
+    label: string;
+    picked?: {
+        id: string;
+        label: string;
+    } | null;
+    onpick: (pick: {
+        id: string;
+        label: string;
+    } | null) => void;
+    delay?: number;
+};
+declare const SlotPicker: import("svelte").Component<$$ComponentProps, {}, "">;
+type SlotPicker = ReturnType<typeof SlotPicker>;
+export default SlotPicker;

package/dist/pages/admin/AdminAudit.svelte

@@ -0,0 +1,33 @@
+<script lang="ts">
+  // The audit, newest first: steps run, cards answered, undos, gates and settings changed.
+  import type { AuditView } from "@g9tm/aiassistant/admin";
+  import { AdminClient, adminTexts } from "@g9tm/aiassistant/admin";
+  import { useUi } from "../../context.js";
+
+  const ui = useUi();
+  const t = adminTexts(ui.texts).t;
+  let rows = $state<AuditView[]>([]);
+  let error = $state<string | null>(null);
+
+  $effect(() => {
+    new AdminClient(ui.assistant.api).audit(200).then((r) => { rows = r; error = null; }, (e: unknown) => { error = e instanceof Error ? e.message : "error.network"; });
+  });
+</script>
+
+{#if error}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+{#if rows.length === 0 && !error}<p class="g9a-note">{t("admin.empty")}</p>{/if}
+<table>
+  <tbody>
+    {#each rows as a, i (i)}
+      <tr data-tainted={a.tainted}>
+        <td><time>{new Date(a.at).toLocaleString(ui.texts.locale)}</time></td>
+        <td>{a.user}</td>
+        <td>{a.actor}</td>
+        <td dir="ltr">{a.action}</td>
+        <td dir="ltr">{a.tool ?? ""}</td>
+        <td dir="ltr">{a.decision ?? ""}</td>
+        <td dir="ltr">{a.outcome ?? ""}</td>
+      </tr>
+    {/each}
+  </tbody>
+</table>

package/dist/pages/admin/AdminAudit.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const AdminAudit: import("svelte").Component<Record<string, never>, {}, "">;
+type AdminAudit = ReturnType<typeof AdminAudit>;
+export default AdminAudit;

package/dist/pages/admin/AdminCapabilities.svelte

@@ -0,0 +1,91 @@
+<script lang="ts">
+  // Capabilities as they run now; a manager changes the route, the limits or the switch without a release, and runs
+  // one entry-test probe at a time on the route's first model.
+  import type { CapabilityLimitsView, CapabilityView, ProbeView } from "@g9tm/aiassistant/admin";
+  import { AdminClient, adminTexts, parseRoute } from "@g9tm/aiassistant/admin";
+  import { useUi } from "../../context.js";
+
+  const ui = useUi();
+  const t = adminTexts(ui.texts).t;
+  const admin = new AdminClient(ui.assistant.api);
+  let list = $state<CapabilityView[]>([]);
+  let probes = $state<string[]>([]);
+  let routes = $state<Record<string, string>>({});
+  let error = $state<string | null>(null);
+  let results = $state<ProbeView[]>([]);
+  let busy = $state(false);
+
+  const FIELDS: [keyof CapabilityLimitsView, string][] = [
+    ["maxRounds", "admin.max_rounds"], ["perMinute", "admin.per_minute"], ["perPersonPerDay", "admin.per_person_day"],
+    ["perTenantPerDay", "admin.per_space_day"], ["monthlyTokenBudget", "admin.monthly_tokens"],
+  ];
+
+  async function load(): Promise<void> {
+    try {
+      const r = await admin.capabilities();
+      list = r.capabilities;
+      probes = r.probes;
+      routes = Object.fromEntries(r.capabilities.map((c) => [c.id, c.route.join(" > ")]));
+      error = null;
+    } catch (e) {
+      error = e instanceof Error ? e.message : "error.network";
+    }
+  }
+  $effect(() => { void load(); });
+
+  function replace(c: CapabilityView): void {
+    list = list.map((x) => (x.id === c.id ? c : x));
+    routes = { ...routes, [c.id]: c.route.join(" > ") };
+  }
+
+  async function save(c: CapabilityView): Promise<void> {
+    const route = parseRoute(new Map(Object.entries(routes)).get(c.id) ?? "");
+    try {
+      replace(await admin.setCapability(c.id, { route, limits: c.limits, enabled: c.enabled }));
+    } catch (e) {
+      error = e instanceof Error ? e.message : "error.network";
+    }
+  }
+
+  async function reset(c: CapabilityView): Promise<void> {
+    try { replace(await admin.resetCapability(c.id)); } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+
+  async function probeAll(c: CapabilityView): Promise<void> {
+    const model = c.route.at(0);
+    if (!model || busy) return;
+    busy = true;
+    results = [];
+    for (const p of probes) {
+      // one probe per request: each shows as it ends
+      try { results = [...results, await admin.probe(p, model)]; } catch { results = [...results, { probe: p, model, quality: "error", rightKind: false, tokensIn: 0, ms: 0, head: null, error: "error.network" }]; }
+    }
+    busy = false;
+  }
+</script>
+
+{#if error}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+{#if list.length === 0 && !error}<p class="g9a-note">{t("admin.empty")}</p>{/if}
+{#each list as c (c.id)}
+  <section class="g9a-admin-capability" data-overridden={c.overridden}>
+    <h4>{c.id} · {c.kind}{#if c.overridden} · <small>{t("admin.overridden")}</small>{/if}</h4>
+    <label>{t("admin.enabled")} <input type="checkbox" bind:checked={c.enabled} /></label>
+    <label>{t("admin.route")} <input dir="ltr" bind:value={routes[c.id]} /></label>
+    {#each FIELDS as [key, label] (key)}
+      <label>{t(label)} <input type="number" min="0" dir="ltr" bind:value={c.limits[key]} /></label>
+    {/each}
+    <div>
+      <button type="button" onclick={() => save(c)}>{t("admin.save")}</button>
+      {#if c.overridden}<button type="button" onclick={() => reset(c)}>{t("admin.reset")}</button>{/if}
+      {#if probes.length > 0 && c.route.length > 0}<button type="button" disabled={busy} onclick={() => probeAll(c)}>{t("admin.probe")}</button>{/if}
+    </div>
+  </section>
+{/each}
+{#if results.length > 0}
+  <h4>{t("admin.probe")}</h4>
+  <ul>
+    {#each results as r (r.probe)}
+      <li data-ok={r.rightKind}>{r.rightKind ? "✓" : "✗"} {r.probe} · {r.quality} · {r.tokensIn} · {r.ms} ms{#if r.error} · {r.error}{/if}</li>
+    {/each}
+  </ul>
+{/if}

package/dist/pages/admin/AdminCapabilities.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const AdminCapabilities: import("svelte").Component<Record<string, never>, {}, "">;
+type AdminCapabilities = ReturnType<typeof AdminCapabilities>;
+export default AdminCapabilities;

package/dist/pages/admin/AdminConnections.svelte

@@ -0,0 +1,58 @@
+<script lang="ts">
+  // The "Connections" group: other MCP servers (an address, a way in, a secret sent once, a test listing the
+  // tools as the assistant would name them, read-only or a change), with the route their traffic takes.
+  import { AdminClient, adminTexts } from "@g9tm/aiassistant/admin";
+  import type { McpServerView } from "@g9tm/aiassistant/admin";
+  import { useUi } from "../../context.js";
+
+  let { level = "app" }: { level?: string } = $props();
+  const ui = useUi();
+  const t = adminTexts(ui.texts).t;
+  const admin = new AdminClient(ui.assistant.api);
+  let client = $state(true);
+  let servers = $state<McpServerView[]>([]);
+  let tested = $state<{ id: string; ok: boolean; error: string | null; tools: { name: string; readOnly: boolean; allowed: boolean }[] } | null>(null);
+  let id = $state("");
+  let url = $state("");
+  let auth = $state("none");
+  let secret = $state("");
+  let error = $state<string | null>(null);
+
+  async function load(): Promise<void> {
+    try { const r = await admin.mcpServers(); client = r.client; servers = r.servers; error = null; } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+  $effect(() => { void load(); });
+
+  async function add(): Promise<void> {
+    if (!id.trim() || !url.trim()) return;
+    try {
+      await admin.saveMcpServer(id.trim(), { url: url.trim(), auth, secret: secret || undefined, level });
+      id = ""; url = ""; secret = "";
+      await load();
+    } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+</script>
+
+{#if error}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+<h4>{t("admin.mcp")}</h4>
+{#if !client}<p class="g9a-note">{t("admin.no_client")}</p>{/if}
+<ul>
+  {#each servers as s (s.id)}
+    <li data-enabled={s.enabled}>
+      <strong dir="ltr">{s.id}</strong> · <span dir="ltr">{s.url}</span> · {s.auth}{s.hasSecret ? " 🔒" : ""} · {s.level} · <span dir="ltr">{s.route}</span>
+      <button type="button" onclick={async () => { tested = { id: s.id, ...(await admin.testMcpServer(s.id).catch(() => ({ ok: false, error: "error.network", tools: [] }))) }; }}>{t("admin.test")}</button>
+      <button type="button" onclick={async () => { await admin.deleteMcpServer(s.id).catch(() => undefined); await load(); }}>{t("admin.remove")}</button>
+    </li>
+  {/each}
+</ul>
+{#if tested}
+  <p>{tested.id}: {tested.ok ? "✓" : "✗ " + (tested.error ?? "")}</p>
+  <ul>{#each tested.tools as x (x.name)}<li dir="ltr" data-allowed={x.allowed}>{x.name} {x.readOnly ? "(read)" : "(change)"}</li>{/each}</ul>
+{/if}
+<form class="g9a-row" onsubmit={(e) => { e.preventDefault(); void add(); }}>
+  <input dir="ltr" bind:value={id} placeholder="name" aria-label="name" />
+  <input dir="ltr" bind:value={url} placeholder="https://…/mcp" aria-label="url" />
+  <select bind:value={auth} aria-label="auth"><option value="none">none</option><option value="bearer">bearer</option></select>
+  {#if auth !== "none"}<input dir="ltr" type="password" bind:value={secret} placeholder={t("admin.secret")} aria-label={t("admin.secret")} autocomplete="off" />{/if}
+  <button type="submit">{t("admin.add")}</button>
+</form>

package/dist/pages/admin/AdminConnections.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    level?: string;
+};
+declare const AdminConnections: import("svelte").Component<$$ComponentProps, {}, "">;
+type AdminConnections = ReturnType<typeof AdminConnections>;
+export default AdminConnections;

package/dist/pages/admin/AdminFeedback.svelte

@@ -0,0 +1,38 @@
+<script lang="ts">
+  // The agents' suggestions: a repeat counts on one row; the manager marks each and leaves a note. The two
+  // knowledge budgets are shown as bars above.
+  import { AdminClient, adminTexts } from "@g9tm/aiassistant/admin";
+  import type { FeedbackView } from "@g9tm/aiassistant/admin";
+  import { useUi } from "../../context.js";
+
+  const ui = useUi();
+  const t = adminTexts(ui.texts).t;
+  const admin = new AdminClient(ui.assistant.api);
+  let rows = $state<FeedbackView[]>([]);
+  let budget = $state<{ notes: number; maxNotes: number; pinnedChars: number; maxPinnedChars: number } | null>(null);
+  const STATES = ["new", "seen", "planned", "done", "dismissed"];
+
+  async function load(): Promise<void> {
+    rows = (await admin.agentFeedback().catch(() => ({ fresh: 0, rows: [] }))).rows;
+    budget = await admin.budget().catch(() => null);
+  }
+  $effect(() => { void load(); });
+</script>
+
+{#if budget}
+  <p>{t("admin.budget", { notes: budget.notes, max: budget.maxNotes, chars: budget.pinnedChars, maxChars: budget.maxPinnedChars })}</p>
+  <progress max={budget.maxNotes} value={budget.notes}></progress>
+  <progress max={budget.maxPinnedChars} value={budget.pinnedChars}></progress>
+{/if}
+{#if rows.length === 0}<p class="g9a-note">{t("admin.empty")}</p>{/if}
+<ul>
+  {#each rows as f (f.id)}
+    <li data-status={f.status}>
+      <strong>{f.title}</strong> · {f.kind} · ×{f.count}
+      {#if f.detail}<p>{f.detail}</p>{/if}
+      <select value={f.status} aria-label={f.title} onchange={async (e) => { await admin.setFeedback(f.id, (e.currentTarget as HTMLSelectElement).value).catch(() => undefined); await load(); }}>
+        {#each STATES as s (s)}<option value={s}>{s}</option>{/each}
+      </select>
+    </li>
+  {/each}
+</ul>

package/dist/pages/admin/AdminFeedback.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const AdminFeedback: import("svelte").Component<Record<string, never>, {}, "">;
+type AdminFeedback = ReturnType<typeof AdminFeedback>;
+export default AdminFeedback;

package/dist/pages/admin/AdminModels.svelte

@@ -0,0 +1,103 @@
+<script lang="ts">
+  // The "Models" group: providers (from a preset, a key sent once, a test that reads the models), the host's
+  // backends with their usage windows, and the gateway's keys (a key shown once) and its request log.
+  import { AdminClient, adminTexts } from "@g9tm/aiassistant/admin";
+  import type { ProviderView, WindowSetView } from "@g9tm/aiassistant/admin";
+  import { useUi } from "../../context.js";
+
+  let { level = "app" }: { level?: string } = $props();
+  const ui = useUi();
+  const t = adminTexts(ui.texts).t;
+  const admin = new AdminClient(ui.assistant.api);
+  let providers = $state<ProviderView[]>([]);
+  let presets = $state<{ id: string; baseUrl: string }[]>([]);
+  let backends = $state<{ id: string; state: string; until: string | null; usage: WindowSetView | null }[]>([]);
+  let keys = $state<{ id: string; name: string; revoked: boolean; lastUsedAt: string | null }[]>([]);
+  let log = $state<{ count: number; errors: number; tokens: number }>({ count: 0, errors: 0, tokens: 0 });
+  let preset = $state("");
+  let newId = $state("");
+  let secret = $state("");
+  let keyName = $state("");
+  let shown = $state<string | null>(null);
+  let error = $state<string | null>(null);
+
+  async function load(): Promise<void> {
+    try {
+      const p = await admin.providers();
+      providers = p.providers;
+      presets = p.presets;
+      backends = await admin.backends().catch(() => []);
+      keys = await admin.gatewayKeys().catch(() => []);
+      log = await admin.gatewayRequests(1).catch(() => ({ count: 0, errors: 0, tokens: 0, rows: [] }));
+      error = null;
+    } catch (e) {
+      error = e instanceof Error ? e.message : "error.network";
+    }
+  }
+  $effect(() => { void load(); });
+
+  async function add(): Promise<void> {
+    const id = (newId || preset).trim();
+    if (!id) return;
+    try {
+      await admin.saveProvider(id, { preset: preset || undefined, secret: secret || undefined, level });
+      secret = "";
+      newId = "";
+      await load();
+    } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+
+  async function test(id: string): Promise<void> {
+    try { const p = await admin.testProvider(id); providers = providers.map((x) => (x.id === id ? p : x)); } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+
+  async function makeKey(): Promise<void> {
+    if (!keyName.trim()) return;
+    try { shown = await admin.createGatewayKey(keyName.trim()); keyName = ""; await load(); } catch (e) { error = e instanceof Error ? e.message : "error.network"; }
+  }
+</script>
+
+{#if error}<p class="g9a-note" role="alert">{t("error.network")}</p>{/if}
+<h4>{t("admin.providers")}</h4>
+<ul>
+  {#each providers as p (p.id)}
+    <li data-state={p.state}>
+      <strong dir="ltr">{p.id}</strong> · {p.state} · {p.level} · <span dir="ltr">{p.route}</span>{#if p.defaultModel} · <span dir="ltr">{p.defaultModel}</span>{/if} · {p.models.length}
+      <button type="button" onclick={() => test(p.id)}>{t("admin.test")}</button>
+      <button type="button" onclick={async () => { await admin.deleteProvider(p.id).catch(() => undefined); await load(); }}>{t("admin.remove")}</button>
+    </li>
+  {/each}
+</ul>
+<form class="g9a-row" onsubmit={(e) => { e.preventDefault(); void add(); }}>
+  <select bind:value={preset} aria-label={t("admin.providers")}>
+    <option value="">—</option>
+    {#each presets as x (x.id)}<option value={x.id}>{x.id}</option>{/each}
+  </select>
+  <input dir="ltr" bind:value={newId} placeholder="id" aria-label="id" />
+  <input dir="ltr" type="password" bind:value={secret} placeholder={t("admin.secret")} aria-label={t("admin.secret")} autocomplete="off" />
+  <button type="submit">{t("admin.add")}</button>
+</form>
+
+{#if backends.length > 0}
+  <h4>{t("admin.backends")}</h4>
+  <ul>
+    {#each backends as b (b.id)}
+      <li data-state={b.state}><span dir="ltr">{b.id}</span> · {b.state}{#if b.until} · {new Date(b.until).toLocaleString(ui.texts.locale)}{/if}
+        {#each b.usage?.windows ?? [] as w (w.name)} · {w.name} {Math.round(w.usedPercent)}%{/each}</li>
+    {/each}
+  </ul>
+{/if}
+
+<h4>{t("admin.gateway")}</h4>
+<p>{log.count} · ✗ {log.errors} · {log.tokens}</p>
+{#if shown}<p class="g9a-note">{t("admin.key_once")} <code dir="ltr">{shown}</code></p>{/if}
+<ul>
+  {#each keys as k (k.id)}
+    <li data-revoked={k.revoked}>{k.name}{#if k.lastUsedAt} · {new Date(k.lastUsedAt).toLocaleString(ui.texts.locale)}{/if}
+      {#if !k.revoked}<button type="button" onclick={async () => { await admin.revokeGatewayKey(k.id).catch(() => undefined); await load(); }}>{t("admin.remove")}</button>{/if}</li>
+  {/each}
+</ul>
+<form class="g9a-row" onsubmit={(e) => { e.preventDefault(); void makeKey(); }}>
+  <input bind:value={keyName} placeholder={t("admin.gateway")} aria-label={t("admin.gateway")} />
+  <button type="submit">{t("admin.add")}</button>
+</form>

package/dist/pages/admin/AdminModels.svelte.d.ts

@@ -0,0 +1,6 @@
+type $$ComponentProps = {
+    level?: string;
+};
+declare const AdminModels: import("svelte").Component<$$ComponentProps, {}, "">;
+type AdminModels = ReturnType<typeof AdminModels>;
+export default AdminModels;