@olares/lares-core 0.15.0

package/larepass/session-cache.js

@@ -0,0 +1,104 @@
+import { mergeEvents } from "./transcript.js";
+
+function emptyPage() {
+  return {
+    events: [],
+    scroll: { top: 0, stick: true },
+    ready: false,
+  };
+}
+
+function eventStamp(event) {
+  return `${event.seq}\0${event.type}\0${JSON.stringify(event.data)}\0${JSON.stringify(event.view ?? null)}`;
+}
+
+export function eventsUpdated(prev, next) {
+  if (prev === next) return false;
+  if (!Array.isArray(prev) || !Array.isArray(next) || prev.length !== next.length) return true;
+  for (let i = 0; i < next.length; i += 1) {
+    if (prev[i] === next[i]) continue;
+    if (eventStamp(prev[i]) !== eventStamp(next[i])) return true;
+  }
+  return false;
+}
+
+export function createSessionCache() {
+  const pages = new Map();
+  const loads = new Map();
+
+  function peek(sessionId) {
+    return sessionId ? pages.get(sessionId) ?? null : null;
+  }
+
+  function ensure(sessionId) {
+    let page = peek(sessionId);
+    if (page) return page;
+    page = emptyPage();
+    pages.set(sessionId, page);
+    return page;
+  }
+
+  function commit(sessionId, extra, ready) {
+    if (!sessionId) return false;
+    const page = ensure(sessionId);
+    const next = extra?.length ? mergeEvents(page.events, extra) : page.events;
+    const changed = eventsUpdated(page.events, next);
+    if (changed) page.events = next;
+    let flipped = false;
+    if (ready && !page.ready) {
+      page.ready = true;
+      flipped = true;
+    }
+    return changed || flipped;
+  }
+
+  return {
+    peek,
+    events(sessionId) {
+      return peek(sessionId)?.events ?? [];
+    },
+    scroll(sessionId) {
+      return peek(sessionId)?.scroll ?? { top: 0, stick: true };
+    },
+    ready(sessionId) {
+      return Boolean(peek(sessionId)?.ready);
+    },
+    loading(sessionId) {
+      return Boolean(sessionId) && loads.has(sessionId);
+    },
+    merge(sessionId, extra) {
+      return commit(sessionId, extra, false);
+    },
+    rememberHistory(sessionId, extra) {
+      return commit(sessionId, extra, true);
+    },
+    readyEmpty(sessionId) {
+      if (!sessionId) return;
+      const page = ensure(sessionId);
+      if (page.events.length === 0) page.ready = true;
+    },
+    drop(sessionId) {
+      if (!sessionId) return;
+      pages.delete(sessionId);
+      loads.delete(sessionId);
+    },
+    setScroll(sessionId, scroll) {
+      if (!sessionId || !scroll) return;
+      ensure(sessionId).scroll = scroll;
+    },
+    load(sessionId, start) {
+      if (!sessionId) return Promise.resolve();
+      const pending = loads.get(sessionId);
+      if (pending) return pending;
+      const job = Promise.resolve().then(start).finally(() => {
+        if (loads.get(sessionId) === job) loads.delete(sessionId);
+      });
+      loads.set(sessionId, job);
+      return job;
+    },
+    clear() {
+      pages.clear();
+      loads.clear();
+    },
+  };
+}

package/larepass/settings.js

