happy-imou-cloud 2.0.20 → 2.0.22

package/bin/happy-cloud.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { execFileSync } from 'child_process';
 import { fileURLToPath } from 'url';

package/dist/{BaseReasoningProcessor-B9z785Pi.cjs → BaseReasoningProcessor-CJVv1aNR.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var index = require('./index-0TIyXMQu.cjs');
-var api = require('./api-BKnzORe4.cjs');
-var registerKillSessionHandler = require('./registerKillSessionHandler-BMUE5Oaj.cjs');
+var index = require('./index-CqCEZDFi.cjs');
+var api = require('./api-DP-RQUao.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-QmBN446A.cjs');
 var node_events = require('node:events');
 var node_crypto = require('node:crypto');
 

package/dist/{BaseReasoningProcessor-iTk5q5Vy.mjs → BaseReasoningProcessor-mIqqngd3.mjs}

@@ -1,6 +1,6 @@
-import { p as publishSessionRegistration } from './index-Bg4KLXYY.mjs';
-import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-_Y2kzqZL.mjs';
-import { c as createSessionMetadata } from './registerKillSessionHandler-DJMH-gar.mjs';
+import { p as publishSessionRegistration } from './index-BIki80pQ.mjs';
+import { s as startOfflineReconnection, c as configuration, i as isAuthenticationRequiredError, l as logger } from './api-DrijKeDb.mjs';
+import { c as createSessionMetadata } from './registerKillSessionHandler-CHEj7UjN.mjs';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
 

package/dist/ProviderSelectionHandler-BjLyIfSR.mjs

@@ -0,0 +1,673 @@
+import { H as HAPPY_ORG_REPEAT_THRESHOLD, b as HAPPY_ORG_TURN_REPORT_TAG, d as HAPPY_ORG_SUMMARY_MAX_LENGTH, l as logger } from './api-DrijKeDb.mjs';
+import { g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, a as INTERACTION_TIMED_OUT_ERROR } from './registerKillSessionHandler-CHEj7UjN.mjs';
+
+async function runModeLoop(opts) {
+  let currentMode = opts.startingMode;
+  if (opts.notifyInitialMode) {
+    await opts.onModeChange?.(currentMode);
+  }
+  while (true) {
+    opts.onIteration?.(currentMode);
+    const result = await opts.launchers[currentMode]();
+    if (result.type === "exit") {
+      return result.value;
+    }
+    currentMode = result.mode;
+    await opts.onModeChange?.(currentMode);
+  }
+}
+
+function createKeepAliveController(opts) {
+  let thinking = opts.initialThinking ?? false;
+  let mode = opts.initialMode;
+  let disposed = false;
+  const sync = () => {
+    if (disposed) {
+      return;
+    }
+    opts.send(thinking, mode);
+  };
+  sync();
+  const intervalId = setInterval(sync, opts.intervalMs ?? 2e3);
+  return {
+    dispose: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      clearInterval(intervalId);
+    },
+    getMode: () => mode,
+    getThinking: () => thinking,
+    setMode: (nextMode) => {
+      mode = nextMode;
+      sync();
+    },
+    setThinking: (nextThinking) => {
+      thinking = nextThinking;
+      sync();
+    },
+    sync
+  };
+}
+
+function normalizeOptionalText(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeSummaryText(value) {
+  const normalized = normalizeOptionalText(value);
+  return normalized ? normalized.replace(/\s+/g, " ").slice(0, HAPPY_ORG_SUMMARY_MAX_LENGTH) : 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: 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: 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 buildMemberBusyStatusMessage(memberAgentId, activeTaskId, nextTaskId) {
+  return `Member ${memberAgentId} is already busy with active task ${activeTaskId}. Reject task ${nextTaskId} without continuing token usage.`;
+}
+function buildOwnerConflictStatusMessage(taskId, ownerAgentId) {
+  return `Task ${taskId} is already active under owner ${ownerAgentId}. This turn must exit without continuing token usage.`;
+}
+function inferDraftTurnStatus(draft) {
+  if (draft?.turnStatus === "turn_update" || draft?.turnStatus === "task_complete") {
+    return draft.turnStatus;
+  }
+  return null;
+}
+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, HAPPY_ORG_SUMMARY_MAX_LENGTH);
+  }
+  return turnStatus === "turn_aborted" ? "Turn aborted before completion." : "Turn completed without a textual summary.";
+}
+function normalizeTurnReportDraft(draft) {
+  return {
+    turnStatus: inferDraftTurnStatus(draft),
+    summary: normalizeSummaryText(draft?.summary),
+    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(
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>\\s*([\\s\\S]*?)\\s*</${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 = {
+      turnStatus: normalizeOptionalText(parsed.turnStatus),
+      summary: normalizeSummaryText(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 resolveReportedTurnStatus(transportTurnStatus, draft) {
+  if (transportTurnStatus === "turn_aborted") {
+    return "turn_aborted";
+  }
+  return draft.turnStatus === "task_complete" ? "task_complete" : "turn_update";
+}
+function buildRuntimeStateAfterTurn(report) {
+  if (report.turnStatus === "task_complete") {
+    return {
+      status: "waiting_close",
+      reason: "awaiting_ceo_close"
+    };
+  }
+  switch (report.interventionType) {
+    case "decision_needed":
+      return {
+        status: "waiting_decision",
+        reason: "awaiting_user_decision"
+      };
+    case "review_needed":
+      return {
+        status: "waiting_review",
+        reason: "awaiting_ceo_review"
+      };
+    case "blocker":
+      return {
+        status: "waiting_review",
+        reason: "awaiting_ceo_context"
+      };
+    default:
+      return {
+        status: "active",
+        reason: null
+      };
+  }
+}
+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:",
+    `<${HAPPY_ORG_TURN_REPORT_TAG}>{"turnStatus":"turn_update","summary":"short task-board summary","interventionType":"none","blockerCode":null,"decisionNeeded":null,"targetArtifact":null}</${HAPPY_ORG_TURN_REPORT_TAG}>`,
+    "Allowed turnStatus values in the JSON block: turn_update, task_complete.",
+    "Allowed interventionType values: none, review_needed, blocker, decision_needed.",
+    "Use turnStatus=task_complete only when you believe the assigned task is finished and ready for CEO acceptance.",
+    "If turnStatus=task_complete, the task will wait for CEO close; do not treat it as automatically closed.",
+    "If turnStatus=task_complete, interventionType must be review_needed.",
+    `summary must fit on a one-line CEO card or task-board card: short, actionable, no long process logs, max ${HAPPY_ORG_SUMMARY_MAX_LENGTH} characters.`,
+    "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) {
+      if (currentHappyOrg.taskContext && currentHappyOrg.runtime?.status === "active") {
+        return {
+          nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+          queuedTurn: null,
+          blocked: true,
+          statusMessage: buildMemberBusyStatusMessage(
+            currentHappyOrg.taskContext.memberAgentId,
+            currentHappyOrg.taskContext.taskId,
+            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") {
+    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 reportTurnStatus = resolveReportedTurnStatus(opts.turnStatus, normalizedDraft);
+  const report = {
+    ...queuedTurn.context,
+    turnStatus: reportTurnStatus,
+    interventionType: reportTurnStatus === "task_complete" ? "review_needed" : normalizedDraft.interventionType ?? "none",
+    summary: normalizedDraft.summary ?? buildFallbackSummary(cleanedText, reportTurnStatus),
+    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: 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 = buildRuntimeStateAfterTurn(report);
+    }
+  } else if (!nextHappyOrg.runtime || nextHappyOrg.runtime.status !== "terminated") {
+    nextHappyOrg.runtime = buildRuntimeStateAfterTurn(report);
+  }
+  return {
+    cleanedText,
+    report,
+    nextMetadata: withHappyOrgMetadata(metadata, nextHappyOrg),
+    terminateMessage
+  };
+}
+
+class ProviderSelectionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  providerLabel;
+  constructor(session, providerLabel) {
+    this.session = session;
+    this.providerLabel = providerLabel;
+    this.setupRpcHandler();
+  }
+  updateSession(newSession) {
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  async requestSelection(request) {
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        request
+      };
+      pending.timeoutHandle = setTimeout(() => {
+        this.handleSelectionTimeout(request.id, pending);
+      }, getPendingInteractionTimeoutMs());
+      this.pendingRequests.set(request.id, pending);
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        requests: {
+          ...currentState.requests,
+          [request.id]: {
+            tool: "AskUserQuestion",
+            arguments: {
+              requestKind: "selection",
+              questions: [
+                {
+                  header: this.providerLabel,
+                  question: request.message,
+                  multiSelect: false,
+                  options: request.options.map((option) => ({
+                    label: option.label,
+                    description: option.description || option.optionId,
+                    optionId: option.optionId
+                  }))
+                }
+              ]
+            },
+            createdAt: Date.now(),
+            requestKind: "selection",
+            options: request.options,
+            defaultOptionId: request.defaultOptionId
+          }
+        }
+      }));
+      logger.debug(`[${this.providerLabel}] Selection request sent (${request.id}) with ${request.options.length} options`);
+    });
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0;
+  }
+  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) {
+      return 0;
+    }
+    this.pendingRequests.clear();
+    const completedAt = Date.now();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt,
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+    logger.debug(`[${this.providerLabel}] Superseded ${pendingSnapshot.length} pending selection request(s)`);
+    return pendingSnapshot.length;
+  }
+  reset(reason = "Session reset") {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    this.pendingRequests.clear();
+    for (const [, pending] of pendingSnapshot) {
+      this.clearPendingRequestTimeout(pending);
+      pending.reject(new Error(reason));
+    }
+    this.session.updateAgentState((currentState) => {
+      const requests = { ...currentState.requests || {} };
+      const completedRequests = { ...currentState.completedRequests || {} };
+      for (const [id, request] of Object.entries(requests)) {
+        if (request.requestKind !== "selection") {
+          continue;
+        }
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason,
+          requestKind: "selection"
+        };
+        delete requests[id];
+      }
+      return {
+        ...currentState,
+        requests,
+        completedRequests
+      };
+    });
+  }
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler("selection", async (response) => {
+      const pending = this.pendingRequests.get(response.id);
+      if (!pending) {
+        logger.debug(`[${this.providerLabel}] Selection request not found or already resolved`);
+        return;
+      }
+      this.pendingRequests.delete(response.id);
+      this.clearPendingRequestTimeout(pending);
+      pending.resolve(response);
+      this.session.updateAgentState((currentState) => {
+        const request = currentState.requests?.[response.id];
+        if (!request) {
+          return currentState;
+        }
+        const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+        return {
+          ...currentState,
+          requests: remainingRequests,
+          completedRequests: {
+            ...currentState.completedRequests,
+            [response.id]: {
+              ...request,
+              completedAt: Date.now(),
+              status: "approved",
+              requestKind: "selection",
+              selectedOptionId: response.optionId
+            }
+          }
+        };
+      });
+    });
+  }
+  clearPendingRequestTimeout(pending) {
+    if (pending?.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+      pending.timeoutHandle = void 0;
+    }
+  }
+  handleSelectionTimeout(requestId, pending) {
+    const active = this.pendingRequests.get(requestId);
+    if (!active || active !== pending) {
+      return;
+    }
+    this.pendingRequests.delete(requestId);
+    this.clearPendingRequestTimeout(active);
+    active.reject(new Error(INTERACTION_TIMED_OUT_ERROR));
+    this.session.updateAgentState((currentState) => {
+      const request = currentState.requests?.[requestId] || {
+        tool: "AskUserQuestion",
+        arguments: {
+          requestKind: "selection",
+          questions: []
+        },
+        createdAt: Date.now(),
+        requestKind: "selection",
+        options: active.request.options,
+        defaultOptionId: active.request.defaultOptionId
+      };
+      const { [requestId]: _, ...remainingRequests } = currentState.requests || {};
+      return {
+        ...currentState,
+        requests: remainingRequests,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [requestId]: {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason: INTERACTION_TIMED_OUT_ERROR,
+            requestKind: "selection"
+          }
+        }
+      };
+    });
+    this.session.sendSessionEvent({
+      type: "message",
+      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
+    });
+    logger.debug(`[${this.providerLabel}] Selection request timed out (${requestId})`);
+  }
+}
+
+export { ProviderSelectionHandler as P, resolveHappyOrgQueuedTurn as a, buildHappyOrgTurnPrompt as b, createKeepAliveController as c, finalizeHappyOrgTurn as f, runModeLoop as r };