@olares/lares-core 0.15.4 → 0.15.6

package/larepass/submission-settings.js

@@ -0,0 +1,26 @@
+export const CONVERSATION_SETTINGS_NAMESPACE = "ui-conversation";
+export const DEFAULT_BUSY_ENTER = "queue";
+
+export function busyEnterBehavior(value) {
+  return value === "steer" ? "steer" : DEFAULT_BUSY_ENTER;
+}
+
+export function resolveSubmitMode(running, accelerated, steeringAvailable, preferred) {
+  if (!running || !steeringAvailable) return "queue";
+  const busyEnter = busyEnterBehavior(preferred);
+  if (!accelerated) return busyEnter;
+  return busyEnter === "queue" ? "steer" : "queue";
+}
+
+export function conversationSettings(described) {
+  const rows = Array.isArray(described?.namespaces) ? described.namespaces : [];
+  const section = rows.find((row) => row?.ns === CONVERSATION_SETTINGS_NAMESPACE);
+  if (!section) {
+    return { busyEnter: DEFAULT_BUSY_ENTER, revision: undefined, writable: false };
+  }
+  return {
+    busyEnter: busyEnterBehavior(section.value?.busyEnter),
+    revision: Number.isInteger(section.revision) ? section.revision : undefined,
+    writable: described?.writable !== false,
+  };
+}

package/larepass/transcript.js

@@ -1,6 +1,7 @@
 import { producedPathsFromView } from "../files/deliverables.js";
 import { contextForm, contextProvenance, isHumanUserSource } from "./context-provenance.js";
 import { toolRowModel } from "./tool-row.js";
