@modusensus/dsh-mneme 0.6.7 → 0.6.9

package/{test → dsh-mneme/test}/graph-api.test.js

@@ -1,175 +1,175 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { createStore } from "../src/store.js";
-import { createService } from "../src/service.js";
-import { createApi } from "../src/api.js";
-import { createSettings } from "../src/settings.js";
-
-// Ego-graph read API (graph panel P1). The routes under test:
-//   GET /api/dsh-mneme/semantic/graph/ego?entity=&depth=&limit=
-//   GET /api/dsh-mneme/semantic/graph/entity-attrs?entity=
-// Both are read-only: they must stay reachable without an apiToken, exactly
-// like list/search/semantic.
-
-class FakeRes extends EventEmitter {
-  constructor() { super(); this.statusCode = 200; this.body = ""; }
-  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
-  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
-}
-
-function req(path) {
-  const r = new EventEmitter();
-  r.url = path;
-  r.method = "GET";
-  r.headers = {};
-  return r;
-}
-
-function setup(apiToken = "") {
-  const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
-  const settings = createSettings(store.db);
-  const commands = { add: () => {}, remove: () => {}, list: () => [] };
-  const routes = [];
-  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
-  createApi(ctx, service, settings, commands, null, undefined, apiToken);
-  return { store, service, routes };
-}
-
-function graphRoute(routes, path) {
-  return routes.find((r) => r.path === path);
-}
-
-function buildChain(service, names, linkType = "related_to") {
-  // names → entities; each consecutive pair gets one relation. Returns a
-  // name→entity map so tests can assert on ids.
-  const map = new Map();
-  for (const n of names) map.set(n, service.createEntity({ name: n, type: "concept" }));
-  for (let i = 0; i < names.length - 1; i++) {
-    service.saveRelation({
-      from_entity: map.get(names[i]).id,
-      to_entity: map.get(names[i + 1]).id,
-      relation_type: linkType
-    });
-  }
-  return map;
-}
-
-test("ego route is registered and open without apiToken", async () => {
-  const { routes } = setup("secret-token");
-  const ego = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  const attrs = graphRoute(routes, "/api/dsh-mneme/semantic/graph/entity-attrs");
-  assert.ok(ego, "ego route must be registered");
-  assert.ok(attrs, "entity-attrs route must be registered");
-  // read-only: no 401 even with a token configured
-  const res = new FakeRes();
-  await ego.handler(req("/api/dsh-mneme/semantic/graph/ego"), res);
-  assert.equal(res.statusCode, 400, "missing param is a 400, not a 401");
-});
-
-test("ego depth 1 returns root + direct neighbors with distances", async () => {
-  const { routes, service } = setup();
-  const map = buildChain(service, ["A", "B", "C"]);
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=1"), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.equal(data.root.name, "A");
-  assert.equal(data.nodes.length, 2, "root + B only (C is 2 hops)");
-  assert.equal(data.edges.length, 1);
-  const b = data.nodes.find((n) => n.name === "B");
-  assert.equal(b.distance, 1);
-  assert.equal(data.nodes.find((n) => n.name === "A").distance, 0);
-  // edge shape: ids + relation_type, memory_id nullable
-  const edge = data.edges[0];
-  assert.ok(edge.id && edge.from && edge.to);
-  assert.equal(edge.relation_type, "related_to");
-  assert.equal(edge.memory_id, null);
-});
-
-test("ego depth 2 includes 2-hop nodes, not 3-hop", async () => {
-  const { routes, service } = setup();
-  buildChain(service, ["A", "B", "C", "D"]);
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=2"), res);
-  const data = JSON.parse(res.body);
-  const names = data.nodes.map((n) => n.name).sort();
-  assert.deepEqual(names, ["A", "B", "C"], "D is 3 hops away and must be excluded");
-  assert.equal(data.nodes.find((n) => n.name === "C").distance, 2);
-  assert.equal(data.edges.length, 2);
-});
-
-test("ego respects limit and keeps only in-graph edges", async () => {
-  const { routes, service } = setup();
-  const map = buildChain(service, ["A", "B", "C"]);
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=2&limit=2"), res);
-  const data = JSON.parse(res.body);
-  assert.equal(data.nodes.length, 2, "limit caps node count");
-  assert.equal(data.edges.length, 1, "edges to cut nodes are dropped");
-});
-
-test("ego reports 404 for unknown entity and 400 without entity", async () => {
-  const { routes } = setup();
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  let res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=ghost"), res);
-  assert.equal(res.statusCode, 404);
-  assert.equal(JSON.parse(res.body).error, "entity-not-found");
-  res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego"), res);
-  assert.equal(res.statusCode, 400);
-  assert.equal(JSON.parse(res.body).error, "missing-entity");
-});
-
-test("entity-attrs returns current valid attrs only", async () => {
-  const { routes, service } = setup();
-  const mem = service.saveWithDedupe({ type: "project", title: "t", content: "c" });
-  const entity = service.createEntity({ name: "X", type: "technology" });
-  service.saveAttr({ entity_id: entity.id, attr_key: "version", attr_value: "1", memory_id: mem.id, confidence: 0.9 });
-  // a second save of the same key invalidates the first: only one row stays valid
-  service.saveAttr({ entity_id: entity.id, attr_key: "version", attr_value: "2", memory_id: mem.id, confidence: 0.8 });
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/entity-attrs");
-  const res = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs?entity=X"), res);
-  assert.equal(res.statusCode, 200);
-  const data = JSON.parse(res.body);
-  assert.equal(data.entity.name, "X");
-  assert.equal(data.attrs.length, 1);
-  assert.equal(data.attrs[0].value, "2", "latest valid attr wins");
-  assert.equal(data.attrs[0].confidence, 0.8);
-  // unknown / missing entity
-  let r2 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs?entity=nope"), r2);
-  assert.equal(r2.statusCode, 404);
-  r2 = new FakeRes();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs"), r2);
-  assert.equal(r2.statusCode, 400);
-});
-
-test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
-  const { routes, service } = setup();
-  // star-of-stars: hub → 20 spokes, each spoke → 5 leaves = 121 nodes, 120 edges
-  const hub = service.createEntity({ name: "hub", type: "project" });
-  for (let i = 0; i < 20; i++) {
-    const spoke = service.createEntity({ name: `spoke-${i}`, type: "technology" });
-    service.saveRelation({ from_entity: hub.id, to_entity: spoke.id, relation_type: "uses" });
-    for (let j = 0; j < 5; j++) {
-      const leaf = service.createEntity({ name: `leaf-${i}-${j}`, type: "concept" });
-      service.saveRelation({ from_entity: spoke.id, to_entity: leaf.id, relation_type: "related_to" });
-    }
-  }
-  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
-  const res = new FakeRes();
-  const start = process.hrtime.bigint();
-  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=hub&depth=2&limit=100"), res);
-  const ms = Number(process.hrtime.bigint() - start) / 1e6;
-  const data = JSON.parse(res.body);
-  assert.equal(data.nodes.length, 100, "limit caps the traversal");
-  assert.ok(data.edges.length > 0);
-  assert.ok(ms < 50, `2-hop query took ${ms.toFixed(1)}ms, spec budget is 50ms`);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+
+// Ego-graph read API (graph panel P1). The routes under test:
+//   GET /api/dsh-mneme/semantic/graph/ego?entity=&depth=&limit=
+//   GET /api/dsh-mneme/semantic/graph/entity-attrs?entity=
+// Both are read-only: they must stay reachable without an apiToken, exactly
+// like list/search/semantic.
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = "GET";
+  r.headers = {};
+  return r;
+}
+
+function setup(apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, apiToken);
+  return { store, service, routes };
+}
+
+function graphRoute(routes, path) {
+  return routes.find((r) => r.path === path);
+}
+
+function buildChain(service, names, linkType = "related_to") {
+  // names → entities; each consecutive pair gets one relation. Returns a
+  // name→entity map so tests can assert on ids.
+  const map = new Map();
+  for (const n of names) map.set(n, service.createEntity({ name: n, type: "concept" }));
+  for (let i = 0; i < names.length - 1; i++) {
+    service.saveRelation({
+      from_entity: map.get(names[i]).id,
+      to_entity: map.get(names[i + 1]).id,
+      relation_type: linkType
+    });
+  }
+  return map;
+}
+
+test("ego route is registered and open without apiToken", async () => {
+  const { routes } = setup("secret-token");
+  const ego = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  const attrs = graphRoute(routes, "/api/dsh-mneme/semantic/graph/entity-attrs");
+  assert.ok(ego, "ego route must be registered");
+  assert.ok(attrs, "entity-attrs route must be registered");
+  // read-only: no 401 even with a token configured
+  const res = new FakeRes();
+  await ego.handler(req("/api/dsh-mneme/semantic/graph/ego"), res);
+  assert.equal(res.statusCode, 400, "missing param is a 400, not a 401");
+});
+
+test("ego depth 1 returns root + direct neighbors with distances", async () => {
+  const { routes, service } = setup();
+  const map = buildChain(service, ["A", "B", "C"]);
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=1"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.root.name, "A");
+  assert.equal(data.nodes.length, 2, "root + B only (C is 2 hops)");
+  assert.equal(data.edges.length, 1);
+  const b = data.nodes.find((n) => n.name === "B");
+  assert.equal(b.distance, 1);
+  assert.equal(data.nodes.find((n) => n.name === "A").distance, 0);
+  // edge shape: ids + relation_type, memory_id nullable
+  const edge = data.edges[0];
+  assert.ok(edge.id && edge.from && edge.to);
+  assert.equal(edge.relation_type, "related_to");
+  assert.equal(edge.memory_id, null);
+});
+
+test("ego depth 2 includes 2-hop nodes, not 3-hop", async () => {
+  const { routes, service } = setup();
+  buildChain(service, ["A", "B", "C", "D"]);
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=2"), res);
+  const data = JSON.parse(res.body);
+  const names = data.nodes.map((n) => n.name).sort();
+  assert.deepEqual(names, ["A", "B", "C"], "D is 3 hops away and must be excluded");
+  assert.equal(data.nodes.find((n) => n.name === "C").distance, 2);
+  assert.equal(data.edges.length, 2);
+});
+
+test("ego respects limit and keeps only in-graph edges", async () => {
+  const { routes, service } = setup();
+  const map = buildChain(service, ["A", "B", "C"]);
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=A&depth=2&limit=2"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.nodes.length, 2, "limit caps node count");
+  assert.equal(data.edges.length, 1, "edges to cut nodes are dropped");
+});
+
+test("ego reports 404 for unknown entity and 400 without entity", async () => {
+  const { routes } = setup();
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  let res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=ghost"), res);
+  assert.equal(res.statusCode, 404);
+  assert.equal(JSON.parse(res.body).error, "entity-not-found");
+  res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego"), res);
+  assert.equal(res.statusCode, 400);
+  assert.equal(JSON.parse(res.body).error, "missing-entity");
+});
+
+test("entity-attrs returns current valid attrs only", async () => {
+  const { routes, service } = setup();
+  const mem = service.saveWithDedupe({ type: "project", title: "t", content: "c" });
+  const entity = service.createEntity({ name: "X", type: "technology" });
+  service.saveAttr({ entity_id: entity.id, attr_key: "version", attr_value: "1", memory_id: mem.id, confidence: 0.9 });
+  // a second save of the same key invalidates the first: only one row stays valid
+  service.saveAttr({ entity_id: entity.id, attr_key: "version", attr_value: "2", memory_id: mem.id, confidence: 0.8 });
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/entity-attrs");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs?entity=X"), res);
+  assert.equal(res.statusCode, 200);
+  const data = JSON.parse(res.body);
+  assert.equal(data.entity.name, "X");
+  assert.equal(data.attrs.length, 1);
+  assert.equal(data.attrs[0].value, "2", "latest valid attr wins");
+  assert.equal(data.attrs[0].confidence, 0.8);
+  // unknown / missing entity
+  let r2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs?entity=nope"), r2);
+  assert.equal(r2.statusCode, 404);
+  r2 = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/entity-attrs"), r2);
+  assert.equal(r2.statusCode, 400);
+});
+
+test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
+  const { routes, service } = setup();
+  // star-of-stars: hub → 20 spokes, each spoke → 5 leaves = 121 nodes, 120 edges
+  const hub = service.createEntity({ name: "hub", type: "project" });
+  for (let i = 0; i < 20; i++) {
+    const spoke = service.createEntity({ name: `spoke-${i}`, type: "technology" });
+    service.saveRelation({ from_entity: hub.id, to_entity: spoke.id, relation_type: "uses" });
+    for (let j = 0; j < 5; j++) {
+      const leaf = service.createEntity({ name: `leaf-${i}-${j}`, type: "concept" });
+      service.saveRelation({ from_entity: spoke.id, to_entity: leaf.id, relation_type: "related_to" });
+    }
+  }
+  const route = graphRoute(routes, "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  const start = process.hrtime.bigint();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=hub&depth=2&limit=100"), res);
+  const ms = Number(process.hrtime.bigint() - start) / 1e6;
+  const data = JSON.parse(res.body);
+  assert.equal(data.nodes.length, 100, "limit caps the traversal");
+  assert.ok(data.edges.length > 0);
+  assert.ok(ms < 50, `2-hop query took ${ms.toFixed(1)}ms, spec budget is 50ms`);
+});

