@band-ai/sdk 0.1.2

package/dist/chunk-FUODYQRE.js

@@ -0,0 +1,2562 @@
+import {
+  SimpleAdapter
+} from "./chunk-AVVDPXP4.js";
+import {
+  renderSystemPrompt
+} from "./chunk-SFVKOEQH.js";
+import {
+  asErrorMessage,
+  asNonEmptyString,
+  asOptionalRecord
+} from "./chunk-ZZJRRBPQ.js";
+import {
+  NoopLogger
+} from "./chunk-OD2G5LFQ.js";
+import {
+  UnsupportedFeatureError,
+  ValidationError
+} from "./chunk-YR3BOQNW.js";
+
+// src/converters/acp-client.ts
+var ACPClientHistoryConverter = class {
+  convert(raw) {
+    const roomToSession = {};
+    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_client_session_id;
+      const roomId = metadata.acp_client_room_id;
+      if (typeof sessionId === "string" && typeof roomId === "string" && sessionId && roomId) {
+        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
+    };
+  }
+};
+
+// src/adapters/shared/history.ts
+function findLatestTaskMetadata(raw, predicate) {
+  for (let index = raw.length - 1; index >= 0; index -= 1) {
+    const message = raw[index] ?? {};
+    const messageType = String(message.message_type ?? message.messageType ?? "");
+    if (messageType !== "task") {
+      continue;
+    }
+    const metadata = asOptionalRecord(message.metadata) ?? {};
+    if (predicate(metadata)) {
+      return metadata;
+    }
+  }
+  return null;
+}
+
+// src/converters/shared.ts
+function asOptionalString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function parseDate(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseToolPayload(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseToolCall(value) {
+  const parsed = parseToolPayload(value);
+  const name = asOptionalString(parsed?.name);
+  const toolCallId = asOptionalString(parsed?.tool_call_id);
+  if (!name || !toolCallId) {
+    return null;
+  }
+  const args = parsed?.args;
+  return {
+    name,
+    toolCallId,
+    args: args && typeof args === "object" && !Array.isArray(args) ? args : {}
+  };
+}
+function parseToolResult(value) {
+  const parsed = parseToolPayload(value);
+  const name = asOptionalString(parsed?.name);
+  const toolCallId = asOptionalString(parsed?.tool_call_id);
+  if (!name || !toolCallId) {
+    return null;
+  }
+  return {
+    name,
+    toolCallId,
+    output: parsed?.output === void 0 ? "" : String(parsed.output),
+    isError: parsed?.is_error === true
+  };
+}
+
+// src/converters/google-adk.ts
+function appendToolCalls(messages, pendingToolCalls) {
+  if (pendingToolCalls.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "model",
+    content: [...pendingToolCalls]
+  });
+  pendingToolCalls.length = 0;
+}
+function appendToolResults(messages, pendingToolResults) {
+  if (pendingToolResults.length === 0) {
+    return;
+  }
+  messages.push({
+    role: "user",
+    content: [...pendingToolResults]
+  });
+  pendingToolResults.length = 0;
+}
+function patchOrphanedToolCalls(messages) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message.role !== "model" || !Array.isArray(message.content)) {
+      continue;
+    }
+    const callNames = /* @__PURE__ */ new Map();
+    for (const block of message.content) {
+      if (block.type === "function_call" && typeof block.id === "string" && block.id.length > 0) {
+        callNames.set(block.id, typeof block.name === "string" ? block.name : "");
+      }
+    }
+    if (callNames.size === 0) {
+      continue;
+    }
+    const nextMessage = messages[index + 1];
+    const matchedIds = /* @__PURE__ */ new Set();
+    if (nextMessage?.role === "user" && Array.isArray(nextMessage.content)) {
+      for (const block of nextMessage.content) {
+        if (block.type === "function_response" && typeof block.tool_call_id === "string" && callNames.has(block.tool_call_id)) {
+          matchedIds.add(block.tool_call_id);
+        }
+      }
+    }
+    const orphanedIds = [...callNames.keys()].filter((toolCallId) => !matchedIds.has(toolCallId));
+    if (orphanedIds.length === 0) {
+      continue;
+    }
+    const syntheticResponses = orphanedIds.map((toolCallId) => ({
+      type: "function_response",
+      tool_call_id: toolCallId,
+      name: callNames.get(toolCallId) ?? "",
+      output: "Error: tool execution was interrupted",
+      is_error: true
+    }));
+    if (nextMessage?.role === "user") {
+      if (typeof nextMessage.content === "string") {
+        nextMessage.content = [
+          ...syntheticResponses,
+          { type: "text", text: nextMessage.content }
+        ];
+      } else if (Array.isArray(nextMessage.content)) {
+        nextMessage.content = [...syntheticResponses, ...nextMessage.content];
+      }
+      continue;
+    }
+    messages.splice(index + 1, 0, {
+      role: "user",
+      content: syntheticResponses
+    });
+    index += 1;
+  }
+}
+var GoogleADKHistoryConverter = class {
+  agentName = "";
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    const messages = [];
+    const pendingToolCalls = [];
+    const pendingToolResults = [];
+    for (const entry of raw) {
+      const messageType = String(entry.message_type ?? "text");
+      const content = String(entry.content ?? "");
+      if (messageType === "tool_call") {
+        appendToolResults(messages, pendingToolResults);
+        const parsed = parseToolCall(content);
+        if (parsed) {
+          pendingToolCalls.push({
+            type: "function_call",
+            id: parsed.toolCallId,
+            name: parsed.name,
+            args: parsed.args
+          });
+        }
+        continue;
+      }
+      if (messageType === "tool_result") {
+        appendToolCalls(messages, pendingToolCalls);
+        const parsed = parseToolResult(content);
+        if (parsed) {
+          pendingToolResults.push({
+            type: "function_response",
+            tool_call_id: parsed.toolCallId,
+            name: parsed.name,
+            output: parsed.output,
+            ...parsed.isError ? { is_error: true } : {}
+          });
+        }
+        continue;
+      }
+      if (messageType === "thought" || messageType === "error") {
+        continue;
+      }
+      appendToolCalls(messages, pendingToolCalls);
+      appendToolResults(messages, pendingToolResults);
+      const senderName = String(entry.sender_name ?? "");
+      const role = String(entry.role ?? "user");
+      if (role === "assistant" && senderName === this.agentName) {
+        continue;
+      }
+      messages.push({
+        role: "user",
+        content: senderName ? `[${senderName}]: ${content}` : content
+      });
+    }
+    appendToolCalls(messages, pendingToolCalls);
+    appendToolResults(messages, pendingToolResults);
+    patchOrphanedToolCalls(messages);
+    return messages;
+  }
+};
+function extractGoogleAdkSessionId(raw) {
+  const metadata = findLatestTaskMetadata(
+    raw,
+    (entry) => typeof entry.google_adk_session_id === "string" && entry.google_adk_session_id.length > 0
+  );
+  const sessionId = metadata?.google_adk_session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+
+// src/adapters/a2a/types.ts
+function buildA2AAuthHeaders(auth) {
+  const headers = {};
+  for (const [key, value] of Object.entries(auth?.headers ?? {})) {
+    headers[key] = sanitizeHeaderValue(value, key);
+  }
+  if (auth?.apiKey) {
+    headers["X-API-Key"] = sanitizeHeaderValue(auth.apiKey, "X-API-Key");
+  }
+  if (auth?.bearerToken) {
+    headers.Authorization = `Bearer ${sanitizeHeaderValue(auth.bearerToken, "Authorization")}`;
+  }
+  return headers;
+}
+function sanitizeHeaderValue(value, headerName) {
+  if (/[\r\n]/u.test(value)) {
+    throw new Error(`${headerName} header value must not contain CR or LF characters.`);
+  }
+  return value;
+}
+var A2AHistoryConverter = class {
+  convert(raw) {
+    const metadata = findLatestTaskMetadata(
+      raw,
+      (entry) => Object.prototype.hasOwnProperty.call(entry, "a2a_context_id")
+    );
+    if (metadata) {
+      return {
+        contextId: asNonEmptyString(metadata.a2a_context_id),
+        taskId: asNonEmptyString(metadata.a2a_task_id),
+        taskState: asNonEmptyString(metadata.a2a_task_state)
+      };
+    }
+    return {
+      contextId: null,
+      taskId: null,
+      taskState: null
+    };
+  }
+};
+
+// src/adapters/a2a/A2AAdapter.ts
+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 {
+  remoteUrl;
+  authHeaders;
+  streaming;
+  clientFactory;
+  maxStreamEvents;
+  logger;
+  client = null;
+  contexts = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  taskSenders = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super({
+      historyConverter: new A2AHistoryConverter()
+    });
+    this.remoteUrl = options.remoteUrl;
+    this.authHeaders = buildA2AAuthHeaders(options.auth);
+    this.streaming = options.streaming ?? true;
+    this.clientFactory = options.clientFactory;
+    this.maxStreamEvents = normalizeMaxStreamEvents(options.maxStreamEvents);
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  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 {
+      if (this.streaming) {
+        let streamEventCount = 0;
+        for await (const event of client.sendMessageStream(request)) {
+          streamEventCount += 1;
+          if (streamEventCount > this.maxStreamEvents) {
+            throw new Error(`A2A stream exceeded maximum event limit (${this.maxStreamEvents})`);
+          }
+          try {
+            await this.handleEvent(event, tools, context.roomId, message.senderId);
+          } catch (handleError) {
+            this.logger.error("A2A stream event handling failed; continuing stream", {
+              roomId: context.roomId,
+              remoteUrl: this.remoteUrl,
+              streamEventCount,
+              error: handleError
+            });
+          }
+        }
+        return;
+      }
+      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", {
+        roomId: context.roomId,
+        remoteUrl: this.remoteUrl,
+        error
+      });
+      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) {
+    this.contexts.delete(roomId);
+    this.tasks.delete(roomId);
+    for (const key of this.taskSenders.keys()) {
+      if (key.startsWith(`${roomId}:`)) {
+        this.taskSenders.delete(key);
+      }
+    }
+  }
+  async handleEvent(rawEvent, tools, roomId, senderId) {
+    const event = unwrapResult(rawEvent);
+    if (!event) {
+      return;
+    }
+    if (isMessageEvent(event)) {
+      const text = extractMessageText(event);
+      if (text) {
+        await tools.sendMessage(text, [{ id: senderId }]);
+      }
+      return;
+    }
+    if (isTaskEvent(event)) {
+      await this.handleTaskEvent(event, tools, roomId, senderId);
+      return;
+    }
+    if (isStatusUpdateEvent(event)) {
+      await this.handleStatusUpdateEvent(event, tools, roomId, senderId);
+      return;
+    }
+    if (isArtifactUpdateEvent(event)) {
+      const text = extractArtifactText(event.artifact);
+      if (text) {
+        await tools.sendMessage(text, [{ id: senderId }]);
+      }
+    }
+  }
+  async handleTaskEvent(task, tools, roomId, senderId) {
+    const state = normalizeState(task.status.state);
+    const key = roomTaskKey(roomId, task.id);
+    const sender = this.trackTask({
+      roomId,
+      key,
+      taskId: task.id,
+      contextId: task.contextId,
+      senderId
+    });
+    await this.handleStateTransition({
+      state,
+      statusMessage: task.status.message,
+      completedMessage: extractTaskResponse(task),
+      tools,
+      sender,
+      contextId: task.contextId,
+      taskId: task.id,
+      roomId,
+      key
+    });
+  }
+  async handleStatusUpdateEvent(event, tools, roomId, senderId) {
+    const state = normalizeState(event.status.state);
+    const key = roomTaskKey(roomId, event.taskId);
+    const sender = this.trackTask({
+      roomId,
+      key,
+      taskId: event.taskId,
+      contextId: event.contextId,
+      senderId
+    });
+    await this.handleStateTransition({
+      state,
+      statusMessage: event.status.message,
+      completedMessage: extractMessageText(event.status.message),
+      tools,
+      sender,
+      contextId: event.contextId,
+      taskId: event.taskId,
+      roomId,
+      key
+    });
+  }
+  trackTask(input) {
+    const sender = this.taskSenders.get(input.key) ?? { id: input.senderId };
+    this.taskSenders.set(input.key, sender);
+    this.tasks.set(input.roomId, input.taskId);
+    if (input.contextId) {
+      this.contexts.set(input.roomId, input.contextId);
+    }
+    return sender;
+  }
+  clearTaskTracking(key, roomId) {
+    this.taskSenders.delete(key);
+    this.tasks.delete(roomId);
+  }
+  async handleStateTransition(input) {
+    if (input.state === "working") {
+      const thought = extractMessageText(input.statusMessage);
+      if (thought) {
+        await input.tools.sendEvent(thought, "thought");
+      }
+      return;
+    }
+    if (input.state === "input-required") {
+      const text = extractMessageText(input.statusMessage) ?? "Please provide more information.";
+      await input.tools.sendMessage(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]);
+      }
+      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);
+    }
+  }
+  async emitTaskEvent(tools, contextId, taskId, state) {
+    await tools.sendEvent(`A2A task ${state}`, "task", {
+      a2a_context_id: contextId ?? null,
+      a2a_task_id: taskId,
+      a2a_task_state: state
+    });
+  }
+  toSendParams(message, roomId) {
+    const contextId = this.contexts.get(roomId);
+    const taskId = this.tasks.get(roomId);
+    return {
+      message: {
+        kind: "message",
+        messageId: randomUUID(),
+        role: "user",
+        parts: [{ kind: "text", text: message.content }],
+        ...contextId ? { contextId } : {},
+        ...taskId ? { taskId } : {}
+      }
+    };
+  }
+  async rehydrateFromHistory(roomId, state, client) {
+    if (state.contextId) {
+      this.contexts.set(roomId, state.contextId);
+    }
+    const normalizedState = normalizeState(state.taskState);
+    if (!state.taskId || TERMINAL_STATES.has(normalizedState) || !client.resubscribeTask) {
+      return;
+    }
+    try {
+      let resubEventCount = 0;
+      for await (const raw of client.resubscribeTask({ id: state.taskId })) {
+        resubEventCount += 1;
+        if (resubEventCount > this.maxStreamEvents) {
+          this.logger.warn("A2A task resubscribe exceeded event limit; continuing with fresh task", {
+            roomId,
+            taskId: state.taskId,
+            maxStreamEvents: this.maxStreamEvents
+          });
+          break;
+        }
+        const event = unwrapResult(raw);
+        if (!event) {
+          continue;
+        }
+        if (isTaskEvent(event)) {
+          const eventState = normalizeState(event.status.state);
+          if (event.contextId) {
+            this.contexts.set(roomId, event.contextId);
+          }
+          if (!TERMINAL_STATES.has(eventState)) {
+            this.tasks.set(roomId, state.taskId);
+          }
+          break;
+        }
+        if (isStatusUpdateEvent(event)) {
+          const eventState = normalizeState(event.status.state);
+          if (event.contextId) {
+            this.contexts.set(roomId, event.contextId);
+          }
+          if (!TERMINAL_STATES.has(eventState)) {
+            this.tasks.set(roomId, state.taskId);
+          }
+          break;
+        }
+      }
+    } catch (error) {
+      this.logger.warn("A2A task resubscribe failed; continuing with fresh task", {
+        roomId,
+        taskId: state.taskId,
+        error
+      });
+    }
+  }
+  async createClient() {
+    const factory = this.clientFactory ?? await loadDefaultA2AClientFactory();
+    return factory({
+      remoteUrl: this.remoteUrl,
+      authHeaders: this.authHeaders
+    });
+  }
+};
+function roomTaskKey(roomId, taskId) {
+  return `${roomId}:${taskId}`;
+}
+function normalizeMaxStreamEvents(value) {
+  const maxStreamEvents = value ?? DEFAULT_MAX_STREAM_EVENTS;
+  if (!Number.isSafeInteger(maxStreamEvents) || maxStreamEvents < 1) {
+    throw new ValidationError("A2AAdapter `maxStreamEvents` must be a positive integer.");
+  }
+  return maxStreamEvents;
+}
+function normalizeState(state) {
+  if (typeof state !== "string") {
+    return "unknown";
+  }
+  const normalized = state.toLowerCase().replaceAll("_", "-");
+  if (normalized === "input-required") {
+    return "input-required";
+  }
+  if (normalized === "submitted") {
+    return "submitted";
+  }
+  if (normalized === "working") {
+    return "working";
+  }
+  if (normalized === "completed") {
+    return "completed";
+  }
+  if (normalized === "canceled") {
+    return "canceled";
+  }
+  if (normalized === "failed") {
+    return "failed";
+  }
+  if (normalized === "rejected") {
+    return "rejected";
+  }
+  if (normalized === "auth-required") {
+    return "auth-required";
+  }
+  return "unknown";
+}
+function extractTaskResponse(task) {
+  for (const artifact of task.artifacts ?? []) {
+    const text = extractArtifactText(artifact);
+    if (text) {
+      return text;
+    }
+  }
+  const statusText = extractMessageText(task.status.message);
+  if (statusText) {
+    return statusText;
+  }
+  for (let index = (task.history?.length ?? 0) - 1; index >= 0; index -= 1) {
+    const message = task.history?.[index];
+    if (!message || message.role !== "agent") {
+      continue;
+    }
+    const text = extractMessageText(message);
+    if (text) {
+      return text;
+    }
+  }
+  return "";
+}
+function extractArtifactText(artifact) {
+  if (!artifact?.parts) {
+    return null;
+  }
+  return extractPartsText(artifact.parts);
+}
+function extractMessageText(message) {
+  if (!message?.parts) {
+    return null;
+  }
+  return extractPartsText(message.parts);
+}
+function extractPartsText(parts) {
+  const chunks = [];
+  for (const part of parts) {
+    const text = extractTextFromPart(part);
+    if (text) {
+      chunks.push(text);
+    }
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  return chunks.join("\n");
+}
+function extractTextFromPart(part) {
+  if (!part) {
+    return null;
+  }
+  if (typeof part.text === "string" && part.text.length > 0) {
+    return part.text;
+  }
+  if (part.root) {
+    return extractTextFromPart(part.root);
+  }
+  return null;
+}
+function unwrapResult(value, depth = 0) {
+  if (!value || typeof value !== "object" || depth > 10) {
+    return null;
+  }
+  const event = value;
+  if (event.result && typeof event.result === "object") {
+    return unwrapResult(event.result, depth + 1);
+  }
+  return event;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isMessagePart(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return isOptionalString(value.kind) && isOptionalString(value.type) && isOptionalString(value.text) && (value.root === void 0 || isMessagePart(value.root));
+}
+function isMessageLike(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (!isOptionalString(value.kind) || !isOptionalString(value.role)) {
+    return false;
+  }
+  if (!isOptionalString(value.contextId) || !isOptionalString(value.taskId) || !isOptionalString(value.messageId)) {
+    return false;
+  }
+  if (value.parts === void 0) {
+    return true;
+  }
+  return Array.isArray(value.parts) && value.parts.every((part) => isMessagePart(part));
+}
+function isStatusLike(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (!isOptionalString(value.state)) {
+    return false;
+  }
+  return value.message === void 0 || isMessageLike(value.message);
+}
+function isArtifactLike(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  if (value.parts === void 0) {
+    return true;
+  }
+  return Array.isArray(value.parts) && value.parts.every((part) => isMessagePart(part));
+}
+function isMessageEvent(event) {
+  return isRecord(event) && event.kind === "message" && isMessageLike(event) && Array.isArray(event.parts);
+}
+function isTaskEvent(event) {
+  if (!isRecord(event) || event.kind !== "task") {
+    return false;
+  }
+  return typeof event.id === "string" && isOptionalString(event.contextId) && isStatusLike(event.status) && (event.artifacts === void 0 || Array.isArray(event.artifacts) && event.artifacts.every((item) => isArtifactLike(item))) && (event.history === void 0 || Array.isArray(event.history) && event.history.every((item) => isMessageLike(item)));
+}
+function isStatusUpdateEvent(event) {
+  return isRecord(event) && event.kind === "status-update" && typeof event.taskId === "string" && typeof event.contextId === "string" && isStatusLike(event.status);
+}
+function isArtifactUpdateEvent(event) {
+  return isRecord(event) && event.kind === "artifact-update" && typeof event.taskId === "string" && typeof event.contextId === "string" && isArtifactLike(event.artifact);
+}
+async function loadDefaultA2AClientFactory() {
+  let module;
+  try {
+    module = await import("@a2a-js/sdk/client");
+  } catch (error) {
+    throw new UnsupportedFeatureError(
+      `A2AAdapter requires optional dependency @a2a-js/sdk. Install it with "pnpm add @a2a-js/sdk". (${asErrorMessage(error)})`
+    );
+  }
+  const ClientFactoryCtor = module.ClientFactory;
+  const JsonRpcTransportFactoryCtor = module.JsonRpcTransportFactory;
+  const RestTransportFactoryCtor = module.RestTransportFactory;
+  if (!ClientFactoryCtor || !JsonRpcTransportFactoryCtor || !RestTransportFactoryCtor) {
+    throw new UnsupportedFeatureError("Failed to initialize A2A client: missing required exports from @a2a-js/sdk/client.");
+  }
+  return async ({ remoteUrl, authHeaders }) => {
+    const fetchImpl = createAuthFetch(authHeaders);
+    const factory = new ClientFactoryCtor({
+      transports: [
+        new JsonRpcTransportFactoryCtor({ fetchImpl }),
+        new RestTransportFactoryCtor({ fetchImpl })
+      ]
+    });
+    return factory.createFromUrl(remoteUrl);
+  };
+}
+var VALID_HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9a-zA-Z]+$/;
+function createAuthFetch(authHeaders) {
+  if (typeof globalThis.fetch !== "function") {
+    throw new UnsupportedFeatureError("A2AAdapter requires global fetch support (Node.js 20+).");
+  }
+  const baseFetch = globalThis.fetch.bind(globalThis);
+  const validatedHeaders = Object.entries(authHeaders).filter(([key]) => {
+    if (!VALID_HEADER_NAME.test(key)) {
+      return false;
+    }
+    return true;
+  });
+  if (validatedHeaders.length === 0) {
+    return baseFetch;
+  }
+  return async (input, init) => {
+    const headers = new Headers(init?.headers ?? {});
+    for (const [key, value] of validatedHeaders) {
+      headers.set(key, value);
+    }
+    return baseFetch(input, {
+      ...init,
+      headers
+    });
+  };
+}
+
+// src/adapters/a2a-gateway/history.ts
+var GatewayHistoryConverter = class {
+  convert(raw) {
+    const contextToRoom = {};
+    const roomParticipants = /* @__PURE__ */ new Map();
+    for (const entry of raw) {
+      const metadata = asOptionalRecord(entry.metadata) ?? {};
+      const contextId = asNonEmptyString(metadata.gateway_context_id);
+      if (contextId) {
+        const roomId2 = asNonEmptyString(metadata.gateway_room_id) ?? asNonEmptyString(entry.room_id) ?? asNonEmptyString(entry.roomId);
+        if (roomId2) {
+          contextToRoom[contextId] = roomId2;
+        }
+      }
+      const senderType = (asNonEmptyString(entry.sender_type) ?? asNonEmptyString(entry.senderType) ?? "").trim().toLowerCase();
+      const roomId = asNonEmptyString(entry.room_id) ?? asNonEmptyString(entry.roomId);
+      const senderId = asNonEmptyString(entry.sender_id) ?? asNonEmptyString(entry.senderId);
+      if (senderType !== "agent" || !roomId || !senderId) {
+        continue;
+      }
+      const participants = roomParticipants.get(roomId) ?? /* @__PURE__ */ new Set();
+      participants.add(senderId);
+      roomParticipants.set(roomId, participants);
+    }
+    const serializedParticipants = {};
+    for (const [roomId, participants] of roomParticipants) {
+      serializedParticipants[roomId] = [...participants];
+    }
+    return {
+      contextToRoom,
+      roomParticipants: serializedParticipants
+    };
+  }
+};
+
+// src/adapters/a2a-gateway/server.ts
+import { randomUUID as randomUUID3, timingSafeEqual } from "crypto";
+
+// src/adapters/a2a-gateway/statusEvent.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function buildStatusEvent(input) {
+  return {
+    kind: "status-update",
+    taskId: input.taskId,
+    contextId: input.contextId,
+    final: input.final,
+    status: {
+      state: input.state,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: {
+        kind: "message",
+        messageId: randomUUID2(),
+        role: "agent",
+        taskId: input.taskId,
+        contextId: input.contextId,
+        parts: input.text ? [
+          {
+            kind: "text",
+            text: input.text
+          }
+        ] : []
+      }
+    },
+    metadata: input.metadata
+  };
+}
+
+// src/adapters/a2a-gateway/server.ts
+var GatewayPeerExecutor = class {
+  peer;
+  onRequest;
+  onCancel;
+  constructor(options) {
+    this.peer = options.peer;
+    this.onRequest = options.onRequest;
+    this.onCancel = options.onCancel;
+  }
+  async execute(requestContext, eventBus) {
+    const taskId = asNonEmptyString(requestContext.taskId) ?? randomUUID3();
+    const contextId = asNonEmptyString(requestContext.contextId) ?? randomUUID3();
+    const message = asA2AMessage(requestContext.userMessage, contextId, taskId);
+    try {
+      for await (const event of this.onRequest({
+        peerId: this.peer.id,
+        peerSlug: this.peer.slug,
+        taskId,
+        contextId,
+        message
+      })) {
+        eventBus.publish(event);
+        if (event.final) {
+          break;
+        }
+      }
+    } catch (error) {
+      eventBus.publish(
+        buildStatusEvent({
+          taskId,
+          contextId,
+          state: "failed",
+          final: true,
+          text: "Peer request failed.",
+          metadata: buildGatewayExecutionFailureMetadata(error)
+        })
+      );
+    } finally {
+      eventBus.finished();
+    }
+  }
+  async cancelTask(taskId, eventBus) {
+    const request = {
+      peerId: this.peer.id,
+      peerSlug: this.peer.slug,
+      taskId
+    };
+    await this.onCancel?.(request);
+    eventBus.publish(
+      buildStatusEvent({
+        taskId,
+        contextId: randomUUID3(),
+        state: "canceled",
+        final: true,
+        text: "Task canceled."
+      })
+    );
+    eventBus.finished();
+  }
+};
+var GatewayServer = class {
+  options;
+  server = null;
+  started = false;
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    if (this.started) {
+      return;
+    }
+    assertGatewayAuthPolicy(
+      this.options.host,
+      this.options.authToken,
+      this.options.allowUnauthenticatedLoopback ?? false
+    );
+    const modules = await this.loadModules();
+    const gatewayAuthMiddleware = createGatewayAuthMiddleware(this.options.authToken);
+    const app = this.createApp(modules, gatewayAuthMiddleware);
+    this.registerPeerRoutes(app, modules, gatewayAuthMiddleware);
+    this.server = await listen(app, this.options.port, this.options.host);
+    this.started = true;
+  }
+  async stop() {
+    if (!this.server) {
+      return;
+    }
+    const server = this.server;
+    this.server = null;
+    this.started = false;
+    await new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+  async loadModules() {
+    const modulesLoader = this.options.loadModules;
+    return modulesLoader ? modulesLoader() : loadA2AServerModules();
+  }
+  createApp(modules, gatewayAuthMiddleware) {
+    const app = modules.createExpressApp();
+    app.use(createSecurityHeadersMiddleware());
+    app.use(modules.createExpressApp.json({ limit: "1mb" }));
+    app.use("/peers", gatewayAuthMiddleware);
+    app.get("/peers", (_request, response) => {
+      const peers = [...this.options.peersBySlug.values()].map((peer) => ({
+        slug: peer.slug,
+        id: peer.id,
+        name: peer.name,
+        description: peer.description
+      }));
+      response.json({
+        peers,
+        count: peers.length
+      });
+    });
+    return app;
+  }
+  registerPeerRoutes(app, modules, gatewayAuthMiddleware) {
+    for (const [slug, peer] of this.options.peersBySlug.entries()) {
+      this.registerPeerRoute(app, modules, gatewayAuthMiddleware, slug, peer);
+    }
+  }
+  registerPeerRoute(app, modules, gatewayAuthMiddleware, slug, peer) {
+    const requestHandler = new modules.DefaultRequestHandler(
+      buildAgentCard(peer, this.options.gatewayUrl),
+      new modules.InMemoryTaskStore(),
+      new GatewayPeerExecutor({
+        peer,
+        onRequest: this.options.onRequest,
+        onCancel: this.options.onCancel
+      })
+    );
+    const userBuilder = createUserBuilder(
+      {
+        authToken: this.options.authToken,
+        allowUnauthenticatedLoopback: this.options.allowUnauthenticatedLoopback ?? false
+      },
+      modules
+    );
+    const peerBasePath = `/agents/${slug}`;
+    app.get(
+      `${peerBasePath}/.well-known/agent.json`,
+      gatewayAuthMiddleware,
+      async (_request, response) => {
+        response.json(await requestHandler.getAgentCard());
+      }
+    );
+    app.use(
+      `${peerBasePath}/${modules.AGENT_CARD_PATH}`,
+      gatewayAuthMiddleware,
+      modules.agentCardHandler({
+        agentCardProvider: requestHandler
+      })
+    );
+    app.use(
+      `${peerBasePath}/v1`,
+      gatewayAuthMiddleware,
+      modules.restHandler({
+        requestHandler,
+        userBuilder
+      })
+    );
+    app.use(
+      peerBasePath,
+      gatewayAuthMiddleware,
+      modules.jsonRpcHandler({
+        requestHandler,
+        userBuilder
+      })
+    );
+  }
+};
+function createGatewayServer(options) {
+  return new GatewayServer(options);
+}
+async function loadA2AServerModules() {
+  const [sdk, server, expressServer, expressModule] = await Promise.all([
+    import("@a2a-js/sdk"),
+    import("@a2a-js/sdk/server"),
+    import("@a2a-js/sdk/server/express"),
+    import("express")
+  ]).catch((error) => {
+    throw new Error(
+      `A2AGatewayAdapter requires optional dependency @a2a-js/sdk and express. (${error instanceof Error ? error.message : String(error)})`,
+      { cause: error }
+    );
+  });
+  const createExpressApp = expressModule.default ?? expressModule;
+  const AGENT_CARD_PATH = asNonEmptyString(sdk.AGENT_CARD_PATH) ?? ".well-known/agent-card.json";
+  const DefaultRequestHandler = server.DefaultRequestHandler;
+  const InMemoryTaskStore = server.InMemoryTaskStore;
+  const UserBuilder = expressServer.UserBuilder;
+  const agentCardHandler = expressServer.agentCardHandler;
+  const jsonRpcHandler = expressServer.jsonRpcHandler;
+  const restHandler = expressServer.restHandler;
+  if (!DefaultRequestHandler || !InMemoryTaskStore || !UserBuilder || typeof agentCardHandler !== "function" || typeof jsonRpcHandler !== "function" || typeof restHandler !== "function" || typeof createExpressApp !== "function" || typeof createExpressApp.json !== "function") {
+    throw new Error(
+      "Failed to initialize A2A gateway server: missing required exports from @a2a-js/sdk/server or @a2a-js/sdk/server/express."
+    );
+  }
+  return {
+    AGENT_CARD_PATH,
+    DefaultRequestHandler,
+    InMemoryTaskStore,
+    UserBuilder,
+    agentCardHandler,
+    jsonRpcHandler,
+    restHandler,
+    createExpressApp
+  };
+}
+function buildAgentCard(peer, gatewayUrl) {
+  const url = `${gatewayUrl}/agents/${peer.slug}`;
+  return {
+    name: peer.name,
+    description: peer.description,
+    protocolVersion: "0.3.0",
+    version: "1.0.0",
+    url,
+    preferredTransport: "JSONRPC",
+    additionalInterfaces: [
+      {
+        transport: "JSONRPC",
+        url
+      },
+      {
+        transport: "HTTP+JSON",
+        url: `${url}/v1`
+      }
+    ],
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      stateTransitionHistory: false
+    },
+    skills: [
+      {
+        id: "default",
+        name: peer.name,
+        description: peer.description,
+        tags: ["thenvoi", "gateway"]
+      }
+    ],
+    defaultInputModes: ["text/plain"],
+    defaultOutputModes: ["text/plain"]
+  };
+}
+function asA2AMessage(value, fallbackContextId, fallbackTaskId) {
+  if (!value || typeof value !== "object") {
+    return {
+      kind: "message",
+      messageId: randomUUID3(),
+      role: "user",
+      contextId: fallbackContextId,
+      taskId: fallbackTaskId,
+      parts: []
+    };
+  }
+  const raw = value;
+  const rawParts = Array.isArray(raw.parts) ? raw.parts : [];
+  const parts = [];
+  for (const part of rawParts) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const candidate = part;
+    parts.push({
+      kind: asNonEmptyString(candidate.kind) ?? void 0,
+      text: asNonEmptyString(candidate.text) ?? void 0,
+      root: candidate.root && typeof candidate.root === "object" ? {
+        text: asNonEmptyString(candidate.root.text) ?? void 0
+      } : void 0
+    });
+  }
+  return {
+    kind: "message",
+    messageId: asNonEmptyString(raw.messageId) ?? randomUUID3(),
+    role: asNonEmptyString(raw.role) === "agent" ? "agent" : "user",
+    contextId: asNonEmptyString(raw.contextId) ?? fallbackContextId,
+    taskId: asNonEmptyString(raw.taskId) ?? fallbackTaskId,
+    parts
+  };
+}
+function listen(app, port, host) {
+  return new Promise((resolve, reject) => {
+    let server = null;
+    const onListening = () => {
+      if (server) {
+        resolve(server);
+        return;
+      }
+      queueMicrotask(() => {
+        if (server) {
+          resolve(server);
+          return;
+        }
+        reject(new Error("Gateway server did not return an HTTP server instance."));
+      });
+    };
+    server = app.listen(port, host, onListening);
+    server.once("error", reject);
+  });
+}
+function assertGatewayAuthPolicy(host, authToken, allowUnauthenticatedLoopback = false) {
+  if (authToken) {
+    return;
+  }
+  if (allowUnauthenticatedLoopback && isLoopbackHost(host)) {
+    return;
+  }
+  throw new Error(
+    "A2A gateway authToken is required unless allowUnauthenticatedLoopback is explicitly enabled on a loopback host."
+  );
+}
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
+}
+function createSecurityHeadersMiddleware() {
+  return (_request, response, next) => {
+    response.setHeader("Cache-Control", "no-store");
+    response.setHeader("Referrer-Policy", "no-referrer");
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    response.setHeader("X-Frame-Options", "DENY");
+    next();
+  };
+}
+function createGatewayAuthMiddleware(authToken) {
+  if (!authToken) {
+    return (_request, _response, next) => {
+      next();
+    };
+  }
+  return (request, response, next) => {
+    if (verifyBearerAuthorization(request.headers, authToken)) {
+      next();
+      return;
+    }
+    response.status(401).json({
+      error: "Unauthorized"
+    });
+  };
+}
+function createUserBuilder(options, modules) {
+  const authToken = options.authToken;
+  if (!authToken) {
+    if (!options.allowUnauthenticatedLoopback) {
+      throw new Error(
+        "A2A gateway authToken is required unless allowUnauthenticatedLoopback is explicitly enabled on a loopback host."
+      );
+    }
+    return async (request) => {
+      const user = await modules.UserBuilder.noAuthentication(request);
+      return {
+        id: asNonEmptyString(user?.id) ?? "loopback-anonymous",
+        authType: "none"
+      };
+    };
+  }
+  return async (request) => {
+    if (!verifyBearerAuthorization(request.headers, authToken)) {
+      throw new Error("Unauthorized");
+    }
+    return {
+      id: "gateway-bearer",
+      authType: "bearer"
+    };
+  };
+}
+function getAuthorizationHeader(headers) {
+  if (!headers) {
+    return null;
+  }
+  const value = headers.authorization ?? headers.Authorization;
+  if (Array.isArray(value)) {
+    return value[0] ?? null;
+  }
+  return typeof value === "string" ? value : null;
+}
+function verifyBearerAuthorization(headers, authToken) {
+  const authorization = getAuthorizationHeader(headers);
+  if (!authorization) {
+    return false;
+  }
+  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);
+  if (leftBuffer.length !== rightBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(leftBuffer, rightBuffer);
+}
+
+// src/adapters/a2a-gateway/A2AGatewayAdapter.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var DEFAULT_HOST = "127.0.0.1";
+var DEFAULT_PORT = 1e4;
+var DEFAULT_GATEWAY_URL = `http://localhost:${DEFAULT_PORT}`;
+var DEFAULT_RESPONSE_TIMEOUT_MS = 12e4;
+var DEFAULT_PEER_PAGE_SIZE = 100;
+var DEFAULT_MAX_PEER_PAGES = 25;
+var A2AGatewayAdapter = class extends SimpleAdapter {
+  thenvoiRest;
+  gatewayUrl;
+  host;
+  port;
+  authToken;
+  allowUnauthenticatedLoopback;
+  responseTimeoutMs;
+  peerPageSize;
+  maxPeerPages;
+  serverFactory;
+  peersBySlug = /* @__PURE__ */ new Map();
+  peersById = /* @__PURE__ */ new Map();
+  contextToRoom = /* @__PURE__ */ new Map();
+  roomParticipants = /* @__PURE__ */ new Map();
+  pendingByRoom = /* @__PURE__ */ new Map();
+  pendingByTask = /* @__PURE__ */ new Map();
+  server = null;
+  constructor(options) {
+    super({
+      historyConverter: new GatewayHistoryConverter()
+    });
+    this.thenvoiRest = options.thenvoiRest;
+    this.gatewayUrl = options.gatewayUrl ?? DEFAULT_GATEWAY_URL;
+    this.host = options.host ?? DEFAULT_HOST;
+    this.port = options.port ?? DEFAULT_PORT;
+    this.authToken = options.authToken;
+    this.allowUnauthenticatedLoopback = options.allowUnauthenticatedLoopback ?? false;
+    this.responseTimeoutMs = options.responseTimeoutMs ?? DEFAULT_RESPONSE_TIMEOUT_MS;
+    this.peerPageSize = options.peerPageSize ?? DEFAULT_PEER_PAGE_SIZE;
+    this.maxPeerPages = options.maxPeerPages ?? DEFAULT_MAX_PEER_PAGES;
+    this.serverFactory = options.serverFactory ?? createGatewayServer;
+    if (this.allowUnauthenticatedLoopback && !isLoopbackHost2(this.host)) {
+      throw new ValidationError(
+        "A2AGatewayAdapter `allowUnauthenticatedLoopback` may only be enabled for loopback hosts."
+      );
+    }
+  }
+  async onStarted(agentName, agentDescription) {
+    await super.onStarted(agentName, agentDescription);
+    await this.refreshPeers();
+    this.server = this.serverFactory({
+      peersBySlug: this.peersBySlug,
+      peersById: this.peersById,
+      gatewayUrl: this.gatewayUrl,
+      host: this.host,
+      port: this.port,
+      authToken: this.authToken,
+      allowUnauthenticatedLoopback: this.allowUnauthenticatedLoopback,
+      onRequest: (request) => this.handleGatewayRequest(request),
+      onCancel: async (request) => {
+        const canonicalPeerId = this.resolveCanonicalPeerId(request);
+        this.cancelPendingTask(request.taskId, canonicalPeerId ?? request.peerId);
+      }
+    });
+    await this.server.start();
+  }
+  async onMessage(message, _tools, history, _participantsMessage, _contactsMessage, context) {
+    if (context.isSessionBootstrap) {
+      this.rehydrate(history);
+    }
+    const pending = this.resolvePendingForMessage(context.roomId, message);
+    if (!pending) {
+      return;
+    }
+    const event = toStatusUpdateEvent(message, pending.taskId, pending.contextId);
+    pending.enqueue(event);
+    if (event.final) {
+      this.removePending(pending);
+    }
+  }
+  async onCleanup(roomId) {
+    const roomPendings = this.pendingByRoom.get(roomId);
+    if (roomPendings && roomPendings.size > 0) {
+      for (const pending of roomPendings.values()) {
+        pending.queue.cancel();
+      }
+      roomPendings.clear();
+      this.pendingByRoom.delete(roomId);
+    }
+    for (const [taskId, pending] of this.pendingByTask) {
+      if (pending.roomId === roomId) {
+        this.pendingByTask.delete(taskId);
+      }
+    }
+    this.forgetRoom(roomId);
+  }
+  async stopGatewayServer() {
+    if (!this.server) {
+      return;
+    }
+    const server = this.server;
+    this.server = null;
+    await server.stop();
+  }
+  async onRuntimeStop() {
+    this.resetState();
+    await this.stopGatewayServer();
+  }
+  async refreshPeers() {
+    this.peersBySlug.clear();
+    this.peersById.clear();
+    if (!this.thenvoiRest.listPeers) {
+      throw new UnsupportedFeatureError(
+        "Peer listing is not available in current REST adapter"
+      );
+    }
+    for (let page = 1; page <= this.maxPeerPages; page += 1) {
+      const response = await this.thenvoiRest.listPeers({
+        page,
+        pageSize: this.peerPageSize,
+        notInChat: ""
+      });
+      const peers = Array.isArray(response.data) ? response.data : [];
+      for (const item of peers) {
+        const peer = toGatewayPeer(item);
+        if (!peer) {
+          continue;
+        }
+        const slug = uniqueSlug(peer.slug, this.peersBySlug);
+        const normalized = {
+          ...peer,
+          slug
+        };
+        this.peersBySlug.set(slug, normalized);
+        this.peersById.set(normalized.id, normalized);
+      }
+      if (peers.length < this.peerPageSize) {
+        break;
+      }
+    }
+  }
+  async *handleGatewayRequest(request) {
+    const peer = this.resolveGatewayPeer(request);
+    if (!peer) {
+      yield buildStatusEvent({
+        taskId: request.taskId,
+        contextId: request.contextId,
+        state: "failed",
+        final: true,
+        text: `Peer not found: ${request.peerId}`
+      });
+      return;
+    }
+    const hadContext = request.contextId.length > 0 && this.contextToRoom.has(request.contextId);
+    const [roomId, contextId] = await this.getOrCreateRoom(
+      request.contextId,
+      peer.id
+    );
+    const roomPendings = this.pendingByRoom.get(roomId);
+    const activeInRoom = roomPendings?.size ?? 0;
+    const queue = new AsyncEventQueue();
+    const strictTaskMetadata = hadContext;
+    const pending = {
+      taskId: request.taskId,
+      contextId,
+      peerId: peer.id,
+      peerSlug: peer.slug,
+      roomId,
+      strictTaskMetadata,
+      requireTaskMetadata: strictTaskMetadata || activeInRoom > 0,
+      queue,
+      enqueue: (event) => {
+        queue.enqueue(event);
+      }
+    };
+    this.registerPending(pending);
+    this.pendingByTask.set(pending.taskId, pending);
+    yield buildStatusEvent({
+      taskId: pending.taskId,
+      contextId: pending.contextId,
+      state: "working",
+      final: false,
+      text: `Routed request to ${peer.name}.`
+    });
+    try {
+      await this.emitContextEvent(roomId, contextId);
+      const content = extractMessageText2(request.message) ?? "";
+      await this.thenvoiRest.createChatMessage(roomId, {
+        content: buildMentionedContent(peer.name, content),
+        mentions: buildMentions(peer),
+        metadata: {
+          gateway_context_id: contextId,
+          gateway_room_id: roomId,
+          gateway_task_id: request.taskId,
+          gateway_peer_id: peer.id,
+          gateway_peer_slug: peer.slug
+        }
+      });
+    } catch (error) {
+      this.removePending(pending);
+      yield buildStatusEvent({
+        taskId: pending.taskId,
+        contextId: pending.contextId,
+        state: "failed",
+        final: true,
+        text: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    while (true) {
+      const next = await pending.queue.dequeue(this.responseTimeoutMs);
+      if (!next) {
+        this.removePending(pending);
+        yield buildStatusEvent({
+          taskId: pending.taskId,
+          contextId: pending.contextId,
+          state: "failed",
+          final: true,
+          text: "Timed out waiting for a Thenvoi peer response."
+        });
+        return;
+      }
+      yield next;
+      if (next.final) {
+        this.removePending(pending);
+        return;
+      }
+    }
+  }
+  cancelPendingTask(taskId, peerId) {
+    const pending = this.pendingByTask.get(taskId);
+    if (!pending) {
+      return;
+    }
+    this.finalizePending(
+      pending,
+      buildStatusEvent({
+        taskId,
+        contextId: pending.contextId,
+        state: "canceled",
+        final: true,
+        text: `Task canceled by A2A client (${peerId}).`
+      })
+    );
+  }
+  registerPending(pending) {
+    const roomPendings = this.pendingByRoom.get(pending.roomId) ?? /* @__PURE__ */ new Map();
+    roomPendings.set(pending.taskId, pending);
+    this.pendingByRoom.set(pending.roomId, roomPendings);
+    if (roomPendings.size > 1) {
+      for (const entry of roomPendings.values()) {
+        entry.requireTaskMetadata = true;
+      }
+    }
+  }
+  resolvePendingForMessage(roomId, message) {
+    const roomPendings = this.pendingByRoom.get(roomId);
+    if (!roomPendings || roomPendings.size === 0) {
+      return null;
+    }
+    const metadata = message.metadata ?? {};
+    const gatewayTaskId = asNonEmptyString(metadata.gateway_task_id);
+    if (gatewayTaskId) {
+      const pending = roomPendings.get(gatewayTaskId) ?? null;
+      if (!pending || !shouldRouteToPendingTask(message, pending)) {
+        return null;
+      }
+      return pending;
+    }
+    let matched = null;
+    for (const pending of roomPendings.values()) {
+      if (!shouldRouteToPendingTask(message, pending)) {
+        continue;
+      }
+      if (matched) {
+        return null;
+      }
+      matched = pending;
+    }
+    return matched;
+  }
+  resolveGatewayPeer(request) {
+    const canonicalPeerId = this.resolveCanonicalPeerId(request);
+    if (!canonicalPeerId) {
+      return null;
+    }
+    return this.peersById.get(canonicalPeerId) ?? null;
+  }
+  resolveCanonicalPeerId(request) {
+    const byId = this.peersById.get(request.peerId);
+    if (byId) {
+      return byId.id;
+    }
+    const legacySlug = request.peerSlug ?? request.peerId;
+    const bySlug = this.peersBySlug.get(legacySlug);
+    if (bySlug) {
+      return bySlug.id;
+    }
+    return null;
+  }
+  async getOrCreateRoom(contextId, targetPeerId) {
+    const existingRoom = this.contextToRoom.get(contextId);
+    if (existingRoom) {
+      const participants = this.roomParticipants.get(existingRoom) ?? /* @__PURE__ */ new Set();
+      if (!participants.has(targetPeerId)) {
+        await this.thenvoiRest.addChatParticipant(existingRoom, {
+          participantId: targetPeerId,
+          role: "member"
+        });
+        participants.add(targetPeerId);
+        this.roomParticipants.set(existingRoom, participants);
+      }
+      return [existingRoom, contextId];
+    }
+    const normalizedContextId = contextId && contextId.length > 0 ? contextId : randomUUID4();
+    const created = await this.thenvoiRest.createChat(
+      `a2a:gateway:${normalizedContextId}`
+    );
+    const roomId = created.id;
+    await this.thenvoiRest.addChatParticipant(roomId, {
+      participantId: targetPeerId,
+      role: "member"
+    });
+    this.contextToRoom.set(normalizedContextId, roomId);
+    this.roomParticipants.set(roomId, /* @__PURE__ */ new Set([targetPeerId]));
+    return [roomId, normalizedContextId];
+  }
+  async emitContextEvent(roomId, contextId) {
+    await this.thenvoiRest.createChatEvent(roomId, {
+      content: "A2A gateway context",
+      messageType: "task",
+      metadata: {
+        gateway_context_id: contextId,
+        gateway_room_id: roomId
+      }
+    });
+  }
+  rehydrate(history) {
+    for (const [contextId, roomId] of Object.entries(history.contextToRoom)) {
+      if (!this.contextToRoom.has(contextId)) {
+        this.contextToRoom.set(contextId, roomId);
+      }
+    }
+    for (const [roomId, peers] of Object.entries(history.roomParticipants)) {
+      const existing = this.roomParticipants.get(roomId) ?? /* @__PURE__ */ new Set();
+      for (const peer of peers) {
+        existing.add(peer);
+      }
+      this.roomParticipants.set(roomId, existing);
+    }
+  }
+  removePending(pending) {
+    const roomPendings = this.pendingByRoom.get(pending.roomId);
+    if (roomPendings) {
+      roomPendings.delete(pending.taskId);
+      if (roomPendings.size === 0) {
+        this.pendingByRoom.delete(pending.roomId);
+      } else {
+        const hasMultiple = roomPendings.size > 1;
+        for (const entry of roomPendings.values()) {
+          entry.requireTaskMetadata = entry.strictTaskMetadata || hasMultiple;
+        }
+      }
+    }
+    const byTask = this.pendingByTask.get(pending.taskId);
+    if (byTask === pending) {
+      this.pendingByTask.delete(pending.taskId);
+    }
+  }
+  finalizePending(pending, event) {
+    pending.queue.clear();
+    pending.enqueue(event);
+    this.removePending(pending);
+  }
+  forgetRoom(roomId) {
+    this.roomParticipants.delete(roomId);
+    for (const [contextId, mappedRoomId] of this.contextToRoom.entries()) {
+      if (mappedRoomId === roomId) {
+        this.contextToRoom.delete(contextId);
+      }
+    }
+  }
+  resetState() {
+    for (const pending of this.pendingByTask.values()) {
+      pending.queue.cancel();
+    }
+    this.peersBySlug.clear();
+    this.peersById.clear();
+    this.contextToRoom.clear();
+    this.roomParticipants.clear();
+    this.pendingByRoom.clear();
+    this.pendingByTask.clear();
+  }
+};
+var AsyncEventQueue = class {
+  items = [];
+  waiters = [];
+  cancelled = false;
+  enqueue(item) {
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter(item);
+      return;
+    }
+    this.items.push(item);
+  }
+  cancel() {
+    this.cancelled = true;
+    this.items.length = 0;
+    const pending = this.waiters.splice(0);
+    for (const waiter of pending) {
+      waiter(null);
+    }
+  }
+  clear() {
+    this.items.length = 0;
+  }
+  async dequeue(timeoutMs) {
+    if (this.cancelled) {
+      return null;
+    }
+    if (this.items.length > 0) {
+      return this.items.shift() ?? null;
+    }
+    return new Promise((resolve) => {
+      const waiter = (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      };
+      const timeout = setTimeout(() => {
+        const index = this.waiters.indexOf(waiter);
+        if (index >= 0) {
+          this.waiters.splice(index, 1);
+        }
+        resolve(null);
+      }, timeoutMs);
+      this.waiters.push(waiter);
+    });
+  }
+};
+function toGatewayPeer(value) {
+  const id = asNonEmptyString(value.id);
+  if (!id) {
+    return null;
+  }
+  const name = asNonEmptyString(value.name) ?? asNonEmptyString(value.handle) ?? id;
+  const description = asNonEmptyString(value.description) ?? "";
+  const handle = asNonEmptyString(value.handle);
+  return {
+    id,
+    name,
+    description,
+    handle,
+    slug: slugify(handle ?? name)
+  };
+}
+function uniqueSlug(baseSlug, existing) {
+  if (!existing.has(baseSlug)) {
+    return baseSlug;
+  }
+  let index = 2;
+  while (existing.has(`${baseSlug}-${index}`)) {
+    index += 1;
+  }
+  return `${baseSlug}-${index}`;
+}
+function isLoopbackHost2(host) {
+  const normalized = host.trim().toLowerCase();
+  return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
+}
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "peer";
+}
+function buildMentionedContent(peerName, content) {
+  const trimmed = content.trim();
+  if (!trimmed) {
+    return `@${peerName}`;
+  }
+  return `@${peerName} ${trimmed}`;
+}
+function buildMentions(peer) {
+  if (peer.handle) {
+    return [{ id: peer.id, handle: peer.handle }];
+  }
+  return [{ id: peer.id }];
+}
+function toStatusUpdateEvent(message, taskId, contextId) {
+  const normalizedType = message.messageType.trim().toLowerCase();
+  let state;
+  let final = false;
+  if (normalizedType === "error") {
+    state = "failed";
+    final = true;
+  } else if (normalizedType === "text") {
+    state = "completed";
+    final = true;
+  } else {
+    state = "working";
+  }
+  return buildStatusEvent({
+    taskId,
+    contextId,
+    state,
+    final,
+    text: message.content,
+    metadata: {
+      thenvoi_message_id: message.id,
+      thenvoi_message_type: message.messageType,
+      thenvoi_sender_id: message.senderId,
+      thenvoi_room_id: message.roomId
+    }
+  });
+}
+function shouldRouteToPendingTask(message, pending) {
+  const metadata = message.metadata ?? {};
+  const gatewayTaskId = asNonEmptyString(metadata.gateway_task_id);
+  if (gatewayTaskId) {
+    return gatewayTaskId === pending.taskId;
+  }
+  if (pending.requireTaskMetadata) {
+    return false;
+  }
+  const gatewayContextId = asNonEmptyString(metadata.gateway_context_id);
+  if (gatewayContextId && gatewayContextId !== pending.contextId) {
+    return false;
+  }
+  const gatewayPeerId = asNonEmptyString(metadata.gateway_peer_id);
+  if (gatewayPeerId) {
+    return peerMatchesPendingIdentifier(gatewayPeerId, pending);
+  }
+  const gatewayPeerSlug = asNonEmptyString(metadata.gateway_peer_slug);
+  if (gatewayPeerSlug) {
+    return gatewayPeerSlug === pending.peerSlug;
+  }
+  return peerMatchesPendingIdentifier(message.senderId, pending);
+}
+function peerMatchesPendingIdentifier(identifier, pending) {
+  return identifier === pending.peerId || identifier === pending.peerSlug;
+}
+function extractMessageText2(message) {
+  const chunks = [];
+  for (const part of message.parts) {
+    if (typeof part.text === "string" && part.text.trim().length > 0) {
+      chunks.push(part.text.trim());
+      continue;
+    }
+    if (part.root && typeof part.root.text === "string" && part.root.text.trim().length > 0) {
+      chunks.push(part.root.text.trim());
+    }
+  }
+  if (chunks.length === 0) {
+    return null;
+  }
+  return chunks.join("\n");
+}
+
+// src/adapters/parlant/types.ts
+var ParlantHistoryConverter = class {
+  convert(raw) {
+    const messages = [];
+    for (const entry of raw) {
+      const messageType = asNonEmptyString(entry.message_type) ?? "text";
+      if (messageType !== "text") {
+        continue;
+      }
+      const content = asNonEmptyString(entry.content);
+      if (!content) {
+        continue;
+      }
+      const sender = asNonEmptyString(entry.sender_name) ?? asNonEmptyString(entry.senderName) ?? "";
+      const senderType = asNonEmptyString(entry.sender_type) ?? asNonEmptyString(entry.senderType) ?? "User";
+      const role = (asNonEmptyString(entry.role) ?? "user").toLowerCase() === "assistant" ? "assistant" : "user";
+      if (role === "assistant") {
+        messages.push({
+          role,
+          content,
+          sender,
+          senderType
+        });
+        continue;
+      }
+      messages.push({
+        role,
+        content: sender ? `[${sender}]: ${content}` : content,
+        sender,
+        senderType
+      });
+    }
+    return messages;
+  }
+};
+
+// src/adapters/shared/lazyAsyncValue.ts
+var DEFAULT_RETRY_BACKOFF_MS = 1e3;
+var LazyAsyncValue = class {
+  load;
+  onRejected;
+  retryBackoffMs;
+  value = null;
+  pending = null;
+  lastFailureAt = 0;
+  constructor(options) {
+    this.load = options.load;
+    this.onRejected = options.onRejected;
+    this.retryBackoffMs = options.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
+  }
+  get current() {
+    return this.value;
+  }
+  async get() {
+    if (this.value) {
+      return this.value;
+    }
+    if (!this.pending) {
+      if (this.lastFailureAt > 0 && Date.now() - this.lastFailureAt < this.retryBackoffMs) {
+        throw new Error(
+          `LazyAsyncValue load failed recently; retrying after ${this.retryBackoffMs}ms backoff.`
+        );
+      }
+      this.pending = this.load().then((value) => {
+        this.value = value;
+        this.lastFailureAt = 0;
+        return value;
+      }).catch((error) => {
+        this.pending = null;
+        this.lastFailureAt = Date.now();
+        this.onRejected?.(error);
+        throw error;
+      });
+    }
+    return this.pending;
+  }
+  clear() {
+    this.value = null;
+    this.pending = null;
+    this.lastFailureAt = 0;
+  }
+};
+
+// src/adapters/parlant/ParlantAdapter.ts
+var DEFAULT_RESPONSE_TIMEOUT_SECONDS = 120;
+var DEFAULT_MAX_HISTORY_MESSAGES = 100;
+var ParlantAdapter = class extends SimpleAdapter {
+  environment;
+  baseUrl;
+  agentId;
+  apiKey;
+  headers;
+  systemPromptOverride;
+  customSection;
+  includeBaseInstructions;
+  responseTimeoutSeconds;
+  maxHistoryMessages;
+  clientFactory;
+  logger;
+  clientLoader;
+  lastInitFailure = 0;
+  systemPrompt = "";
+  roomSessions = /* @__PURE__ */ new Map();
+  roomCustomers = /* @__PURE__ */ new Map();
+  bootstrappedRooms = /* @__PURE__ */ new Set();
+  roomSessionInitPromises = /* @__PURE__ */ new Map();
+  roomBootstrapInitPromises = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super({
+      historyConverter: options.historyConverter ?? new ParlantHistoryConverter()
+    });
+    this.environment = options.environment;
+    this.baseUrl = options.baseUrl;
+    this.agentId = options.agentId;
+    this.apiKey = options.apiKey;
+    this.headers = { ...options.headers ?? {} };
+    this.systemPromptOverride = options.systemPrompt;
+    this.customSection = options.customSection;
+    this.includeBaseInstructions = options.includeBaseInstructions ?? true;
+    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.clientLoader = new LazyAsyncValue({
+      load: async () => this.createClient(),
+      onRejected: (error) => {
+        this.lastInitFailure = Date.now();
+        this.logger.error("Parlant client initialization failed", {
+          error
+        });
+      }
+    });
+  }
+  async onStarted(agentName, agentDescription) {
+    await super.onStarted(agentName, agentDescription);
+    this.systemPrompt = this.systemPromptOverride ?? renderSystemPrompt({
+      agentName,
+      agentDescription,
+      customSection: this.customSection,
+      includeBaseInstructions: this.includeBaseInstructions
+    });
+  }
+  async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
+    const senderName = message.senderName ?? message.senderId ?? "User";
+    try {
+      const client = await this.ensureClient();
+      const sessionId = await this.getOrCreateSession(
+        client,
+        context.roomId,
+        senderName
+      );
+      if (context.isSessionBootstrap) {
+        await this.ensureBootstrapHistory(client, sessionId, context.roomId, history);
+      }
+      const userMessage = buildUserMessage({
+        content: message.content,
+        participantsMessage,
+        contactsMessage
+      });
+      const createdEvent = await client.sessions.createEvent(
+        sessionId,
+        {
+          kind: "message",
+          source: "customer",
+          message: userMessage,
+          moderation: "none",
+          metadata: {
+            thenvoi_source: "thenvoi-sdk-typescript",
+            thenvoi_room_id: context.roomId
+          }
+        },
+        this.requestOptions()
+      );
+      const reply = await this.waitForAiResponse(
+        client,
+        sessionId,
+        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;
+      }
+      await tools.sendMessage(reply, [{ id: message.senderId }]);
+    } catch (error) {
+      const errorMessage = asErrorMessage(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);
+    }
+  }
+  async onCleanup(roomId) {
+    const pendingSession = this.roomSessionInitPromises.get(roomId);
+    const pendingBootstrap = this.roomBootstrapInitPromises.get(roomId);
+    const pendingOperations = [pendingSession, pendingBootstrap].filter(
+      (promise) => promise !== void 0
+    );
+    await Promise.allSettled(pendingOperations);
+    this.roomSessions.delete(roomId);
+    this.roomCustomers.delete(roomId);
+    this.bootstrappedRooms.delete(roomId);
+    this.roomSessionInitPromises.delete(roomId);
+    this.roomBootstrapInitPromises.delete(roomId);
+  }
+  async getOrCreateSession(client, roomId, customerName) {
+    const existingSession = this.roomSessions.get(roomId);
+    if (existingSession) {
+      return existingSession;
+    }
+    const initializing = this.roomSessionInitPromises.get(roomId);
+    if (initializing) {
+      return initializing;
+    }
+    const initPromise = (async () => {
+      const customerId = await this.getOrCreateCustomer(client, roomId, customerName);
+      const session = await client.sessions.create(
+        {
+          agentId: this.agentId,
+          customerId,
+          title: `Thenvoi Room ${roomId.slice(0, 8)}`,
+          metadata: {
+            thenvoi_room_id: roomId
+          }
+        },
+        this.requestOptions()
+      );
+      if (this.systemPrompt.trim().length > 0) {
+        await client.sessions.createEvent(
+          session.id,
+          {
+            kind: "message",
+            source: "system",
+            message: this.systemPrompt,
+            metadata: {
+              thenvoi_system_prompt: true
+            }
+          },
+          this.requestOptions()
+        );
+      }
+      this.roomSessions.set(roomId, session.id);
+      return session.id;
+    })();
+    this.roomSessionInitPromises.set(roomId, initPromise);
+    try {
+      return await initPromise;
+    } finally {
+      const pending = this.roomSessionInitPromises.get(roomId);
+      if (pending === initPromise) {
+        this.roomSessionInitPromises.delete(roomId);
+      }
+    }
+  }
+  async ensureBootstrapHistory(client, sessionId, roomId, history) {
+    if (this.bootstrappedRooms.has(roomId)) {
+      return;
+    }
+    const initializing = this.roomBootstrapInitPromises.get(roomId);
+    if (initializing) {
+      await initializing;
+      return;
+    }
+    const initPromise = (async () => {
+      if (this.bootstrappedRooms.has(roomId)) {
+        return;
+      }
+      await this.injectHistory(client, sessionId, history);
+      this.bootstrappedRooms.add(roomId);
+    })();
+    this.roomBootstrapInitPromises.set(roomId, initPromise);
+    try {
+      await initPromise;
+    } finally {
+      const pending = this.roomBootstrapInitPromises.get(roomId);
+      if (pending === initPromise) {
+        this.roomBootstrapInitPromises.delete(roomId);
+      }
+    }
+  }
+  async getOrCreateCustomer(client, roomId, customerName) {
+    const existingCustomer = this.roomCustomers.get(roomId);
+    if (existingCustomer) {
+      return existingCustomer;
+    }
+    const customer = await client.customers.create(
+      {
+        name: customerName,
+        metadata: {
+          thenvoi_room_id: roomId
+        }
+      },
+      this.requestOptions()
+    );
+    this.roomCustomers.set(roomId, customer.id);
+    return customer.id;
+  }
+  async injectHistory(client, sessionId, history) {
+    if (history.length === 0) {
+      return;
+    }
+    const completeHistory = selectCompleteExchanges(history).slice(
+      -this.maxHistoryMessages
+    );
+    let failedEvents = 0;
+    for (const item of completeHistory) {
+      try {
+        if (item.role === "user") {
+          await client.sessions.createEvent(
+            sessionId,
+            {
+              kind: "message",
+              source: "customer",
+              message: item.content,
+              moderation: "none",
+              metadata: {
+                historical: true
+              }
+            },
+            this.requestOptions()
+          );
+          continue;
+        }
+        await client.sessions.createEvent(
+          sessionId,
+          {
+            kind: "message",
+            source: "ai_agent",
+            data: {
+              message: item.content,
+              participant: {
+                displayName: item.sender || this.agentName || "Assistant"
+              }
+            },
+            metadata: {
+              historical: true
+            }
+          },
+          this.requestOptions()
+        );
+      } catch (error) {
+        failedEvents += 1;
+        this.logger.warn("Parlant history injection failed", {
+          sessionId,
+          roomRole: item.role,
+          error
+        });
+      }
+    }
+    if (failedEvents > 0) {
+      this.logger.warn("Parlant history injection completed with skipped events", {
+        sessionId,
+        failedEvents
+      });
+    }
+  }
+  async waitForAiResponse(client, sessionId, minOffset) {
+    const deadline = Date.now() + this.responseTimeoutSeconds * 1e3;
+    let nextOffset = Math.max(0, minOffset + 1);
+    while (Date.now() < deadline) {
+      const remainingSeconds = Math.max(
+        1,
+        Math.ceil((deadline - Date.now()) / 1e3)
+      );
+      const waitForData = Math.min(10, remainingSeconds);
+      const events = await client.sessions.listEvents(
+        sessionId,
+        {
+          minOffset: nextOffset,
+          source: "ai_agent",
+          kinds: "message,status",
+          waitForData
+        },
+        this.requestOptions()
+      );
+      if (!Array.isArray(events) || events.length === 0) {
+        continue;
+      }
+      const ordered = [...events].sort((left, right) => {
+        const leftOffset = asNumber(left.offset) ?? Number.MAX_SAFE_INTEGER;
+        const rightOffset = asNumber(right.offset) ?? Number.MAX_SAFE_INTEGER;
+        return leftOffset - rightOffset;
+      });
+      for (const event of ordered) {
+        const offset = asNumber(event.offset);
+        if (offset !== null) {
+          nextOffset = Math.max(nextOffset, offset + 1);
+        }
+        const state = extractStatusState(event);
+        if (state === "error" || state === "cancelled") {
+          throw new Error(
+            `Parlant session ${sessionId} entered terminal status: ${state}`
+          );
+        }
+        const text = extractEventMessage(event);
+        if (text) {
+          return text;
+        }
+      }
+    }
+    return null;
+  }
+  requestOptions() {
+    const headers = { ...this.headers };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (Object.keys(headers).length === 0) {
+      return void 0;
+    }
+    return { headers };
+  }
+  async ensureClient() {
+    if (this.clientLoader.current) {
+      return this.clientLoader.get();
+    }
+    const cooldownMs = 2e3;
+    const elapsed = Date.now() - this.lastInitFailure;
+    if (this.lastInitFailure > 0 && elapsed < cooldownMs) {
+      throw new Error(
+        `Parlant client init failed recently (${elapsed}ms ago). Retrying after ${cooldownMs}ms cooldown.`
+      );
+    }
+    return this.clientLoader.get();
+  }
+  async createClient() {
+    const factory = this.clientFactory ?? await loadParlantClientFactory({
+      environment: this.environment,
+      baseUrl: this.baseUrl
+    });
+    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) {
+    updates.push(`[System Update]: ${input.participantsMessage}`);
+  }
+  if (input.contactsMessage) {
+    updates.push(`[System Update]: ${input.contactsMessage}`);
+  }
+  if (updates.length === 0) {
+    return input.content;
+  }
+  return `${updates.join("\n\n")}
+
+${input.content}`;
+}
+async function loadParlantClientFactory(config) {
+  const module = await import("parlant-client").catch((error) => {
+    throw new UnsupportedFeatureError(
+      `ParlantAdapter requires optional dependency parlant-client. Install it with "pnpm add parlant-client". (${error instanceof Error ? error.message : String(error)})`
+    );
+  });
+  if (!module.ParlantClient) {
+    throw new UnsupportedFeatureError(
+      'ParlantAdapter requires optional dependency parlant-client. Install it with "pnpm add parlant-client".'
+    );
+  }
+  const ParlantClientCtor = module.ParlantClient;
+  return async () => new ParlantClientCtor({
+    environment: () => config.environment,
+    ...config.baseUrl ? { baseUrl: () => config.baseUrl } : {}
+  });
+}
+function extractStatusState(event) {
+  if ((asNonEmptyString(event.kind) ?? "") !== "status") {
+    return null;
+  }
+  const data = asOptionalRecord(event.data) ?? {};
+  return asNonEmptyString(data.state) ?? null;
+}
+function extractEventMessage(event) {
+  const directData = event.data;
+  if (typeof directData === "string" && directData.trim().length > 0) {
+    return directData.trim();
+  }
+  const data = asOptionalRecord(directData) ?? {};
+  const message = data.message;
+  if (typeof message === "string" && message.trim().length > 0) {
+    return message.trim();
+  }
+  if (message && typeof message === "object") {
+    const messageObject = message;
+    const text = asNonEmptyString(messageObject.text) ?? asNonEmptyString(messageObject.content);
+    if (text) {
+      return text;
+    }
+  }
+  const content = asNonEmptyString(data.content);
+  if (content) {
+    return content;
+  }
+  const chunks = data.chunks;
+  if (Array.isArray(chunks)) {
+    const lines = chunks.filter((chunk) => typeof chunk === "string").map((chunk) => chunk.trim()).filter((chunk) => chunk.length > 0);
+    if (lines.length > 0) {
+      return lines.join("");
+    }
+  }
+  return null;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return null;
+}
+
+// src/converters/opencode.ts
+var OpencodeHistoryConverter = class {
+  setAgentName(_name) {
+  }
+  convert(raw) {
+    const replayMessages = buildReplayMessages(raw);
+    const metadata = findLatestTaskMetadata(
+      raw,
+      (entry) => typeof entry.opencode_session_id === "string" && entry.opencode_session_id.length > 0
+    );
+    if (!metadata) {
+      return {
+        sessionId: null,
+        roomId: null,
+        createdAt: null,
+        replayMessages
+      };
+    }
+    return {
+      sessionId: asOptionalString(metadata.opencode_session_id),
+      roomId: asOptionalString(metadata.opencode_room_id),
+      createdAt: parseDate(metadata.opencode_created_at),
+      replayMessages
+    };
+  }
+};
+function extractOpencodeSessionId(raw) {
+  return asOptionalString(
+    findLatestTaskMetadata(
+      raw,
+      (entry) => typeof entry.opencode_session_id === "string" && entry.opencode_session_id.length > 0
+    )?.opencode_session_id
+  );
+}
+function buildReplayMessages(raw) {
+  const replayMessages = [];
+  for (const entry of raw) {
+    if (String(entry.message_type ?? "text") !== "text") {
+      continue;
+    }
+    const content = asOptionalString(entry.content);
+    if (!content) {
+      continue;
+    }
+    const senderName = asOptionalString(entry.sender_name) ?? asOptionalString(entry.sender_type) ?? "Unknown";
+    replayMessages.push(`[${senderName}]: ${content}`);
+  }
+  return replayMessages;
+}
+
+// src/converters/claude-sdk.ts
+var ClaudeSDKHistoryConverter = class {
+  agentName = "";
+  constructor(agentName = "") {
+    this.agentName = agentName;
+  }
+  setAgentName(name) {
+    this.agentName = name;
+  }
+  convert(raw) {
+    return {
+      text: buildClaudeSdkText(raw, this.agentName),
+      sessionId: extractClaudeSessionId(raw)
+    };
+  }
+};
+function extractClaudeSessionId(raw) {
+  const metadata = findLatestTaskMetadata(
+    raw,
+    (entry) => typeof entry.claude_sdk_session_id === "string" && entry.claude_sdk_session_id.length > 0 || typeof entry.claude_session_id === "string" && entry.claude_session_id.length > 0
+  );
+  const sessionId = metadata?.claude_sdk_session_id ?? metadata?.claude_session_id;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+function buildClaudeSdkText(raw, agentName) {
+  const lines = [];
+  for (const entry of raw) {
+    const messageType = String(entry.message_type ?? "text");
+    if (messageType === "task") {
+      continue;
+    }
+    const content = asOptionalString(entry.content);
+    if (!content) {
+      continue;
+    }
+    const role = String(entry.role ?? "user");
+    const senderName = asOptionalString(entry.sender_name) ?? "Unknown";
+    if (messageType === "text") {
+      if (role === "assistant" && senderName === agentName) {
+        continue;
+      }
+      lines.push(`[${senderName}]: ${content}`);
+      continue;
+    }
+    if (messageType === "tool_call" || messageType === "tool_result") {
+      lines.push(content);
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter,
+  asOptionalString,
+  parseDate,
+  parseToolCall,
+  parseToolResult,
+  LazyAsyncValue,
+  findLatestTaskMetadata,
+  GoogleADKHistoryConverter,
+  extractGoogleAdkSessionId,
+  buildA2AAuthHeaders,
+  A2AHistoryConverter,
+  A2AAdapter,
+  GatewayHistoryConverter,
+  GatewayServer,
+  createGatewayServer,
+  A2AGatewayAdapter,
+  ParlantHistoryConverter,
+  ParlantAdapter,
+  OpencodeHistoryConverter,
+  extractOpencodeSessionId,
+  ClaudeSDKHistoryConverter,
+  extractClaudeSessionId
+};