@band-ai/sdk 0.3.3 → 0.4.0

package/dist/{chunk-OH6VVVKT.js → chunk-CBCHTTUY.js}

@@ -113,7 +113,17 @@ function buildParticipantsMessage(participants) {
   return lines.join("\n");
 }
 
+// src/core/deferred.ts
+function createDeferred() {
+  let resolve;
+  const promise = new Promise((innerResolve) => {
+    resolve = innerResolve;
+  });
+  return { promise, resolve };
+}
+
 export {
+  createDeferred,
   HistoryProvider,
   SYNTHETIC_SENDER_TYPE,
   SYNTHETIC_CONTACT_EVENTS_SENDER_ID,

package/dist/{chunk-K5KAEYPF.js → chunk-HNWZZXAE.js}

@@ -1,21 +1,34 @@
 import {
-  SimpleAdapter
-} from "./chunk-AVVDPXP4.js";
+  FAILURE_CODE_TIMEOUT,
+  SimpleAdapter,
+  agentFailure,
+  deliverReply,
+  reportProviderTurnFailure,
+  reportTurnFailure
+} from "./chunk-OGOXY43L.js";
 import {
   renderSystemPrompt
-} from "./chunk-YJ42AZO4.js";
+} from "./chunk-RJNJUISR.js";
 import {
-  asErrorMessage,
   asNonEmptyString,
-  asOptionalRecord
-} from "./chunk-KXJ74J73.js";
+  asOptionalRecord,
+  asString
+} from "./chunk-JIZE4EC6.js";
 import {
-  NoopLogger
-} from "./chunk-OD2G5LFQ.js";
+  asErrorMessage
+} from "./chunk-6BE2EG5P.js";
+import {
+  FAILURE_METADATA_KEY
+} from "./chunk-TGDDFBYS.js";
+import {
+  GATEWAY_FREE_TEXT_SENSITIVE_KEY_TERMS,
+  resolveLogger
+} from "./chunk-ZYOXI4JL.js";
 import {
   UnsupportedFeatureError,
-  ValidationError
-} from "./chunk-JY75VSQK.js";
+  ValidationError,
+  rethrowIfRecoverableTurnFailure
+} from "./chunk-4OVNFDD7.js";
 
 // src/adapters/shared/history.ts
 function findLatestTaskMetadata(raw, predicate) {
@@ -32,6 +45,76 @@ function findLatestTaskMetadata(raw, predicate) {
   }
   return null;
 }