+import { createTurnMetrics } from "./turn-metrics.js";
 
 export function textFromBlocks(blocks) {
   if (!Array.isArray(blocks)) return "";
@@ -98,6 +99,8 @@ export function foldTranscript(entries) {
   const items = [];
   const blocks = new Map();
   const tools = new Map();
+  const metrics = createTurnMetrics();
+  const lastReply = new Map();
   const retries = new Map();
   const fileSeen = new Set();
   let files = [];
@@ -132,7 +135,10 @@ export function foldTranscript(entries) {
   };
 
   const putBlock = (turn, step, index, row) => {
-    upsert(items, blocks, blockKey(turn, step, index), row);
+    const stored = upsert(items, blocks, blockKey(turn, step, index), row);
+    // The turn's readings belong under its closing reply, the row whose action
+    // bar ends the turn on screen.
+    if (stored.type === "assistant") lastReply.set(Number(turn) || 0, stored);
   };
 
   const chunkIndex = (data, chunk) => {
@@ -219,6 +225,7 @@ export function foldTranscript(entries) {
     if (!event) continue;
     const data = event.data ?? {};
     const view = entryView(entry, event);
+    metrics.observe(event);
 
     if (event.type === "turn/start") {
       closeTurn();
@@ -322,6 +329,10 @@ export function foldTranscript(entries) {
   }
 
   settleOpen(items, running);
+  for (const [turn, row] of lastReply) {
+    const value = metrics.value(turn);
+    if (value) row.metrics = value;
+  }
   if (running) syncFiles();
   return {
     items,

package/larepass/turn-metrics.js

@@ -0,0 +1,142 @@
+/**
+ * Turn timings read off the session log the way the harness client reads them:
+ * the turn's own wall time, its first step's time to first token, and decode
+ * throughput over the steps that report both a first token and provider usage.
+ * Every event carries `time` (epoch ms), so nothing here needs a clock.
+ */
+
+function isTokenDelta(chunk) {
+  return chunk?.type === "text-delta" || chunk?.type === "reasoning-delta";
+}
+
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+export function createTurnMetrics() {
+  const turns = new Map();
+
+  const turnRow = (turn) => {
+    const key = Number(turn) || 0;
+    let row = turns.get(key);
+    if (!row) {
+      row = {
+        startTime: 0,
+        endTime: 0,
+        messageTime: 0,
+        ttftMs: null,
+        ttftStep: Infinity,
+        decodeMs: 0,
+        decodeTokens: 0,
+        steps: new Map(),
+      };
+      turns.set(key, row);
+    }
+    return row;
+  };
+
+  const stepRow = (row, step) => {
+    const key = Number(step) || 0;
+    let cell = row.steps.get(key);
+    if (!cell) {
+      cell = { startTime: 0, firstTokenTime: 0 };
+      row.steps.set(key, cell);
+    }
+    return cell;
+  };
+
+  return {
+    observe(event) {
+      const time = Number(event?.time) || 0;
+      if (!time) return;
+      const data = event.data ?? {};
+      const turn = data.turn ?? data.message?.turn;
+      const step = data.step ?? data.message?.step;
+      if (event.type === "turn/start") {
+        turnRow(turn).startTime = time;
+        return;
+      }
+      if (event.type === "turn/end") {
+        turnRow(turn).endTime = time;
+        return;
+      }
+      if (event.type === "step/start") {
+        stepRow(turnRow(turn), step).startTime = time;
+        return;
+      }
+      if (event.type === "assistant/chunk") {
+        if (!isTokenDelta(data.chunk)) return;
+        const cell = stepRow(turnRow(turn), step);
+        if (!cell.firstTokenTime) cell.firstTokenTime = time;
+        return;
+      }
+      if (event.type !== "assistant/message") return;
+      const row = turnRow(turn);
+      const index = Number(step) || 0;
+      const cell = stepRow(row, index);
+      row.messageTime = time;
+      // The turn shows its earliest step's latency; later steps answer a tool
+      // result rather than the person, so their wait is a different question.
+      if (cell.startTime && cell.firstTokenTime && index < row.ttftStep) {
+        row.ttftStep = index;
+        row.ttftMs = Math.max(0, cell.firstTokenTime - cell.startTime);
+      }
+      const outputTokens = Number(data.usage?.outputTokens);
+      if (cell.firstTokenTime && Number.isFinite(outputTokens) && outputTokens > 0) {
+        row.decodeMs += Math.max(0, time - cell.firstTokenTime);
+        row.decodeTokens += outputTokens;
+      }
+    },
+    /** Readings for a turn the log has closed; null while it is still open. */
+    value(turn) {
+      const row = turns.get(Number(turn) || 0);
+      if (!row?.startTime || !row.endTime) return null;
+      const metrics = {
+        time: row.messageTime || row.endTime,
+        runMs: Math.max(0, row.endTime - row.startTime),
+      };
+      if (row.ttftMs !== null) metrics.ttftMs = row.ttftMs;
+      if (row.decodeMs > 0 && row.decodeTokens > 0) {
+        metrics.tokensPerSecond = row.decodeTokens / (row.decodeMs / 1000);
+      }
+      return metrics;
+    },
+  };
+}
+
+/** Wall clock of the reply, plus the calendar scope a reader needs to place it. */
+export function clockParts(time, now = Date.now()) {
+  const at = new Date(Number(time) || 0);
+  const today = new Date(Number(now) || 0);
+  const sameYear = at.getFullYear() === today.getFullYear();
+  const sameDay = sameYear
+    && at.getMonth() === today.getMonth()
+    && at.getDate() === today.getDate();
+  return {
+    clock: `${pad2(at.getHours())}:${pad2(at.getMinutes())}`,
+    scope: sameDay ? "day" : sameYear ? "md" : "ymd",
+    y: at.getFullYear(),
+    m: at.getMonth() + 1,
+    d: at.getDate(),
+  };
+}
+
+/** Run time as whole seconds, carrying into minutes with padded seconds. */
+export function durationParts(ms) {
+  const total = Math.max(0, Math.floor((Number(ms) || 0) / 1000));
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  return { minutes, seconds: minutes > 0 ? pad2(seconds) : String(seconds) };
+}
+
+/** Sub-turn latency: one decimal under ten seconds, whole seconds beyond. */
+export function latencySeconds(ms) {
+  const seconds = Math.max(0, Number(ms) || 0) / 1000;
+  return seconds < 10 ? String(Math.round(seconds * 10) / 10) : String(Math.round(seconds));
+}
+
+/** Decode throughput: whole tokens from ten up, one decimal below. */
+export function throughputTokens(tokensPerSecond) {
+  const value = Math.max(0, Number(tokensPerSecond) || 0);
+  return value >= 10 ? String(Math.round(value)) : String(Math.round(value * 10) / 10);
+}

package/larepass/unread.js

@@ -0,0 +1,64 @@
+/**
+ * Which sessions moved on without being watched.
+ *
+ * The host has no read state to hand down: `session.list` carries `updatedAt`,
+ * `running` and `blank` and nothing else. The mux, however, streams events for
+ * every session at once, so a client knows about work landing in a session it
+ * is not showing. "Seen" is therefore decided here, per device, against the
+ * last moment each session was the open one.
+ */
+
+export const SEEN_STORAGE_KEY = "lares.session.seen";
+
+/**
+ * @param {unknown} value - whatever the store held, including nothing.
+ * @param {number} [now]
+ * @returns {{ since: number, sessions: Record<string, number> }}
+ */
+export function readSeen(value, now = Date.now()) {
+  const rows = value && typeof value === "object" ? value.sessions : null;
+  const sessions = {};
+  if (rows && typeof rows === "object") {
+    for (const [sessionId, at] of Object.entries(rows)) {
+      const stamp = Number(at);
+      if (sessionId && Number.isFinite(stamp) && stamp > 0) sessions[sessionId] = stamp;
+    }
+  }
+  const since = Number(value && typeof value === "object" ? value.since : 0);
+  return { since: Number.isFinite(since) && since > 0 ? since : now, sessions };
+}
+
+export function markSeen(seen, sessionId, at = Date.now()) {
+  if (!sessionId) return seen;
+  const previous = seen.sessions[sessionId] ?? 0;
+  const stamp = Math.max(previous, Number(at) || 0);
+  if (stamp === previous) return seen;
+  return { since: seen.since, sessions: { ...seen.sessions, [sessionId]: stamp } };
+}
+
+/** Forget rows the host no longer lists, so the store cannot grow forever. */
+export function pruneSeen(seen, sessions) {
+  const live = new Set((Array.isArray(sessions) ? sessions : []).map((row) => row?.sessionId).filter(Boolean));
+  const kept = Object.entries(seen.sessions).filter(([sessionId]) => live.has(sessionId));
+  if (kept.length === Object.keys(seen.sessions).length) return seen;
+  return { since: seen.since, sessions: Object.fromEntries(kept) };
+}
+
+/**
+ * A session never opened on this device is only news when it moved after
+ * tracking began — otherwise every history row would light up on first run.
+ * The open session is never marked: it is being watched right now.
+ *
+ * @returns {Record<string, true>} keyed by session id, for template lookups.
+ */
+export function unseenSessions(sessions, seen, openSessionId = "") {
+  const marks = {};
+  for (const row of Array.isArray(sessions) ? sessions : []) {
+    const sessionId = row?.sessionId;
+    if (!sessionId || sessionId === openSessionId || row.blank) continue;
+    const updatedAt = Number(row.updatedAt) || 0;
+    if (!updatedAt) continue;
+    if (updatedAt > (seen.sessions[sessionId] ?? seen.since)) marks[sessionId] = true;
+  }
+  return marks;
+}

package/larepass/workspace.js

@@ -0,0 +1,161 @@
+import { visibleHistorySessions } from "./chat.js";
+
+export const UNGROUPED_WORKSPACE = "";
+
+/** Rows a workspace group shows before the "show more" cut (Lares app parity). */
+export const COLLAPSED_SESSION_LIMIT = 5;
+
+export function collapsedSessions(sessions, expanded) {
+  const rows = Array.isArray(sessions) ? sessions : [];
+  return expanded ? rows : rows.slice(0, COLLAPSED_SESSION_LIMIT);
+}
+
+export function hiddenSessionCount(sessions) {
+  return Math.max(0, (Array.isArray(sessions) ? sessions.length : 0) - COLLAPSED_SESSION_LIMIT);
+}
+
+export const FLAT_SESSION_ORDER_KEY = "__flat_session_order__";
+
+export function reconciledSessionOrder(sessionIds, stored) {
+  if (!Array.isArray(stored)) return [...sessionIds];
+  const available = new Set(sessionIds);
+  const included = new Set();
+  const ordered = [];
+  for (const id of stored) {
+    if (!available.has(id) || included.has(id)) continue;
+    ordered.push(id);
+    included.add(id);
+  }
+  for (const id of sessionIds) {
+    if (!included.has(id)) ordered.push(id);
+  }
+  return ordered;
+}
+
+function compareSessionRecency(leftId, rightId, byId) {
+  const left = Number(byId.get(leftId)?.updatedAt) || 0;
+  const right = Number(byId.get(rightId)?.updatedAt) || 0;
+  if (left !== right) return right - left;
+  return leftId < rightId ? -1 : 1;
+}
+
+function sessionIdsByRecency(rows) {
+  const byId = new Map(rows.map((row) => [row.sessionId, row]));
+  return rows
+    .map((row) => row.sessionId)
+    .sort((left, right) => compareSessionRecency(left, right, byId));
+}
+
+export function nextSessionOrderAccount({
+  sessionIds,
+  previousOrder,
+  previousUpdatedAt = {},
+  sessions,
+  orderBy,
+  sortByRecency = false,
+}) {
+  const byId = new Map((Array.isArray(sessions) ? sessions : []).map((row) => [row.sessionId, row]));
+  let order = reconciledSessionOrder(sessionIds, previousOrder);
+  if (sortByRecency) {
+    order.sort((left, right) => compareSessionRecency(left, right, byId));
+  } else if (orderBy === "updated") {
+    const promoted = sessionIds
+      .filter((id) => {
+        const row = byId.get(id);
+        return row && (previousUpdatedAt[id] === undefined || Number(row.updatedAt) > previousUpdatedAt[id]);
+      })
+      .sort((left, right) => compareSessionRecency(left, right, byId));
+    if (promoted.length) {
+      const ids = new Set(promoted);
+      order = [...promoted, ...order.filter((id) => !ids.has(id))];
+    }
+  }
+  return {
+    order,
+    updatedAt: Object.fromEntries(sessionIds.flatMap((id) => {
+      const row = byId.get(id);
+      return row ? [[id, Number(row.updatedAt) || 0]] : [];
+    })),
+  };
+}
+
+export function workspaceForSession(workspaces, sessionId) {
+  if (!sessionId) return undefined;
+  return (Array.isArray(workspaces) ? workspaces : []).find(
+    (workspace) => Array.isArray(workspace?.sessionIds) && workspace.sessionIds.includes(sessionId),
+  );
+}
+
+export function normalizeWorkspaceList(value) {
+  return {
+    items: Array.isArray(value?.items) ? value.items.filter((row) => row?.workspaceId) : [],
+    archivedSessionIds: Array.isArray(value?.archivedSessionIds) ? value.archivedSessionIds : [],
+  };
+}
+
+export function groupWorkspaceSessions(
+  sessions,
+  workspaces,
+  archivedSessionIds = [],
+  { query = "", flat = false, currentSessionId = "", sessionOrderByAccount = {} } = {},
+) {
+  const archived = new Set(archivedSessionIds);
+  const normalizedQuery = String(query).trim().toLocaleLowerCase();
+  // Same visibility cut as the Lares app: archived rows never show, and a blank
+  // session is only ever the selected provisional one.
+  const visible = visibleHistorySessions(sessions, currentSessionId).filter((row) => {
+    if (archived.has(row.sessionId)) return false;
+    if (!normalizedQuery) return true;
+    return String(row.title || "").toLocaleLowerCase().includes(normalizedQuery);
+  });
+  const byId = new Map(visible.map((row) => [row.sessionId, row]));
+
+  if (flat) {
+    const baseIds = sessionIdsByRecency(visible);
+    const ids = reconciledSessionOrder(
+      baseIds,
+      sessionOrderByAccount[FLAT_SESSION_ORDER_KEY],
+    );
+    return [{
+      key: "__all__",
+      workspaceId: undefined,
+      title: "",
+      sessions: ids.map((id) => byId.get(id)).filter(Boolean),
+    }];
+  }
+
+  const accounted = new Set();
+  const groups = (Array.isArray(workspaces) ? workspaces : []).map((workspace) => {
+    const rows = [];
+    const ids = reconciledSessionOrder(
+      workspace.sessionIds ?? [],
+      sessionOrderByAccount[workspace.workspaceId],
+    );
+    for (const sessionId of ids) {
+      accounted.add(sessionId);
+      const row = byId.get(sessionId);
+      if (row) rows.push(row);
+    }
+    return {
+      key: workspace.workspaceId,
+      workspaceId: workspace.workspaceId,
+      title: workspace.title,
+      path: workspace.path,
+      sessions: rows,
+    };
+  });
+  const ungroupedRows = visible.filter((row) => !accounted.has(row.sessionId));
+  const ungrouped = reconciledSessionOrder(
+    sessionIdsByRecency(ungroupedRows),
+    sessionOrderByAccount[UNGROUPED_WORKSPACE],
+  ).map((id) => byId.get(id)).filter(Boolean);
+  if (ungrouped.length) {
+    groups.push({
+      key: UNGROUPED_WORKSPACE,
+      workspaceId: undefined,
+      title: "",
+      sessions: ungrouped,
+    });
+  }
+  return groups.filter((group) => !normalizedQuery || group.sessions.length > 0);
+}

package/olares/trusted-host.js

@@ -34,4 +34,13 @@ export function loopbackAuthority(port) {
 export function applyLoopbackHeaders(headers, authority) {
   headers.host = authority;
   if (headers.origin !== undefined) headers.origin = `http://${authority}`;
+  // Fetch Metadata outlives the origin rewrite. The browser decides this one and
+  // we cannot argue with it: a packaged page calling the entrance is `cross-site`
+  // however the host and origin now read, and dsh refuses that outright — the
+  // rewrite lands, the request is still 403. Restate it to match the loopback
+  // pair the two lines above just produced.
+  //
+  // Only secure contexts get `Sec-` headers at all, which is why the LAN
+  // entrance (plain http) never ran into this and the https one always did.
+  if (headers["sec-fetch-site"] !== undefined) headers["sec-fetch-site"] = "same-origin";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.4",
+  "version": "0.15.6",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {
@@ -61,6 +61,7 @@
     "./workspace/env": "./workspace/env.js",
     "./workspace/home": "./workspace/home.js",
     "./workspace/path": "./workspace/path.js",
+    "./workspace/constants": "./workspace/constants.js",
     "./workspace/seed": "./workspace/seed.js",
     "./workspace/session": "./workspace/session.js",
     "./files/filename": "./files/filename.js",
@@ -70,12 +71,14 @@
     "./files/upload-client": "./files/upload-client.js",
     "./files/preview": "./files/preview.js",
     "./files/preview-workspace": "./files/preview-workspace.js",
+    "./files/preview-tabs": "./files/preview-tabs.js",
     "./files/preview-groups": "./files/preview-groups.js",
     "./files/preview-cache": "./files/preview-cache.js",
     "./files/markdown": "./files/markdown.js",
     "./files/deliverables": "./files/deliverables.js",
     "./files/disposition": "./files/disposition.js",
     "./files/intake": "./files/intake.js",
+    "./files/draft-images": "./files/draft-images.js",
     "./files/mention": "./files/mention.js",
     "./drive/files-path": "./drive/files-path.js",
     "./drive/paths": "./drive/paths.js",
@@ -110,6 +113,15 @@
     "./larepass/session-cache": "./larepass/session-cache.js",
     "./larepass/runtime": "./larepass/runtime.js",
     "./larepass/questions": "./larepass/questions.js",
-    "./larepass/settings": "./larepass/settings.js"
+    "./larepass/settings": "./larepass/settings.js",
+    "./larepass/workspace": "./larepass/workspace.js",
+    "./larepass/unread": "./larepass/unread.js",
+    "./larepass/permissions": "./larepass/permissions.js",
+    "./larepass/commands": "./larepass/commands.js",
+    "./larepass/queue": "./larepass/queue.js",
+    "./larepass/references": "./larepass/references.js",
+    "./larepass/submission-settings": "./larepass/submission-settings.js",
+    "./larepass/turn-metrics": "./larepass/turn-metrics.js",
+    "./larepass/context-occupancy": "./larepass/context-occupancy.js"
   }
 }

package/router/session-model.js

@@ -127,7 +127,7 @@ export function groupModelsByProvider(models) {
   for (const model of models) {
     let group = index.get(model.provider);
     if (group === undefined) {
-      group = { provider: model.provider, models: [] };
+      group = { provider: model.provider, name: model.providerName || model.provider, models: [] };
       index.set(model.provider, group);
       groups.push(group);
     }

package/workspace/constants.js

@@ -0,0 +1 @@
+export const DEFAULT_WORKSPACE_TITLE = "Default";

package/workspace/seed.js

@@ -1,6 +1,7 @@
 import { mkdirSync } from "node:fs";
+import { DEFAULT_WORKSPACE_TITLE } from "./constants.js";
 
-export const DEFAULT_WORKSPACE_TITLE = "Default";
+export { DEFAULT_WORKSPACE_TITLE };
 
 /**
  * @param {{ create: (path: string, title?: string) => Promise<{ id: string, path: string, title: string }> }} registry