@everme/dsh 0.6.3 → 0.6.5

package/README.md

@@ -10,6 +10,53 @@ The Cordis plugin complements `@everme/memory-mcp`:
 - Recall and save failures degrade open: DSH continues without blocking the user turn.
 - The MCP server remains available through `npx -y @everme/memory-mcp@latest` for explicit read-only `mem_context` and `mem_search` tool calls (saving is automatic via the hooks).
 
+## Message conversion
+
+The native turn-end writer uses task-aware batching: preserve fitting tasks,
+compress oversized tool results with 4/3/2 KiB budgets, then split only if
+necessary. This does not alter the existing flush-on-turn-end contract.
+Native child sessions without genuine human input are skipped at the writer.
+After a native browser-authored follow-up, later assistant-only turns remain
+eligible; root sessions are not subject to this child-only admission rule.
+
+The native turn collector uses `turn/start` and `turn/end` from the session log.
+Only `user/message` records whose source is `user` become human messages;
+plugin context, reasoning, and control events do not become conversation text.
+For native child sessions (`origin: subagent` with a v3 one-shot or continuable
+descriptor), initial delegated tasks use a bare user source and are excluded.
+Browser-authored follow-ups retain their native `source.rpcId` and are preserved.
+This distinction does not depend on message position, text, or configurable
+provider names. Root-session user messages and child assistant/tool activity
+are unchanged; inherited history is not replayed as new turn content.
+Trusted user text is extracted without channel-metadata pattern stripping, so
+quoted Sender blocks, message IDs, and timestamps remain part of the dialogue.
+Recall query cleaning is unchanged; ordinary write limits still apply.
+Assistant tool-call blocks carry the provider's string ID and name. Arguments
+must be a valid JSON string; the native runtime's explicit empty-string argument
+form means no parameters and is encoded as `{}`. Missing fields are not filled in.
+The separate `tool/call` log record is not uploaded a second time.
+
+Tool results retain their native `toolCallId` and content array. An explicit
+empty array remains one empty result; a missing content field is rejected.
+Long tool results have no additional 8000-character cap. Normal text extraction,
+ordinary-message limits, and the SDK's request budgets still apply. Invalid
+native IDs, names, arguments, or result fields are counted in bounded diagnostics;
+valid neighboring text is retained. A missing real session ID prevents the write.
+When an invalid call has a unique native ID within the turn, its corresponding
+result is excluded as well. Duplicate native IDs are ambiguous, so they do not
+authorize guessing which result belongs to the rejected call.
+
+Only an actual final assistant text message in a `completed` turn, without tool
+calls or interruption, carries the internal completion marker. A tool can itself
+conclude a native DSH turn, so `turn/end` does not authorize inventing a final
+assistant message. Other assistant messages explicitly remain non-final. The
+marker reaches the BFF for batching but is not sent to EverOS.
+
+`collectTurnMessages` accepts an optional fourth logger argument for conversion
+diagnostics; existing three-argument callers remain compatible. Historical
+non-native object arguments, string result containers, and coerced IDs are not
+part of the native DSH contract and are rejected rather than repaired.
+
 ## Install
 
 Use EverCLI so the native plugin, MCP server, Cordis patch, and credentials stay in sync:

package/index.js

