@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/src/runtime/worker/models.js

@@ -0,0 +1,137 @@
+'use strict';
+
+                 
+                                     
+                                                     
+                        
+  
+
+                          
+                       
+                                                    
+                                            
+                                          
+                                         
+  
+
+                                 
+
+/** Tier for a dispatch: the task line's tier when valid, else the owner's, else the default (IC-004).
+ * A registry without `dispatchTiers` (the key is optional) gives `standard` with a note. */
+function resolveTier({ dispatchTiers, owner, tier, missing }     ) {
+  if (!dispatchTiers) {
+    missing.push('models.json has no dispatchTiers; tier standard assumed');
+    return { tier: 'standard', source: 'default', note: 'models.json has no dispatchTiers' };
+  }
+  if (tier !== undefined && tier !== null && tier !== '') {
+    if (dispatchTiers.tiers.includes(tier)) return { tier, source: 'task' };
+    missing.push(`tier '${tier}' is not in dispatchTiers.tiers; ignored`);
+  }
+  if (Object.hasOwn(dispatchTiers.byOwner, owner)) return { tier: dispatchTiers.byOwner[owner], source: 'owner' };
+  missing.push(`owner '${owner}' has no tier in models.json dispatchTiers`);
+  return { tier: dispatchTiers.default, source: 'default' };
+}
+
+/** IC-012: read global bindings afresh; errors report resolver reasons, never setting values. */
+function readBindings({ env = process.env, projectRoot = null }      = {})           {
+  try {
+    const { loadSettings } = require('../settings/resolve.js');
+    const res = loadSettings({ projectRoot, env: { ...env } }).get('workers.models', 'global');
+    const invalid = res.state === 'invalid' || res.origin?.via === 'no-config-home'
+      || res.value?.state === 'invalid';
+    if (invalid) {
+      const candidate = res.candidates.find((item     ) => item.status === 'invalid');
+      return {
+        state: 'invalid', map: null,
+        reason: candidate?.reason || (res.origin?.via === 'no-config-home' ? 'no-config-home' : 'invalid'),
+      };
+    }
+    if (res.value === null) return { state: 'unset', map: null, reason: null };
+    return { state: 'set', map: structuredClone(res.value), reason: null };
+  } catch {
+    return { state: 'invalid', map: null, reason: 'unreadable' };
+  }
+}
+
+/** IC-002: read project-effective models.enabled setting afresh. */
+function readAllowedModels({ env = process.env, projectRoot = null }      = {})                  {
+  try {
+    const { loadSettings } = require('../settings/resolve.js');
+    const res = loadSettings({ projectRoot, env: { ...env } }).get('models.enabled', 'project');
+    if (res.state === 'invalid' || res.origin?.via === 'no-config-home') return [];
+    return Array.isArray(res.value) ? res.value : [];
+  } catch {
+    return [];
+  }
+}
+
+/** IC-012, IC-003: resolve one worker and task tier, checking catalogue sync and models.enabled allow-list. */
+function resolveBinding({ worker, tier, bindings, descriptor, catalogue, allowedModels }     )                    {
+  if (bindings?.state === 'invalid') {
+    const res                    = { model: null, source: 'invalid', flag: 'n/a' };
+    if (catalogue !== undefined) res.catalogueStatus = 'unsynced';
+    if (allowedModels !== undefined) res.enabledStatus = 'disabled';
+    return res;
+  }
+  const map = bindings?.state === 'set' ? bindings.map : null;
+  if (!map || !Object.hasOwn(map, worker) || !Object.hasOwn(map[worker], tier)) {
+    const res                    = { model: null, source: 'harness-default', flag: 'n/a' };
+    if (catalogue !== undefined) res.catalogueStatus = 'synced';
+    if (allowedModels !== undefined) res.enabledStatus = 'enabled';
+    return res;
+  }
+  const boundModel = map[worker][tier];
+  const supported = descriptor?.model?.status === 'supported' && Array.isArray(descriptor.model.argv);
+
+  const res                    = {
+    model: boundModel,
+    source: 'binding',
+    flag: supported ? 'supported' : 'unevidenced',
+  };
+
+  if (catalogue !== undefined) {
+    if (catalogue && catalogue.harnesses && Object.hasOwn(catalogue.harnesses, worker)) {
+      const offered = catalogue.harnesses[worker]?.offeredModels || [];
+      res.catalogueStatus = offered.some((m     ) => m.id === boundModel) ? 'synced' : 'unsynced';
+    } else {
+      res.catalogueStatus = 'unsynced';
+    }
+  }
+
+  if (allowedModels !== undefined) {
+    if (Array.isArray(allowedModels)) {
+      res.enabledStatus = allowedModels.includes(boundModel) ? 'enabled' : 'disabled';
+    } else {
+      res.enabledStatus = 'disabled';
+    }
+  }
+
+  return res;
+}
+
+/** IC-012, IC-003: a binding denial narrows this task's ladder, rather than becoming a launch failure. */
+function bindingGap(result                   ) {
+  if (result.source === 'invalid') return { requirement: 'binding', result: 'failed', reason: 'binding:invalid' };
+  if (result.source === 'binding') {
+    if (result.flag === 'unevidenced') {
+      return { requirement: 'binding', result: 'failed', reason: 'model-flag:unevidenced' };
+    }
+    if (result.catalogueStatus === 'unsynced') {
+      return { requirement: 'binding', result: 'failed', reason: 'model-unsynced' };
+    }
+    if (result.enabledStatus === 'disabled') {
+      return { requirement: 'binding', result: 'failed', reason: 'model-disabled' };
+    }
+  }
+  return null;
+}
+
+/** IC-014: describe every registry tier without changing worker eligibility. */
+function bindingsOf({ worker, descriptor, bindings, tiers, catalogue, allowedModels }     ) {
+  return Object.fromEntries(tiers.map((tier        ) => {
+    const { model, flag, catalogueStatus, enabledStatus } = resolveBinding({ worker, tier, bindings, descriptor, catalogue, allowedModels });
+    return [tier, { model, flag, ...(catalogueStatus ? { catalogueStatus } : {}), ...(enabledStatus ? { enabledStatus } : {}) }];
+  }));
+}
+
+module.exports = { resolveTier, readBindings, readAllowedModels, resolveBinding, bindingGap, bindingsOf };

