happy-imou-cloud 2.0.19 → 2.0.21

package/dist/{registerKillSessionHandler-DZ1sXUOg.cjs → registerKillSessionHandler-Cs_INk4A.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var index = require('./index-D0VIxWJC.cjs');
-var persistence = require('./persistence-ZZDZ6dl9.cjs');
+var index = require('./index-CgVjDJpt.cjs');
+var persistence = require('./persistence-DLFUNI9q.cjs');
 var os = require('node:os');
 var path = require('node:path');
-var api = require('./api-DmpNsXS1.cjs');
+var api = require('./api-MGlKcEf3.cjs');
 var node_crypto = require('node:crypto');
 var crypto = require('crypto');
 require('axios');
@@ -353,6 +353,356 @@ async function syncControlledByUserState(sessionClient, controlledByUser) {
   });
 }
 
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function cloneHappyOrgMetadata(happyOrg) {
+  return {
+    taskContext: happyOrg?.taskContext ? { ...happyOrg.taskContext } : void 0,
+    runtime: happyOrg?.runtime ? { ...happyOrg.runtime } : void 0,
+    activeOwner: happyOrg?.activeOwner ? { ...happyOrg.activeOwner } : null,
+    repeat: happyOrg?.repeat ? {
+      threshold: happyOrg.repeat.threshold,
+      fingerprints: Object.fromEntries(
+        Object.entries(happyOrg.repeat.fingerprints ?? {}).map(([fingerprint, entry]) => [
+          fingerprint,
+          { ...entry }
+        ])
+      )
+    } : void 0,
+    lastTurnReport: happyOrg?.lastTurnReport ? { ...happyOrg.lastTurnReport } : void 0
+  };
+}
+function normalizeHappyOrgMetadata(metadata) {
+  const happyOrg = cloneHappyOrgMetadata(metadata?.happyOrg);
+  return {
+    ...happyOrg,
+    runtime: happyOrg.runtime ?? {
+      status: "active",
+      reason: null
+    },
+    repeat: happyOrg.repeat ?? {
+      threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function withHappyOrgMetadata(metadata, happyOrg) {
+  return {
+    ...metadata,
+    happyOrg
+  };
+}
+function resetHappyOrgRuntimeForTask(taskContext) {
+  return {
+    taskContext,
+    runtime: {
+      status: "active",
+      reason: null
+    },
+    activeOwner: null,
+    repeat: {
+      threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+      fingerprints: {}
+    }
+  };
+}
+function buildTerminatedStatusMessage(taskId) {
+  return `Task ${taskId} is terminated. Reopen it with new context, a new decision, or a new resource before continuing.`;
+}
+function buildOwnerConflictStatusMessage(taskId, ownerAgentId) {
+  return `Task ${taskId} is already active under owner ${ownerAgentId}. This turn must exit without continuing token usage.`;
+}
+function inferInterventionType(draft) {
+  if (draft?.interventionType === "none" || draft?.interventionType === "review_needed" || draft?.interventionType === "blocker" || draft?.interventionType === "decision_needed") {
+    return draft.interventionType;
+  }
+  if (normalizeOptionalText(draft?.decisionNeeded)) {
+    return "decision_needed";
+  }
+  if (normalizeOptionalText(draft?.blockerCode)) {
+    return "blocker";
+  }
+  return "none";
+}
+function buildFallbackSummary(text, turnStatus) {
+  const trimmed = text.trim();
+  if (trimmed) {
+    return trimmed.replace(/\s+/g, " ").slice(0, 160);
+  }
+  return turnStatus === "turn_aborted" ? "Turn aborted before completion." : "Turn completed without a textual summary.";
+}
+function normalizeTurnReportDraft(draft) {
+  return {
+    summary: normalizeOptionalText(draft?.summary)?.replace(/\s+/g, " ").slice(0, 160) ?? null,
+    interventionType: inferInterventionType(draft),
+    blockerCode: normalizeOptionalText(draft?.blockerCode),
+    decisionNeeded: normalizeOptionalText(draft?.decisionNeeded),
+    targetArtifact: normalizeOptionalText(draft?.targetArtifact)
+  };
+}
+function stripCodeFence(text) {
+  return text.replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "").trim();
+}
+function extractTaggedTurnReport(text) {
+  const matcher = new RegExp(
+    `<${api.HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${api.HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "gi"
+  );
+  let lastMatch = null;
+  for (let match = matcher.exec(text); match; match = matcher.exec(text)) {
+    lastMatch = match;
+  }
+  if (!lastMatch) {
+    return {
+      cleanedText: text.trim(),
+      draft: null
+    };
+  }
+  const rawBlock = stripCodeFence(lastMatch[1] ?? "");
+  let draft = null;
+  try {
+    const parsed = JSON.parse(rawBlock);
+    draft = {
+      summary: normalizeOptionalText(parsed.summary),
+      interventionType: normalizeOptionalText(parsed.interventionType),
+      blockerCode: normalizeOptionalText(parsed.blockerCode),
+      decisionNeeded: normalizeOptionalText(parsed.decisionNeeded),
+      targetArtifact: normalizeOptionalText(parsed.targetArtifact)
+    };
+  } catch {
+    draft = null;
+  }
+  const cleanedText = `${text.slice(0, lastMatch.index)}${text.slice(lastMatch.index + lastMatch[0].length)}`.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    cleanedText,
+    draft
+  };
+}
+function buildRepeatFingerprint(context, blockerCode, targetArtifact) {
+  if (!blockerCode) {
+    return null;
+  }
+  return [
+    context.taskId,
+    context.memberAgentId,
+    blockerCode,
+    targetArtifact ?? ""
+  ].join("::");
+}
+function buildHappyOrgTurnPrompt(prompt, turn) {
+  const reopenLines = turn.reopenContext ? [
+    "",
+    "This task was explicitly reopened for this turn with the following new inputs:",
+    turn.reopenContext.newContext ? `- newContext: ${turn.reopenContext.newContext}` : null,
+    turn.reopenContext.newDecision ? `- newDecision: ${turn.reopenContext.newDecision}` : null,
+    turn.reopenContext.newResource ? `- newResource: ${turn.reopenContext.newResource}` : null
+  ].filter(Boolean) : [];
+  const header = [
+    "[HAPPY_ORG_TASK_CONTEXT]",
+    `taskId=${turn.context.taskId}`,
+    `organizationId=${turn.context.organizationId}`,
+    `memberAgentId=${turn.context.memberAgentId}`,
+    `supervisorAgentId=${turn.context.supervisorAgentId}`,
+    "Stay on this exact task for the whole turn.",
+    "End your response with exactly one raw JSON block inside these tags and do not wrap it in a markdown code fence:",
+    `<${api.HAPPY_ORG_TURN_REPORT_TAG}>{"summary":"short factual summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null}</${api.HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "Allowed interventionType values: none, review_needed, blocker, decision_needed.",
+    "summary must read like a CEO todo card title: short, actionable, and without long process logs.",
+    "Use blocker only for problems the organization may still solve internally.",
+    "Use decision_needed only when a CEO or user decision is required.",
+    "Use review_needed when supervisor review is needed but the work is not blocked.",
+    ...reopenLines,
+    "[/HAPPY_ORG_TASK_CONTEXT]",
+    "",
+    prompt
+  ];
+  return header.join("\n");
+}
+function resolveHappyOrgQueuedTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  if (!metadata) {
+    return {
+      nextMetadata: null,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const currentHappyOrg = normalizeHappyOrgMetadata(metadata);
+  let nextHappyOrg = cloneHappyOrgMetadata(currentHappyOrg);
+  const messageHappyOrg = opts.message.meta?.happyOrg;
+  const now = opts.now?.() ?? Date.now();
+  const createRunId = opts.createRunId ?? ((taskContext2, currentNow) => `${taskContext2.taskId}:${taskContext2.memberAgentId}:${currentNow}`);
+  if (messageHappyOrg?.taskContext) {
+    const currentTaskId = currentHappyOrg.taskContext?.taskId ?? null;
+    if (currentTaskId !== messageHappyOrg.taskContext.taskId) {
+      nextHappyOrg = resetHappyOrgRuntimeForTask(messageHappyOrg.taskContext);
+    } else {
+      nextHappyOrg.taskContext = { ...messageHappyOrg.taskContext };
+    }
+  }
+  const taskContext = nextHappyOrg.taskContext ?? null;
+  if (!taskContext) {
+    return {
+      nextMetadata: metadata,
+      queuedTurn: null,
+      blocked: false
+    };
+  }
+  const control = messageHappyOrg?.control;
+  if (control?.action === "terminate") {
+    nextHappyOrg.runtime = {
+      status: "terminated",
+      reason: normalizeOptionalText(control.reason) ?? "terminated_by_supervisor",
+      terminatedAt: now
+    };
+    nextHappyOrg.activeOwner = null;
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+    };
+  }
+  const hasReopenInputs = Boolean(
+    normalizeOptionalText(control?.newContext) || normalizeOptionalText(control?.newDecision) || normalizeOptionalText(control?.newResource)
+  );
+  if (nextHappyOrg.runtime?.status === "terminated") {
+    if (control?.action !== "reopen") {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: buildTerminatedStatusMessage(taskContext.taskId)
+      };
+    }
+    if (!hasReopenInputs) {
+      return {
+        nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+        queuedTurn: null,
+        blocked: true,
+        statusMessage: `Task ${taskContext.taskId} can only reopen with new context, a new decision, or a new resource.`
+      };
+    }
+  }
+  const reopenContext = control?.action === "reopen" && hasReopenInputs ? {
+    newContext: normalizeOptionalText(control.newContext),
+    newDecision: normalizeOptionalText(control.newDecision),
+    newResource: normalizeOptionalText(control.newResource)
+  } : void 0;
+  if (reopenContext) {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null,
+      reopenedAt: now
+    };
+  } else if (!nextHappyOrg.runtime) {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null
+    };
+  }
+  if (!nextHappyOrg.activeOwner) {
+    nextHappyOrg.activeOwner = {
+      ownerAgentId: taskContext.memberAgentId,
+      ownerRunId: createRunId(taskContext, now),
+      claimedAt: now
+    };
+  } else if (nextHappyOrg.activeOwner.ownerAgentId !== taskContext.memberAgentId) {
+    return {
+      nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+      queuedTurn: null,
+      blocked: true,
+      statusMessage: buildOwnerConflictStatusMessage(
+        taskContext.taskId,
+        nextHappyOrg.activeOwner.ownerAgentId
+      )
+    };
+  }
+  return {
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    queuedTurn: {
+      context: taskContext,
+      ...reopenContext ? { reopenContext } : {}
+    },
+    blocked: false
+  };
+}
+function finalizeHappyOrgTurn(opts) {
+  const metadata = opts.metadata ?? null;
+  const queuedTurn = opts.queuedTurn ?? null;
+  const { cleanedText, draft } = extractTaggedTurnReport(opts.responseText);
+  if (!metadata || !queuedTurn) {
+    return {
+      cleanedText,
+      report: null,
+      nextMetadata: metadata
+    };
+  }
+  const now = opts.now?.() ?? Date.now();
+  const normalizedDraft = normalizeTurnReportDraft(draft);
+  const report = {
+    ...queuedTurn.context,
+    turnStatus: opts.turnStatus,
+    interventionType: normalizedDraft.interventionType ?? "none",
+    summary: normalizedDraft.summary ?? buildFallbackSummary(cleanedText, opts.turnStatus),
+    blockerCode: normalizedDraft.blockerCode ?? null,
+    decisionNeeded: normalizedDraft.decisionNeeded ?? null,
+    targetArtifact: normalizedDraft.targetArtifact ?? null,
+    repeatFingerprint: buildRepeatFingerprint(
+      queuedTurn.context,
+      normalizedDraft.blockerCode ?? null,
+      normalizedDraft.targetArtifact ?? null
+    )
+  };
+  const nextHappyOrg = normalizeHappyOrgMetadata(metadata);
+  nextHappyOrg.taskContext = { ...queuedTurn.context };
+  nextHappyOrg.lastTurnReport = report;
+  nextHappyOrg.activeOwner = null;
+  nextHappyOrg.repeat = nextHappyOrg.repeat ?? {
+    threshold: api.HAPPY_ORG_REPEAT_THRESHOLD,
+    fingerprints: {}
+  };
+  let terminateMessage;
+  if (report.repeatFingerprint) {
+    const currentEntry = nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] ?? {
+      count: 0};
+    const nextCount = currentEntry.count + 1;
+    nextHappyOrg.repeat.fingerprints[report.repeatFingerprint] = {
+      count: nextCount,
+      lastSeenAt: now
+    };
+    if (nextCount >= nextHappyOrg.repeat.threshold) {
+      nextHappyOrg.runtime = {
+        status: "terminated",
+        reason: `repeat_fingerprint:${report.repeatFingerprint}`,
+        terminatedAt: now
+      };
+      terminateMessage = `Task ${queuedTurn.context.taskId} hit repeat threshold for ${report.repeatFingerprint} and is now terminated until reopen.`;
+    } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+      nextHappyOrg.runtime = {
+        status: "active",
+        reason: null
+      };
+    }
+  } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+    nextHappyOrg.runtime = {
+      status: "active",
+      reason: null
+    };
+  }
+  return {
+    cleanedText,
+    report,
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    terminateMessage
+  };
+}
+
 const DEFAULT_MAX_MESSAGES = 200;
 const DEFAULT_MAX_CHARACTERS = 1e5;
 const DEFAULT_MAX_MESSAGE_CHARACTERS = 8e3;
