dsh-decision-layer 0.4.0

package/service/session-state.mjs

@@ -0,0 +1,116 @@
+function sessionKey(value) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 512) throw new Error('Invalid session ID');
+  return value.trim();
+}
+
+function emptyState() {
+  return { enabled: true, attempts: 0, failures: 0,
+    gate: { attempts: 0, failures: 0, ask: 0, deny: 0, allow: 0, actual: { allow: 0, deny: 0, error: 0 } },
+    check: { attempts: 0, failures: 0, low: 0 },
+    narrow: { attempts: 0, failures: 0, applied: 0, dropped: 0 }, log: [] };
+}
+
+function safeTool(value) {
+  return typeof value === 'string' && value.trim() ? value.trim().slice(0, 128) : undefined;
+}
+
+export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onLog } = {}) {
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1) throw new Error('Invalid session limit');
+  if (!Number.isSafeInteger(maxLogEntries) || maxLogEntries < 1) throw new Error('Invalid log limit');
+  const sessions = new Map();
+  const sink = typeof onLog === 'function' ? onLog : undefined;
+  const writable = id => {
+    const key = sessionKey(id);
+    let state = sessions.get(key);
+    if (!state) {
+      if (sessions.size >= maxSessions) throw new Error('Session state limit reached');
+      state = emptyState();
+      sessions.set(key, state);
+    }
+    return state;
+  };
+  return {
+    setEnabled(id, enabled) {
+      if (typeof enabled !== 'boolean') throw new Error('Invalid enabled value');
+      const key = sessionKey(id);
+      if (!sessions.has(key) && sessions.size >= maxSessions && !enabled) return;
+      writable(key).enabled = enabled;
+    },
+    snapshot(id) {
+      const stored = sessions.get(sessionKey(id));
+      const overflow = !stored && sessions.size >= maxSessions;
+      const state = stored ?? emptyState();
+      const value = { enabled: overflow ? false : state.enabled, hasAutomaticDecisions: state.attempts > 0, attempts: state.attempts, failures: state.failures };
+      if (overflow) value.capacityExceeded = true;
+      if (state.gate.attempts > 0) value.gate = { ...state.gate, actual: { ...state.gate.actual } };
+      if (state.check.attempts > 0) value.check = { ...state.check };
+      if (state.narrow.attempts > 0) value.narrow = { ...state.narrow };
+      if (state.log.length > 0) value.log = state.log.map(entry => ({ ...entry }));
+      return value;
+    },
+    record(id, kind, outcome) {
+      if (kind !== 'gate' || !['allow', 'ask', 'deny', 'error'].includes(outcome)) throw new Error('Invalid automatic decision');
+      const state = writable(id);
+      state.attempts++;
+      state.gate.attempts++;
+      if (outcome === 'error') { state.failures++; state.gate.failures++; }
+      else state.gate[outcome]++;
+    },
+    recordActual(id, outcome) {
+      if (!['allow', 'deny', 'error'].includes(outcome)) throw new Error('Invalid actual decision');
+      writable(id).gate.actual[outcome]++;
+    },
+    recordCheck(id, outcome) {
+      if (!['ok', 'low', 'error'].includes(outcome)) throw new Error('Invalid self-check outcome');
+      const state = writable(id);
+      state.attempts++;
+      state.check.attempts++;
+      if (outcome === 'error') { state.failures++; state.check.failures++; }
+      else if (outcome === 'low') state.check.low++;
+    },
+    recordNarrow(id, outcome, dropped = 0) {
+      if (!['ok', 'applied', 'error'].includes(outcome)) throw new Error('Invalid narrowing outcome');
+      const state = writable(id);
+      state.attempts++;
+      state.narrow.attempts++;
+      if (outcome === 'error') { state.failures++; state.narrow.failures++; }
+      else if (outcome === 'applied') {
+        state.narrow.applied++;
+        if (Number.isSafeInteger(dropped) && dropped > 0) state.narrow.dropped += dropped;
+      }
+    },
+    log(id, entry) {
+      if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) throw new Error('Invalid log entry');
+      if (!['gate', 'check', 'narrow'].includes(entry.kind)) throw new Error('Invalid log entry');
+      const record = { at: Date.now(), kind: entry.kind, outcome: typeof entry.outcome === 'string' ? entry.outcome.slice(0, 32) : '' };
+      const tool = safeTool(entry.tool);
+      if (tool) record.tool = tool;
+      if (typeof entry.suggestion === 'string' && entry.suggestion) record.suggestion = entry.suggestion.slice(0, 16);
+      if (typeof entry.action === 'string' && entry.action) record.action = entry.action.slice(0, 16);
+      if (typeof entry.reason === 'string' && entry.reason) record.reason = entry.reason.slice(0, 32);
+      if (typeof entry.mode === 'string' && entry.mode) record.mode = entry.mode.slice(0, 16);
+      if (typeof entry.score === 'number' && Number.isFinite(entry.score)) record.score = Math.round(entry.score * 100) / 100;
+      if (typeof entry.confidence === 'number' && Number.isFinite(entry.confidence)) record.confidence = Math.round(entry.confidence * 100) / 100;
+      if (Number.isSafeInteger(entry.dropped) && entry.dropped >= 0) record.dropped = entry.dropped;
+      if (Number.isSafeInteger(entry.kept) && entry.kept >= 0) record.kept = entry.kept;
+      if (Number.isSafeInteger(entry.candidates) && entry.candidates >= 0) record.candidates = entry.candidates;
+      if (Array.isArray(entry.tools)) {
+        const names = entry.tools.filter(name => typeof name === 'string' && name.trim()).slice(0, 12).map(name => name.trim().slice(0, 64));
+        if (names.length > 0) record.tools = names;
+      }
+      const state = writable(id);
+      state.log.push(record);
+      if (state.log.length > maxLogEntries) state.log.splice(0, state.log.length - maxLogEntries);
+      // Full, untruncated record for the research log sink (all dropped tool
+      // names, keyed by session id). The in-memory panel record above stays capped.
+      if (sink) {
+        const full = { ...record, sessionId: sessionKey(id) };
+        if (Array.isArray(entry.tools)) {
+          const allNames = entry.tools.filter(name => typeof name === 'string' && name.trim()).map(name => name.trim());
+          if (allNames.length > 0) full.tools = allNames;
+        }
+        try { sink(full); } catch { /* persistence is best effort */ }
+      }
+    },
+  };
+}

package/skills/decision-layer/SKILL.md

@@ -0,0 +1,15 @@
+---
+name: decision-layer
+description: 显式发起一次结构化裁决，适用于有明确候选项或评分标准的判断；不用于开放式创作。
+---
+
+# 手动裁决
+
+当用户要求手动裁决时，用 `decision_evaluate` 提交最少的任务上下文和一组结构化问题。此调用只展示判断结果，不控制 agent 工具、审批或回合流程，也不计入自动裁决总数。
+
+- `state` 是与判断相关的文字、对象或数组，不放密钥或不必要的完整对话。
+- `questions` 以稳定 ID 作为键；每个问题必须有 `type` 与完整的 `instructions`。
+- `choice` 的 `criteria` 是至少两个候选 ID 到描述的映射；`score` 的 `criteria` 是从低到高的 2–10 个等级；`noul` 用于明确的二元条件。
+- 解释结果时如实呈现概率、分数及模型名。裁决建议不替代用户选择，也不授予权限。服务不可用时说明事实，不杜撰结果。
+
+需要验证配置时，可调用 `decision_check_connection`；它会向已配置的后端发送一条测试请求，但不会增加自动裁决计数。不要请用户在对话里粘贴 Key。