@letta-ai/letta-code 0.30.18 → 0.30.20

package/dist/gateway-core.js

@@ -1,3 +1,490 @@
+// src/channels/interactive.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isAffirmativeResponse(text) {
+  const normalized = normalizeWhitespace(text).toLowerCase();
+  return [
+    "approve",
+    "approved",
+    "allow",
+    "yes",
+    "y",
+    "ok",
+    "okay",
+    "continue",
+    "go ahead",
+    "looks good",
+    "lgtm",
+    "sgtm",
+    "ship it"
+  ].includes(normalized);
+}
+function stripApprovalPrefix(text) {
+  return normalizeWhitespace(text.replace(/^(approve|allow|yes|y|ok|okay|deny|reject|no|n)\s*[:-]?\s*/i, ""));
+}
+function summarizeControlRequestInput(input) {
+  const serialized = JSON.stringify(input, null, 2);
+  if (!serialized || serialized === "{}") {
+    return null;
+  }
+  if (serialized.length <= 1200) {
+    return serialized;
+  }
+  return `${serialized.slice(0, 1197).trimEnd()}...`;
+}
+function buildQuestionPrompt(question, index) {
+  const lines = [
+    `${index + 1}. ${question.question ?? `Question ${index + 1}`}`
+  ];
+  const options = question.options ?? [];
+  options.forEach((option, optionIndex) => {
+    const label = option.label?.trim() || `Option ${optionIndex + 1}`;
+    const description = option.description?.trim();
+    lines.push(description ? `   ${optionIndex + 1}) ${label} — ${description}` : `   ${optionIndex + 1}) ${label}`);
+  });
+  if (question.multiSelect) {
+    lines.push("   Choose one or more options. Separate multiple answers with commas.");
+  }
+  return lines;
+}
+function matchQuestionOption(question, text) {
+  const trimmed = normalizeWhitespace(text);
+  const options = question.options ?? [];
+  if (!trimmed || options.length === 0) {
+    return trimmed;
+  }
+  const numberMatch = trimmed.match(/^(\d+)$/);
+  if (numberMatch?.[1]) {
+    const option = options[Number(numberMatch[1]) - 1];
+    if (option?.label?.trim()) {
+      return option.label.trim();
+    }
+  }
+  const exactLabel = options.find((option) => option.label && normalizeWhitespace(option.label).toLowerCase() === trimmed.toLowerCase());
+  if (exactLabel?.label?.trim()) {
+    return exactLabel.label.trim();
+  }
+  const trimmedLower = trimmed.toLowerCase();
+  const exactAlias = options.find((option) => optionAliases(option).some((alias) => normalizeWhitespace(alias).toLowerCase() === trimmedLower));
+  if (exactAlias?.label?.trim()) {
+    return exactAlias.label.trim();
+  }
+  if (/^(recommended|default|defaults)$/i.test(trimmed)) {
+    const recommended = options.find((option) => {
+      const label = option.label?.toLowerCase() ?? "";
+      const description = option.description?.toLowerCase() ?? "";
+      return label.includes("recommended") || description.includes("recommended");
+    });
+    if (recommended?.label?.trim()) {
+      return recommended.label.trim();
+    }
+  }
+  return trimmed;
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function optionAliases(option) {
+  const aliases = new Set;
+  const label = normalizeWhitespace(option.label ?? "");
+  if (label) {
+    aliases.add(label);
+    const withoutParenthetical = normalizeWhitespace(label.replace(/\s*\([^)]*\)\s*/g, " "));
+    if (withoutParenthetical) {
+      aliases.add(withoutParenthetical);
+    }
+  }
+  return Array.from(aliases).filter((alias) => alias.length >= 3);
+}
+function containsPhrase(text, phrase) {
+  const normalizedText = normalizeWhitespace(text);
+  const normalizedPhrase = normalizeWhitespace(phrase);
+  if (!normalizedText || !normalizedPhrase) {
+    return false;
+  }
+  const escapedPhrase = escapeRegExp(normalizedPhrase).replace(/\s+/g, "\\s+");
+  return new RegExp(`(^|\\W)${escapedPhrase}(?=$|\\W)`, "i").test(normalizedText);
+}
+function inferQuestionAnswerFromText(question, rawText) {
+  const options = question.options ?? [];
+  const matches = options.filter((option) => optionAliases(option).some((alias) => containsPhrase(rawText, alias))).map((option) => option.label?.trim()).filter((label) => Boolean(label));
+  const uniqueMatches = Array.from(new Set(matches));
+  if (uniqueMatches.length === 1) {
+    return uniqueMatches[0] ?? null;
+  }
+  const normalized = normalizeWhitespace(rawText).toLowerCase();
+  if (/\b(recommended|default|defaults|you decide|whatever you recommend)\b/.test(normalized)) {
+    const recommended = options.find((option) => {
+      const label = option.label?.toLowerCase() ?? "";
+      const description = option.description?.toLowerCase() ?? "";
+      return label.includes("recommended") || description.includes("recommended");
+    });
+    if (recommended?.label?.trim()) {
+      return recommended.label.trim();
+    }
+  }
+  return null;
+}
+function matchQuestionAnswer(question, text) {
+  if (!question.multiSelect) {
+    return matchQuestionOption(question, text);
+  }
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return normalized;
+  }
+  const selections = normalized.replace(/\band\b/gi, ",").split(/\s*(?:,|\/|;)\s*/).map((entry) => normalizeWhitespace(entry)).filter(Boolean);
+  if (selections.length <= 1) {
+    return matchQuestionOption(question, normalized);
+  }
+  const matchedSelections = Array.from(new Set(selections.map((selection) => matchQuestionOption(question, selection)).filter(Boolean)));
+  return matchedSelections.length > 0 ? matchedSelections.join(", ") : normalized;
+}
+function parseNumberedAnswers(rawText, questions) {
+  const matches = Array.from(rawText.matchAll(/(?:^|\n)\s*(\d+)[).:-]\s*(.+?)(?=(?:\n\s*\d+[).:-]\s*)|$)/gs));
+  if (matches.length === 0) {
+    return null;
+  }
+  const answers = {};
+  for (const match of matches) {
+    const questionIndex = Number(match[1]) - 1;
+    const question = questions[questionIndex];
+    const answerText = match[2]?.trim();
+    if (!question?.question || !answerText) {
+      continue;
+    }
+    answers[question.question] = matchQuestionAnswer(question, answerText);
+  }
+  return Object.keys(answers).length > 0 ? answers : null;
+}
+function parsePositionalAnswers(rawText, questions) {
+  const lines = rawText.split(/\r?\n/).map((line) => normalizeWhitespace(line)).filter(Boolean);
+  if (lines.length === questions.length) {
+    const answers = {};
+    questions.forEach((question, index) => {
+      if (question.question) {
+        answers[question.question] = matchQuestionAnswer(question, lines[index] ?? "");
+      }
+    });
+    return answers;
+  }
+  const normalized = normalizeWhitespace(rawText);
+  const compactParts = normalized.split(/\s*(?:,|\/|;)\s*/).map((part) => normalizeWhitespace(part)).filter(Boolean);
+  if (compactParts.length === questions.length && compactParts.every((part) => /^\d+$/.test(part))) {
+    const answers = {};
+    questions.forEach((question, index) => {
+      if (question.question) {
+        answers[question.question] = matchQuestionAnswer(question, compactParts[index] ?? "");
+      }
+    });
+    return answers;
+  }
+  return null;
+}
+function parseFlexibleMultiQuestionAnswers(rawText, questions) {
+  const normalized = normalizeWhitespace(rawText);
+  if (!normalized) {
+    return null;
+  }
+  const positionalAnswers = parsePositionalAnswers(rawText, questions);
+  if (positionalAnswers) {
+    return positionalAnswers;
+  }
+  const answers = {};
+  for (const question of questions) {
+    if (!question.question) {
+      continue;
+    }
+    const inferred = inferQuestionAnswerFromText(question, rawText);
+    if (inferred) {
+      answers[question.question] = inferred;
+    }
+  }
+  const hasInferredAnswers = Object.keys(answers).length > 0;
+  for (const question of questions) {
+    if (!question.question || Object.hasOwn(answers, question.question)) {
+      continue;
+    }
+    answers[question.question] = hasInferredAnswers ? `Not specified. Full user reply: ${normalized}` : normalized;
+  }
+  return Object.keys(answers).length > 0 ? answers : null;
+}
+function buildAllowResponse(requestId, decision) {
+  return {
+    request_id: requestId,
+    decision
+  };
+}
+function buildDenyResponse(requestId, message) {
+  return {
+    request_id: requestId,
+    decision: {
+      behavior: "deny",
+      message
+    }
+  };
+}
+function getAskUserQuestionInput(input) {
+  return input;
+}
+function formatAskUserQuestionPrompt(event) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  const lines = [
+    "SYSTEM MESSAGE — reply required to continue",
+    "",
+    ...questions.flatMap((question, index) => buildQuestionPrompt(question, index)),
+    ""
+  ];
+  if (questions.length <= 1) {
+    const singleQuestion = questions[0];
+    lines.push(singleQuestion?.multiSelect ? "Reply with one or more option numbers/labels separated by commas, or just send a freeform answer in your next message." : "Reply with an option number/label, or just send a freeform answer in your next message.");
+  } else {
+    lines.push("Reply in plain language, or answer each question separately with numbered lines:", "1: your answer", "2: your answer", "", "Option numbers/labels work too. For multi-select questions, separate multiple answers with commas.");
+  }
+  return lines.join(`
+`);
+}
+function formatGenericToolApprovalPrompt(event) {
+  const inputSummary = summarizeControlRequestInput(event.input);
+  const lines = [`The agent wants approval to run \`${event.toolName}\`.`];
+  if (inputSummary) {
+    lines.push("", "Tool input:", inputSummary);
+  }
+  lines.push("", "Reply `approve` to allow it.", "Reply with feedback instead if you want to deny it.");
+  return lines.join(`
+`);
+}
+function formatChannelControlRequestPrompt(event) {
+  switch (event.kind) {
+    case "ask_user_question":
+      return formatAskUserQuestionPrompt(event);
+    case "generic_tool_approval":
+      return formatGenericToolApprovalPrompt(event);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+function parseAskUserQuestionResponse(event, rawText) {
+  const input = getAskUserQuestionInput(event.input);
+  const questions = (input.questions ?? []).filter((question) => normalizeWhitespace(question.question ?? ""));
+  if (questions.length === 0) {
+    return {
+      type: "reprompt",
+      message: "I couldn't find the original question payload. Please ask the agent to try again."
+    };
+  }
+  if (questions.length === 1) {
+    const [question] = questions;
+    if (!question?.question) {
+      return {
+        type: "reprompt",
+        message: "I couldn't find the original question text. Please ask the agent to try again."
+      };
+    }
+    const answer = matchQuestionAnswer(question, rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        updated_input: {
+          ...event.input,
+          answers: {
+            ...input.answers ?? {},
+            [question.question]: answer
+          }
+        }
+      })
+    };
+  }
+  const numberedAnswers = parseNumberedAnswers(rawText, questions);
+  const answers = numberedAnswers ?? parseFlexibleMultiQuestionAnswers(rawText, questions);
+  if (!answers) {
+    return {
+      type: "reprompt",
+      message: "Please send a reply so I can pass it back to the agent. You can answer naturally or use numbered lines like `1: ...` and `2: ...`."
+    };
+  }
+  return {
+    type: "response",
+    response: buildAllowResponse(event.requestId, {
+      behavior: "allow",
+      updated_input: {
+        ...event.input,
+        answers: {
+          ...input.answers ?? {},
+          ...answers
+        }
+      }
+    })
+  };
+}
+function parseGenericToolApprovalResponse(event, rawText) {
+  if (isAffirmativeResponse(rawText)) {
+    const message = stripApprovalPrefix(rawText);
+    return {
+      type: "response",
+      response: buildAllowResponse(event.requestId, {
+        behavior: "allow",
+        ...message ? { message } : {}
+      })
+    };
+  }
+  const feedback = stripApprovalPrefix(rawText);
+  return {
+    type: "response",
+    response: buildDenyResponse(event.requestId, feedback || "Denied by channel user.")
+  };
+}
+function parseChannelControlRequestResponse(event, rawText) {
+  const trimmed = rawText.trim();
+  if (!trimmed) {
+    return {
+      type: "reprompt",
+      message: formatChannelControlRequestPrompt(event)
+    };
+  }
+  switch (event.kind) {
+    case "ask_user_question":
+      return parseAskUserQuestionResponse(event, trimmed);
+    case "generic_tool_approval":
+      return parseGenericToolApprovalResponse(event, trimmed);
+    default: {
+      const exhaustiveCheck = event.kind;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+// src/channels/control-request-coordinator.ts
+function getChannelControlRequestScopeKey(params) {
+  return [
+    params.channel,
+    params.accountId ?? "default",
+    params.chatId,
+    params.threadId ?? ""
+  ].join(":");
+}
+function cloneEvent(event) {
+  return structuredClone(event);
+}
+
+class ChannelControlRequestCoordinator {
+  options;
+  pendingById = new Map;
+  requestIdByScope = new Map;
+  constructor(options) {
+    this.options = options;
+  }
+  restore(events) {
+    for (const event of events) {
+      this.remember(event, false);
+    }
+  }
+  has(requestId) {
+    return this.pendingById.has(requestId);
+  }
+  getAll() {
+    return Array.from(this.pendingById.values()).map((pending) => ({
+      event: cloneEvent(pending.event),
+      deliveredThisProcess: pending.deliveredThisProcess
+    }));
+  }
+  async register(event) {
+    const scopeKey = getChannelControlRequestScopeKey(event.source);
+    const existingRequestId = this.requestIdByScope.get(scopeKey);
+    if (existingRequestId && existingRequestId !== event.requestId) {
+      await this.clear(existingRequestId);
+    }
+    this.remember(event, false);
+    await this.options.persist(cloneEvent(event));
+    await this.deliver(event.requestId);
+  }
+  async redeliver(requestId) {
+    return this.deliver(requestId);
+  }
+  async handleNativeResponse(input) {
+    const pending = this.pendingById.get(input.requestId);
+    if (!pending)
+      return "expired";
+    const source = pending.event.source;
+    if (source.channel !== input.channel || (source.accountId ?? "default") !== (input.accountId ?? "default") || source.chatId !== input.chatId || (source.threadId ?? null) !== (input.threadId ?? null) || source.senderId && source.senderId !== input.senderId) {
+      return "forbidden";
+    }
+    const result = await this.options.deliverResponse(cloneEvent(pending.event), input.response);
+    if (result === "handled" || result === "expired") {
+      await this.clear(input.requestId);
+    }
+    return result;
+  }
+  async tryHandleInbound(input) {
+    if (input.bypass)
+      return false;
+    const requestId = this.requestIdByScope.get(getChannelControlRequestScopeKey(input));
+    if (!requestId)
+      return false;
+    const pending = this.pendingById.get(requestId);
+    if (!pending) {
+      this.requestIdByScope.delete(getChannelControlRequestScopeKey(input));
+      return false;
+    }
+    if (pending.event.source.senderId && pending.event.source.senderId !== input.senderId) {
+      return false;
+    }
+    if (input.channel === "slack" && pending.event.kind === "generic_tool_approval") {
+      return false;
+    }
+    const parsed = parseChannelControlRequestResponse(pending.event, input.text);
+    if (parsed.type === "reprompt") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, parsed.message);
+      return true;
+    }
+    const result = await this.options.deliverResponse(cloneEvent(pending.event), parsed.response);
+    if (result === "unavailable") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, "I’m reconnecting to Letta Code right now, so I couldn’t use that reply yet. Please send it again in a moment.");
+      return true;
+    }
+    await this.clear(requestId);
+    if (result === "expired") {
+      await this.options.deliverReprompt(cloneEvent(pending.event), input, "That approval prompt expired before I could use your reply. Please ask the agent to try again.");
+    }
+    return true;
+  }
+  async clear(requestId) {
+    const pending = this.pendingById.get(requestId);
+    if (pending) {
+      this.pendingById.delete(requestId);
+      const scopeKey = getChannelControlRequestScopeKey(pending.event.source);
+      if (this.requestIdByScope.get(scopeKey) === requestId) {
+        this.requestIdByScope.delete(scopeKey);
+      }
+    }
+    await this.options.remove(requestId);
+  }
+  clearAll() {
+    this.pendingById.clear();
+    this.requestIdByScope.clear();
+  }
+  remember(event, deliveredThisProcess) {
+    const nextEvent = cloneEvent(event);
+    this.pendingById.set(event.requestId, {
+      event: nextEvent,
+      deliveredThisProcess
+    });
+    this.requestIdByScope.set(getChannelControlRequestScopeKey(event.source), event.requestId);
+  }
+  async deliver(requestId) {
+    const pending = this.pendingById.get(requestId);
+    if (!pending)
+      return false;
+    await this.options.deliverPrompt(cloneEvent(pending.event));
+    pending.deliveredThisProcess = true;
+    return true;
+  }
+}
 // src/tools/interactive-policy.ts
 var INTERACTIVE_APPROVAL_TOOLS = new Set(["AskUserQuestion"]);
 var INTERACTIVE_USER_INPUT_TOOL_NAMES = [
@@ -846,7 +1333,7 @@ var MAX_ACCEPTED_CLIENT_MESSAGE_IDS = 2048;
 function runtimeKey(runtime) {
   return `${runtime.agent_id}:${runtime.conversation_id}`;
 }
-function sourceKey(source) {
+function sourceRouteKey(source) {
   return [
     source.channel,
     source.accountId ?? "",
@@ -854,12 +1341,26 @@ function sourceKey(source) {
     source.threadId ?? ""
   ].join(":");
 }
-function uniqueSources(sources) {
+function sourceLifecycleKey(source) {
+  return [
+    sourceRouteKey(source),
+    source.messageId ?? "",
+    source.agentId,
+    source.conversationId
+  ].join(":");
+}
+function uniqueSourcesBy(sources, getKey) {
   const byKey = new Map;
   for (const source of sources)
-    byKey.set(sourceKey(source), source);
+    byKey.set(getKey(source), source);
   return [...byKey.values()];
 }
+function uniqueRoutedSources(sources) {
+  return uniqueSourcesBy(sources, sourceRouteKey);
+}
+function uniqueLifecycleSources(sources) {
+  return uniqueSourcesBy(sources, sourceLifecycleKey);
+}
 function channelTagsForSources(sources) {
   return [...new Set(sources.map((source) => `channel:${source.channel}`))];
 }
@@ -892,7 +1393,7 @@ class ChannelGateway {
     this.disposers.push(client.onMessage((message) => this.handleMessage(message)), client.onExternalToolCall((request) => {
       const state = request.runtime ? this.states.get(runtimeKey(request.runtime)) : undefined;
       const active = state?.active;
-      const sources = active?.sources ?? state?.routedSources ?? [];
+      const sources = active?.routingSources ?? state?.routedSources ?? [];
       return hooks.executeExternalTool(request, sources, active?.idempotencyScope ?? null);
     }));
   }
@@ -919,12 +1420,12 @@ class ChannelGateway {
       return true;
     }
     state.pendingSourcesByClientMessageId.set(delivery.clientMessageId, {
-      sources: uniqueSources(delivery.sources),
+      sources: uniqueLifecycleSources(delivery.sources),
       disposition: "submitting"
     });
     try {
       await this.enqueueRegistration(async () => {
-        state.routedSources = uniqueSources([
+        state.routedSources = uniqueRoutedSources([
           ...state.routedSources,
           ...delivery.sources
         ]);
@@ -962,8 +1463,8 @@ class ChannelGateway {
         const pending = state.pendingSourcesByClientMessageId.get(delivery.clientMessageId);
         if (pending) {
           pending.disposition = "queued";
-          pending.acceptedAtQueueRevision = state.queueRevision;
         }
+        this.reconcileExplicitQueueRemovals(state);
       }
       await Promise.all(queuedEvents);
       return true;
@@ -979,7 +1480,8 @@ class ChannelGateway {
     if (!state.active) {
       recoveredTurn = {
         batchId: `channel-recovered-${crypto.randomUUID()}`,
-        sources: uniqueSources(sources),
+        routingSources: uniqueRoutedSources(sources),
+        lifecycleSources: uniqueLifecycleSources(sources),
         progress: createChannelTurnProgressBuilder(),
         richDraft: null,
         idempotencyScope: createMessageChannelIdempotencyScope()
@@ -1012,6 +1514,38 @@ class ChannelGateway {
       });
     });
   }
+  async publishRuntimeTools(runtime, sources = []) {
+    return await this.enqueueRegistration(async () => {
+      if (this.states.has(runtimeKey(runtime)))
+        return false;
+      const tool = await this.hooks.buildExternalTool(runtime, sources);
+      const response = await this.client.runtimeExternalToolsUpdate({
+        updates: [
+          {
+            runtimes: [runtime],
+            external_tools: tool ? [{ tools: [tool] }] : []
+          }
+        ]
+      });
+      if (!response.success) {
+        throw new Error(response.error ?? "Failed to publish channel runtime tools");
+      }
+      return tool !== null;
+    });
+  }
+  async releaseRuntimeTools(runtime, routedSources = []) {
+    await this.enqueueRegistration(async () => {
+      if (routedSources.length > 0 || this.states.has(runtimeKey(runtime))) {
+        return;
+      }
+      const response = await this.client.runtimeExternalToolsUpdate({
+        updates: [{ runtimes: [runtime], external_tools: [] }]
+      });
+      if (!response.success) {
+        throw new Error(response.error ?? "Failed to release channel runtime tools");
+      }
+    });
+  }
   async submitApprovalResponse(runtime, response) {
     const result = await this.client.submitInput({
       runtime,
@@ -1020,7 +1554,7 @@ class ChannelGateway {
     return result.accepted;
   }
   setRoutedSources(runtime, sources) {
-    this.getState(runtime).routedSources = uniqueSources(sources);
+    this.getState(runtime).routedSources = uniqueRoutedSources(sources);
   }
   getKnownRuntimes() {
     return [...this.states.values()].map((state) => state.runtime);
@@ -1057,7 +1591,6 @@ class ChannelGateway {
       state = {
         runtime,
         pendingSourcesByClientMessageId: new Map,
-        queueRevision: 0,
         active: null,
         registrationSignature: null,
         registration: null,
@@ -1174,43 +1707,81 @@ class ChannelGateway {
   }
   handleQueueUpdate(message) {
     const state = this.getState(message.runtime);
-    state.queueRevision += 1;
-    const nextQueued = new Set(message.queue.map((entry) => entry.client_message_id));
-    const removed = [];
+    for (const transition of message.removed) {
+      const pending = state.pendingSourcesByClientMessageId.get(transition.client_message_id);
+      if (pending) {
+        pending.removalDisposition = transition.disposition;
+      }
+    }
+    this.reconcileExplicitQueueRemovals(state);
+  }
+  reconcileExplicitQueueRemovals(state) {
+    const dequeued = [];
+    const cancelled = [];
     for (const [
       clientMessageId,
       pending
     ] of state.pendingSourcesByClientMessageId) {
-      if (pending.disposition === "queued" && state.queueRevision > (pending.acceptedAtQueueRevision ?? -1) && !nextQueued.has(clientMessageId)) {
-        removed.push({ clientMessageId, sources: pending.sources });
-        state.pendingSourcesByClientMessageId.delete(clientMessageId);
-      }
-    }
-    if (!state.active && removed.length > 0) {
-      const first = removed[0];
-      if (first) {
-        this.activateSources(state, first.clientMessageId, removed.flatMap((entry) => entry.sources));
+      if (pending.disposition !== "queued" || !pending.removalDisposition) {
+        continue;
       }
+      const target = pending.removalDisposition === "dequeued" ? dequeued : cancelled;
+      target.push({ clientMessageId, sources: pending.sources });
+      state.pendingSourcesByClientMessageId.delete(clientMessageId);
+    }
+    const firstDequeued = dequeued[0];
+    if (firstDequeued) {
+      this.activateSources(state, firstDequeued.clientMessageId, dequeued.flatMap((entry) => entry.sources));
+    }
+    for (const entry of cancelled) {
+      this.enqueueHook(state, () => this.hooks.onLifecycle({
+        type: "finished",
+        batchId: `channel-${entry.clientMessageId}`,
+        sources: entry.sources,
+        outcome: "cancelled",
+        stopReason: "cancelled"
+      }));
     }
   }
   activateSources(state, clientMessageId, sources) {
     if (state.active) {
+      const knownLifecycleKeys = new Set(state.active.lifecycleSources.map(sourceLifecycleKey));
+      const addedLifecycleSources = uniqueLifecycleSources(sources).filter((source) => !knownLifecycleKeys.has(sourceLifecycleKey(source)));
+      if (addedLifecycleSources.length === 0)
+        return;
+      state.active.lifecycleSources = uniqueLifecycleSources([
+        ...state.active.lifecycleSources,
+        ...addedLifecycleSources
+      ]);
+      state.active.routingSources = uniqueRoutedSources([
+        ...state.active.routingSources,
+        ...sources
+      ]);
+      const processingEvent2 = {
+        type: "processing",
+        batchId: state.active.batchId,
+        sources: addedLifecycleSources
+      };
+      this.enqueueHook(state, () => this.hooks.onLifecycle(processingEvent2));
       return;
     }
+    const routingSources = uniqueRoutedSources(sources);
+    const lifecycleSources = uniqueLifecycleSources(sources);
     state.active = {
       batchId: `channel-${clientMessageId}`,
-      sources: uniqueSources(sources),
+      routingSources,
+      lifecycleSources,
       progress: createChannelTurnProgressBuilder(),
       richDraft: this.hooks.createRichDraft?.({
         batchId: `channel-${clientMessageId}`,
-        sources
+        sources: routingSources
       }) ?? null,
       idempotencyScope: createMessageChannelIdempotencyScope()
     };
     const processingEvent = {
       type: "processing",
       batchId: state.active.batchId,
-      sources: state.active.sources
+      sources: state.active.lifecycleSources
     };
     this.enqueueHook(state, () => this.hooks.onLifecycle(processingEvent));
   }
@@ -1228,7 +1799,7 @@ class ChannelGateway {
       this.enqueueHook(state, () => this.hooks.onProgress({
         type: "progress",
         batchId: active.batchId,
-        sources: active.sources,
+        sources: active.routingSources,
         ...update
       }));
     }
@@ -1248,7 +1819,7 @@ class ChannelGateway {
     this.enqueueHook(state, () => this.hooks.onLifecycle({
       type: "finished",
       batchId: active.batchId,
-      sources: active.sources,
+      sources: active.lifecycleSources,
       outcome: lifecycleOutcome(terminal.stopReason),
       stopReason: terminal.stopReason,
       ...terminal.runId ?? active.runId ? { runId: terminal.runId ?? active.runId } : {},
@@ -1264,9 +1835,9 @@ class ChannelGateway {
     }));
     if (!state)
       return;
-    const sources = state.active?.sources ?? [];
+    const sources = state.active?.routingSources ?? [];
     state.replayedControlRequestIds.add(message.request_id);
-    const sourceScopes = new Map(sources.map((source2) => [sourceKey(source2), source2]));
+    const sourceScopes = new Map(sources.map((source2) => [sourceRouteKey(source2), source2]));
     if (sourceScopes.size !== 1)
       return;
     const source = [...sourceScopes.values()][0];
@@ -2312,10 +2883,12 @@ function buildMessageChannelExternalToolDefinition(options) {
   };
 }
 export {
+  formatChannelControlRequestPrompt,
   executeMessageChannelExternalTool,
   executeMessageChannel,
   buildMessageChannelExternalToolDefinition,
-  ChannelGateway
+  ChannelGateway,
+  ChannelControlRequestCoordinator
 };
 
-//# debugId=E1A24CF28F090AA064756E2164756E21
+//# debugId=CA56D3159193925764756E2164756E21