@@ -0,0 +1,100 @@
+import { createSnapshotStore } from "../tools/async.js";
+
+const modelsStore = createSnapshotStore();
+const voiceStore = createSnapshotStore();
+const searchStore = createSnapshotStore();
+
+function fail(res, path) {
+  const err = res?.body?.error;
+  throw new Error(err?.message || err?.code || `${path} ${res?.status ?? ""}`.trim());
+}
+
+function payload(res, path) {
+  if (!res?.ok) fail(res, path);
+  return res.body;
+}
+
+function sttModels(body) {
+  const list = Array.isArray(body?.stt) ? body.stt : [];
+  return list.map((item) => (typeof item === "string" ? item : item?.id)).filter(Boolean);
+}
+
+export function rememberedSettings() {
+  return {
+    models: modelsStore.peek(),
+    voice: voiceStore.peek(),
+    search: searchStore.peek(),
+  };
+}
+
+export function resetHostSettingsCache() {
+  modelsStore.remember(null);
+  voiceStore.remember(null);
+  searchStore.remember(null);
+}
+
+export function createHostSettings(request) {
+  return {
+    async models(options = {}) {
+      return modelsStore.load(
+        async () => payload(await request("/api/lares/models"), "/api/lares/models"),
+        options,
+      );
+    },
+    async refreshModels() {
+      return modelsStore.remember(
+        payload(
+          await request("/api/lares/models/refresh", { method: "POST" }),
+          "/api/lares/models/refresh",
+        ),
+      );
+    },
+    async setDefaultModel(selection) {
+      return modelsStore.remember(
+        payload(
+          await request("/api/lares/models/default", { method: "POST", body: selection }),
+          "/api/lares/models/default",
+        ),
+      );
+    },
+    async voice(force = false) {
+      return voiceStore.load(async () => {
+        const query = force ? "?refresh=1" : "";
+        const [config, status, models] = await Promise.all([
+          request("/api/lares/voice/config"),
+          request(`/api/lares/voice/status${query}`),
+          request(`/api/lares/voice/models${query}`),
+        ]);
+        return {
+          config: payload(config, "/api/lares/voice/config"),
+          status: payload(status, "/api/lares/voice/status"),
+          sttModels: sttModels(payload(models, "/api/lares/voice/models")),
+        };
+      }, { force: Boolean(force) });
+    },
+    async saveVoice(patch) {
+      payload(
+        await request("/api/lares/voice/config", { method: "POST", body: patch }),
+        "/api/lares/voice/config",
+      );
+      return this.voice(true);
+    },
+    async search(options = {}) {
+      return searchStore.load(
+        async () => payload(await request("/api/lares/web-search/config"), "/api/lares/web-search/config"),
+        options,
+      );
+    },
+    async setSearchDefault(id) {
+      return searchStore.remember(
+        payload(
+          await request("/api/lares/web-search/config/default", {
+            method: "POST",
+            body: { defaultSearchModel: id },
+          }),
+          "/api/lares/web-search/config/default",
+        ),
+      );
+    },
+  };
+}

package/larepass/stage-copy.js

@@ -0,0 +1,16 @@
+/** Stage chrome copy matches dsh conversation EN / design literals, not locale. */
+
+export const STAGE_COPY = {
+  think: "Think",
+  contextInjection: "Context injection",
+  contextRecall: "Session recall",
+  retry: {
+    active: "Retrying model request",
+    cancelled: "Model request retry cancelled",
+    started: "Retried model request",
+    scheduled: "Waiting to retry model request",
+    status: "{label} ({retry}/{maximum}) · {seconds}s",
+    delay: "Retry delay: ",
+    failure: "Failure reason: ",
+  },
+};

package/larepass/tool-row.js