@@ -2,6 +2,7 @@ import { createUserMessage } from "@deepseek-ai/dsh-llm";
 import {
   assertConfigUsable,
   createClient,
+  extractText,
   redactError,
   resolveConfig,
   runInject,
@@ -64,13 +65,28 @@ export function installEverMeHooks(ctx, config = {}, dependencies = {}) {
 
   ctx.on("session/event", (session, event) => {
     if (event?.type !== "turn/end") return;
-    const messages = collectTurnMessages(session, event.data?.turn, event.seq);
+    if (!validId(session?.id)) {
+      log.warn("[everme] conversion reason=invalid_session_id dropped=1");
+      return;
+    }
+    const turn = event.data?.turn;
+    const messages = collectTurnMessages(session, turn, event.seq, log);
     if (!messages.length) return;
+    if (isNativeSubagent(session) && !hasHumanInput(session, event.seq)) {
+      log.warn("[everme] conversion reason=subagent_without_user skipped=1");
+      return;
+    }
     enqueue(pending, session, async () => {
       await save(client, {
-        conversationId: String(session.id),
+        conversationId: session.id,
         messages,
+        taskBatching: true,
         flush: true,
+        // The host numbers turns from 1; the gate's whole-turn ordinals
+        // start at 0. Claiming the hook channel lets the gate advance its
+        // turn watermark for this live writer.
+        channel: "hook",
+        baseTurn: turn - 1,
       }, log);
     }, log);
   });
@@ -82,7 +98,7 @@ export function installEverMeHooks(ctx, config = {}, dependencies = {}) {
   return { enabled: true, pending };
 }
 
-export function collectTurnMessages(session, turn, endSeq = Number.POSITIVE_INFINITY) {
+export function collectTurnMessages(session, turn, endSeq = Number.POSITIVE_INFINITY, log = { warn() {} }) {
   if (!session || !Number.isSafeInteger(turn) || !Array.isArray(session.events)) return [];
   const events = session.events;
   let startIndex = -1;
@@ -99,60 +115,148 @@ export function collectTurnMessages(session, turn, endSeq = Number.POSITIVE_INFI
       break;
     }
   }
-  if (startIndex < 0) return [];
+  if (startIndex < 0) {
+    log.warn("[everme] conversion reason=missing_turn_start dropped=1");
+    return [];
+  }
 
   const messages = [];
-  for (const event of events.slice(startIndex + 1, endIndex)) {
-    const converted = convertSessionEvent(event);
+  const rejected = new Map();
+  const reject = (reason) => rejected.set(reason, (rejected.get(reason) || 0) + 1);
+  const turnEvents = events.slice(startIndex + 1, endIndex);
+  const invalidResults = rejectedResultIDs(turnEvents);
+  const nativeSubagent = isNativeSubagent(session);
+  const lastSurface = turnEvents.findLast(event => ["user/message", "assistant/message", "tool/result"].includes(event.type));
+  const completed = turnEvents.at(-1)?.type === "turn/end" && turnEvents.at(-1).data?.reason?.kind === "completed";
+  for (const event of turnEvents) {
+    const converted = convertSessionEvent(event, reject, nativeSubagent);
+    if (converted?.role === "tool" && invalidResults.has(converted.toolCallId)) {
+      reject(invalidResults.get(converted.toolCallId));
+      continue;
+    }
+    if (converted?.role === "assistant") {
+      const original = event.data?.message?.content || [];
+      converted.turnComplete = completed && event === lastSurface && !event.data?.interrupted
+        && !original.some(block => block.type === "tool-call")
+        && converted.content.some(block => block.type === "text" && block.text.trim());
+    }
     if (converted) messages.push(converted);
   }
+  for (const [reason, count] of rejected) log.warn(`[everme] conversion reason=${reason} dropped=${count}`);
   return messages;
 }
 
-function convertSessionEvent(event) {
+function isNativeSubagent(session) {
+  if (session.header?.origin !== "subagent") return false;
+  const descriptor = session.events.find(event => event.type === "subagent/descriptor")?.data;
+  return descriptor?.version === 3 && ["one-shot", "continuable"].includes(descriptor.mode);
+}
+
+function hasHumanInput(session, endSeq) {
+  return session.events.some(event => event.seq <= endSeq && event.type === "user/message"
+    && convertSessionEvent(event, () => {}, true)?.role === "user");
+}
+
+function convertSessionEvent(event, reject, nativeSubagent) {
   if (event?.type === "user/message") {
     const message = event.data;
-    if (message?.source?.kind !== "user") return null;
-    const content = toText(message.content);
+    if (message?.source?.kind !== "user") {
+      reject("non_user_source");
+      return null;
+    }
+    if (nativeSubagent && !("rpcId" in message.source)) {
+      reject("delegated_task");
+      return null;
+    }
+    const content = extractText(message.content).trim();
+    if (!content) reject("empty_message");
     return content ? { role: "user", content, timestamp: event.time } : null;
   }
 
   if (event?.type === "assistant/message") {
-    const content = normalizeAssistantContent(event.data?.message?.content);
+    const content = normalizeAssistantContent(event.data?.message?.content, reject);
+    if (!content.length) reject("empty_message");
     return content.length ? { role: "assistant", content, timestamp: event.time } : null;
   }
 
   if (event?.type === "tool/result") {
     const block = event.data?.message?.content?.find((item) => item?.type === "tool-result");
-    if (!block?.toolCallId) return null;
+    if (!validId(block?.toolCallId)) {
+      reject("invalid_tool_result_id");
+      return null;
+    }
+    if (!Array.isArray(block.content)) {
+      reject("invalid_tool_result_content");
+      return null;
+    }
     return {
       role: "tool",
-      toolCallId: String(block.toolCallId),
-      content: block.content || [],
+      toolCallId: block.toolCallId,
+      content: block.content,
       timestamp: event.time,
     };
   }
 
+  if (!["turn/start", "turn/end", "step/start", "step/end", "tool/call"].includes(event?.type)) reject("non_dialogue_event");
   return null;
 }
 
-function normalizeAssistantContent(content) {
+function normalizeAssistantContent(content, reject) {
   const normalized = [];
   for (const block of Array.isArray(content) ? content : []) {
     if (block?.type === "text" && block.text) {
       normalized.push({ type: "text", text: block.text });
-    } else if (block?.type === "tool-call" && block.id) {
+    } else if (block?.type === "tool-call") {
+      const reason = invalidCallReason(block);
+      if (reason) {
+        reject(reason);
+        continue;
+      }
       normalized.push({
         type: "toolCall",
-        id: String(block.id),
-        name: block.name || "unknown",
+        id: block.id,
+        name: block.name,
         arguments: block.arguments || "{}",
       });
+    } else if (block?.type !== "text") {
+      reject("non_dialogue_content");
     }
   }
   return normalized;
 }
 
+function validId(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+function rejectedResultIDs(events) {
+  const counts = new Map();
+  const invalid = new Map();
+  for (const event of events) {
+    if (event.type !== "assistant/message") continue;
+    for (const block of event.data?.message?.content || []) {
+      if (block.type !== "tool-call" || !validId(block.id)) continue;
+      counts.set(block.id, (counts.get(block.id) || 0) + 1);
+      const reason = invalidCallReason(block);
+      if (reason) invalid.set(block.id, reason);
+    }
+  }
+  // Duplicate native IDs do not identify which call owns a result.
+  return new Map([...invalid].filter(([id]) => counts.get(id) === 1));
+}
+
+function invalidCallReason(block) {
+  if (!validId(block.id)) return "invalid_tool_call_id";
+  if (!validId(block.name)) return "invalid_tool_name";
+  if (typeof block.arguments !== "string") return "invalid_tool_arguments";
+  try {
+    JSON.parse(block.arguments || "{}");
+  } catch {
+    return "invalid_tool_arguments";
+  }
+  return "";
+}
+
 function humanPrompt(messages) {
   return (Array.isArray(messages) ? messages : [])
     .filter((message) => message?.source?.kind === "user")
@@ -186,5 +290,6 @@ function createLogger(ctx, override) {
 }
 
 function safeError(error) {
-  return redactError(error instanceof Error ? error.message : String(error));
+  const text = redactError(error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ").trim();
+  return text.length > 240 ? `${text.slice(0, 240)}…` : text;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/dsh",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "type": "module",
   "description": "Native EverMe lifecycle hooks for DeepSeek Harness.",
   "license": "Apache-2.0",
@@ -43,7 +43,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@everme/agent-sdk": "^0.6.3"
+    "@everme/agent-sdk": "^0.6.5"
   },
   "peerDependencies": {
     "@deepseek-ai/dsh-llm": ">=0.1.0-rc.6 <0.2.0"