package/{test → dsh-mneme/test}/helpers/dream-mock.js

@@ -1,82 +1,82 @@
-// test/helpers/dream-mock.js
-// 共享的确定性 LLM 测试桩：consolidation 决策生成器 + 最小 DSH ctx。
-// 被 scripts/stress-dsh.js 与 test/stress.test.js 共用，保证压测与单测
-// 走同一套"LLM 行为"，避免两边决策逻辑漂移。
-
-export function parseEntries(listText) {
-  return [...listText.matchAll(
-    /id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=(\d+)\s*\|\s*updated=([^\s|]+)\s*\|\s*title=([^|]*)/g
-  )].map((m) => ({ id: m[1], type: m[2], importance: Number(m[3]), updated: m[4], title: m[5].trim() }));
-}
-
-/**
- * 长会话检索的确定性决策：title 含「变体」→ archive，其余 keep。
- */
-export function sessionDecisions(listText) {
-  const entries = parseEntries(listText);
-  const decisions = [];
-  const claimed = new Set();
-  for (const e of entries) {
-    if (e.title.includes("变体")) {
-      decisions.push({ action: "archive", ids: [e.id], reason: "stale variant" });
-      claimed.add(e.id);
-    }
-  }
-  for (const e of entries) {
-    if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
-  }
-  return JSON.stringify(decisions);
-}
-
-/**
- * 冲突裁决的确定性决策：title 以「(旧)」结尾 → conflict（胜者为同主题
- * 不带「(旧)」者），无对手 → keep。同一快照必然产出同一决策。
- */
-export function arbitrationDecisions(listText) {
-  const entries = parseEntries(listText);
-  const byKey = new Map();
-  for (const e of entries) {
-    const key = e.title.replace(/\(旧\)$/, "").trim();
-    if (!byKey.has(key)) byKey.set(key, []);
-    byKey.get(key).push(e);
-  }
-  const decisions = [];
-  const claimed = new Set();
-  for (const group of byKey.values()) {
-    const loser = group.find((e) => e.title.includes("(旧)"));
-    const winner = group.find((e) => !e.title.includes("(旧)"));
-    if (winner && loser) {
-      decisions.push({ action: "conflict", winner: winner.id, loser: loser.id, reason: "新信息覆盖旧信息" });
-      claimed.add(winner.id);
-      claimed.add(loser.id);
-      continue;
-    }
-    for (const e of group) {
-      if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
-      claimed.add(e.id);
-    }
-  }
-  return JSON.stringify(decisions);
-}
-
-/**
- * 最小 DSH ctx：consolidation 用 onConsolidation(listText) 产出决策，
- * summary 返回固定文本。
- */
-export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文；关键决策已巩固。" } = {}) {
-  return {
-    logger: { warn: () => {} },
-    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
-    llm: {
-      async *stream(options) {
-        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
-        if (userText.startsWith("id=")) {
-          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
-        } else {
-          yield { type: "text-delta", index: 0, text: summaryText };
-        }
-        yield { type: "finish", reason: { kind: "stop" } };
-      }
-    }
-  };
-}
+// test/helpers/dream-mock.js
+// 共享的确定性 LLM 测试桩：consolidation 决策生成器 + 最小 DSH ctx。
+// 被 scripts/stress-dsh.js 与 test/stress.test.js 共用，保证压测与单测
+// 走同一套"LLM 行为"，避免两边决策逻辑漂移。
+
+export function parseEntries(listText) {
+  return [...listText.matchAll(
+    /id=([^\s|]+)\s*\|\s*type=(\w+)\s*\|\s*importance=(\d+)\s*\|\s*updated=([^\s|]+)\s*\|\s*title=([^|]*)/g
+  )].map((m) => ({ id: m[1], type: m[2], importance: Number(m[3]), updated: m[4], title: m[5].trim() }));
+}
+
+/**
+ * 长会话检索的确定性决策：title 含「变体」→ archive，其余 keep。
+ */
+export function sessionDecisions(listText) {
+  const entries = parseEntries(listText);
+  const decisions = [];
+  const claimed = new Set();
+  for (const e of entries) {
+    if (e.title.includes("变体")) {
+      decisions.push({ action: "archive", ids: [e.id], reason: "stale variant" });
+      claimed.add(e.id);
+    }
+  }
+  for (const e of entries) {
+    if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 冲突裁决的确定性决策：title 以「(旧)」结尾 → conflict（胜者为同主题
+ * 不带「(旧)」者），无对手 → keep。同一快照必然产出同一决策。
+ */
+export function arbitrationDecisions(listText) {
+  const entries = parseEntries(listText);
+  const byKey = new Map();
+  for (const e of entries) {
+    const key = e.title.replace(/\(旧\)$/, "").trim();
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(e);
+  }
+  const decisions = [];
+  const claimed = new Set();
+  for (const group of byKey.values()) {
+    const loser = group.find((e) => e.title.includes("(旧)"));
+    const winner = group.find((e) => !e.title.includes("(旧)"));
+    if (winner && loser) {
+      decisions.push({ action: "conflict", winner: winner.id, loser: loser.id, reason: "新信息覆盖旧信息" });
+      claimed.add(winner.id);
+      claimed.add(loser.id);
+      continue;
+    }
+    for (const e of group) {
+      if (!claimed.has(e.id)) decisions.push({ action: "keep", ids: [e.id] });
+      claimed.add(e.id);
+    }
+  }
+  return JSON.stringify(decisions);
+}
+
+/**
+ * 最小 DSH ctx：consolidation 用 onConsolidation(listText) 产出决策，
+ * summary 返回固定文本。
+ */
+export function mockCtx({ onConsolidation, summaryText = "记忆库总览：用户偏好中文；关键决策已巩固。" } = {}) {
+  return {
+    logger: { warn: () => {} },
+    agentDefaultModel: { currentSelection: () => ({ provider: "mock", model: "stress-model" }) },
+    llm: {
+      async *stream(options) {
+        const userText = options.messages.find((m) => m.role === "user")?.content?.[0]?.text ?? "";
+        if (userText.startsWith("id=")) {
+          yield { type: "text-delta", index: 0, text: onConsolidation ? onConsolidation(userText) : "[]" };
+        } else {
+          yield { type: "text-delta", index: 0, text: summaryText };
+        }
+        yield { type: "finish", reason: { kind: "stop" } };
+      }
+    }
+  };
+}