@@ -0,0 +1,132 @@
+/** Same row model as dsh-client-ui-tool `toolRowModel` (titles are design literals). */
+
+const VARIANT_TITLES = {
+  search: "Search",
+  read: "Read",
+  bash: "Bash",
+  write: "Write",
+  edit: "Edit",
+  code: "Code",
+  others: "Tool call",
+};
+
+const TOOL_VARIANTS = {
+  bash: "bash",
+  pwsh: "bash",
+  read: "read",
+  web_fetch: "read",
+  web_search: "search",
+  grep: "search",
+  glob: "search",
+  write: "write",
+  edit: "edit",
+  run_code: "code",
+  cordis_package_inspect: "read",
+  cordis_runtime_inspect: "read",
+  cordis_run: "others",
+  cordis_stop: "others",
+  cordis_undefine: "others",
+};
+
+const TOOL_TITLES = {
+  cordis_package_inspect: "Inspect",
+  cordis_runtime_inspect: "Inspect",
+  cordis_run: "Run Cordis Plugin",
+  cordis_stop: "Stop Cordis Plugin",
+  cordis_undefine: "Remove Cordis Plugin",
+  pwsh: "Pwsh",
+};
+
+const SUMMARY_KEYS = {
+  bash: ["description", "command"],
+  read: ["path", "file_path", "url"],
+  search: ["query", "pattern", "url"],
+  write: ["path", "file_path"],
+  edit: ["path", "file_path"],
+  code: ["description"],
+  others: [],
+};
+
+function firstLine(text) {
+  const newline = String(text ?? "").indexOf("\n");
+  return newline === -1 ? String(text ?? "") : String(text).slice(0, newline);
+}
+
+function parseArgs(argsRaw) {
+  try {
+    return JSON.parse(argsRaw);
+  } catch {
+    return undefined;
+  }
+}
+
+function pickString(args, keys) {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === "string" && value !== "") return value;
+  }
+}
+
+function deriveSummary(variant, argsRaw) {
+  const parsed = parseArgs(argsRaw);
+  if (typeof parsed !== "object" || parsed === null) return firstLine(argsRaw);
+  if (variant === "search" && Array.isArray(parsed.queries)) {
+    const queries = parsed.queries.filter((query) => typeof query === "string" && query !== "");
+    if (queries.length > 0) return queries.map(firstLine).join(", ");
+  }
+  const picked = pickString(parsed, SUMMARY_KEYS[variant]);
+  if (picked !== undefined) return firstLine(picked);
+  for (const value of Object.values(parsed)) {
+    if (typeof value === "string" && value !== "") return firstLine(value);
+  }
+  return firstLine(argsRaw);
+}
+
+const BODY_KEYS = {
+  write: ["contents", "content", "code"],
+  edit: ["new_string", "newString", "contents", "content"],
+  code: ["code"],
+};
+
+function deriveBody(variant, argsRaw) {
+  if (!argsRaw) return "";
+  const parsed = parseArgs(argsRaw);
+  if (parsed === undefined) return argsRaw;
+  const text = pickString(parsed, BODY_KEYS[variant] ?? []);
+  if (text !== undefined) return text;
+  return JSON.stringify(parsed, null, 2);
+}
+
+export function classifyTool(toolName) {
+  return TOOL_VARIANTS[toolName] ?? "others";
+}
+
+const VARIANT_ICONS = {
+  search: "search",
+  read: "browse",
+  bash: "api",
+  write: "edit",
+  edit: "edit",
+  code: "code",
+  others: "sparkle",
+};
+
+export function toolVariantIcon(variant) {
+  return VARIANT_ICONS[variant] ?? "sparkle";
+}
+
+export function toolRowModel(toolName, argsRaw = "") {
+  const name = String(toolName || "");
+  const variant = classifyTool(name);
+  const base = argsRaw === "" ? "" : deriveSummary(variant, argsRaw);
+  const toolTitle = TOOL_TITLES[name];
+  const summary = variant === "others" && name && toolTitle === undefined && base
+    ? `${name} · ${base}`
+    : base;
+  return {
+    variant,
+    title: toolTitle ?? VARIANT_TITLES[variant],
+    summary,
+    body: deriveBody(variant, argsRaw),
+  };
+}

package/larepass/transcript.js