package/src/runtime/worker/parsers.js

@@ -0,0 +1,218 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+/**
+ * The worker parser table (IC-016, DEC-027). A descriptor's `structuredOutput.parser` names an entry
+ * of `PARSERS`; the supervisor feeds it stdout one line at a time and reads one `Report` at the end.
+ *
+ *   - `doflow-jsonl-v1`: a line that parses as a JSON object with a string `type` is an event;
+ *     every other line, and every event whose type or fields this format does not accept, is counted
+ *     in `ignoredLines`.
+ *   - Any `permission-denied` event makes the report `denied`, whatever the `result` line says and
+ *     whatever the exit status.
+ *   - A line over the supervisor's 4 MiB line buffer arrives as one `oversize(looksJson)` event; a
+ *     JSON-looking one makes the report `unparsed`, reason `oversize-line`, unless a denial was seen
+ *     (DEC-057).
+ *   - `unparsed` is the fallback for a null or unknown id, and always reports `status: 'unparsed'`.
+ *
+ * Every free-text field is masked before it is kept: `summary` with the body profile, `action` and
+ * `detail` with the line profile. No I/O and no state outside one parser instance.
+ */
+
+const { maskLine, maskBody } = require('../mask.js');
+
+const JSONL_V1 = 'doflow-jsonl-v1';
+const CODEX_EXEC_JSON_V1 = 'codex-exec-json-v1';
+const UNPARSED = 'unparsed';
+const MAX_DENIALS = 20;
+const DETAIL_CHARS = 200;
+const SUMMARY_BYTES = 2000;
+const RESULT_STATUSES = new Set(['success', 'failure']);
+
+                                                 
+               
+                 
+                                                        
+                        
+                         
+                    
+                      
+                                   
+                       
+  
+
+/** Cuts `text` to at most `max` UTF-8 bytes without splitting a character. */
+function cutBytes(text        , max        )         {
+  const bytes = Buffer.from(text, 'utf8');
+  if (bytes.length <= max) return text;
+  let end = max;
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) end--; // back off a continuation byte
+  return bytes.subarray(0, end).toString('utf8');
+}
+
+/** Cuts `text` to at most `max` characters (code points, so no surrogate pair is split). */
+function cutChars(text        , max        )         {
+  const chars = Array.from(text);
+  return chars.length <= max ? text : chars.slice(0, max).join('');
+}
+
+/** Parses one line as a `doflow-jsonl-v1` event, or returns null. */
+function eventOf(text        )      {
+  let value     ;
+  try { value = JSON.parse(text); } catch { return null; }
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return null;
+  return typeof value.type === 'string' ? value : null;
+}
+
+function createJsonlV1() {
+  let result                                                            = null;
+  const denials           = [];
+  let deniedCount = 0;
+  let usage                            = null;
+  let ignoredLines = 0;
+  let oversizeJson = false;
+
+  return {
+    /** IC-016 (DEC-057): a stdout line over `OUTPUT_MAX_BYTES`, never a line with no denial. */
+    oversize(looksJson         )       {
+      ignoredLines++;
+      if (looksJson) oversizeJson = true;
+    },
+    line(text        )       {
+      const event = eventOf(String(text ?? '').replace(/\r$/, ''));
+      if (event && event.type === 'result' && RESULT_STATUSES.has(event.status) && typeof event.summary === 'string') {
+        result = { status: event.status, summary: event.summary };
+      } else if (event && event.type === 'permission-denied' && typeof event.action === 'string' && typeof event.detail === 'string') {
+        deniedCount++;
+        if (denials.length < MAX_DENIALS) {
+          denials.push({ action: maskLine(event.action).text, detail: cutChars(maskLine(event.detail).text, DETAIL_CHARS) });
+        }
+      } else if (event && event.type === 'usage' && Number.isInteger(event.tokens) && event.tokens >= 0) {
+        usage = { tokens: event.tokens };
+      } else {
+        ignoredLines++;
+      }
+    },
+    end()         {
+      // Masked first and cut second, so a cut never leaves an unmasked prefix of a secret behind.
+      const summary = result ? cutBytes(maskBody(result.summary).text, SUMMARY_BYTES) : null;
+      let status                  ;
+      let reason                = null;
+      if (deniedCount > 0) status = 'denied';
+      else if (oversizeJson) { status = 'unparsed'; reason = 'oversize-line'; }
+      else if (result) status = result.status;
+      else { status = 'unparsed'; reason = 'no-result-line'; }
+      return { parser: JSONL_V1, status, reason, summary, denials: denials.slice(), deniedCount, usage, ignoredLines };
+    },
+  };
+}
+
+/** Parses Codex `exec --json` events (IC-003). */
+function createCodexExecJsonV1() {
+  const denials           = [];
+  let deniedCount = 0;
+  let usage                            = null;
+  let ignoredLines = 0;
+  let oversizeJson = false;
+  let final                = null;
+  let fileFinal                = null;
+  let spawnObserved = false;
+  let terminal                                = null;
+  let failMessage                = null;
+  let streamError                = null;
+
+  return {
+    oversize(looksJson         )       {
+      ignoredLines++;
+      if (looksJson) oversizeJson = true;
+    },
+    line(text        )       {
+      const event = eventOf(String(text ?? '').replace(/\r$/, ''));
+      if (!event) {
+        ignoredLines++;
+        return;
+      }
+
+      const item = event.item;
+      if (event.type === 'item.completed' && item?.type === 'agent_message' && typeof item.text === 'string') {
+        final = item.text;
+      } else if (['item.started', 'item.updated', 'item.completed'].includes(event.type)
+        && item?.type === 'collab_tool_call' && item.tool === 'spawn_agent') {
+        spawnObserved = true;
+      } else if (event.type === 'item.completed' && item?.type === 'command_execution' && item.status === 'declined') {
+        deniedCount++;
+        if (denials.length < MAX_DENIALS) {
+          denials.push({ action: 'command', detail: cutChars(maskLine(String(item.command ?? '')).text, DETAIL_CHARS) });
+        }
+      } else if (event.type === 'turn.completed') {
+        terminal = 'completed';
+        const reported = event.usage;
+        const input = Number.isInteger(reported?.input_tokens) && reported.input_tokens >= 0 ? reported.input_tokens : null;
+        const output = Number.isInteger(reported?.output_tokens) && reported.output_tokens >= 0 ? reported.output_tokens : null;
+        usage = input === null && output === null ? null : { tokens: (input ?? 0) + (output ?? 0) };
+      } else if (event.type === 'turn.failed' && typeof event.error?.message === 'string') {
+        terminal = 'failed';
+        failMessage = event.error.message;
+      } else if (event.type === 'error' && typeof event.message === 'string') {
+        streamError = event.message;
+      } else {
+        ignoredLines++;
+      }
+    },
+    lastMessage(text        )       {
+      if (String(text ?? '').trim()) fileFinal = String(text);
+    },
+    end()         {
+      let status                  ;
+      let reason                = null;
+      let rawSummary                = null;
+      if (deniedCount > 0) status = 'denied';
+      else if (oversizeJson) { status = 'unparsed'; reason = 'oversize-line'; }
+      else if (spawnObserved) { status = 'failure'; reason = 'spawn-observed'; }
+      else if (terminal === 'failed') { status = 'failure'; rawSummary = failMessage; }
+      else if (terminal === 'completed' && (final ?? fileFinal) !== null) {
+        status = 'success';
+        rawSummary = final ?? fileFinal;
+      } else if (terminal === 'completed') { status = 'unparsed'; reason = 'no-final-message'; }
+      else if (streamError !== null) { status = 'failure'; reason = 'stream-error'; rawSummary = streamError; }
+      else { status = 'unparsed'; reason = 'no-turn-end'; }
+
+      const summary = rawSummary === null ? null : cutBytes(maskBody(rawSummary).text, SUMMARY_BYTES);
+      return { parser: CODEX_EXEC_JSON_V1, status, reason, summary, denials: denials.slice(), deniedCount, usage, ignoredLines };
+    },
+  };
+}
+
+/** The fallback: reads nothing and reports `unparsed` with the reason it was chosen. */
+function unparsedParser(reason                                                    ) {
+  return {
+    id: UNPARSED,
+    create() {
+      let ignoredLines = 0;
+      return {
+        line()       { ignoredLines++; },
+        oversize()       { ignoredLines++; },
+        end()         {
+          return { parser: UNPARSED, status: 'unparsed', reason, summary: null, denials: [], deniedCount: 0, usage: null, ignoredLines };
+        },
+      };
+    },
+  };
+}
+
+                                                                                                                                            
+                                                              
+
+const PARSERS                                          = Object.freeze({
+  [JSONL_V1]: Object.freeze({ id: JSONL_V1, create: createJsonlV1 }),
+  [CODEX_EXEC_JSON_V1]: Object.freeze({ id: CODEX_EXEC_JSON_V1, create: createCodexExecJsonV1 }),
+});
+
+/** The parser for `id`; the `unparsed` fallback for a null or unknown one. */
+function parserFor(id                           ) {
+  if (id === null || id === undefined) return unparsedParser('no-structured-output-declared');
+  return Object.prototype.hasOwnProperty.call(PARSERS, id) ? PARSERS[id] : unparsedParser('parser-unknown');
+}
+
+module.exports = { PARSERS, parserFor, JSONL_V1, CODEX_EXEC_JSON_V1, UNPARSED, MAX_DENIALS, DETAIL_CHARS, SUMMARY_BYTES };