+var UNKNOWN_SENDER = "Unknown";
+function mergeConsecutiveSameRole(turns) {
+  const merged = [];
+  let attributedTo = "";
+  for (const turn of turns) {
+    if (!turn.content) {
+      continue;
+    }
+    const previous = merged[merged.length - 1];
+    if (!previous || previous.role !== turn.role) {
+      merged.push({ ...turn });
+      attributedTo = turn.sender ?? "";
+      continue;
+    }
+    const speaker = turn.sender ?? "";
+    previous.content += speaker === attributedTo ? `
+${turn.content}` : `
+${nameContribution(turn.content, speaker)}`;
+    attributedTo = speaker;
+  }
+  return merged;
+}
+function nameContribution(content, speaker) {
+  if (speaker !== "" && content.startsWith(`[${speaker}]: `)) {
+    return content;
+  }
+  return `[${speaker || UNKNOWN_SENDER}]: ${content}`;
+}
+function pairUserAssistantTurns(turns) {
+  const paired = [];
+  let index = 0;
+  while (index < turns.length) {
+    const current = turns[index];
+    if (current.role !== "user" || !current.content) {
+      index += 1;
+      continue;
+    }
+    const next = turns[index + 1];
+    if (next && next.role === "assistant" && next.content) {
+      paired.push(current, next);
+      index += 2;
+      continue;
+    }
+    if (index === turns.length - 1) {
+      paired.push(current);
+    }
+    index += 1;
+  }
+  return paired;
+}
+function takeRecentTurns(turns, limit) {
+  const cap = Number.isNaN(limit) ? 0 : Math.floor(limit);
+  if (cap <= 0) {
+    return [];
+  }
+  if (turns.length <= cap) {
+    return [...turns];
+  }
+  const truncated = turns.slice(-cap);
+  if (truncated[0]?.role === "assistant") {
+    truncated.shift();
+  }
+  return truncated;
+}
+function selectCompleteExchanges(history, limit) {
+  return takeRecentTurns(
+    pairUserAssistantTurns(mergeConsecutiveSameRole(history)),
+    limit
+  );
+}
 
 // src/converters/shared.ts
 function asOptionalString(value) {
@@ -280,6 +363,7 @@ import { randomUUID } from "crypto";
 var TERMINAL_STATES = /* @__PURE__ */ new Set(["completed", "failed", "canceled", "rejected", "auth-required"]);
 var DEFAULT_MAX_STREAM_EVENTS = 1e4;
 var A2AAdapter = class extends SimpleAdapter {
+  provider = "a2a";
   remoteUrl;
   authHeaders;
   streaming;
@@ -299,20 +383,20 @@ var A2AAdapter = class extends SimpleAdapter {
     this.streaming = options.streaming ?? true;
     this.clientFactory = options.clientFactory;
     this.maxStreamEvents = normalizeMaxStreamEvents(options.maxStreamEvents);
-    this.logger = options.logger ?? new NoopLogger();
+    this.logger = resolveLogger(options.logger);
   }
   async onStarted(agentName, agentDescription) {
     await super.onStarted(agentName, agentDescription);
     this.client = await this.createClient();
   }
   async onMessage(message, tools, history, _participantsMessage, _contactsMessage, context) {
-    const client = this.client ?? await this.createClient();
-    this.client = client;
-    if (context.isSessionBootstrap) {
-      await this.rehydrateFromHistory(context.roomId, history, client);
-    }
-    const request = this.toSendParams(message, context.roomId);
     try {
+      const client = this.client ?? await this.createClient();
+      this.client = client;
+      if (context.isSessionBootstrap) {
+        await this.rehydrateFromHistory(context.roomId, history, client);
+      }
+      const request = this.toSendParams(message, context.roomId);
       if (this.streaming) {
         let streamEventCount = 0;
         for await (const event of client.sendMessageStream(request)) {
@@ -323,6 +407,7 @@ var A2AAdapter = class extends SimpleAdapter {
           try {
             await this.handleEvent(event, tools, context.roomId, message.senderId);
           } catch (handleError) {
+            rethrowIfRecoverableTurnFailure(handleError);
             this.logger.error("A2A stream event handling failed; continuing stream", {
               roomId: context.roomId,
               remoteUrl: this.remoteUrl,
@@ -336,24 +421,11 @@ var A2AAdapter = class extends SimpleAdapter {
       const response = await client.sendMessage(request);
       await this.handleEvent(response, tools, context.roomId, message.senderId);
     } catch (error) {
-      const errorMessage = asErrorMessage(error);
-      this.logger.error("A2A adapter request failed", {
+      rethrowIfRecoverableTurnFailure(error);
+      await reportProviderTurnFailure(tools, this.logger, this.provider, "A2A adapter request failed", error, {
         roomId: context.roomId,
-        remoteUrl: this.remoteUrl,
-        error
+        remoteUrl: this.remoteUrl
       });
-      try {
-        await tools.sendEvent(`A2A agent error: ${errorMessage}`, "error", {
-          a2a_error: errorMessage
-        });
-      } catch (eventError) {
-        this.logger.warn("A2A adapter failed to emit error event", {
-          roomId: context.roomId,
-          remoteUrl: this.remoteUrl,
-          error: eventError
-        });
-      }
-      throw error instanceof Error ? error : new Error(errorMessage);
     }
   }
   async onCleanup(roomId) {
@@ -373,7 +445,7 @@ var A2AAdapter = class extends SimpleAdapter {
     if (isMessageEvent(event)) {
       const text = extractMessageText(event);
       if (text) {
-        await tools.sendMessage(text, [{ id: senderId }]);
+        await deliverReply(tools, text, [{ id: senderId }]);
       }
       return;
     }
@@ -388,7 +460,7 @@ var A2AAdapter = class extends SimpleAdapter {
     if (isArtifactUpdateEvent(event)) {
       const text = extractArtifactText(event.artifact);
       if (text) {
-        await tools.sendMessage(text, [{ id: senderId }]);
+        await deliverReply(tools, text, [{ id: senderId }]);
       }
     }
   }
@@ -459,23 +531,29 @@ var A2AAdapter = class extends SimpleAdapter {
     }
     if (input.state === "input-required") {
       const text = extractMessageText(input.statusMessage) ?? "Please provide more information.";
-      await input.tools.sendMessage(text, [input.sender]);
+      await deliverReply(input.tools, text, [input.sender]);
       await this.emitTaskEvent(input.tools, input.contextId, input.taskId, input.state);
       return;
     }
     if (input.state === "completed") {
-      if (input.completedMessage) {
-        await input.tools.sendMessage(input.completedMessage, [input.sender]);
+      try {
+        if (input.completedMessage) {
+          await deliverReply(input.tools, input.completedMessage, [input.sender]);
+        }
+        await this.emitTaskEvent(input.tools, input.contextId, input.taskId, input.state);
+      } finally {
+        this.clearTaskTracking(input.key, input.roomId);
       }
-      await this.emitTaskEvent(input.tools, input.contextId, input.taskId, input.state);
-      this.clearTaskTracking(input.key, input.roomId);
       return;
     }
     if (TERMINAL_STATES.has(input.state)) {
       const text = extractMessageText(input.statusMessage) ?? `A2A task ${input.state}`;
-      await input.tools.sendEvent(text, "error", { a2a_state: input.state });
-      await this.emitTaskEvent(input.tools, input.contextId, input.taskId, input.state);
-      this.clearTaskTracking(input.key, input.roomId);
+      try {
+        await this.emitTaskEvent(input.tools, input.contextId, input.taskId, input.state);
+      } finally {
+        this.clearTaskTracking(input.key, input.roomId);
+      }
+      await reportTurnFailure(input.tools, agentFailure(this.provider, text, input.state), this.logger, { roomId: input.roomId });
     }
   }
   async emitTaskEvent(tools, contextId, taskId, state) {
@@ -851,15 +929,57 @@ function buildStatusEvent(input) {
   };
 }
 
+// src/adapters/a2a-gateway/failure.ts
+import { AgentFailure } from "@band-ai/band-sdk-core";
+var PROVIDER = "a2a-gateway";
+var SENSITIVE_VALUE_PATTERN = new RegExp(
+  `(${GATEWAY_FREE_TEXT_SENSITIVE_KEY_TERMS})"?\\s*(?:[A-Za-z]+\\s*)?[:=]\\s*"?(?:[A-Za-z][\\w-]*\\s+)?[^\\s,;"]+`,
+  "gi"
+);
+function buildGatewayFailureMetadata(error, code, message = sanitizeGatewayErrorMessage(error)) {
+  return {
+    [FAILURE_METADATA_KEY]: new AgentFailure(
+      PROVIDER,
+      message,
+      code ?? (error instanceof Error ? error.name : "UnknownError")
+    ).toObject()
+  };
+}
+function sanitizeGatewayErrorMessage(error) {
+  const rawMessage = error instanceof Error ? error.message : String(error);
+  const trimmed = rawMessage.trim();
+  if (!trimmed) {
+    return "Unknown error";
+  }
+  const withBearerRedaction = trimmed.replace(/Bearer\s+[^\s,;]+/gi, "Bearer [REDACTED]").replace(SENSITIVE_VALUE_PATTERN, "$1=[REDACTED]");
+  const maxLength = 240;
+  if (withBearerRedaction.length <= maxLength) {
+    return withBearerRedaction;
+  }
+  return `${withBearerRedaction.slice(0, maxLength - 3)}...`;
+}
+function sanitizeForwardedFailure(value) {
+  const record = asOptionalRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const provider = asString(record.provider) ?? "unknown";
+  const code = asString(record.code) ?? void 0;
+  const message = sanitizeGatewayErrorMessage(asString(record.message) ?? "Unknown error");
+  return new AgentFailure(provider, message, code).toObject();
+}
+
 // src/adapters/a2a-gateway/server.ts
 var GatewayPeerExecutor = class {
   peer;
   onRequest;
   onCancel;
+  logger;
   constructor(options) {
     this.peer = options.peer;
     this.onRequest = options.onRequest;
     this.onCancel = options.onCancel;
+    this.logger = options.logger;
   }
   async execute(requestContext, eventBus) {
     const taskId = asNonEmptyString(requestContext.taskId) ?? randomUUID3();
@@ -879,6 +999,12 @@ var GatewayPeerExecutor = class {
         }
       }
     } catch (error) {
+      this.logger.warn("a2a_gateway.peer_request_failed", {
+        peerId: this.peer.id,
+        taskId,
+        contextId,
+        error
+      });
       eventBus.publish(
         buildStatusEvent({
           taskId,
@@ -886,7 +1012,7 @@ var GatewayPeerExecutor = class {
           state: "failed",
           final: true,
           text: "Peer request failed.",
-          metadata: buildGatewayExecutionFailureMetadata(error)
+          metadata: buildGatewayFailureMetadata(error)
         })
       );
     } finally {
@@ -914,10 +1040,12 @@ var GatewayPeerExecutor = class {
 };
 var GatewayServer = class {
   options;
+  logger;
   server = null;
   started = false;
   constructor(options) {
     this.options = options;
+    this.logger = resolveLogger(options.logger);
   }
   async start() {
     if (this.started) {
@@ -987,7 +1115,8 @@ var GatewayServer = class {
       new GatewayPeerExecutor({
         peer,
         onRequest: this.options.onRequest,
-        onCancel: this.options.onCancel
+        onCancel: this.options.onCancel,
+        logger: this.logger
       })
     );
     const userBuilder = createUserBuilder(
@@ -1244,25 +1373,6 @@ function verifyBearerAuthorization(headers, authToken) {
   }
   return safeHeaderEquals(authorization, `Bearer ${authToken}`);
 }
-function buildGatewayExecutionFailureMetadata(error) {
-  return {
-    error_type: error instanceof Error ? error.name : "UnknownError",
-    error_message: sanitizeGatewayErrorMessage(error)
-  };
-}
-function sanitizeGatewayErrorMessage(error) {
-  const rawMessage = error instanceof Error ? error.message : String(error);
-  const trimmed = rawMessage.trim();
-  if (!trimmed) {
-    return "Unknown error";
-  }
-  const withBearerRedaction = trimmed.replace(/Bearer\s+[^\s,;]+/gi, "Bearer [REDACTED]").replace(/(token|authorization|api[_-]?key)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]");
-  const maxLength = 240;
-  if (withBearerRedaction.length <= maxLength) {
-    return withBearerRedaction;
-  }
-  return `${withBearerRedaction.slice(0, maxLength - 3)}...`;
-}
 function safeHeaderEquals(left, right) {
   const leftBuffer = Buffer.from(left);
   const rightBuffer = Buffer.from(right);
@@ -1281,6 +1391,7 @@ var DEFAULT_RESPONSE_TIMEOUT_MS = 12e4;
 var DEFAULT_PEER_PAGE_SIZE = 100;
 var DEFAULT_MAX_PEER_PAGES = 25;
 var A2AGatewayAdapter = class extends SimpleAdapter {
+  provider = PROVIDER;
   bandRest;
   gatewayUrl;
   host;
@@ -1291,6 +1402,7 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
   peerPageSize;
   maxPeerPages;
   serverFactory;
+  logger;
   peersBySlug = /* @__PURE__ */ new Map();
   peersById = /* @__PURE__ */ new Map();
   contextToRoom = /* @__PURE__ */ new Map();
@@ -1312,6 +1424,7 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
     this.peerPageSize = options.peerPageSize ?? DEFAULT_PEER_PAGE_SIZE;
     this.maxPeerPages = options.maxPeerPages ?? DEFAULT_MAX_PEER_PAGES;
     this.serverFactory = options.serverFactory ?? createGatewayServer;
+    this.logger = resolveLogger(options.logger);
     if (this.allowUnauthenticatedLoopback && !isLoopbackHost2(this.host)) {
       throw new ValidationError(
         "A2AGatewayAdapter `allowUnauthenticatedLoopback` may only be enabled for loopback hosts."
@@ -1333,7 +1446,8 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
       onCancel: async (request) => {
         const canonicalPeerId = this.resolveCanonicalPeerId(request);
         this.cancelPendingTask(request.taskId, canonicalPeerId ?? request.peerId);
-      }
+      },
+      logger: this.logger
     });
     await this.server.start();
   }
@@ -1415,12 +1529,15 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
   async *handleGatewayRequest(request) {
     const peer = this.resolveGatewayPeer(request);
     if (!peer) {
+      const text = `Peer not found: ${request.peerId}`;
+      this.logger.warn("a2a_gateway.peer_not_found", { peerId: request.peerId, taskId: request.taskId });
       yield buildStatusEvent({
         taskId: request.taskId,
         contextId: request.contextId,
         state: "failed",
         final: true,
-        text: `Peer not found: ${request.peerId}`
+        text,
+        metadata: buildGatewayFailureMetadata(text, "peer_not_found")
       });
       return;
     }
@@ -1471,12 +1588,20 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
       });
     } catch (error) {
       this.removePending(pending);
+      const text = sanitizeGatewayErrorMessage(error);
+      this.logger.warn("a2a_gateway.relay_failed", {
+        roomId,
+        peerId: peer.id,
+        taskId: pending.taskId,
+        error
+      });
       yield buildStatusEvent({
         taskId: pending.taskId,
         contextId: pending.contextId,
         state: "failed",
         final: true,
-        text: error instanceof Error ? error.message : String(error)
+        text,
+        metadata: buildGatewayFailureMetadata(error, void 0, text)
       });
       return;
     }
@@ -1484,12 +1609,20 @@ var A2AGatewayAdapter = class extends SimpleAdapter {
       const next = await pending.queue.dequeue(this.responseTimeoutMs);
       if (!next) {
         this.removePending(pending);
+        const text = "Timed out waiting for a Band peer response.";
+        this.logger.warn("a2a_gateway.peer_response_timeout", {
+          roomId,
+          peerId: peer.id,
+          taskId: pending.taskId,
+          responseTimeoutMs: this.responseTimeoutMs
+        });
         yield buildStatusEvent({
           taskId: pending.taskId,
           contextId: pending.contextId,
           state: "failed",
           final: true,
-          text: "Timed out waiting for a Band peer response."
+          text,
+          metadata: buildGatewayFailureMetadata(text, FAILURE_CODE_TIMEOUT)
         });
         return;
       }
@@ -1770,17 +1903,22 @@ function toStatusUpdateEvent(message, taskId, contextId) {
   } else {
     state = "working";
   }
+  const failure = sanitizeForwardedFailure(message.metadata?.[FAILURE_METADATA_KEY]);
   return buildStatusEvent({
     taskId,
     contextId,
     state,
     final,
-    text: message.content,
+    // A room's own "error" event reaches an external A2A client verbatim
+    // otherwise — sanitize it the same way a gateway-originated failure is,
+    // since neither is guaranteed to be pre-redacted upstream.
+    text: normalizedType === "error" ? sanitizeGatewayErrorMessage(message.content) : message.content,
     metadata: {
       band_message_id: message.id,
       band_message_type: message.messageType,
       band_sender_id: message.senderId,
-      band_room_id: message.roomId
+      band_room_id: message.roomId,
+      ...failure !== void 0 ? { [FAILURE_METADATA_KEY]: failure } : {}
     }
   });
 }
@@ -1914,6 +2052,7 @@ var LazyAsyncValue = class {
 var DEFAULT_RESPONSE_TIMEOUT_SECONDS = 120;
 var DEFAULT_MAX_HISTORY_MESSAGES = 100;
 var ParlantAdapter = class extends SimpleAdapter {
+  provider = "parlant";
   environment;
   baseUrl;
   agentId;
@@ -1949,7 +2088,7 @@ var ParlantAdapter = class extends SimpleAdapter {
     this.responseTimeoutSeconds = options.responseTimeoutSeconds ?? DEFAULT_RESPONSE_TIMEOUT_SECONDS;
     this.maxHistoryMessages = options.maxHistoryMessages ?? DEFAULT_MAX_HISTORY_MESSAGES;
     this.clientFactory = options.clientFactory;
-    this.logger = options.logger ?? new NoopLogger();
+    this.logger = resolveLogger(options.logger);
     this.clientLoader = new LazyAsyncValue({
       load: async () => this.createClient(),
       onRejected: (error) => {
@@ -2006,40 +2145,27 @@ var ParlantAdapter = class extends SimpleAdapter {
         createdEvent.offset
       );
       if (!reply) {
-        await tools.sendEvent(
-          "Parlant did not return a response before timeout.",
-          "error",
-          {
-            parlant_session_id: sessionId,
-            parlant_timeout_seconds: this.responseTimeoutSeconds
-          }
+        return reportTurnFailure(
+          tools,
+          agentFailure(this.provider, "Parlant did not return a response before timeout.", FAILURE_CODE_TIMEOUT),
+          this.logger,
+          { roomId: context.roomId, agentId: this.agentId }
         );
-        return;
       }
-      await tools.sendMessage(reply, [{ id: message.senderId }]);
+      await deliverReply(tools, reply, [{ id: message.senderId }]);
     } catch (error) {
-      const errorMessage = asErrorMessage(error);
+      rethrowIfRecoverableTurnFailure(error);
       this.logger.error("Parlant adapter request failed", {
         roomId: context.roomId,
         agentId: this.agentId,
         error
       });
-      try {
-        await tools.sendEvent(
-          `Parlant adapter error: ${errorMessage}`,
-          "error",
-          {
-            parlant_error: errorMessage
-          }
-        );
-      } catch (eventError) {
-        this.logger.warn("Parlant adapter failed to emit error event", {
-          roomId: context.roomId,
-          agentId: this.agentId,
-          error: eventError
-        });
-      }
-      throw error instanceof Error ? error : new Error(errorMessage);
+      await reportTurnFailure(
+        tools,
+        agentFailure(this.provider, asErrorMessage(error)),
+        this.logger,
+        { roomId: context.roomId, agentId: this.agentId }
+      );
     }
   }
   async onCleanup(roomId) {
@@ -2151,8 +2277,9 @@ var ParlantAdapter = class extends SimpleAdapter {
     if (history.length === 0) {
       return;
     }
-    const completeHistory = selectCompleteExchanges(history).slice(
-      -this.maxHistoryMessages
+    const completeHistory = selectCompleteExchanges(
+      history,
+      this.maxHistoryMessages
     );
     let failedEvents = 0;
     for (const item of completeHistory) {
@@ -2283,26 +2410,6 @@ var ParlantAdapter = class extends SimpleAdapter {
     return factory();
   }
 };
-function selectCompleteExchanges(history) {
-  const complete = [];
-  let index = 0;
-  while (index < history.length) {
-    const current = history[index];
-    if (current.role === "user" && current.content) {
-      const next = history[index + 1];
-      if (next && next.role === "assistant" && next.content) {
-        complete.push(current);
-        complete.push(next);
-        index += 2;
-        continue;
-      }
-      index += 1;
-      continue;
-    }
-    index += 1;
-  }
-  return complete;
-}
 function buildUserMessage(input) {
   const updates = [];
   if (input.participantsMessage) {
@@ -2480,8 +2587,67 @@ function buildClaudeSdkText(raw, agentName) {
   return lines.join("\n");
 }
 
+// src/converters/acp-client.ts
+var ACPClientHistoryConverter = class {
+  convert(raw) {
+    const roomToSession = {};
+    for (const entry of raw) {
+      if (entry.message_type !== "task") {
+        continue;
+      }
+      const metadataRaw = entry.metadata;
+      if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+        continue;
+      }
+      const metadata = metadataRaw;
+      const sessionId = metadata.acp_client_session_id;
+      const roomId = metadata.acp_client_room_id;
+      if (typeof sessionId === "string" && typeof roomId === "string" && sessionId && roomId && roomId === entry.room_id) {
+        roomToSession[roomId] = sessionId;
+      }
+    }
+    return { roomToSession };
+  }
+};
+
+// src/converters/acp-server.ts
+var ACPServerHistoryConverter = class {
+  convert(raw) {
+    const sessionToRoom = {};
+    const sessionCwd = {};
+    const sessionMcpServers = {};
+    for (const entry of raw) {
+      const metadataRaw = entry.metadata;
+      if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+        continue;
+      }
+      const metadata = metadataRaw;
+      const sessionId = metadata.acp_session_id;
+      if (typeof sessionId !== "string" || sessionId.length === 0) {
+        continue;
+      }
+      const roomId = typeof metadata.acp_room_id === "string" ? metadata.acp_room_id : typeof entry.room_id === "string" ? entry.room_id : null;
+      if (roomId) {
+        sessionToRoom[sessionId] = roomId;
+      }
+      if (typeof metadata.acp_cwd === "string" && metadata.acp_cwd.length > 0) {
+        sessionCwd[sessionId] = metadata.acp_cwd;
+      }
+      if (Array.isArray(metadata.acp_mcp_servers)) {
+        sessionMcpServers[sessionId] = metadata.acp_mcp_servers.filter((server) => !!server && typeof server === "object" && !Array.isArray(server));
+      }
+    }
+    return {
+      sessionToRoom,
+      sessionCwd,
+      sessionMcpServers
+    };
+  }
+};
+
 export {
   findLatestTaskMetadata,
+  selectCompleteExchanges,
   LazyAsyncValue,
   asOptionalString,
   parseDate,
@@ -2501,5 +2667,7 @@ export {
   OpencodeHistoryConverter,
   extractOpencodeSessionId,
   ClaudeSDKHistoryConverter,
-  extractClaudeSessionId
+  extractClaudeSessionId,
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter
 };

package/dist/chunk-I34SXMTJ.js

@@ -0,0 +1,6 @@
+// src/core/index.ts
+import { AgentFailure } from "@band-ai/band-sdk-core";
+
+export {
+  AgentFailure
+};