@@ -0,0 +1,332 @@
+import { producedPathsFromView } from "../files/deliverables.js";
+import { contextForm, contextProvenance, isHumanUserSource } from "./context-provenance.js";
+import { toolRowModel } from "./tool-row.js";
+
+export function textFromBlocks(blocks) {
+  if (!Array.isArray(blocks)) return "";
+  return blocks
+    .filter((block) => block?.type === "text" && typeof block.text === "string")
+    .map((block) => block.text)
+    .join("");
+}
+
+function eventOf(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const event = "event" in entry && entry.event ? entry.event : entry;
+  return event && typeof event === "object" ? event : null;
+}
+
+function entryView(entry, event) {
+  return entry?.view ?? event?.view ?? null;
+}
+
+export function mergeEvents(base, extra) {
+  const bySeq = new Map();
+  for (const item of [...(Array.isArray(base) ? base : []), ...(Array.isArray(extra) ? extra : [])]) {
+    const event = eventOf(item);
+    if (!event || typeof event.seq !== "number") continue;
+    const view = entryView(item, event);
+    bySeq.set(event.seq, view ? { ...event, view } : event);
+  }
+  return [...bySeq.entries()]
+    .sort((left, right) => left[0] - right[0])
+    .map(([, event]) => event);
+}
+
+function callViewOf(view) {
+  return view?.for === "call" ? view.view : null;
+}
+
+function resultViewOf(view) {
+  return view?.for === "result" ? view.view : null;
+}
+
+function resultCallId(data) {
+  return data?.message?.source?.callId || data?.callId || "";
+}
+
+function resultIsError(data) {
+  if (data?.error) return true;
+  const blocks = data?.message?.content;
+  return Array.isArray(blocks) && blocks.some((block) => block?.isError);
+}
+
+function retrySeconds(milliseconds) {
+  return Math.max(1, Math.ceil(Number(milliseconds) / 1000) || 1);
+}
+
+function blockKey(turn, step, index) {
+  return `${turn ?? 0}:${step ?? 0}:${index ?? 0}`;
+}
+
+function messagesFromItems(items) {
+  const messages = [];
+  for (const item of items) {
+    if (item.type === "user") messages.push({ role: "user", text: item.text });
+    if (item.type === "assistant") {
+      messages.push({
+        role: "assistant",
+        text: item.text,
+        ...(item.pending ? { pending: true } : {}),
+      });
+    }
+  }
+  return messages;
+}
+
+function upsert(items, indexOf, key, row) {
+  if (indexOf.has(key)) {
+    Object.assign(items[indexOf.get(key)], row);
+    return items[indexOf.get(key)];
+  }
+  items.push(row);
+  indexOf.set(key, items.length - 1);
+  return row;
+}
+
+function settleOpen(items, running) {
+  for (const row of items) {
+    if (row.type === "reasoning") row.running = Boolean(running && row.running);
+    if (row.type === "assistant" && !running) delete row.pending;
+    if (row.type === "retry" && !running && row.retryState === "scheduled") {
+      row.retryState = "cancelled";
+    }
+  }
+}
+
+export function foldTranscript(entries) {
+  const items = [];
+  const blocks = new Map();
+  const tools = new Map();
+  const retries = new Map();
+  const fileSeen = new Set();
+  let files = [];
+  let filesAt = -1;
+  let running = false;
+  let error = "";
+  let streamCursor = { loc: "", kind: "", index: 0 };
+
+  const rememberFile = (path) => {
+    if (!path || fileSeen.has(path)) return;
+    fileSeen.add(path);
+    files.push(path);
+  };
+
+  const syncFiles = () => {
+    if (!files.length) return;
+    if (filesAt >= 0) {
+      items[filesAt].paths = [...files];
+      return;
+    }
+    items.push({ type: "files", paths: [...files] });
+    filesAt = items.length - 1;
+  };
+
+  const closeTurn = () => {
+    running = false;
+    for (const row of items) {
+      if (row.type === "reasoning") row.running = false;
+      if (row.type === "assistant") delete row.pending;
+    }
+    syncFiles();
+  };
+
+  const putBlock = (turn, step, index, row) => {
+    upsert(items, blocks, blockKey(turn, step, index), row);
+  };
+
+  const chunkIndex = (data, chunk) => {
+    if (typeof chunk.index === "number") return chunk.index;
+    const loc = `${data.turn ?? 0}:${data.step ?? 0}`;
+    const kind = chunk.type === "reasoning-delta" || chunk.block?.type === "reasoning"
+      ? "reasoning"
+      : chunk.type === "text-delta" || chunk.block?.type === "text"
+        ? "text"
+        : chunk.type;
+    if (streamCursor.loc !== loc || streamCursor.kind !== kind) {
+      streamCursor.index = streamCursor.loc === loc ? streamCursor.index + 1 : 0;
+      streamCursor.loc = loc;
+      streamCursor.kind = kind;
+    }
+    return streamCursor.index;
+  };
+
+  const applyChunk = (data) => {
+    const chunk = data?.chunk;
+    if (!chunk || typeof chunk !== "object") return;
+    const turn = data.turn;
+    const step = data.step;
+    const index = chunkIndex(data, chunk);
+    if (chunk.type === "text-delta" && typeof chunk.text === "string") {
+      const prev = blocks.has(blockKey(turn, step, index))
+        ? items[blocks.get(blockKey(turn, step, index))]
+        : null;
+      const text = `${prev?.type === "assistant" ? prev.text : ""}${chunk.text}`;
+      putBlock(turn, step, index, {
+        type: "assistant",
+        text,
+        ...(running ? { pending: true } : {}),
+      });
+      return;
+    }
+    if (chunk.type === "reasoning-delta" && typeof chunk.text === "string") {
+      const prev = blocks.has(blockKey(turn, step, index))
+        ? items[blocks.get(blockKey(turn, step, index))]
+        : null;
+      const text = `${prev?.type === "reasoning" ? prev.text : ""}${chunk.text}`;
+      putBlock(turn, step, index, {
+        type: "reasoning",
+        text,
+        running: Boolean(running),
+      });
+      return;
+    }
+    if (chunk.type === "block-end" && chunk.block?.type === "text" && typeof chunk.block.text === "string") {
+      putBlock(turn, step, index, {
+        type: "assistant",
+        text: chunk.block.text,
+        ...(running ? { pending: true } : {}),
+      });
+      return;
+    }
+    if (chunk.type === "block-end" && chunk.block?.type === "reasoning" && typeof chunk.block.text === "string") {
+      putBlock(turn, step, index, {
+        type: "reasoning",
+        text: chunk.block.text,
+        running: Boolean(running),
+      });
+    }
+  };
+
+  const applyAssistantMessage = (data) => {
+    const content = data?.message?.content;
+    const turn = data?.turn ?? data?.message?.turn;
+    const step = data?.step ?? data?.message?.step;
+    if (!Array.isArray(content)) return;
+    content.forEach((block, index) => {
+      if (block?.type === "reasoning" && typeof block.text === "string") {
+        putBlock(turn, step, index, { type: "reasoning", text: block.text, running: false });
+        return;
+      }
+      if (block?.type === "text" && typeof block.text === "string") {
+        putBlock(turn, step, index, { type: "assistant", text: block.text });
+      }
+    });
+  };
+
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const event = eventOf(entry);
+    if (!event) continue;
+    const data = event.data ?? {};
+    const view = entryView(entry, event);
+
+    if (event.type === "turn/start") {
+      closeTurn();
+      files = [];
+      fileSeen.clear();
+      filesAt = -1;
+      running = true;
+      error = "";
+      continue;
+    }
+
+    if (event.type === "turn/end") {
+      if (data.reason?.kind === "error") {
+        error = data.reason.error?.message || "turn failed";
+      }
+      closeTurn();
+      continue;
+    }
+
+    if (event.type === "user/message") {
+      const text = textFromBlocks(data.content);
+      if (isHumanUserSource(data.source)) {
+        if (text) items.push({ type: "user", text });
+        continue;
+      }
+      const provenance = contextProvenance(data.source);
+      items.push({
+        type: "context",
+        role: provenance.role,
+        label: provenance.label,
+        form: contextForm(data.source),
+        text,
+      });
+      continue;
+    }
+
+    if (event.type === "assistant/message") {
+      applyAssistantMessage(data);
+      continue;
+    }
+
+    if (event.type === "assistant/chunk") {
+      applyChunk(data);
+      continue;
+    }
+
+    if (event.type === "tool/call") {
+      const callView = callViewOf(view);
+      const argsRaw = typeof data.arguments === "string" ? data.arguments : "";
+      const model = toolRowModel(data.name, argsRaw);
+      const row = {
+        type: "tool",
+        callId: data.callId,
+        name: data.name,
+        status: "running",
+        argsRaw,
+        paths: producedPathsFromView(callView),
+        ...model,
+      };
+      items.push(row);
+      if (data.callId) tools.set(data.callId, items.length - 1);
+      continue;
+    }
+
+    if (event.type === "tool/result") {
+      const id = resultCallId(data);
+      const index = tools.get(id);
+      const tool = index === undefined ? null : items[index];
+      if (tool) {
+        tool.status = resultIsError(data) ? "error" : "done";
+        const resultView = resultViewOf(view);
+        if (resultView?.title) tool.title = resultView.title;
+        if (tool.status === "done") {
+          for (const path of tool.paths) rememberFile(path);
+        }
+      }
+      continue;
+    }
+
+    if (event.type === "llm/retry") {
+      const retryId = data.retryId || String(event.seq ?? items.length);
+      upsert(items, retries, retryId, {
+        type: "retry",
+        retryId,
+        retry: data.retry,
+        maxRetries: data.maxRetries,
+        mode: data.mode,
+        delayMs: data.delayMs,
+        seconds: retrySeconds(data.delayMs),
+        failure: data.failure,
+        retryState: "scheduled",
+      });
+      continue;
+    }
+
+    if (event.type === "llm/retry-started") {
+      const retryId = data.retryId;
+      const index = retries.get(retryId);
+      if (index !== undefined) items[index].retryState = "started";
+    }
+  }
+
+  settleOpen(items, running);
+  if (running) syncFiles();
+  return {
+    items,
+    messages: messagesFromItems(items),
+    running,
+    error,
+  };
+}