@@ -1185,14 +1535,17 @@ exports.INTERACTION_TIMED_OUT_ERROR = INTERACTION_TIMED_OUT_ERROR;
 exports.MessageBuffer = MessageBuffer;
 exports.MessageQueue2 = MessageQueue2;
 exports.MissingMachineIdError = MissingMachineIdError;
+exports.buildHappyOrgTurnPrompt = buildHappyOrgTurnPrompt;
 exports.closeProviderSession = closeProviderSession;
 exports.createSessionMetadata = createSessionMetadata;
 exports.ensureManagedProviderMachine = ensureManagedProviderMachine;
+exports.finalizeHappyOrgTurn = finalizeHappyOrgTurn;
 exports.forwardAgentMessageToProviderSession = forwardAgentMessageToProviderSession;
 exports.getPendingInteractionTimeoutMs = getPendingInteractionTimeoutMs;
 exports.hashObject = hashObject;
 exports.inferToolResultError = inferToolResultError;
 exports.launchRuntimeHandleWithFactoryResult = launchRuntimeHandleWithFactoryResult;
 exports.registerKillSessionHandler = registerKillSessionHandler;
+exports.resolveHappyOrgQueuedTurn = resolveHappyOrgQueuedTurn;
 exports.syncControlledByUserState = syncControlledByUserState;
 exports.waitForResponseCompleteWithAbort = waitForResponseCompleteWithAbort;