@automagik/omni 2.260717.7 → 2.260718.1

package/dist/server/index.js

@@ -156056,6 +156056,1149 @@ var init_audio_converter = __esm(() => {
   };
 });
 
+// ../channel-a2a/src/task-store.ts
+function taskKey(instanceId, taskId) {
+  return `${TASK_KEY_PREFIX}/${instanceId}/${taskId}`;
+}
+function isTerminal(state) {
+  return state === "TASK_STATE_COMPLETED" || state === "TASK_STATE_FAILED" || state === "TASK_STATE_CANCELED" || state === "TASK_STATE_REJECTED" || state === "completed" || state === "failed" || state === "canceled";
+}
+
+class A2ATaskStore {
+  memory = new Map;
+  storage;
+  constructor(storage) {
+    this.storage = storage;
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  async createTask(params) {
+    const now = new Date().toISOString();
+    const task = {
+      id: params.taskId,
+      contextId: params.contextId,
+      status: {
+        state: "TASK_STATE_WORKING",
+        timestamp: now
+      },
+      history: [params.message],
+      artifacts: [],
+      createdAt: now,
+      lastModified: now,
+      metadata: {
+        ...params.metadata ?? {},
+        instanceId: params.instanceId,
+        createdAt: now,
+        updatedAt: now
+      }
+    };
+    await this.set(params.instanceId, params.taskId, task);
+    return task;
+  }
+  async appendMessage(params) {
+    const task = await this.get(params.instanceId, params.taskId);
+    if (!task)
+      return null;
+    const now = new Date().toISOString();
+    const updated = {
+      ...task,
+      contextId: task.contextId ?? params.contextId,
+      status: {
+        state: "TASK_STATE_WORKING",
+        timestamp: now,
+        message: params.message
+      },
+      history: [...task.history ?? [], params.message],
+      lastModified: now,
+      metadata: {
+        ...task.metadata ?? {},
+        ...params.metadata ?? {},
+        instanceId: params.instanceId,
+        updatedAt: now
+      }
+    };
+    await this.set(params.instanceId, params.taskId, updated);
+    return updated;
+  }
+  async getTask(instanceId, taskId) {
+    return this.get(instanceId, taskId);
+  }
+  async listTasks(instanceId, options = {}) {
+    const pageSize = Math.min(Math.max(options.pageSize ?? 50, 1), 100);
+    const keys = await this.keys(instanceId);
+    const tasks = [];
+    const allTasks = await Promise.all(keys.map((key) => {
+      const taskId = key.split("/").pop();
+      return taskId ? this.get(instanceId, taskId) : Promise.resolve(null);
+    }));
+    for (const task of allTasks) {
+      if (!task)
+        continue;
+      if (!taskMatchesListOptions(task, options))
+        continue;
+      tasks.push(task);
+    }
+    tasks.sort((a, b2) => {
+      const aTime = String(a.lastModified ?? a.metadata?.updatedAt ?? a.status.timestamp ?? "");
+      const bTime = String(b2.lastModified ?? b2.metadata?.updatedAt ?? b2.status.timestamp ?? "");
+      return bTime.localeCompare(aTime);
+    });
+    const offset = Number.parseInt(options.pageToken ?? "0", 10);
+    const start = Number.isFinite(offset) && offset > 0 ? offset : 0;
+    const page = tasks.slice(start, start + pageSize).map((task) => shapeListTask(task, options));
+    const nextOffset = start + page.length;
+    return {
+      tasks: page,
+      nextPageToken: nextOffset < tasks.length ? String(nextOffset) : "",
+      pageSize,
+      totalSize: tasks.length
+    };
+  }
+  async appendArtifact(instanceId, taskId, text) {
+    const task = await this.get(instanceId, taskId);
+    if (!task || isTerminal(task.status.state))
+      return task;
+    const now = new Date().toISOString();
+    const artifacts = task.artifacts ?? [];
+    const artifact = {
+      artifactId: `artifact-${artifacts.length + 1}`,
+      parts: [textPart(text)]
+    };
+    const updated = {
+      ...task,
+      status: { state: "TASK_STATE_WORKING", timestamp: now },
+      artifacts: [...artifacts, artifact],
+      lastModified: now,
+      metadata: { ...task.metadata ?? {}, updatedAt: now }
+    };
+    await this.set(instanceId, taskId, updated);
+    return updated;
+  }
+  async updateStatus(instanceId, taskId, state, message2) {
+    const task = await this.get(instanceId, taskId);
+    if (!task)
+      return null;
+    const now = new Date().toISOString();
+    const history3 = message2 ? [...task.history ?? [], message2] : task.history;
+    const updated = {
+      ...task,
+      status: { state, timestamp: now, ...message2 ? { message: message2 } : {} },
+      history: history3,
+      lastModified: now,
+      metadata: { ...task.metadata ?? {}, updatedAt: now }
+    };
+    await this.set(instanceId, taskId, updated);
+    return updated;
+  }
+  async cancelTask(instanceId, taskId) {
+    return this.updateStatus(instanceId, taskId, "TASK_STATE_CANCELED");
+  }
+  async get(instanceId, taskId) {
+    const key = taskKey(instanceId, taskId);
+    if (this.storage) {
+      return this.storage.get(key);
+    }
+    return this.memory.get(key) ?? null;
+  }
+  async set(instanceId, taskId, task) {
+    const key = taskKey(instanceId, taskId);
+    if (this.storage) {
+      await this.storage.set(key, task);
+      return;
+    }
+    this.memory.set(key, task);
+  }
+  async keys(instanceId) {
+    const pattern = `${TASK_KEY_PREFIX}/${instanceId}/*`;
+    if (this.storage) {
+      return this.storage.keys(pattern);
+    }
+    const prefix = `${TASK_KEY_PREFIX}/${instanceId}/`;
+    return Array.from(this.memory.keys()).filter((key) => key.startsWith(prefix));
+  }
+}
+function textPart(text) {
+  return { text, mediaType: "text/plain" };
+}
+function taskIsTerminal(task) {
+  return isTerminal(task.status.state);
+}
+function shapeListTask(task, options) {
+  return {
+    ...task,
+    artifacts: options.includeArtifacts ? task.artifacts : [],
+    history: trimHistory(task.history, options.historyLength)
+  };
+}
+function trimHistory(history3, historyLength) {
+  if (historyLength === undefined)
+    return history3;
+  if (historyLength <= 0)
+    return [];
+  return history3?.slice(-historyLength) ?? [];
+}
+function taskMatchesListOptions(task, options) {
+  if (options.callerKey && task.metadata?.callerKey !== options.callerKey)
+    return false;
+  if (options.contextId && task.contextId !== options.contextId)
+    return false;
+  if (options.status && task.status.state !== options.status)
+    return false;
+  if (options.statusTimestampAfter && String(task.status.timestamp ?? "") <= options.statusTimestampAfter)
+    return false;
+  return true;
+}
+var TASK_KEY_PREFIX = "a2a-tasks";
+
+// ../channel-a2a/src/a2a-handler.ts
+function normalizeRole(role) {
+  if (role === "agent")
+    return "ROLE_AGENT";
+  if (role === "user")
+    return "ROLE_USER";
+  return role;
+}
+function normalizePart(part) {
+  if (typeof part.text === "string")
+    return textPart(part.text);
+  if (part.data !== undefined)
+    return { data: part.data, mediaType: part.mediaType, metadata: part.metadata };
+  if (typeof part.url === "string") {
+    return { url: part.url, filename: part.filename, mediaType: part.mediaType, metadata: part.metadata };
+  }
+  if (typeof part.raw === "string") {
+    return { raw: part.raw, filename: part.filename, mediaType: part.mediaType, metadata: part.metadata };
+  }
+  if (part.type === "text" && typeof part.text === "string")
+    return textPart(part.text);
+  if (part.type === "data")
+    return { data: part.data, mediaType: part.mediaType, metadata: part.metadata };
+  if (part.type === "file" && part.file?.uri) {
+    return {
+      url: part.file.uri,
+      filename: part.file.name,
+      mediaType: part.file.mimeType,
+      metadata: part.metadata
+    };
+  }
+  return { data: part, mediaType: "application/json" };
+}
+function normalizeMessage(message2) {
+  return {
+    role: normalizeRole(message2.role),
+    parts: message2.parts.map(normalizePart),
+    messageId: message2.messageId,
+    taskId: message2.taskId,
+    contextId: message2.contextId,
+    extensions: message2.extensions,
+    metadata: message2.metadata
+  };
+}
+function extractText(message2) {
+  return message2.parts.filter((p2) => typeof p2.text === "string").map((p2) => p2.text).join(`
+`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asOmniExecutionContext(value) {
+  if (!isRecord(value))
+    return;
+  const identity = value.identity;
+  const source = value.source;
+  const session = value.session;
+  const trace4 = value.trace;
+  if (!isRecord(identity) || typeof identity.userId !== "string")
+    return;
+  if (!isRecord(source) || typeof source.instanceId !== "string")
+    return;
+  if (!isRecord(session) || typeof session.id !== "string")
+    return;
+  if (!isRecord(trace4) || typeof trace4.id !== "string")
+    return;
+  return value;
+}
+function extractOmniExecutionContext(message2, requestMetadata) {
+  const messageContext = asOmniExecutionContext(message2.metadata?.omniExecutionContext);
+  if (messageContext)
+    return messageContext;
+  const requestContext = asOmniExecutionContext(requestMetadata?.omniExecutionContext);
+  if (requestContext)
+    return requestContext;
+  return;
+}
+function a2aEventFrom(contextId, executionContext) {
+  return executionContext?.customer?.externalUserId ?? executionContext?.identity.platformUserId ?? executionContext?.identity.userId ?? `a2a:${contextId}`;
+}
+function hasOmniExecutionContextExtension(message2) {
+  return message2.extensions?.includes(OMNI_EXECUTION_CONTEXT_EXTENSION_URI) ?? false;
+}
+function jsonRpc(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function jsonRpcError(id, code, message2, data) {
+  return { jsonrpc: "2.0", id, error: { code, message: message2, ...data ? { data } : {} } };
+}
+function a2aErrorReason(code) {
+  switch (code) {
+    case A2A_TASK_NOT_FOUND:
+      return "TASK_NOT_FOUND";
+    case A2A_TASK_NOT_CANCELABLE:
+      return "TASK_NOT_CANCELABLE";
+    case A2A_PUSH_NOTIFICATION_NOT_SUPPORTED:
+      return "PUSH_NOTIFICATION_NOT_SUPPORTED";
+    case A2A_UNSUPPORTED_OPERATION:
+      return "UNSUPPORTED_OPERATION";
+    case A2A_CONTENT_TYPE_NOT_SUPPORTED:
+      return "CONTENT_TYPE_NOT_SUPPORTED";
+    case A2A_VERSION_NOT_SUPPORTED:
+      return "VERSION_NOT_SUPPORTED";
+    case A2A_UNAUTHORIZED:
+      return "UNAUTHORIZED";
+    default:
+      return;
+  }
+}
+function a2aErrorInfo(code, metadata) {
+  const reason = a2aErrorReason(code);
+  if (!reason)
+    return;
+  return [
+    {
+      "@type": "type.googleapis.com/google.rpc.ErrorInfo",
+      reason,
+      domain: A2A_ERROR_DOMAIN,
+      ...metadata && Object.keys(metadata).length > 0 ? { metadata } : {}
+    }
+  ];
+}
+function jsonRpcA2AError(id, code, message2, metadata) {
+  return jsonRpcError(id, code, message2, a2aErrorInfo(code, metadata));
+}
+function jsonResponse(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function validateVersion(request, method) {
+  const url = new URL(request.url);
+  const requested = request.headers.get("A2A-Version") ?? url.searchParams.get("A2A-Version") ?? "";
+  if (!requested)
+    return null;
+  const isLegacyMethod = LEGACY_METHODS.has(method);
+  if (requested === "1.0" && !isLegacyMethod)
+    return null;
+  if (requested === "0.3" && isLegacyMethod)
+    return null;
+  return jsonRpcA2AError(null, A2A_VERSION_NOT_SUPPORTED, `A2A version '${requested}' is not supported by method '${method}'`, { version: requested, method });
+}
+function getTaskStore(ctx) {
+  ctx.taskStore ??= new A2ATaskStore;
+  return ctx.taskStore;
+}
+function getCallerKey(ctx) {
+  return typeof ctx.callerKey === "string" ? ctx.callerKey.trim() : "";
+}
+function taskOwnedByCaller(task, callerKey) {
+  return typeof task.metadata?.callerKey === "string" && task.metadata.callerKey === callerKey;
+}
+function canAccessTask(ctx, task) {
+  const callerKey = getCallerKey(ctx);
+  return callerKey.length > 0 && taskOwnedByCaller(task, callerKey);
+}
+function requireCallerKey(id, ctx) {
+  const callerKey = getCallerKey(ctx);
+  if (callerKey.length > 0)
+    return callerKey;
+  return jsonResponse(jsonRpcA2AError(id, A2A_UNAUTHORIZED, "Authentication required"), 401);
+}
+function shouldReturnImmediately(sendParams) {
+  if (sendParams.configuration?.returnImmediately !== undefined)
+    return sendParams.configuration.returnImmediately;
+  if (sendParams.configuration?.blocking !== undefined)
+    return !sendParams.configuration.blocking;
+  return false;
+}
+function parseSendWaitMs() {
+  const configured = Number.parseInt(process.env.A2A_SEND_WAIT_MS ?? "", 10);
+  return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_SEND_WAIT_MS;
+}
+function taskIsSettled(task) {
+  return taskIsTerminal(task) || task.status.state === "TASK_STATE_INPUT_REQUIRED" || task.status.state === "TASK_STATE_AUTH_REQUIRED" || task.status.state === "input-required";
+}
+async function waitForSettledTask(taskStore, instanceId, taskId, initialTask) {
+  const deadline = Date.now() + SEND_WAIT_MS;
+  let current = initialTask;
+  let pollIndex = 0;
+  while (Date.now() < deadline) {
+    const latest = await taskStore.getTask(instanceId, taskId);
+    if (latest)
+      current = latest;
+    if (taskIsSettled(current))
+      return current;
+    const pollMs = SEND_WAIT_POLL_BACKOFF_MS[Math.min(pollIndex, SEND_WAIT_POLL_BACKOFF_MS.length - 1)] ?? 1000;
+    pollIndex++;
+    await sleep2(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+  }
+  return await taskStore.getTask(instanceId, taskId) ?? current;
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function handleA2ARequest(request, ctx) {
+  const t0 = Date.now();
+  let rpcReq;
+  try {
+    rpcReq = await request.json();
+  } catch {
+    return jsonResponse(jsonRpcError(null, RPC_PARSE_ERROR, "Invalid JSON payload"), 400);
+  }
+  if (typeof rpcReq !== "object" || rpcReq === null) {
+    return jsonResponse(jsonRpcError(null, RPC_INVALID_REQUEST, "Request payload validation error"), 400);
+  }
+  if (rpcReq.jsonrpc !== "2.0" || !rpcReq.method) {
+    return jsonResponse(jsonRpcError(rpcReq.id ?? null, RPC_INVALID_REQUEST, "Request payload validation error"), 400);
+  }
+  const { id, method, params } = rpcReq;
+  ctx.callerKey = request.headers.get("x-omni-api-key-id") ?? undefined;
+  const versionError = validateVersion(request, method);
+  if (versionError) {
+    return jsonResponse({ ...versionError, id }, 400);
+  }
+  switch (method) {
+    case "SendMessage":
+    case "message/send":
+      return handleMessageSend(id, params, ctx, t0);
+    case "SendStreamingMessage":
+    case "message/stream":
+      return handleMessageStream(id, params, ctx, t0);
+    case "GetTask":
+    case "tasks/get":
+      return handleGetTask(id, params, ctx);
+    case "ListTasks":
+      return handleListTasks(id, params, ctx);
+    case "CancelTask":
+    case "tasks/cancel":
+      return handleCancelTask(id, params, ctx);
+    case "SubscribeToTask":
+    case "tasks/resubscribe":
+      return handleSubscribeToTask(id, params, ctx);
+    case "GetExtendedAgentCard":
+      return jsonResponse(jsonRpcA2AError(id, A2A_UNSUPPORTED_OPERATION, "GetExtendedAgentCard is exposed through /api/v2/a2a/agents/:agentId/card", {
+        method
+      }), 400);
+    case "CreateTaskPushNotificationConfig":
+    case "GetTaskPushNotificationConfig":
+    case "ListTaskPushNotificationConfigs":
+    case "DeleteTaskPushNotificationConfig":
+    case "tasks/pushNotificationConfig/set":
+    case "tasks/pushNotificationConfig/get":
+      return jsonResponse(jsonRpcA2AError(id, A2A_UNSUPPORTED_OPERATION, `Method '${method}' is not supported`, { method }), 400);
+    default:
+      return jsonResponse(jsonRpcError(id, RPC_METHOD_NOT_FOUND, `Method not found: ${method}`), 404);
+  }
+}
+async function handleMessageSend(id, params, ctx, t0) {
+  const parsed = parseSendParams(id, params);
+  if (parsed instanceof Response)
+    return parsed;
+  const { sendParams, message: message2, text } = parsed;
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  if (sendParams.configuration?.pushNotificationConfig !== undefined) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_PUSH_NOTIFICATION_NOT_SUPPORTED, "Push notifications are not supported"), 400);
+  }
+  const prepared = await prepareTaskForSend(id, ctx, sendParams, message2, callerKey);
+  if (prepared instanceof Response)
+    return prepared;
+  const { taskStore, task, taskId, contextId, normalizedMessage } = prepared;
+  const timings = ctx.plugin.inboundTimings(t0);
+  try {
+    const correlationId = await emitMessageReceived(normalizedMessage, text, taskId, contextId, ctx, timings, sendParams.metadata);
+    if (timings)
+      ctx.plugin.recordT2(correlationId, timings);
+  } catch {
+    await taskStore.updateStatus(ctx.instanceId, taskId, "TASK_STATE_FAILED");
+    return jsonResponse(jsonRpcError(id, RPC_INTERNAL_ERROR, "Internal error"), 500);
+  }
+  const responseTask = shouldReturnImmediately(sendParams) ? task : await waitForSettledTask(taskStore, ctx.instanceId, taskId, task);
+  return jsonResponse(jsonRpc(id, { task: trimHistory2(responseTask, sendParams.configuration?.historyLength) }));
+}
+async function handleMessageStream(id, params, ctx, t0) {
+  const parsed = parseSendParams(id, params);
+  if (parsed instanceof Response)
+    return parsed;
+  const { sendParams, message: message2, text } = parsed;
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  if (sendParams.configuration?.pushNotificationConfig !== undefined) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_PUSH_NOTIFICATION_NOT_SUPPORTED, "Push notifications are not supported"), 400);
+  }
+  const prepared = await prepareTaskForSend(id, ctx, sendParams, message2, callerKey);
+  if (prepared instanceof Response)
+    return prepared;
+  const { taskStore, task, taskId, contextId, normalizedMessage } = prepared;
+  const sseStream = ctx.streamStore.createPendingStream(ctx.instanceId, taskId, id, contextId);
+  ctx.streamStore.writeTask(ctx.instanceId, taskId, task);
+  const timings = ctx.plugin.inboundTimings(t0);
+  try {
+    const correlationId = await emitMessageReceived(normalizedMessage, text, taskId, contextId, ctx, timings, sendParams.metadata);
+    if (timings)
+      ctx.plugin.recordT2(correlationId, timings);
+  } catch {
+    await taskStore.updateStatus(ctx.instanceId, taskId, "TASK_STATE_FAILED");
+    ctx.streamStore.closeStream(ctx.instanceId, taskId, "TASK_STATE_FAILED");
+  }
+  return new Response(sseStream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}
+function parseSendParams(id, params) {
+  const parseResult = MessageSendParamsSchema.safeParse(params);
+  if (!parseResult.success) {
+    return jsonResponse(jsonRpcError(id, RPC_INVALID_PARAMS, `Invalid params: ${parseResult.error.message}`), 400);
+  }
+  const raw = parseResult.data;
+  const message2 = normalizeMessage(raw.message);
+  const text = extractText(message2);
+  if (!text.trim()) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_CONTENT_TYPE_NOT_SUPPORTED, "Only text parts are currently supported"), 400);
+  }
+  return { sendParams: { ...raw, message: message2 }, message: message2, text };
+}
+async function prepareTaskForSend(id, ctx, sendParams, message2, callerKey) {
+  const taskId = sendParams.taskId ?? message2.taskId ?? generateCorrelationId("a2a");
+  const requestedContextId = sendParams.contextId ?? message2.contextId ?? taskId;
+  const taskStore = getTaskStore(ctx);
+  const existingTask = await taskStore.getTask(ctx.instanceId, taskId);
+  const contextId = existingTask?.contextId ?? requestedContextId;
+  const normalizedMessage = {
+    ...message2,
+    messageId: message2.messageId ?? generateCorrelationId("msg"),
+    taskId,
+    contextId
+  };
+  const metadata = { ...sendParams.metadata ?? {}, callerKey };
+  if (existingTask) {
+    if (!taskOwnedByCaller(existingTask, callerKey)) {
+      return jsonResponse(jsonRpcA2AError(id, A2A_TASK_NOT_FOUND, "Task not found", { taskId }), 404);
+    }
+    const task2 = await taskStore.appendMessage({
+      instanceId: ctx.instanceId,
+      taskId,
+      contextId,
+      message: normalizedMessage,
+      metadata
+    });
+    if (!task2) {
+      return jsonResponse(jsonRpcError(id, RPC_INTERNAL_ERROR, "Internal error"), 500);
+    }
+    return { taskStore, task: task2, taskId, contextId, normalizedMessage };
+  }
+  const task = await taskStore.createTask({
+    instanceId: ctx.instanceId,
+    taskId,
+    contextId,
+    message: normalizedMessage,
+    metadata
+  });
+  return { taskStore, task, taskId, contextId, normalizedMessage };
+}
+async function handleGetTask(id, params, ctx) {
+  const parseResult = GetTaskParamsSchema.safeParse(params);
+  if (!parseResult.success) {
+    return jsonResponse(jsonRpcError(id, RPC_INVALID_PARAMS, `Invalid params: ${parseResult.error.message}`), 400);
+  }
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  const task = await getTaskStore(ctx).getTask(ctx.instanceId, parseResult.data.id);
+  if (!task || !canAccessTask(ctx, task)) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_TASK_NOT_FOUND, "Task not found", { taskId: parseResult.data.id }), 404);
+  }
+  return jsonResponse(jsonRpc(id, { task: trimHistory2(task, parseResult.data.historyLength) }));
+}
+async function handleListTasks(id, params, ctx) {
+  const parseResult = ListTasksParamsSchema.safeParse(params ?? {});
+  if (!parseResult.success) {
+    return jsonResponse(jsonRpcError(id, RPC_INVALID_PARAMS, `Invalid params: ${parseResult.error.message}`), 400);
+  }
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  const result = await getTaskStore(ctx).listTasks(ctx.instanceId, {
+    ...parseResult.data,
+    callerKey
+  });
+  return jsonResponse(jsonRpc(id, result));
+}
+async function handleCancelTask(id, params, ctx) {
+  const parseResult = CancelTaskParamsSchema.safeParse(params);
+  if (!parseResult.success) {
+    return jsonResponse(jsonRpcError(id, RPC_INVALID_PARAMS, `Invalid params: ${parseResult.error.message}`), 400);
+  }
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  const taskStore = getTaskStore(ctx);
+  const task = await taskStore.getTask(ctx.instanceId, parseResult.data.id);
+  if (!task || !canAccessTask(ctx, task)) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_TASK_NOT_FOUND, "Task not found", { taskId: parseResult.data.id }), 404);
+  }
+  if (taskIsTerminal(task)) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_TASK_NOT_CANCELABLE, "Task is already terminal", { taskId: parseResult.data.id }), 400);
+  }
+  const canceled = await taskStore.cancelTask(ctx.instanceId, parseResult.data.id);
+  ctx.streamStore.closeStream(ctx.instanceId, parseResult.data.id, "TASK_STATE_CANCELED");
+  return jsonResponse(jsonRpc(id, { task: canceled }));
+}
+async function handleSubscribeToTask(id, params, ctx) {
+  const parseResult = SubscribeToTaskParamsSchema.safeParse(params);
+  if (!parseResult.success) {
+    return jsonResponse(jsonRpcError(id, RPC_INVALID_PARAMS, `Invalid params: ${parseResult.error.message}`), 400);
+  }
+  const callerKey = requireCallerKey(id, ctx);
+  if (callerKey instanceof Response)
+    return callerKey;
+  const task = await getTaskStore(ctx).getTask(ctx.instanceId, parseResult.data.id);
+  if (!task || !canAccessTask(ctx, task)) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_TASK_NOT_FOUND, "Task not found", { taskId: parseResult.data.id }), 404);
+  }
+  if (taskIsTerminal(task)) {
+    return jsonResponse(jsonRpcA2AError(id, A2A_UNSUPPORTED_OPERATION, "Cannot subscribe to a terminal task", {
+      taskId: parseResult.data.id
+    }), 400);
+  }
+  const sseStream = ctx.streamStore.createPendingStream(ctx.instanceId, task.id, id, task.contextId ?? task.id);
+  ctx.streamStore.writeTask(ctx.instanceId, task.id, task);
+  return new Response(sseStream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+}
+function trimHistory2(task, historyLength) {
+  if (historyLength === undefined)
+    return task;
+  if (historyLength <= 0)
+    return { ...task, history: [] };
+  return { ...task, history: task.history?.slice(-historyLength) ?? [] };
+}
+async function emitMessageReceived(message2, text, taskId, contextId, ctx, timings, requestMetadata) {
+  const correlationId = generateCorrelationId("evt");
+  const executionContext = extractOmniExecutionContext(message2, requestMetadata);
+  const rawPayload = {
+    a2aTaskId: taskId,
+    a2aContextId: contextId,
+    a2aMessage: message2
+  };
+  if (executionContext) {
+    rawPayload.omniExecutionContext = executionContext;
+    rawPayload.omniExecutionContextExtension = hasOmniExecutionContextExtension(message2);
+  }
+  const eventPayload = {
+    externalId: message2.messageId ?? taskId,
+    chatId: taskId,
+    from: a2aEventFrom(contextId, executionContext),
+    ...executionContext?.identity.displayName ? { senderName: executionContext.identity.displayName } : {},
+    ...executionContext?.source.threadId ? { threadId: executionContext.source.threadId } : {},
+    content: { type: "text", text },
+    rawPayload
+  };
+  const eventMetadata = {
+    correlationId,
+    instanceId: ctx.instanceId,
+    channelType: ctx.channelType,
+    ...executionContext?.trace.id ? { traceId: executionContext.trace.id } : {},
+    source: "channel:a2a",
+    ...timings ? { timings } : {}
+  };
+  await ctx.eventBus.publish("message.received", eventPayload, eventMetadata);
+  return correlationId;
+}
+var A2APartSchema, MessageSendParamsSchema, GetTaskParamsSchema, ListTasksParamsSchema, CancelTaskParamsSchema, SubscribeToTaskParamsSchema, RPC_PARSE_ERROR = -32700, RPC_INVALID_REQUEST = -32600, RPC_METHOD_NOT_FOUND = -32601, RPC_INVALID_PARAMS = -32602, RPC_INTERNAL_ERROR = -32603, A2A_TASK_NOT_FOUND = -32001, A2A_TASK_NOT_CANCELABLE = -32002, A2A_PUSH_NOTIFICATION_NOT_SUPPORTED = -32003, A2A_UNSUPPORTED_OPERATION = -32004, A2A_CONTENT_TYPE_NOT_SUPPORTED = -32005, A2A_VERSION_NOT_SUPPORTED = -32009, A2A_UNAUTHORIZED = -32010, A2A_ERROR_DOMAIN = "a2a-protocol.org", DEFAULT_SEND_WAIT_MS = 30000, SEND_WAIT_POLL_BACKOFF_MS, SEND_WAIT_MS, LEGACY_METHODS;
+var init_a2a_handler = __esm(() => {
+  init_src();
+  init_zod();
+  A2APartSchema = exports_external.object({
+    text: exports_external.string().optional(),
+    data: exports_external.unknown().optional(),
+    url: exports_external.string().optional(),
+    raw: exports_external.string().optional(),
+    mediaType: exports_external.string().optional(),
+    filename: exports_external.string().optional(),
+    metadata: exports_external.record(exports_external.unknown()).optional(),
+    type: exports_external.string().optional(),
+    file: exports_external.object({
+      name: exports_external.string().optional(),
+      mimeType: exports_external.string().optional(),
+      uri: exports_external.string().optional()
+    }).optional()
+  }).passthrough();
+  MessageSendParamsSchema = exports_external.object({
+    tenant: exports_external.string().optional(),
+    message: exports_external.object({
+      role: exports_external.enum(["ROLE_USER", "ROLE_AGENT", "user", "agent"]),
+      parts: exports_external.array(A2APartSchema).min(1),
+      messageId: exports_external.string().optional(),
+      taskId: exports_external.string().optional(),
+      contextId: exports_external.string().optional(),
+      extensions: exports_external.array(exports_external.string()).optional(),
+      metadata: exports_external.record(exports_external.unknown()).optional()
+    }),
+    configuration: exports_external.object({
+      acceptedOutputModes: exports_external.array(exports_external.string()).optional(),
+      pushNotificationConfig: exports_external.unknown().optional(),
+      historyLength: exports_external.number().int().optional(),
+      returnImmediately: exports_external.boolean().optional(),
+      blocking: exports_external.boolean().optional()
+    }).optional(),
+    taskId: exports_external.string().optional(),
+    contextId: exports_external.string().optional(),
+    metadata: exports_external.record(exports_external.unknown()).optional()
+  });
+  GetTaskParamsSchema = exports_external.object({
+    tenant: exports_external.string().optional(),
+    id: exports_external.string(),
+    historyLength: exports_external.number().int().optional()
+  });
+  ListTasksParamsSchema = exports_external.object({
+    tenant: exports_external.string().optional(),
+    contextId: exports_external.string().optional(),
+    status: exports_external.enum([
+      "TASK_STATE_SUBMITTED",
+      "TASK_STATE_WORKING",
+      "TASK_STATE_COMPLETED",
+      "TASK_STATE_FAILED",
+      "TASK_STATE_CANCELED",
+      "TASK_STATE_INPUT_REQUIRED",
+      "TASK_STATE_REJECTED",
+      "TASK_STATE_AUTH_REQUIRED"
+    ]).optional(),
+    historyLength: exports_external.number().int().optional(),
+    statusTimestampAfter: exports_external.string().optional(),
+    includeArtifacts: exports_external.boolean().optional(),
+    pageSize: exports_external.number().int().optional(),
+    pageToken: exports_external.string().optional()
+  });
+  CancelTaskParamsSchema = exports_external.object({ tenant: exports_external.string().optional(), id: exports_external.string() });
+  SubscribeToTaskParamsSchema = exports_external.object({ tenant: exports_external.string().optional(), id: exports_external.string() });
+  SEND_WAIT_POLL_BACKOFF_MS = [100, 250, 500, 1000];
+  SEND_WAIT_MS = parseSendWaitMs();
+  LEGACY_METHODS = new Set([
+    "message/send",
+    "message/stream",
+    "tasks/get",
+    "tasks/cancel",
+    "tasks/resubscribe",
+    "tasks/pushNotificationConfig/set",
+    "tasks/pushNotificationConfig/get"
+  ]);
+});
+
+// ../channel-a2a/src/agent-card.ts
+function strOverride(val) {
+  return typeof val === "string" ? val : undefined;
+}
+function objectOverride(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val) ? val : undefined;
+}
+function stringArrayOverride(val) {
+  return Array.isArray(val) && val.every((item) => typeof item === "string") ? val : undefined;
+}
+function buildDefaultSkills(capabilities3) {
+  const skills = [
+    {
+      id: "messaging",
+      name: "Messaging",
+      description: "Process and respond to text messages",
+      tags: ["messaging", "chat"],
+      inputModes: ["text/plain"],
+      outputModes: ["text/plain"]
+    }
+  ];
+  if (capabilities3.includes("image") || capabilities3.includes("vision")) {
+    skills.push({
+      id: "vision",
+      name: "Vision",
+      description: "Process and describe images",
+      tags: ["vision", "image"],
+      inputModes: ["text/plain", "image/png", "image/jpeg", "image/webp"],
+      outputModes: ["text/plain"]
+    });
+  }
+  if (capabilities3.includes("audio") || capabilities3.includes("transcription")) {
+    skills.push({
+      id: "audio",
+      name: "Audio",
+      description: "Transcribe and process audio",
+      tags: ["audio", "transcription"],
+      inputModes: ["audio/mpeg", "audio/ogg", "audio/wav"],
+      outputModes: ["text/plain"]
+    });
+  }
+  return skills;
+}
+function buildAgentCard(params) {
+  const { instanceId, instanceName, agentName, capabilities: capabilities3, agentCardOverride, baseUrl } = params;
+  const baseCard = normalizeBaseUrl(baseUrl);
+  const agentUrl = `${baseCard}/a2a/${instanceId}`;
+  const skills = buildDefaultSkills(capabilities3);
+  const overrideSkills = Array.isArray(agentCardOverride?.skills) ? agentCardOverride.skills : undefined;
+  const overrideInterfaces = Array.isArray(agentCardOverride?.supportedInterfaces) ? agentCardOverride.supportedInterfaces : undefined;
+  const defaultInputModes = stringArrayOverride(agentCardOverride?.defaultInputModes) ?? ["text/plain"];
+  const defaultOutputModes = stringArrayOverride(agentCardOverride?.defaultOutputModes) ?? ["text/plain"];
+  const card = {
+    name: strOverride(agentCardOverride?.name) ?? agentName ?? instanceName,
+    description: strOverride(agentCardOverride?.description) ?? `Omni agent ${agentName} on instance ${instanceName}`,
+    version: strOverride(agentCardOverride?.version) ?? "1.0.0",
+    supportedInterfaces: overrideInterfaces ?? [
+      {
+        url: agentUrl,
+        protocolBinding: "JSONRPC",
+        protocolVersion: "1.0"
+      }
+    ],
+    capabilities: {
+      streaming: true,
+      pushNotifications: false,
+      extendedAgentCard: false,
+      ...objectOverride(agentCardOverride?.capabilities) ?? {}
+    },
+    defaultInputModes,
+    defaultOutputModes,
+    skills: overrideSkills ?? skills,
+    securitySchemes: {
+      bearerAuth: {
+        httpAuthSecurityScheme: {
+          scheme: "Bearer",
+          bearerFormat: "Omni API key",
+          description: "Use an Omni API key as a bearer token."
+        }
+      },
+      apiKeyHeader: {
+        apiKeySecurityScheme: {
+          location: "header",
+          name: "x-api-key",
+          description: "Legacy Omni API key header."
+        }
+      },
+      ...objectOverride(agentCardOverride?.securitySchemes) ?? {}
+    },
+    securityRequirements: [{ schemes: { bearerAuth: { list: [] } } }, { schemes: { apiKeyHeader: { list: [] } } }]
+  };
+  const providerOverride = objectOverride(agentCardOverride?.provider);
+  if (providerOverride) {
+    card.provider = providerOverride;
+  }
+  const iconUrl = strOverride(agentCardOverride?.iconUrl);
+  if (iconUrl)
+    card.iconUrl = iconUrl;
+  const documentationUrl = strOverride(agentCardOverride?.documentationUrl);
+  if (documentationUrl)
+    card.documentationUrl = documentationUrl;
+  return card;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+// ../channel-a2a/src/stream-store.ts
+class A2AStreamStore {
+  onClose;
+  idleCloseMs;
+  streams = new Map;
+  encoder = new TextEncoder;
+  constructor(onClose, idleCloseMs = IDLE_CLOSE_MS) {
+    this.onClose = onClose;
+    this.idleCloseMs = idleCloseMs;
+  }
+  streamKey(instanceId, taskId) {
+    return `${instanceId}:${taskId}`;
+  }
+  createPendingStream(instanceId, taskId, rpcId = null, contextId = taskId) {
+    if (this.streams.size >= MAX_STREAMS) {
+      throw new Error("Stream store capacity exceeded");
+    }
+    let instanceCount = 0;
+    for (const key2 of this.streams.keys()) {
+      if (key2.startsWith(`${instanceId}:`)) {
+        instanceCount++;
+      }
+    }
+    if (instanceCount >= MAX_STREAMS_PER_INSTANCE) {
+      throw new Error(`Stream limit exceeded for instance ${instanceId}`);
+    }
+    const key = this.streamKey(instanceId, taskId);
+    const store = this;
+    const existing = this.streams.get(key);
+    if (existing) {
+      if (existing.closeTimer !== undefined)
+        clearTimeout(existing.closeTimer);
+      existing.close();
+    }
+    let entryRef;
+    const stream = new ReadableStream({
+      start(controller) {
+        const entry = {
+          enqueue: (data) => {
+            try {
+              controller.enqueue(data);
+            } catch {}
+          },
+          close: () => {
+            try {
+              controller.close();
+            } catch {}
+            if (store.streams.get(key) === entryRef) {
+              store.streams.delete(key);
+            }
+          },
+          contextId,
+          partIndex: 0,
+          rpcId
+        };
+        entryRef = entry;
+        store.streams.set(key, entry);
+        entry.closeTimer = setTimeout(() => {
+          store.closeIdleStream(instanceId, taskId);
+        }, store.idleCloseMs);
+      },
+      cancel() {
+        if (store.streams.get(key) === entryRef) {
+          if (entryRef.closeTimer !== undefined) {
+            clearTimeout(entryRef.closeTimer);
+          }
+          store.streams.delete(key);
+        }
+      }
+    });
+    return stream;
+  }
+  writeTask(instanceId, taskId, task) {
+    const key = this.streamKey(instanceId, taskId);
+    const entry = this.streams.get(key);
+    if (!entry)
+      return;
+    this.resetIdleTimer(instanceId, taskId, entry);
+    this.writeStreamResponse(entry, { task });
+  }
+  writePart(instanceId, taskId, text) {
+    const key = this.streamKey(instanceId, taskId);
+    const entry = this.streams.get(key);
+    if (!entry)
+      return;
+    this.resetIdleTimer(instanceId, taskId, entry);
+    entry.partIndex++;
+    const artifact = {
+      artifactId: `artifact-${entry.partIndex}`,
+      parts: [textPart(text)]
+    };
+    this.writeStreamResponse(entry, {
+      taskArtifactUpdate: {
+        taskId,
+        contextId: entry.contextId,
+        artifact,
+        index: entry.partIndex - 1
+      }
+    });
+  }
+  closeStream(instanceId, taskId, state) {
+    const key = this.streamKey(instanceId, taskId);
+    const entry = this.streams.get(key);
+    if (!entry)
+      return;
+    if (entry.closeTimer !== undefined) {
+      clearTimeout(entry.closeTimer);
+    }
+    this.writeStreamResponse(entry, {
+      taskStatusUpdate: {
+        taskId,
+        contextId: entry.contextId,
+        status: { state, timestamp: new Date().toISOString() }
+      }
+    });
+    this.onClose?.(instanceId, taskId, state);
+    entry.close();
+  }
+  closeIdleStream(instanceId, taskId) {
+    const key = this.streamKey(instanceId, taskId);
+    const entry = this.streams.get(key);
+    if (!entry)
+      return;
+    if (entry.closeTimer !== undefined) {
+      clearTimeout(entry.closeTimer);
+    }
+    entry.close();
+  }
+  hasStream(instanceId, taskId) {
+    return this.streams.has(this.streamKey(instanceId, taskId));
+  }
+  resetIdleTimer(instanceId, taskId, entry) {
+    if (entry.closeTimer !== undefined) {
+      clearTimeout(entry.closeTimer);
+    }
+    entry.closeTimer = setTimeout(() => {
+      this.closeStream(instanceId, taskId, "TASK_STATE_FAILED");
+    }, IDLE_CLOSE_MS);
+  }
+  writeStreamResponse(entry, result) {
+    const sseData = `data: ${JSON.stringify({ jsonrpc: "2.0", id: entry.rpcId, result })}
+
+`;
+    entry.enqueue(this.encoder.encode(sseData));
+  }
+}
+var IDLE_CLOSE_MS = 30000, MAX_STREAMS = 5000, MAX_STREAMS_PER_INSTANCE = 100;
+var init_stream_store = () => {};
+
+// ../channel-a2a/src/plugin.ts
+var A2A_CAPABILITIES, A2AChannelPlugin;
+var init_plugin = __esm(() => {
+  init_src2();
+  init_a2a_handler();
+  init_stream_store();
+  A2A_CAPABILITIES = {
+    ...DEFAULT_CAPABILITIES,
+    canSendText: true
+  };
+  A2AChannelPlugin = class A2AChannelPlugin extends BaseChannelPlugin {
+    id = "a2a";
+    name = "A2A Protocol Server";
+    version = "0.1.0";
+    capabilities = A2A_CAPABILITIES;
+    taskStore = new A2ATaskStore;
+    streamStore = new A2AStreamStore((instanceId, taskId, state) => {
+      this.taskStore.updateStatus(instanceId, taskId, state).catch(() => {});
+    });
+    async onInitialize(context2) {
+      this.taskStore.setStorage(context2.storage);
+    }
+    async connect(instanceId, config2) {
+      await this.updateInstanceStatus(instanceId, config2, {
+        state: "connected",
+        since: new Date,
+        message: "A2A channel ready"
+      });
+      await this.emitInstanceConnected(instanceId, {});
+    }
+    async disconnect(instanceId) {
+      const entry = this.instances.get(instanceId);
+      if (entry) {
+        await this.updateInstanceStatus(instanceId, entry.config, {
+          state: "disconnected",
+          since: new Date
+        });
+      }
+      await this.emitInstanceDisconnected(instanceId, "disconnect requested");
+    }
+    async sendMessage(instanceId, message2) {
+      const taskId = message2.to;
+      const text = message2.content.text ?? "";
+      if (text) {
+        await this.taskStore.appendArtifact(instanceId, taskId, text);
+        if (this.streamStore.hasStream(instanceId, taskId)) {
+          this.streamStore.writePart(instanceId, taskId, text);
+        }
+      }
+      return { success: true, timestamp: Date.now() };
+    }
+    async sendTyping(instanceId, chatId, duration) {
+      if (duration === 0) {
+        await this.taskStore.updateStatus(instanceId, chatId, "TASK_STATE_COMPLETED");
+        if (this.streamStore.hasStream(instanceId, chatId)) {
+          this.streamStore.closeStream(instanceId, chatId, "TASK_STATE_COMPLETED");
+        }
+      }
+    }
+    inboundTimings(platformTimestamp) {
+      return this.captureInboundTimings(platformTimestamp);
+    }
+    recordT2(correlationId, timings) {
+      this.captureT2(correlationId, timings);
+    }
+    async handleWebhook(request) {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      if (pathname.endsWith("/.well-known/agent-card.json") || pathname === "/.well-known/agent-card.json" || pathname.endsWith("/.well-known/agent.json") || pathname === "/.well-known/agent.json") {
+        return this.handleAgentCardRequest(url);
+      }
+      const a2aMatch = /\/a2a\/([^/]+)\/?$/.exec(pathname);
+      if (a2aMatch?.[1] && request.method === "POST") {
+        const instanceId = a2aMatch[1];
+        return handleA2ARequest(request, {
+          instanceId,
+          eventBus: this.eventBus,
+          streamStore: this.streamStore,
+          taskStore: this.taskStore,
+          channelType: "a2a",
+          plugin: this
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+    handleAgentCardRequest(url) {
+      const instanceId = url.searchParams.get("instanceId");
+      if (!instanceId) {
+        return new Response(JSON.stringify({ error: "instanceId query parameter required" }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const baseUrl = `${url.protocol}//${url.host}`;
+      const card = buildAgentCard({
+        instanceId,
+        instanceName: instanceId,
+        agentName: "Omni Agent",
+        capabilities: [],
+        agentCardOverride: null,
+        baseUrl,
+        extended: false
+      });
+      return new Response(JSON.stringify(card), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+});
+
+// ../channel-a2a/src/index.ts
+var exports_src2 = {};
+__export(exports_src2, {
+  handleA2ARequest: () => handleA2ARequest,
+  default: () => src_default6,
+  buildAgentCard: () => buildAgentCard,
+  A2ATaskStore: () => A2ATaskStore,
+  A2AStreamStore: () => A2AStreamStore,
+  A2AChannelPlugin: () => A2AChannelPlugin
+});
+var plugin7, src_default6;
+var init_src4 = __esm(() => {
+  init_src2();
+  init_plugin();
+  init_plugin();
+  init_stream_store();
+  init_a2a_handler();
+  plugin7 = new A2AChannelPlugin;
+  channelRegistry.register(plugin7);
+  src_default6 = plugin7;
+});
+
 // ../../node_modules/.bun/@sentry+core@10.52.0/node_modules/@sentry/core/build/esm/debug-build.js
 var DEBUG_BUILD;
 var init_debug_build = __esm(() => {
@@ -171126,7 +172269,7 @@ function shouldIgnoreSpansForIncomingRequest(request, {
   ignoreStaticAssets,
   ignoreIncomingRequests
 }) {
-  if (import_core53.isTracingSuppressed(import_api7.context.active())) {
+  if (import_core54.isTracingSuppressed(import_api7.context.active())) {
     return true;
   }
   const urlPath = request.url;
@@ -171178,7 +172321,7 @@ function getIncomingRequestAttributesOnResponse(request, response) {
     [import_semantic_conventions.SEMATTRS_HTTP_STATUS_CODE]: statusCode,
     "http.status_text": statusMessage?.toUpperCase()
   };
-  const rpcMetadata = import_core53.getRPCMetadata(import_api7.context.active());
+  const rpcMetadata = import_core54.getRPCMetadata(import_api7.context.active());
   if (socket) {
     const { localAddress, localPort, remoteAddress, remotePort } = socket;
     newAttributes[import_semantic_conventions.SEMATTRS_NET_HOST_IP] = localAddress;
@@ -171188,7 +172331,7 @@ function getIncomingRequestAttributesOnResponse(request, response) {
   }
   newAttributes[import_semantic_conventions.SEMATTRS_HTTP_STATUS_CODE] = statusCode;
   newAttributes["http.status_text"] = (statusMessage || "").toUpperCase();
-  if (rpcMetadata?.type === import_core53.RPCType.HTTP && rpcMetadata.route !== undefined) {
+  if (rpcMetadata?.type === import_core54.RPCType.HTTP && rpcMetadata.route !== undefined) {
     const routeName = rpcMetadata.route;
     newAttributes[import_semantic_conventions.ATTR_HTTP_ROUTE] = routeName;
   }
@@ -171203,7 +172346,7 @@ function shouldFilterStatusCode(statusCode, dropForStatusCodes) {
     return statusCode >= min && statusCode <= max;
   });
 }
-var import_api7, import_core53, import_semantic_conventions, INTEGRATION_NAME8 = "Http.ServerSpans", _httpServerSpansIntegration = (options = {}) => {
+var import_api7, import_core54, import_semantic_conventions, INTEGRATION_NAME8 = "Http.ServerSpans", _httpServerSpansIntegration = (options = {}) => {
   const ignoreStaticAssets = options.ignoreStaticAssets ?? true;
   const ignoreIncomingRequests = options.ignoreIncomingRequests;
   const ignoreStatusCodes = options.ignoreStatusCodes ?? [
@@ -171268,10 +172411,10 @@ var import_api7, import_core53, import_semantic_conventions, INTEGRATION_NAME8 =
           applyCustomAttributesOnSpan?.(span, request, response);
           onSpanCreated?.(span, request, response);
           const rpcMetadata = {
-            type: import_core53.RPCType.HTTP,
+            type: import_core54.RPCType.HTTP,
             span
           };
-          return import_api7.context.with(import_core53.setRPCMetadata(import_api7.trace.setSpan(import_api7.context.active(), span), rpcMetadata), () => {
+          return import_api7.context.with(import_core54.setRPCMetadata(import_api7.trace.setSpan(import_api7.context.active(), span), rpcMetadata), () => {
             import_api7.context.bind(import_api7.context.active(), request);
             import_api7.context.bind(import_api7.context.active(), response);
             let isEnded = false;
@@ -171333,7 +172476,7 @@ var init_httpServerSpansIntegration = __esm(() => {
   init_debug_build2();
   init_httpServerIntegration();
   import_api7 = __toESM(require_src(), 1);
-  import_core53 = __toESM(require_src6(), 1);
+  import_core54 = __toESM(require_src6(), 1);
   import_semantic_conventions = __toESM(require_src5(), 1);
   httpServerSpansIntegration = _httpServerSpansIntegration;
 });
@@ -173167,13 +174310,13 @@ import { subscribe as subscribe2 } from "diagnostics_channel";
 import { errorMonitor as errorMonitor2 } from "events";
 import * as http from "http";
 import * as https from "https";
-var import_api8, import_core56, import_instrumentation, FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL, SentryHttpInstrumentation;
+var import_api8, import_core57, import_instrumentation, FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL, SentryHttpInstrumentation;
 var init_SentryHttpInstrumentation = __esm(() => {
   init_esm();
   init_constants10();
   init_nodeVersion();
   import_api8 = __toESM(require_src(), 1);
-  import_core56 = __toESM(require_src6(), 1);
+  import_core57 = __toESM(require_src6(), 1);
   import_instrumentation = __toESM(require_src8(), 1);
   FULLY_SUPPORTS_HTTP_DIAGNOSTICS_CHANNEL = NODE_VERSION.major === 22 && NODE_VERSION.minor >= 12 || NODE_VERSION.major === 23 && NODE_VERSION.minor >= 2 || NODE_VERSION.major >= 24;
   SentryHttpInstrumentation = class SentryHttpInstrumentation extends import_instrumentation.InstrumentationBase {
@@ -173188,7 +174331,7 @@ var init_SentryHttpInstrumentation = __esm(() => {
         ...options,
         spans: options.createSpansForOutgoingRequests && (options.spans ?? true),
         ignoreOutgoingRequests(url, request) {
-          return import_core56.isTracingSuppressed(import_api8.context.active()) || !!options.ignoreOutgoingRequests?.(url, getRequestOptions(request));
+          return import_core57.isTracingSuppressed(import_api8.context.active()) || !!options.ignoreOutgoingRequests?.(url, getRequestOptions(request));
         },
         outgoingRequestHook(span, request) {
           options.outgoingRequestHook?.(span, request);
@@ -173408,13 +174551,13 @@ var init_outgoingFetchRequest = __esm(() => {
 
 // ../../node_modules/.bun/@sentry+node-core@10.52.0+6488de8736d8e524/node_modules/@sentry/node-core/build/esm/integrations/node-fetch/SentryNodeFetchInstrumentation.js
 import * as diagch from "diagnostics_channel";
-var import_api9, import_core59, import_instrumentation2, SentryNodeFetchInstrumentation;
+var import_api9, import_core60, import_instrumentation2, SentryNodeFetchInstrumentation;
 var init_SentryNodeFetchInstrumentation = __esm(() => {
   init_esm();
   init_nodeVersion();
   init_outgoingFetchRequest();
   import_api9 = __toESM(require_src(), 1);
-  import_core59 = __toESM(require_src6(), 1);
+  import_core60 = __toESM(require_src6(), 1);
   import_instrumentation2 = __toESM(require_src8(), 1);
   SentryNodeFetchInstrumentation = class SentryNodeFetchInstrumentation extends import_instrumentation2.InstrumentationBase {
     constructor(config2 = {}) {
@@ -173485,7 +174628,7 @@ var init_SentryNodeFetchInstrumentation = __esm(() => {
       });
     }
     _shouldIgnoreOutgoingRequest(request) {
-      if (import_core59.isTracingSuppressed(import_api9.context.active())) {
+      if (import_core60.isTracingSuppressed(import_api9.context.active())) {
         return true;
       }
       const url = getAbsoluteUrl2(request.origin, request.path);
@@ -175845,7 +176988,7 @@ function makeTraceState({
   sampled
 }) {
   const dscString = dsc ? dynamicSamplingContextToSentryBaggageHeader(dsc) : undefined;
-  const traceStateBase = new import_core62.TraceState;
+  const traceStateBase = new import_core63.TraceState;
   const traceStateWithDsc = dscString ? traceStateBase.set(SENTRY_TRACE_STATE_DSC, dscString) : traceStateBase;
   return sampled === false ? traceStateWithDsc.set(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING, "1") : traceStateWithDsc;
 }
@@ -175969,13 +177112,13 @@ function _startSpan(options, callback, autoEnd) {
   return wrapper(() => {
     const activeCtx = getContext(options.scope, options.forceTransaction);
     const missingRequiredParent = options.onlyIfParent && !import_api10.trace.getSpan(activeCtx);
-    const ctx = missingRequiredParent ? import_core62.suppressTracing(activeCtx) : activeCtx;
+    const ctx = missingRequiredParent ? import_core63.suppressTracing(activeCtx) : activeCtx;
     if (missingRequiredParent) {
       getClient()?.recordDroppedEvent("no_parent_span", "span");
     }
     const spanOptions = getSpanOptions(options);
     if (!hasSpansEnabled()) {
-      const suppressedCtx = import_core62.isTracingSuppressed(ctx) ? ctx : import_core62.suppressTracing(ctx);
+      const suppressedCtx = import_core63.isTracingSuppressed(ctx) ? ctx : import_core63.suppressTracing(ctx);
       return import_api10.context.with(suppressedCtx, () => {
         return tracer.startActiveSpan(name, spanOptions, suppressedCtx, (span) => {
           patchSpanEnd(span);
@@ -176012,13 +177155,13 @@ function startInactiveSpan2(options) {
   return wrapper(() => {
     const activeCtx = getContext(options.scope, options.forceTransaction);
     const missingRequiredParent = options.onlyIfParent && !import_api10.trace.getSpan(activeCtx);
-    let ctx = missingRequiredParent ? import_core62.suppressTracing(activeCtx) : activeCtx;
+    let ctx = missingRequiredParent ? import_core63.suppressTracing(activeCtx) : activeCtx;
     if (missingRequiredParent) {
       getClient()?.recordDroppedEvent("no_parent_span", "span");
     }
     const spanOptions = getSpanOptions(options);
     if (!hasSpansEnabled()) {
-      ctx = import_core62.isTracingSuppressed(ctx) ? ctx : import_core62.suppressTracing(ctx);
+      ctx = import_core63.isTracingSuppressed(ctx) ? ctx : import_core63.suppressTracing(ctx);
     }
     const span = tracer.startSpan(name, spanOptions, ctx);
     patchSpanEnd(span);
@@ -176127,7 +177270,7 @@ function getActiveSpanWrapper2(parentSpan) {
   } : (callback) => callback();
 }
 function suppressTracing2(callback) {
-  const ctx = import_core62.suppressTracing(import_api10.context.active());
+  const ctx = import_core63.suppressTracing(import_api10.context.active());
   return import_api10.context.with(ctx, callback);
 }
 function setupEventContextTrace(client) {
@@ -176814,7 +177957,7 @@ function wrapSamplingDecision({
 function getBaseTraceState(context8, spanAttributes) {
   const parentSpan = import_api10.trace.getSpan(context8);
   const parentContext = parentSpan?.spanContext();
-  let traceState = parentContext?.traceState || new import_core62.TraceState;
+  let traceState = parentContext?.traceState || new import_core63.TraceState;
   const url = spanAttributes[import_semantic_conventions2.SEMATTRS_HTTP_URL] || spanAttributes[import_semantic_conventions2.ATTR_URL_FULL];
   if (url && typeof url === "string") {
     traceState = traceState.set(SENTRY_TRACE_STATE_URL, url);
@@ -176875,12 +178018,12 @@ function getSentryResource(serviceNameFallback) {
     ...otelResourceAttrs,
     ...otelServiceName ? { [import_semantic_conventions2.ATTR_SERVICE_NAME]: otelServiceName } : {},
     [import_semantic_conventions2.ATTR_SERVICE_VERSION]: SDK_VERSION,
-    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_LANGUAGE]: import_core62.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_LANGUAGE],
-    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_NAME]: import_core62.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_NAME],
-    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_VERSION]: import_core62.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_VERSION]
+    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_LANGUAGE]: import_core63.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_LANGUAGE],
+    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_NAME]: import_core63.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_NAME],
+    [import_semantic_conventions2.ATTR_TELEMETRY_SDK_VERSION]: import_core63.SDK_INFO[import_semantic_conventions2.ATTR_TELEMETRY_SDK_VERSION]
   });
 }
-var api, import_api10, import_semantic_conventions2, import_core62, import_sdk_trace_base, SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE = "sentry.parentIsRemote", SEMANTIC_ATTRIBUTE_SENTRY_GRAPHQL_OPERATION = "sentry.graphql.operation", SENTRY_TRACE_HEADER2 = "sentry-trace", SENTRY_BAGGAGE_HEADER2 = "baggage", SENTRY_TRACE_STATE_DSC = "sentry.dsc", SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING = "sentry.sampled_not_recording", SENTRY_TRACE_STATE_URL = "sentry.url", SENTRY_TRACE_STATE_SAMPLE_RAND = "sentry.sample_rand", SENTRY_TRACE_STATE_SAMPLE_RATE = "sentry.sample_rate", SENTRY_TRACE_STATE_CHILD_IGNORED = "sentry.ignored", SENTRY_TRACE_STATE_SEGMENT_IGNORED = "sentry.segment_ignored", SENTRY_SCOPES_CONTEXT_KEY, SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY, SENTRY_FORK_SET_SCOPE_CONTEXT_KEY, SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY, SCOPE_CONTEXT_FIELD = "_scopeContext", setupElements, SentryPropagator, canonicalGrpcErrorCodesMap, isStatusErrorMessageValid = (message2) => {
+var api, import_api10, import_semantic_conventions2, import_core63, import_sdk_trace_base, SEMANTIC_ATTRIBUTE_SENTRY_PARENT_IS_REMOTE = "sentry.parentIsRemote", SEMANTIC_ATTRIBUTE_SENTRY_GRAPHQL_OPERATION = "sentry.graphql.operation", SENTRY_TRACE_HEADER2 = "sentry-trace", SENTRY_BAGGAGE_HEADER2 = "baggage", SENTRY_TRACE_STATE_DSC = "sentry.dsc", SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING = "sentry.sampled_not_recording", SENTRY_TRACE_STATE_URL = "sentry.url", SENTRY_TRACE_STATE_SAMPLE_RAND = "sentry.sample_rand", SENTRY_TRACE_STATE_SAMPLE_RATE = "sentry.sample_rate", SENTRY_TRACE_STATE_CHILD_IGNORED = "sentry.ignored", SENTRY_TRACE_STATE_SEGMENT_IGNORED = "sentry.segment_ignored", SENTRY_SCOPES_CONTEXT_KEY, SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY, SENTRY_FORK_SET_SCOPE_CONTEXT_KEY, SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY, SCOPE_CONTEXT_FIELD = "_scopeContext", setupElements, SentryPropagator, canonicalGrpcErrorCodesMap, isStatusErrorMessageValid = (message2) => {
   return Object.values(canonicalGrpcErrorCodesMap).includes(message2);
 }, MAX_SPAN_COUNT2 = 1000, DEFAULT_TIMEOUT = 300;
 var init_resource_Bhpm2sLf = __esm(() => {
@@ -176889,21 +178032,21 @@ var init_resource_Bhpm2sLf = __esm(() => {
   api = __toESM(require_src(), 1);
   import_api10 = __toESM(require_src(), 1);
   import_semantic_conventions2 = __toESM(require_src5(), 1);
-  import_core62 = __toESM(require_src6(), 1);
+  import_core63 = __toESM(require_src6(), 1);
   import_sdk_trace_base = __toESM(require_src10(), 1);
   SENTRY_SCOPES_CONTEXT_KEY = import_api10.createContextKey("sentry_scopes");
   SENTRY_FORK_ISOLATION_SCOPE_CONTEXT_KEY = import_api10.createContextKey("sentry_fork_isolation_scope");
   SENTRY_FORK_SET_SCOPE_CONTEXT_KEY = import_api10.createContextKey("sentry_fork_set_scope");
   SENTRY_FORK_SET_ISOLATION_SCOPE_CONTEXT_KEY = import_api10.createContextKey("sentry_fork_set_isolation_scope");
   setupElements = new Set;
-  SentryPropagator = class SentryPropagator extends import_core62.W3CBaggagePropagator {
+  SentryPropagator = class SentryPropagator extends import_core63.W3CBaggagePropagator {
     constructor() {
       super();
       setIsSetup("SentryPropagator");
       this._urlMatchesTargetsMap = new LRUMap(100);
     }
     inject(context8, carrier, setter) {
-      if (import_core62.isTracingSuppressed(context8)) {
+      if (import_core63.isTracingSuppressed(context8)) {
         DEBUG_BUILD3 && debug32.log("[Tracing] Not injecting trace data for url because tracing is suppressed.");
         return;
       }
@@ -179752,12 +180895,12 @@ var init_http3 = __esm(() => {
 // ../../node_modules/.bun/@sentry+node@10.52.0+1b9a589cee1ff949/node_modules/@sentry/node/build/esm/integrations/node-fetch/vendored/undici.js
 import * as diagch2 from "diagnostics_channel";
 import { URL as URL4 } from "url";
-var import_instrumentation5, import_api15, import_core91, import_semantic_conventions3, PACKAGE_NAME = "@sentry/instrumentation-undici", UndiciInstrumentation;
+var import_instrumentation5, import_api15, import_core92, import_semantic_conventions3, PACKAGE_NAME = "@sentry/instrumentation-undici", UndiciInstrumentation;
 var init_undici = __esm(() => {
   init_esm();
   import_instrumentation5 = __toESM(require_src8(), 1);
   import_api15 = __toESM(require_src(), 1);
-  import_core91 = __toESM(require_src6(), 1);
+  import_core92 = __toESM(require_src6(), 1);
   import_semantic_conventions3 = __toESM(require_src5(), 1);
   UndiciInstrumentation = class UndiciInstrumentation extends import_instrumentation5.InstrumentationBase {
     __init() {
@@ -179856,7 +180999,7 @@ var init_undici = __esm(() => {
       if (shouldIgnoreReq) {
         return;
       }
-      const startTime = import_core91.hrTime();
+      const startTime = import_core92.hrTime();
       let requestUrl;
       try {
         requestUrl = new URL4(request2.path, request2.origin);
@@ -180029,7 +181172,7 @@ var init_undici = __esm(() => {
           metricsAttributes[key] = attributes[key];
         }
       });
-      const durationSeconds = import_core91.hrTimeToMilliseconds(import_core91.hrTimeDuration(startTime, import_core91.hrTime())) / 1000;
+      const durationSeconds = import_core92.hrTimeToMilliseconds(import_core92.hrTimeDuration(startTime, import_core92.hrTime())) / 1000;
       this._httpClientDurationHistogram.record(durationSeconds, metricsAttributes);
     }
     getRequestMethod(original) {
@@ -180574,7 +181717,7 @@ var init_debug_build3 = __esm(() => {
 });
 
 // ../../node_modules/.bun/@sentry+node@10.52.0+1b9a589cee1ff949/node_modules/@sentry/node/build/esm/integrations/tracing/express.js
-var import_instrumentation6, import_api16, import_core94, INTEGRATION_NAME23 = "Express", SUPPORTED_VERSIONS, instrumentExpress, ExpressInstrumentation, _expressIntegration = (options) => {
+var import_instrumentation6, import_api16, import_core95, INTEGRATION_NAME23 = "Express", SUPPORTED_VERSIONS, instrumentExpress, ExpressInstrumentation, _expressIntegration = (options) => {
   return {
     name: INTEGRATION_NAME23,
     setupOnce() {
@@ -180588,7 +181731,7 @@ var init_express2 = __esm(() => {
   init_debug_build3();
   import_instrumentation6 = __toESM(require_src8(), 1);
   import_api16 = __toESM(require_src(), 1);
-  import_core94 = __toESM(require_src6(), 1);
+  import_core95 = __toESM(require_src6(), 1);
   SUPPORTED_VERSIONS = [">=4.0.0 <6"];
   instrumentExpress = generateInstrumentOnce(INTEGRATION_NAME23, (options) => new ExpressInstrumentation(options));
   ExpressInstrumentation = class ExpressInstrumentation extends import_instrumentation6.InstrumentationBase {
@@ -180601,8 +181744,8 @@ var init_express2 = __esm(() => {
           patchExpressModule(express, () => ({
             ...this.getConfig(),
             onRouteResolved(route) {
-              const rpcMetadata = import_core94.getRPCMetadata(import_api16.context.active());
-              if (route && rpcMetadata?.type === import_core94.RPCType.HTTP) {
+              const rpcMetadata = import_core95.getRPCMetadata(import_api16.context.active());
+              if (route && rpcMetadata?.type === import_core95.RPCType.HTTP) {
                 rpcMetadata.route = route;
               }
             }
@@ -184498,13 +185641,13 @@ function addFastifyV3SpanAttributes(span) {
     span.updateName(updatedName);
   }
 }
-var import_api18, import_core96, import_instrumentation7, import_semantic_conventions4, PACKAGE_VERSION = "0.1.0", PACKAGE_NAME2 = "@sentry/instrumentation-fastify-v3", ANONYMOUS_NAME = "anonymous", hooksNamesToWrap, FastifyInstrumentationV3;
+var import_api18, import_core97, import_instrumentation7, import_semantic_conventions4, PACKAGE_VERSION = "0.1.0", PACKAGE_NAME2 = "@sentry/instrumentation-fastify-v3", ANONYMOUS_NAME = "anonymous", hooksNamesToWrap, FastifyInstrumentationV3;
 var init_instrumentation = __esm(() => {
   init_esm();
   init_AttributeNames();
   init_utils10();
   import_api18 = __toESM(require_src(), 1);
-  import_core96 = __toESM(require_src6(), 1);
+  import_core97 = __toESM(require_src6(), 1);
   import_instrumentation7 = __toESM(require_src8(), 1);
   import_semantic_conventions4 = __toESM(require_src5(), 1);
   hooksNamesToWrap = new Set([
@@ -184537,9 +185680,9 @@ var init_instrumentation = __esm(() => {
         }
         instrumentation._wrap(reply, "send", instrumentation._patchSend());
         const anyRequest = request2;
-        const rpcMetadata = import_core96.getRPCMetadata(import_api18.context.active());
+        const rpcMetadata = import_core97.getRPCMetadata(import_api18.context.active());
         const routeName = anyRequest.routeOptions ? anyRequest.routeOptions.url : request2.routerPath;
-        if (routeName && rpcMetadata?.type === import_core96.RPCType.HTTP) {
+        if (routeName && rpcMetadata?.type === import_core97.RPCType.HTTP) {
           rpcMetadata.route = routeName;
         }
         const method = request2.method || "GET";
@@ -184776,10 +185919,10 @@ var init_fastify = __esm(() => {
   instrumentFastifyV3 = generateInstrumentOnce(`${INTEGRATION_NAME24}.v3`, () => new FastifyInstrumentationV3);
   instrumentFastify = generateInstrumentOnce(`${INTEGRATION_NAME24}.v5`, () => {
     const fastifyOtelInstrumentationInstance = new import_otel.FastifyOtelInstrumentation;
-    const plugin7 = fastifyOtelInstrumentationInstance.plugin();
+    const plugin8 = fastifyOtelInstrumentationInstance.plugin();
     diagnosticsChannel2.subscribe("fastify.initialization", (message2) => {
       const fastifyInstance = message2.fastify;
-      fastifyInstance?.register(plugin7).after((err) => {
+      fastifyInstance?.register(plugin8).after((err) => {
         if (err) {
           DEBUG_BUILD4 && debug32.error("Failed to setup Fastify instrumentation", err);
         } else {
@@ -188703,7 +189846,7 @@ var init_redis_instrumentation = __esm(() => {
       return new import_instrumentation10.InstrumentationNodeModuleDefinition(basePackageName, ["^1.0.0", ">=5.0.0 <5.12.0"], (moduleExports) => moduleExports, () => {}, [commanderModuleFile, multiCommanderModule, clientIndexModule]);
     }
     _getPatchExtendWithCommands(transformCommandArguments) {
-      const plugin7 = this;
+      const plugin8 = this;
       return function extendWithCommandsPatchWrapper(original) {
         return function extendWithCommandsPatch(config2) {
           if (config2?.BaseClass?.name !== "RedisClient") {
@@ -188712,32 +189855,32 @@ var init_redis_instrumentation = __esm(() => {
           const origExecutor = config2.executor;
           config2.executor = function(command, args) {
             const redisCommandArguments = transformCommandArguments(command, args).args;
-            return plugin7._traceClientCommand(origExecutor, this, arguments, redisCommandArguments);
+            return plugin8._traceClientCommand(origExecutor, this, arguments, redisCommandArguments);
           };
           return original.apply(this, arguments);
         };
       };
     }
     _getPatchMultiCommandsExec(isPipeline) {
-      const plugin7 = this;
+      const plugin8 = this;
       return function execPatchWrapper(original) {
         return function execPatch() {
           const execRes = original.apply(this, arguments);
           if (typeof execRes?.then !== "function") {
-            plugin7._diag.error("non-promise result when patching exec/execAsPipeline");
+            plugin8._diag.error("non-promise result when patching exec/execAsPipeline");
             return execRes;
           }
           return execRes.then((redisRes) => {
             const openSpans = this[OTEL_OPEN_SPANS];
-            plugin7._endSpansWithRedisReplies(openSpans, redisRes, isPipeline);
+            plugin8._endSpansWithRedisReplies(openSpans, redisRes, isPipeline);
             return redisRes;
           }).catch((err) => {
             const openSpans = this[OTEL_OPEN_SPANS];
             if (!openSpans) {
-              plugin7._diag.error("cannot find open spans to end for multi/pipeline");
+              plugin8._diag.error("cannot find open spans to end for multi/pipeline");
             } else {
               const replies = err.constructor.name === "MultiErrorReply" ? err.replies : new Array(openSpans.length).fill(err);
-              plugin7._endSpansWithRedisReplies(openSpans, replies, isPipeline);
+              plugin8._endSpansWithRedisReplies(openSpans, replies, isPipeline);
             }
             return Promise.reject(err);
           });
@@ -188745,10 +189888,10 @@ var init_redis_instrumentation = __esm(() => {
       };
     }
     _getPatchMultiCommandsAddCommand() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function addCommandWrapper(original) {
         return function addCommandPatch(args) {
-          return plugin7._traceClientCommand(original, this, arguments, args);
+          return plugin8._traceClientCommand(original, this, arguments, args);
         };
       };
     }
@@ -188762,21 +189905,21 @@ var init_redis_instrumentation = __esm(() => {
       };
     }
     _getPatchRedisClientSendCommand() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function sendCommandWrapper(original) {
         return function sendCommandPatch(args) {
-          return plugin7._traceClientCommand(original, this, arguments, args);
+          return plugin8._traceClientCommand(original, this, arguments, args);
         };
       };
     }
     _getPatchedClientConnect() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function connectWrapper(original) {
         return function patchedConnect() {
           const options = this.options;
-          const attributes = getClientAttributes(plugin7._diag, options, plugin7._semconvStability);
+          const attributes = getClientAttributes(plugin8._diag, options, plugin8._semconvStability);
           attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = "auto.db.otel.redis";
-          const span = plugin7.tracer.startSpan(`${RedisInstrumentationV4_V5.COMPONENT}-connect`, {
+          const span = plugin8.tracer.startSpan(`${RedisInstrumentationV4_V5.COMPONENT}-connect`, {
             kind: import_api21.SpanKind.CLIENT,
             attributes
           });
@@ -189618,16 +190761,16 @@ var require_instrumentation12 = __commonJS((exports) => {
       return module2;
     }
     _getClientConnectPatch() {
-      const plugin7 = this;
+      const plugin8 = this;
       return (original) => {
         return function connect5(callback) {
-          const config2 = plugin7.getConfig();
+          const config2 = plugin8.getConfig();
           if (utils.shouldSkipInstrumentation(config2) || config2.ignoreConnectSpans) {
             return original.call(this, callback);
           }
-          const span = plugin7.tracer.startSpan(SpanNames_1.SpanNames.CONNECT, {
+          const span = plugin8.tracer.startSpan(SpanNames_1.SpanNames.CONNECT, {
             kind: api_1.SpanKind.CLIENT,
-            attributes: utils.getSemanticAttributesFromConnection(this, plugin7._semconvStability)
+            attributes: utils.getSemanticAttributesFromConnection(this, plugin8._semconvStability)
           });
           if (callback) {
             const parentSpan = api_1.trace.getSpan(api_1.context.active());
@@ -189667,11 +190810,11 @@ var require_instrumentation12 = __commonJS((exports) => {
       this._operationDuration.record(durationSeconds, metricsAttributes);
     }
     _getClientQueryPatch() {
-      const plugin7 = this;
+      const plugin8 = this;
       return (original) => {
         this._diag.debug("Patching pg.Client.prototype.query");
         return function query(...args) {
-          if (utils.shouldSkipInstrumentation(plugin7.getConfig())) {
+          if (utils.shouldSkipInstrumentation(plugin8.getConfig())) {
             return original.apply(this, args);
           }
           const startTime = (0, core_1.hrTime)();
@@ -189697,10 +190840,10 @@ var require_instrumentation12 = __commonJS((exports) => {
             attributes[semantic_conventions_1.ATTR_DB_OPERATION_NAME] = utils.parseNormalizedOperationName(queryConfig?.text);
           }
           const recordDuration = () => {
-            plugin7.recordOperationDuration(attributes, startTime);
+            plugin8.recordOperationDuration(attributes, startTime);
           };
-          const instrumentationConfig = plugin7.getConfig();
-          const span = utils.handleConfigQuery.call(this, plugin7.tracer, instrumentationConfig, plugin7._semconvStability, queryConfig);
+          const instrumentationConfig = plugin8.getConfig();
+          const span = utils.handleConfigQuery.call(this, plugin8.tracer, instrumentationConfig, plugin8._semconvStability, queryConfig);
           if (instrumentationConfig.addSqlCommenterCommentToQueries) {
             if (firstArgIsString) {
               args[0] = (0, sql_common_1.addSqlCommenterComment)(span, arg0);
@@ -189719,7 +190862,7 @@ var require_instrumentation12 = __commonJS((exports) => {
                 args[args.length - 1] = api_1.context.bind(api_1.context.active(), args[args.length - 1]);
               }
             } else if (typeof queryConfig?.callback === "function") {
-              let callback = utils.patchCallback(plugin7.getConfig(), span, queryConfig.callback, attributes, recordDuration);
+              let callback = utils.patchCallback(plugin8.getConfig(), span, queryConfig.callback, attributes, recordDuration);
               if (parentSpan) {
                 callback = api_1.context.bind(api_1.context.active(), callback);
               }
@@ -189741,7 +190884,7 @@ var require_instrumentation12 = __commonJS((exports) => {
               });
             }, (err) => {
               if (err) {
-                plugin7._diag.error("Error running query hook", err);
+                plugin8._diag.error("Error running query hook", err);
               }
             }, true);
           }
@@ -189762,7 +190905,7 @@ var require_instrumentation12 = __commonJS((exports) => {
           if (result instanceof Promise) {
             return result.then((result2) => {
               return new Promise((resolve3) => {
-                utils.handleExecutionResult(plugin7.getConfig(), span, result2);
+                utils.handleExecutionResult(plugin8.getConfig(), span, result2);
                 recordDuration();
                 span.end();
                 resolve3(result2);
@@ -189805,20 +190948,20 @@ var require_instrumentation12 = __commonJS((exports) => {
       pgPool[internal_types_1.EVENT_LISTENERS_SET] = true;
     }
     _getPoolConnectPatch() {
-      const plugin7 = this;
+      const plugin8 = this;
       return (originalConnect) => {
         return function connect5(callback) {
-          const config2 = plugin7.getConfig();
+          const config2 = plugin8.getConfig();
           if (utils.shouldSkipInstrumentation(config2)) {
             return originalConnect.call(this, callback);
           }
-          plugin7._setPoolConnectEventListeners(this);
+          plugin8._setPoolConnectEventListeners(this);
           if (config2.ignoreConnectSpans) {
             return originalConnect.call(this, callback);
           }
-          const span = plugin7.tracer.startSpan(SpanNames_1.SpanNames.POOL_CONNECT, {
+          const span = plugin8.tracer.startSpan(SpanNames_1.SpanNames.POOL_CONNECT, {
             kind: api_1.SpanKind.CLIENT,
-            attributes: utils.getSemanticAttributesFromPoolConnection(this.options, plugin7._semconvStability)
+            attributes: utils.getSemanticAttributesFromPoolConnection(this.options, plugin8._semconvStability)
           });
           if (callback) {
             const parentSpan = api_1.trace.getSpan(api_1.context.active());
@@ -191918,11 +193061,11 @@ var require_utils21 = __commonJS((exports) => {
   var internal_types_1 = require_internal_types5();
   var AttributeNames_1 = require_AttributeNames4();
   var instrumentation_1 = require_src8();
-  function getPluginName(plugin7) {
-    if (plugin7.name) {
-      return plugin7.name;
+  function getPluginName(plugin8) {
+    if (plugin8.name) {
+      return plugin8.name;
     } else {
-      return plugin7.pkg.name;
+      return plugin8.pkg.name;
     }
   }
   exports.getPluginName = getPluginName;
@@ -192053,12 +193196,12 @@ var require_instrumentation15 = __commonJS((exports) => {
       return function register2(pluginInput, options) {
         if (Array.isArray(pluginInput)) {
           for (const pluginObj of pluginInput) {
-            const plugin7 = (0, utils_1.getPluginFromInput)(pluginObj);
-            instrumentation._wrapRegisterHandler(plugin7);
+            const plugin8 = (0, utils_1.getPluginFromInput)(pluginObj);
+            instrumentation._wrapRegisterHandler(plugin8);
           }
         } else {
-          const plugin7 = (0, utils_1.getPluginFromInput)(pluginInput);
-          instrumentation._wrapRegisterHandler(plugin7);
+          const plugin8 = (0, utils_1.getPluginFromInput)(pluginInput);
+          instrumentation._wrapRegisterHandler(plugin8);
         }
         return original.apply(this, [pluginInput, options]);
       };
@@ -192106,10 +193249,10 @@ var require_instrumentation15 = __commonJS((exports) => {
         return original.apply(this, [route]);
       };
     }
-    _wrapRegisterHandler(plugin7) {
+    _wrapRegisterHandler(plugin8) {
       const instrumentation = this;
-      const pluginName = (0, utils_1.getPluginName)(plugin7);
-      const oldRegister = plugin7.register;
+      const pluginName = (0, utils_1.getPluginName)(plugin8);
+      const oldRegister = plugin8.register;
       const self2 = this;
       const newRegisterHandler = function(server, options) {
         self2._wrap(server, "route", (original) => {
@@ -192120,7 +193263,7 @@ var require_instrumentation15 = __commonJS((exports) => {
         });
         return oldRegister.call(this, server, options);
       };
-      plugin7.register = newRegisterHandler;
+      plugin8.register = newRegisterHandler;
     }
     _wrapExtMethods(method, extPoint, pluginName) {
       const instrumentation = this;
@@ -192564,13 +193707,13 @@ var require_instrumentation16 = __commonJS((exports) => {
       });
     }
     _getKoaUsePatch(original) {
-      const plugin7 = this;
+      const plugin8 = this;
       return function use(middlewareFunction) {
         let patchedFunction;
         if (middlewareFunction.router) {
-          patchedFunction = plugin7._patchRouterDispatch(middlewareFunction);
+          patchedFunction = plugin8._patchRouterDispatch(middlewareFunction);
         } else {
-          patchedFunction = plugin7._patchLayer(middlewareFunction, false);
+          patchedFunction = plugin8._patchLayer(middlewareFunction, false);
         }
         return original.apply(this, [patchedFunction]);
       };
@@ -208653,11 +209796,11 @@ var require_transport3 = __commonJS((exports) => {
   function captureJsonRpcErrorResponse(errorResponse) {
     try {
       if (errorResponse && typeof errorResponse === "object" && "code" in errorResponse && "message" in errorResponse) {
-        const jsonRpcError = errorResponse;
-        const isServerError = jsonRpcError.code === -32603 || jsonRpcError.code >= -32099 && jsonRpcError.code <= -32000;
+        const jsonRpcError2 = errorResponse;
+        const isServerError = jsonRpcError2.code === -32603 || jsonRpcError2.code >= -32099 && jsonRpcError2.code <= -32000;
         if (isServerError) {
-          const error3 = new Error(jsonRpcError.message);
-          error3.name = `JsonRpcError_${jsonRpcError.code}`;
+          const error3 = new Error(jsonRpcError2.message);
+          error3.name = `JsonRpcError_${jsonRpcError2.code}`;
           errorCapture.captureError(error3, "protocol");
         }
       }
@@ -220834,10 +221977,10 @@ var require_fastify = __commonJS((exports) => {
   }
   var instrumentFastify2 = nodeCore.generateInstrumentOnce(`${INTEGRATION_NAME46}.v5`, () => {
     const fastifyOtelInstrumentationInstance = new otel.FastifyOtelInstrumentation;
-    const plugin7 = fastifyOtelInstrumentationInstance.plugin();
+    const plugin8 = fastifyOtelInstrumentationInstance.plugin();
     diagnosticsChannel3.subscribe("fastify.initialization", (message2) => {
       const fastifyInstance = message2.fastify;
-      fastifyInstance?.register(plugin7).after((err) => {
+      fastifyInstance?.register(plugin8).after((err) => {
         if (err) {
           debugBuild.DEBUG_BUILD && core3.debug.error("Failed to setup Fastify instrumentation", err);
         } else {
@@ -220880,7 +222023,7 @@ var require_fastify = __commonJS((exports) => {
     if (options?.shouldHandleError) {
       getFastifyIntegration2()?.setShouldHandleError(options.shouldHandleError);
     }
-    const plugin7 = Object.assign(function(fastify2, _options, done) {
+    const plugin8 = Object.assign(function(fastify2, _options, done) {
       fastify2.addHook("onError", async (request2, reply, error3) => {
         handleFastifyError2.call(handleFastifyError2, error3, request2, reply, "onError-hook");
       });
@@ -220889,7 +222032,7 @@ var require_fastify = __commonJS((exports) => {
       [Symbol.for("skip-override")]: true,
       [Symbol.for("fastify.display-name")]: "sentry-fastify-error-handler"
     });
-    fastify.register(plugin7);
+    fastify.register(plugin8);
   }
   function addFastifySpanAttributes2(span) {
     const spanJSON = core3.spanToJSON(span);
@@ -221857,7 +223000,7 @@ var require_redis_instrumentation = __commonJS((exports) => {
       return new instrumentation.InstrumentationNodeModuleDefinition(basePackageName, ["^1.0.0", ">=5.0.0 <5.12.0"], (moduleExports) => moduleExports, () => {}, [commanderModuleFile, multiCommanderModule, clientIndexModule]);
     }
     _getPatchExtendWithCommands(transformCommandArguments) {
-      const plugin7 = this;
+      const plugin8 = this;
       return function extendWithCommandsPatchWrapper(original) {
         return function extendWithCommandsPatch(config4) {
           if (config4?.BaseClass?.name !== "RedisClient") {
@@ -221866,32 +223009,32 @@ var require_redis_instrumentation = __commonJS((exports) => {
           const origExecutor = config4.executor;
           config4.executor = function(command, args) {
             const redisCommandArguments = transformCommandArguments(command, args).args;
-            return plugin7._traceClientCommand(origExecutor, this, arguments, redisCommandArguments);
+            return plugin8._traceClientCommand(origExecutor, this, arguments, redisCommandArguments);
           };
           return original.apply(this, arguments);
         };
       };
     }
     _getPatchMultiCommandsExec(isPipeline) {
-      const plugin7 = this;
+      const plugin8 = this;
       return function execPatchWrapper(original) {
         return function execPatch() {
           const execRes = original.apply(this, arguments);
           if (typeof execRes?.then !== "function") {
-            plugin7._diag.error("non-promise result when patching exec/execAsPipeline");
+            plugin8._diag.error("non-promise result when patching exec/execAsPipeline");
             return execRes;
           }
           return execRes.then((redisRes) => {
             const openSpans = this[OTEL_OPEN_SPANS2];
-            plugin7._endSpansWithRedisReplies(openSpans, redisRes, isPipeline);
+            plugin8._endSpansWithRedisReplies(openSpans, redisRes, isPipeline);
             return redisRes;
           }).catch((err) => {
             const openSpans = this[OTEL_OPEN_SPANS2];
             if (!openSpans) {
-              plugin7._diag.error("cannot find open spans to end for multi/pipeline");
+              plugin8._diag.error("cannot find open spans to end for multi/pipeline");
             } else {
               const replies = err.constructor.name === "MultiErrorReply" ? err.replies : new Array(openSpans.length).fill(err);
-              plugin7._endSpansWithRedisReplies(openSpans, replies, isPipeline);
+              plugin8._endSpansWithRedisReplies(openSpans, replies, isPipeline);
             }
             return Promise.reject(err);
           });
@@ -221899,10 +223042,10 @@ var require_redis_instrumentation = __commonJS((exports) => {
       };
     }
     _getPatchMultiCommandsAddCommand() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function addCommandWrapper(original) {
         return function addCommandPatch(args) {
-          return plugin7._traceClientCommand(original, this, arguments, args);
+          return plugin8._traceClientCommand(original, this, arguments, args);
         };
       };
     }
@@ -221916,21 +223059,21 @@ var require_redis_instrumentation = __commonJS((exports) => {
       };
     }
     _getPatchRedisClientSendCommand() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function sendCommandWrapper(original) {
         return function sendCommandPatch(args) {
-          return plugin7._traceClientCommand(original, this, arguments, args);
+          return plugin8._traceClientCommand(original, this, arguments, args);
         };
       };
     }
     _getPatchedClientConnect() {
-      const plugin7 = this;
+      const plugin8 = this;
       return function connectWrapper(original) {
         return function patchedConnect() {
           const options = this.options;
-          const attributes = getClientAttributes2(plugin7._diag, options, plugin7._semconvStability);
+          const attributes = getClientAttributes2(plugin8._diag, options, plugin8._semconvStability);
           attributes[core3.SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = "auto.db.otel.redis";
-          const span = plugin7.tracer.startSpan(`${RedisInstrumentationV4_V52.COMPONENT}-connect`, {
+          const span = plugin8.tracer.startSpan(`${RedisInstrumentationV4_V52.COMPONENT}-connect`, {
             kind: api2.SpanKind.CLIENT,
             attributes
           });
@@ -225883,7 +227026,7 @@ var init_sentry_scrub = __esm(() => {
 var require_package7 = __commonJS((exports, module) => {
   module.exports = {
     name: "@omni/api",
-    version: "2.260717.7",
+    version: "2.260718.1",
     type: "module",
     exports: {
       ".": {
@@ -281422,8 +282565,8 @@ function osUsername() {
     return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
   }
 }
-var src_default6;
-var init_src4 = __esm(() => {
+var src_default7;
+var init_src5 = __esm(() => {
   init_types14();
   init_connection();
   init_query2();
@@ -281448,7 +282591,7 @@ var init_src4 = __esm(() => {
       serialize: (x) => x.toString()
     }
   });
-  src_default6 = Postgres;
+  src_default7 = Postgres;
 });
 
 // ../../node_modules/.bun/drizzle-orm@0.38.4+db1fc555b1037084/node_modules/drizzle-orm/postgres-js/session.js
@@ -281599,7 +282742,7 @@ function construct(client, config4 = {}) {
 }
 function drizzle(...params) {
   if (typeof params[0] === "string") {
-    const instance4 = src_default6(params[0]);
+    const instance4 = src_default7(params[0]);
     return construct(instance4, params[1]);
   }
   if (isConfig(params[0])) {
@@ -281608,17 +282751,17 @@ function drizzle(...params) {
       return construct(client, drizzleConfig);
     if (typeof connection2 === "object" && connection2.url !== undefined) {
       const { url, ...config4 } = connection2;
-      const instance22 = src_default6(url, config4);
+      const instance22 = src_default7(url, config4);
       return construct(instance22, drizzleConfig);
     }
-    const instance4 = src_default6(connection2);
+    const instance4 = src_default7(connection2);
     return construct(instance4, drizzleConfig);
   }
   return construct(params[0], params[1]);
 }
 var PostgresJsDatabase;
 var init_driver = __esm(() => {
-  init_src4();
+  init_src5();
   init_entity();
   init_logger3();
   init_db();
@@ -281667,7 +282810,7 @@ function getDefaultDatabaseUrl() {
 function createPostgresClient(config4) {
   const url = config4?.url ?? getDefaultDatabaseUrl();
   const ssl = resolveSslConfig(config4?.sslCaFile);
-  const client = src_default6(url, {
+  const client = src_default7(url, {
     max: config4?.maxConnections ?? 10,
     idle_timeout: config4?.idleTimeout ?? 20,
     connect_timeout: config4?.connectTimeout ?? 10,
@@ -281690,7 +282833,7 @@ async function closeDb() {
 var sqlClient = null, dbInstance = null;
 var init_client5 = __esm(() => {
   init_postgres_js();
-  init_src4();
+  init_src5();
   init_schema2();
 });
 
@@ -281827,7 +282970,7 @@ var init_verify_schema = __esm(() => {
 });
 
 // ../db/src/index.ts
-var init_src5 = __esm(() => {
+var init_src6 = __esm(() => {
   init_client5();
   init_migrate();
   init_verify_schema();
@@ -284709,7 +285852,7 @@ class ApiKeyService {
 var log58, API_KEY_PREFIX = "omni_sk_", PRIMARY_KEY_NAME = "__primary__";
 var init_api_keys = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_cache2();
   log58 = createLogger("api-keys");
@@ -284926,7 +286069,7 @@ function loadPubkey(pubkeyB64Url) {
 }
 async function verifySignature3(opts) {
   const { hostIdHeader, timestampHeader, signatureHeader, method, path: path2, body, now, findHost } = opts;
-  if (!hostIdHeader && !timestampHeader && !signatureHeader) {
+  if (hostIdHeader === undefined && timestampHeader === undefined && signatureHeader === undefined) {
     return { status: "no-signature" };
   }
   if (!hostIdHeader || !timestampHeader || !signatureHeader) {
@@ -284987,7 +286130,7 @@ var init_genie_signature = __esm(() => {
     const hostIdHeader = c.req.header(HEADER_HOST_ID);
     const timestampHeader = c.req.header(HEADER_TIMESTAMP);
     const signatureHeader = c.req.header(HEADER_SIGNATURE);
-    if (!hostIdHeader && !timestampHeader && !signatureHeader) {
+    if (hostIdHeader === undefined && timestampHeader === undefined && signatureHeader === undefined) {
       return next();
     }
     const services = c.get("services");
@@ -286134,7 +287277,7 @@ class DeepSeekVisionProvider {
     if (!response.ok) {
       throw new Error(`DeepSeek vision error (${response.status}): ${body.error?.message ?? bodyText.slice(0, 300)}`);
     }
-    const text3 = extractText(body).trim();
+    const text3 = extractText2(body).trim();
     if (!text3) {
       throw new Error("DeepSeek returned empty vision response");
     }
@@ -286152,7 +287295,7 @@ ${base2}`;
     return base2;
   }
 }
-function extractText(body) {
+function extractText2(body) {
   return (body.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
 `);
 }
@@ -307248,7 +308391,7 @@ async function uploadBlobInternal(file, uploadUrl, apiClient, httpOptions) {
         break;
       }
       retryCount++;
-      await sleep2(currentDelayMs);
+      await sleep3(currentDelayMs);
       currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
     }
     offset += chunkSize;
@@ -307265,7 +308408,7 @@ async function getBlobStat(file) {
   const fileStat = { size: file.size, type: file.type };
   return fileStat;
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 
@@ -307445,7 +308588,7 @@ class NodeUploader {
             break;
           }
           retryCount++;
-          await sleep2(currentDelayMs);
+          await sleep3(currentDelayMs);
           currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
         }
         offset += bytesRead;
@@ -308630,8 +309773,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308658,8 +309801,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308693,8 +309836,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308719,8 +309862,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308851,8 +309994,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308879,8 +310022,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308959,8 +310102,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -308987,8 +310130,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309058,8 +310201,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309154,8 +310297,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309569,8 +310712,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309597,8 +310740,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309728,8 +310871,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309756,8 +310899,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309791,8 +310934,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309819,8 +310962,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309854,8 +310997,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -309891,8 +311034,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310037,8 +311180,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310065,8 +311208,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310147,8 +311290,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310175,8 +311318,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310210,8 +311353,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310238,8 +311381,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -310273,8 +311416,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a2 = params.config) === null || _a2 === undefined ? undefined : _a2.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311309,8 +312452,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a3 = params.config) === null || _a3 === undefined ? undefined : _a3.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311335,8 +312478,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311368,8 +312511,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a3 = params.config) === null || _a3 === undefined ? undefined : _a3.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311405,8 +312548,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a3 = params.config) === null || _a3 === undefined ? undefined : _a3.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311433,8 +312576,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_c = params.config) === null || _c === undefined ? undefined : _c.httpOptions,
           abortSignal: (_d = params.config) === null || _d === undefined ? undefined : _d.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311468,8 +312611,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a3 = params.config) === null || _a3 === undefined ? undefined : _a3.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -311505,8 +312648,8 @@ var init_node6 = __esm(() => {
           httpOptions: (_a3 = params.config) === null || _a3 === undefined ? undefined : _a3.httpOptions,
           abortSignal: (_b = params.config) === null || _b === undefined ? undefined : _b.abortSignal
         }).then((httpResponse) => {
-          return httpResponse.json().then((jsonResponse) => {
-            const response2 = jsonResponse;
+          return httpResponse.json().then((jsonResponse2) => {
+            const response2 = jsonResponse2;
             response2.sdkHttpResponse = {
               headers: httpResponse.headers
             };
@@ -313425,7 +314568,7 @@ class AccessService {
 var DEFAULT_PAIRING_EXPIRY_MS, MAX_PENDING_PER_INSTANCE = 3, PAIRING_CODE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", PAIRING_CODE_LENGTH = 6, PairingRequestExpiredError, PairingRequestConsumedError;
 var init_access = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_cache_keys();
   DEFAULT_PAIRING_EXPIRY_MS = 60 * 60 * 1000;
@@ -313774,7 +314917,7 @@ var log76;
 var init_agent_runner = __esm(() => {
   init_src();
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log76 = createLogger("agent-runner");
 });
@@ -314186,7 +315329,7 @@ class AgentTaskService {
 var log78;
 var init_agent_tasks = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log78 = createLogger("services:agent-tasks");
 });
@@ -314257,7 +315400,7 @@ class AgentService {
 }
 var init_agents = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -314318,7 +315461,7 @@ class AuditService {
 var log79;
 var init_audit = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log79 = createLogger("audit");
 });
@@ -314527,7 +315670,7 @@ class AutomationService {
 }
 var init_automations2 = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -315876,7 +317019,7 @@ class APIClient {
       const maxRetries = options.maxRetries ?? this.maxRetries;
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
-    await sleep3(timeoutMillis);
+    await sleep4(timeoutMillis);
     return this.makeRequest(options, retriesRemaining - 1);
   }
   calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
@@ -316056,7 +317199,7 @@ var __classPrivateFieldSet = function(receiver, state, value, kind2, f2) {
   }
 }, startsWithSchemeRegexp2, isAbsoluteURL2 = (url) => {
   return startsWithSchemeRegexp2.test(url);
-}, sleep3 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)), validatePositiveInteger2 = (name, n2) => {
+}, sleep4 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)), validatePositiveInteger2 = (name, n2) => {
   if (typeof n2 !== "number" || !Number.isInteger(n2)) {
     throw new GroqError(`${name} must be an integer`);
   }
@@ -316664,7 +317807,7 @@ function buildPrompt4(language, options, defaultPrompt, defaultGlossary) {
 
 `).slice(0, 4000);
 }
-function extractText2(content) {
+function extractText3(content) {
   let raw2 = "";
   if (typeof content === "string")
     raw2 = content;
@@ -316894,7 +318037,7 @@ var init_audio2 = __esm(() => {
           if (!response.ok)
             throw new Error(`OpenAI audio chat error (${response.status}): ${await response.text()}`);
           const data = await response.json();
-          return extractText2(data.choices?.[0]?.message?.content);
+          return extractText3(data.choices?.[0]?.message?.content);
         }, { timeoutMs: timeouts.audioTimeoutMs });
         return this.createSuccessResult(text3, "openai", model, language);
       } catch (error3) {
@@ -319224,7 +320367,7 @@ class APIClient2 {
       const maxRetries = options.maxRetries ?? this.maxRetries;
       timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
     }
-    await sleep4(timeoutMillis);
+    await sleep5(timeoutMillis);
     return this.makeRequest(options, retriesRemaining - 1);
   }
   calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
@@ -319431,7 +320574,7 @@ var __classPrivateFieldSet3 = function(receiver, state, value, kind3, f2) {
   }
 }, startsWithSchemeRegexp3, isAbsoluteURL3 = (url) => {
   return startsWithSchemeRegexp3.test(url);
-}, sleep4 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)), validatePositiveInteger3 = (name, n2) => {
+}, sleep5 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)), validatePositiveInteger3 = (name, n2) => {
   if (typeof n2 !== "number" || !Number.isInteger(n2)) {
     throw new OpenAIError(`${name} must be an integer`);
   }
@@ -322049,7 +323192,7 @@ var init_runs = __esm(() => {
                 }
               }
             }
-            await sleep4(sleepInterval);
+            await sleep5(sleepInterval);
             break;
           case "requires_action":
           case "incomplete":
@@ -322452,7 +323595,7 @@ var init_files3 = __esm(() => {
       const start = Date.now();
       let file = await this.retrieve(id);
       while (!file.status || !TERMINAL_STATES.has(file.status)) {
-        await sleep4(pollInterval);
+        await sleep5(pollInterval);
         file = await this.retrieve(id);
         if (Date.now() - start > maxWait) {
           throw new APIConnectionTimeoutError3({
@@ -323275,7 +324418,7 @@ var init_files4 = __esm(() => {
                 }
               }
             }
-            await sleep4(sleepInterval);
+            await sleep5(sleepInterval);
             break;
           case "failed":
           case "completed":
@@ -323363,7 +324506,7 @@ var init_file_batches = __esm(() => {
                 }
               }
             }
-            await sleep4(sleepInterval);
+            await sleep5(sleepInterval);
             break;
           case "failed":
           case "cancelled":
@@ -333712,7 +334855,7 @@ var init_service = __esm(() => {
 });
 
 // ../media-processing/src/index.ts
-var init_src6 = __esm(() => {
+var init_src7 = __esm(() => {
   init_service();
   init_processors();
   init_retry();
@@ -334085,7 +335228,7 @@ var log84, DEFAULT_MEDIA_PATH = "./data/media";
 var init_media_storage = __esm(() => {
   init_src2();
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_safe_media_fetch();
   log84 = createLogger("services:media-storage");
@@ -334681,8 +335824,8 @@ class BatchJobService {
 var log85, PROCESSABLE_CONTENT_TYPES;
 var init_batch_jobs = __esm(() => {
   init_src();
-  init_src5();
   init_src6();
+  init_src7();
   init_drizzle_orm();
   init_batch_pricing();
   init_media_storage();
@@ -335211,7 +336354,7 @@ class ChatService {
 var log86, ATTENTION_LABEL = "follow-up", GROUP_CHAT_TYPES;
 var init_chats = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log86 = createLogger("chats");
   GROUP_CHAT_TYPES = new Set(["group", "community"]);
@@ -335276,7 +336419,7 @@ class ConsumerOffsetService {
 var log87;
 var init_consumer_offsets = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log87 = createLogger("consumer-offsets");
 });
@@ -335336,7 +336479,7 @@ class ConversationService {
 var log88;
 var init_conversations = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log88 = createLogger("services:conversations");
 });
@@ -335560,7 +336703,7 @@ class DeadLetterService {
 var log89;
 var init_dead_letters = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log89 = createLogger("dead-letters");
 });
@@ -335817,7 +336960,7 @@ class EventOpsService {
 var log90;
 var init_event_ops = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log90 = createLogger("event-ops");
 });
@@ -335999,7 +337142,7 @@ class EventService {
 }
 var init_events2 = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -336272,7 +337415,7 @@ class FollowUpLifecycleService {
 var log91, TERMINAL_DISARM_REASONS, TERMINAL_OVERRIDE_PROTECTED;
 var init_follow_up_lifecycle = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log91 = createLogger("follow-up-lifecycle");
   TERMINAL_DISARM_REASONS = new Set([
@@ -336434,7 +337577,7 @@ class FollowUpSweeperService {
 var log92, STALE_PAUSE_MAX_AGE_MS, STALE_PAUSE_MIN_AGE_MS = 60000, STALE_PAUSE_MAX_PER_TICK = 100;
 var init_follow_up_sweeper = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log92 = createLogger("follow-up-sweeper");
   STALE_PAUSE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -336496,7 +337639,7 @@ class GenieHostsService {
 var log93;
 var init_genie_hosts = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log93 = createLogger("genie-hosts");
 });
@@ -336633,7 +337776,7 @@ class InstanceService {
 }
 var init_instances = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -337051,7 +338194,7 @@ class MessageService {
 var MEDIA_BADGES;
 var init_messages3 = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   MEDIA_BADGES = {
     image: "[Image]",
@@ -337215,7 +338358,7 @@ class PayloadStoreService {
 var log94;
 var init_payload_store2 = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log94 = createLogger("payload-store");
 });
@@ -337665,7 +338808,7 @@ class PersonService {
 }
 var init_persons = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -337687,7 +338830,7 @@ async function withIdempotency(db2, eventId, handler, fn) {
 var log95;
 var init_idempotency = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   log95 = createLogger("idempotency");
 });
 
@@ -338233,7 +339376,7 @@ function getPluginStorage(pluginId) {
 var log97, globalDb = null, storageInstances;
 var init_storage = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log97 = createLogger("api:storage");
   storageInstances = new Map;
@@ -338315,13 +339458,13 @@ async function loadChannelPlugins2(options) {
   const preRegistered = channelRegistry2.getAll();
   if (preRegistered.length > 0) {
     logger6.info("Using pre-registered channel plugins", { count: preRegistered.length });
-    for (const plugin7 of preRegistered) {
+    for (const plugin8 of preRegistered) {
       try {
-        const context20 = createPluginContext({ pluginId: plugin7.id, eventBus, db: db2 });
-        await channelRegistry2.initialize(plugin7.id, context20);
-        logger6.info(`Initialized channel: ${plugin7.id}`, { name: plugin7.name, version: plugin7.version });
+        const context20 = createPluginContext({ pluginId: plugin8.id, eventBus, db: db2 });
+        await channelRegistry2.initialize(plugin8.id, context20);
+        logger6.info(`Initialized channel: ${plugin8.id}`, { name: plugin8.name, version: plugin8.version });
       } catch (error3) {
-        logger6.error(`Failed to initialize channel: ${plugin7.id}`, { error: String(error3) });
+        logger6.error(`Failed to initialize channel: ${plugin8.id}`, { error: String(error3) });
       }
     }
     return {
@@ -338345,17 +339488,17 @@ async function loadChannelPlugins2(options) {
   for (const failure of discoveryResult.failed) {
     logger6.error("Failed to load plugin", { path: failure.path, error: failure.error });
   }
-  for (const plugin7 of discoveryResult.registered) {
+  for (const plugin8 of discoveryResult.registered) {
     try {
       const context20 = createPluginContext({
-        pluginId: plugin7.id,
+        pluginId: plugin8.id,
         eventBus,
         db: db2
       });
-      await channelRegistry2.initialize(plugin7.id, context20);
-      logger6.info(`Initialized channel: ${plugin7.id}`, { name: plugin7.name, version: plugin7.version });
+      await channelRegistry2.initialize(plugin8.id, context20);
+      logger6.info(`Initialized channel: ${plugin8.id}`, { name: plugin8.name, version: plugin8.version });
     } catch (error3) {
-      logger6.error(`Failed to initialize channel: ${plugin7.id}`, { error: String(error3) });
+      logger6.error(`Failed to initialize channel: ${plugin8.id}`, { error: String(error3) });
     }
   }
   return {
@@ -338650,11 +339793,11 @@ async function processSenderIdentity(services, payload, metadata, channel5) {
 }
 async function fetchAndUpdateProfile(services, channel5, instanceId, userId, identityId) {
   try {
-    const plugin7 = await getPlugin(channel5);
-    if (!plugin7 || !("fetchUserProfile" in plugin7))
+    const plugin8 = await getPlugin(channel5);
+    if (!plugin8 || !("fetchUserProfile" in plugin8))
       return;
-    const fetchProfile = plugin7.fetchUserProfile;
-    const profile = await fetchProfile.call(plugin7, instanceId, userId);
+    const fetchProfile = plugin8.fetchUserProfile;
+    const profile = await fetchProfile.call(plugin8, instanceId, userId);
     if (profile.avatarUrl || profile.bio || profile.platformData) {
       await services.persons.updateIdentityProfile(identityId, profile);
       log100.debug("Updated identity with profile data", {
@@ -339191,7 +340334,7 @@ function createSessionStorage(db2, providerId = "default", maxSessionAgeMs = DEF
 }
 var DEFAULT_MAX_SESSION_AGE_MS;
 var init_session_storage = __esm(() => {
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   DEFAULT_MAX_SESSION_AGE_MS = 4 * 60 * 60 * 1000;
 });
@@ -339316,11 +340459,11 @@ function activeProviderTraceContext() {
     traceState: spanContext.traceState?.serialize()
   };
 }
-function createPluginAckProvider(plugin7) {
-  if (!plugin7?.react || !plugin7?.unreact)
+function createPluginAckProvider(plugin8) {
+  if (!plugin8?.react || !plugin8?.unreact)
     return null;
-  const reactFn = plugin7.react.bind(plugin7);
-  const unreactFn = plugin7.unreact.bind(plugin7);
+  const reactFn = plugin8.react.bind(plugin8);
+  const unreactFn = plugin8.unreact.bind(plugin8);
   return {
     ack: (instanceId, chatId, messageId, emoji) => reactFn(instanceId, chatId, messageId, emoji),
     removeAck: (instanceId, chatId, messageId, emoji) => unreactFn(instanceId, chatId, messageId, emoji)
@@ -339451,23 +340594,23 @@ function determineChatType(chatId, channel5, rawPayload) {
 }
 async function sendTypingPresence(channel5, instanceId, chatId, state) {
   try {
-    const plugin7 = await getPlugin(channel5);
-    if (plugin7 && "sendTyping" in plugin7 && typeof plugin7.sendTyping === "function") {
+    const plugin8 = await getPlugin(channel5);
+    if (plugin8 && "sendTyping" in plugin8 && typeof plugin8.sendTyping === "function") {
       const duration = state === "composing" ? 30000 : 0;
-      await plugin7.sendTyping(instanceId, chatId, duration);
+      await plugin8.sendTyping(instanceId, chatId, duration);
     }
   } catch (error3) {
     log101.debug("Failed to send typing presence", { error: String(error3) });
   }
 }
 async function sendTextMessage5(channel5, instanceId, chatId, text3, messageFormatMode = "convert", replyTo, correlationId, senderAgentId) {
-  const plugin7 = await getPlugin(channel5);
-  if (!plugin7)
+  const plugin8 = await getPlugin(channel5);
+  if (!plugin8)
     throw new Error(`Channel plugin not found: ${channel5}`);
   const sanitized = sanitizeOutboundText(text3);
   if (!sanitized)
     return;
-  await plugin7.sendMessage(instanceId, {
+  await plugin8.sendMessage(instanceId, {
     to: chatId,
     content: { type: "text", text: sanitized },
     replyTo,
@@ -339492,12 +340635,12 @@ function resolveErrorHandoffMessage(env2 = process.env) {
   return env2.OMNI_AGENT_ERROR_HANDOFF_MESSAGE?.trim() || DEFAULT_ERROR_HANDOFF_MESSAGE;
 }
 async function triggerErrorHandoff(services, db2, channel5, instance4, chatId, message2) {
-  const plugin7 = await getPlugin(channel5);
-  if (plugin7?.capabilities?.canHandoff !== true)
+  const plugin8 = await getPlugin(channel5);
+  if (plugin8?.capabilities?.canHandoff !== true)
     return false;
   let sendResult;
   try {
-    sendResult = await plugin7.sendMessage(instance4.id, {
+    sendResult = await plugin8.sendMessage(instance4.id, {
       to: chatId,
       content: { type: "text", text: message2 },
       metadata: { isHandoff: true, motivoHandoff: "agent_dispatch_error" }
@@ -339555,7 +340698,7 @@ async function handleDispatchFailure(services, db2, channel5, instance4, chatId,
     return;
   await sendErrorFeedback(channel5, instance4.id, chatId, error3, resolveDispatchErrorMessage(null)).catch(() => {});
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function extractErrorFields(error3) {
@@ -339576,7 +340719,7 @@ function isTransientDispatchError(error3) {
 async function runWithTransientDispatchRetry(fn, context20, options = {}) {
   const delays = options.delaysMs ?? TRANSIENT_DISPATCH_RETRY_DELAYS_MS;
   const transient = options.isTransient ?? isTransientDispatchError;
-  const sleeper = options.sleeper ?? sleep5;
+  const sleeper = options.sleeper ?? sleep6;
   const logger7 = options.logger ?? log101;
   let lastError;
   for (let attempt = 0;attempt <= delays.length; attempt++) {
@@ -339736,7 +340879,7 @@ async function waitForRecord(fn, maxMs = 5000, pollMs = 250) {
     return result;
   const deadline = Date.now() + maxMs;
   while (Date.now() < deadline) {
-    await sleep5(pollMs);
+    await sleep6(pollMs);
     result = await fn();
     if (result)
       return result;
@@ -339912,7 +341055,7 @@ async function sendResponseParts(channel5, instanceId, chatId, parts, splitConfi
       const delay2 = calculateSplitDelay(splitConfig);
       if (delay2 > 0) {
         await sendTypingPresence(channel5, instanceId, chatId, "composing");
-        await sleep5(delay2);
+        await sleep6(delay2);
       }
     }
   }
@@ -339944,11 +341087,11 @@ async function collectProcessedMedia(services, instance4, messages4) {
 function extractQuotedProviderAliases(rawPayload) {
   if (!rawPayload)
     return [];
-  const messageObj = isRecord(rawPayload.messageobj) ? rawPayload.messageobj : undefined;
-  const replyContext = isRecord(messageObj?.replyContext) ? messageObj.replyContext : undefined;
-  const rawMessage = isRecord(messageObj?.raw) ? messageObj.raw : undefined;
-  const rawContext = isRecord(rawMessage?.context) ? rawMessage.context : undefined;
-  const topContext = isRecord(rawPayload.context) ? rawPayload.context : undefined;
+  const messageObj = isRecord2(rawPayload.messageobj) ? rawPayload.messageobj : undefined;
+  const replyContext = isRecord2(messageObj?.replyContext) ? messageObj.replyContext : undefined;
+  const rawMessage = isRecord2(messageObj?.raw) ? messageObj.raw : undefined;
+  const rawContext = isRecord2(rawMessage?.context) ? rawMessage.context : undefined;
+  const topContext = isRecord2(rawPayload.context) ? rawPayload.context : undefined;
   return uniqueNonEmpty([
     replyContext?.internalId,
     rawContext?.gsId,
@@ -339960,7 +341103,7 @@ function extractQuotedProviderAliases(rawPayload) {
 function extractInboundPlatformDate(rawPayload) {
   if (!rawPayload)
     return;
-  const messageObj = isRecord(rawPayload.messageobj) ? rawPayload.messageobj : undefined;
+  const messageObj = isRecord2(rawPayload.messageobj) ? rawPayload.messageobj : undefined;
   const timestamp3 = messageObj?.timestamp;
   if (typeof timestamp3 === "number" && Number.isFinite(timestamp3) && timestamp3 > 0) {
     return new Date(timestamp3 * 1000);
@@ -340098,11 +341241,11 @@ async function resolvePersonId(services, channel5, instanceId, senderId, metadat
     const identity = await services.persons.getIdentityByPlatformId(channel5, instanceId, senderId);
     if (identity?.personId)
       return identity.personId;
-    await sleep5(200);
+    await sleep6(200);
   }
   return;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function pickString(record, ...keys) {
@@ -340129,13 +341272,13 @@ function extractA2ACustomerContext(messages4, channel5) {
   if (channel5 !== "a2a")
     return;
   const rawPayload = messages4[0]?.payload.rawPayload;
-  if (!isRecord(rawPayload))
+  if (!isRecord2(rawPayload))
     return;
   const executionContext = rawPayload.omniExecutionContext;
-  if (!isRecord(executionContext))
+  if (!isRecord2(executionContext))
     return;
-  const customer = isRecord(executionContext.customer) ? executionContext.customer : {};
-  const identity = isRecord(executionContext.identity) ? executionContext.identity : {};
+  const customer = isRecord2(executionContext.customer) ? executionContext.customer : {};
+  const identity = isRecord2(executionContext.identity) ? executionContext.identity : {};
   return compactCustomerContext({
     ...customerContextFromRecord(customer),
     externalUserId: pickString(customer, "externalUserId", "external_user_id") ?? pickString(identity, "platformUserId", "userId")
@@ -340146,7 +341289,7 @@ async function resolveCustomerContext(services, personId, externalContext) {
   if (personId) {
     try {
       const person2 = await services.persons.getById(personId);
-      if (person2 && isRecord(person2.metadata)) {
+      if (person2 && isRecord2(person2.metadata)) {
         storedContext = customerContextFromRecord(person2.metadata);
       }
     } catch (error3) {
@@ -340218,11 +341361,11 @@ async function resolveStreamingCapabilities(services, instance4, channel5, chatI
     });
     return null;
   }
-  const plugin7 = await getPlugin(channel5);
-  if (!plugin7?.capabilities?.canStreamResponse || !plugin7.createStreamSender) {
+  const plugin8 = await getPlugin(channel5);
+  if (!plugin8?.capabilities?.canStreamResponse || !plugin8.createStreamSender) {
     log101.debug("Stream guard: channel does not support streaming", {
       channel: channel5,
-      canStream: plugin7?.capabilities?.canStreamResponse,
+      canStream: plugin8?.capabilities?.canStreamResponse,
       chatId
     });
     return null;
@@ -340238,7 +341381,7 @@ async function resolveStreamingCapabilities(services, instance4, channel5, chatI
   }
   return {
     provider,
-    createSender: plugin7.createStreamSender.bind(plugin7)
+    createSender: plugin8.createStreamSender.bind(plugin8)
   };
 }
 async function consumeStream(generator, sender, instanceId, chatId, traceId) {
@@ -340964,14 +342107,14 @@ async function processHistoryMessage2(msg, mediaService, reactFn, unreactFn) {
   return buildHistoryMediaResult(header, icon, contentType, processedContent, msg.content.caption, msg.content.text);
 }
 async function fetchAndProcessThreadHistory(services, instance4, channel5, chatId, threadId2) {
-  const plugin7 = await getPlugin(channel5);
-  if (!plugin7?.fetchHistory) {
+  const plugin8 = await getPlugin(channel5);
+  if (!plugin8?.fetchHistory) {
     log101.debug("Channel plugin does not support fetchHistory", { instanceId: instance4.id, channel: channel5 });
     return [];
   }
   let historyResult;
   try {
-    historyResult = await plugin7.fetchHistory(instance4.id, {
+    historyResult = await plugin8.fetchHistory(instance4.id, {
       channelId: chatId,
       threadId: threadId2,
       limit: 200
@@ -340995,8 +342138,8 @@ async function fetchAndProcessThreadHistory(services, instance4, channel5, chatI
       mediaService = createMediaProcessingService({ groqApiKey, openaiApiKey, geminiApiKey });
     }
   } catch {}
-  const boundReact = plugin7.react?.bind(plugin7);
-  const boundUnreact = plugin7.unreact?.bind(plugin7);
+  const boundReact = plugin8.react?.bind(plugin8);
+  const boundUnreact = plugin8.unreact?.bind(plugin8);
   const reactFn = boundReact ? (msgId, emoji) => boundReact(instance4.id, chatId, msgId, emoji) : null;
   const unreactFn = boundUnreact ? (msgId, emoji) => boundUnreact(instance4.id, chatId, msgId, emoji) : null;
   const CONCURRENCY = 5;
@@ -341142,10 +342285,10 @@ async function processAgentResponse(services, instance4, messages4, triggerType,
   const senderId = firstMessage.payload.from ?? "";
   const channel5 = firstMessage.metadata.channelType ?? instance4.channel;
   const traceId = firstMessage.metadata.traceId ?? "";
-  const plugin7 = await getPlugin(channel5) ?? null;
-  const ackProvider = createPluginAckProvider(plugin7);
+  const plugin8 = await getPlugin(channel5) ?? null;
+  const ackProvider = createPluginAckProvider(plugin8);
   const messageId = firstMessage.payload.externalId ?? "";
-  const ackHandle = startAck(plugin7, ackProvider, instance4.id, chatId, messageId, channel5, buildAckConfig(instance4));
+  const ackHandle = startAck(plugin8, ackProvider, instance4.id, chatId, messageId, channel5, buildAckConfig(instance4));
   const personId = await resolvePersonId(services, channel5, instance4.id, senderId, firstMessage.metadata.personId);
   if (!personId) {
     log101.warn("Could not resolve person ID, skipping agent", { instanceId: instance4.id, chatId, senderId });
@@ -342350,8 +343493,8 @@ var import_api32, log101, agentDispatchLimiter, _natsGenieProviderCtor, QUOTED_M
 var init_agent_dispatcher = __esm(() => {
   init_src2();
   init_src();
-  init_src5();
   init_src6();
+  init_src7();
   init_esm5();
   init_drizzle_orm();
   init_idempotency();
@@ -342364,7 +343507,7 @@ var init_agent_dispatcher = __esm(() => {
   init_message_debouncer();
   init_message_persistence();
   init_session_storage();
-  init_src6();
+  init_src7();
   import_api32 = __toESM(require_src(), 1);
   log101 = createLogger("agent-dispatcher");
   agentDispatchLimiter = new AgentDispatchLimiter(loadAgentDispatchLimiterConfig(process.env, log101), log101);
@@ -342501,7 +343644,7 @@ class ProviderService {
 }
 var init_providers2 = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_agent_dispatcher();
 });
@@ -342605,7 +343748,7 @@ class RouteResolver {
 var log102, UUID_RE2, NO_ROUTE;
 var init_route_resolver = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_index_min();
   log102 = createLogger("route-resolver");
@@ -342732,7 +343875,7 @@ class RouteService {
 }
 var init_routes = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -342908,7 +344051,7 @@ class SettingsService {
 var log103, DEFAULT_SETTINGS;
 var init_settings = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log103 = createLogger("settings");
   DEFAULT_SETTINGS = [
@@ -343365,7 +344508,7 @@ class SyncJobService {
 }
 var init_sync_jobs = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -343699,7 +344842,7 @@ class TurnService {
 var log104;
 var init_turns = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log104 = createLogger("turns");
 });
@@ -343811,7 +344954,7 @@ class WebhookService {
 var init_webhooks = __esm(() => {
   init_src();
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
 });
 
@@ -344493,8 +345636,8 @@ var import__package2, VERSION6, startTime2, healthRoutes, getHealth = async (c)
     }
     let connected = 0;
     if (channelRegistry2) {
-      for (const plugin7 of channelRegistry2.getAll()) {
-        connected += plugin7.getConnectedInstances().length;
+      for (const plugin8 of channelRegistry2.getAll()) {
+        connected += plugin8.getConnectedInstances().length;
       }
     }
     instanceStats = { total, active, connected, byChannel };
@@ -344518,7 +345661,7 @@ var import__package2, VERSION6, startTime2, healthRoutes, getHealth = async (c)
   return c.json(response, status === "healthy" ? 200 : 503);
 };
 var init_health2 = __esm(() => {
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_dist2();
   import__package2 = __toESM(require_package7(), 1);
@@ -344543,8 +345686,8 @@ var init_health2 = __esm(() => {
     } catch {}
     let instancesConnected = 0;
     if (channelRegistry2) {
-      for (const plugin7 of channelRegistry2.getAll()) {
-        instancesConnected += plugin7.getConnectedInstances().length;
+      for (const plugin8 of channelRegistry2.getAll()) {
+        instancesConnected += plugin8.getConnectedInstances().length;
       }
     }
     return c.json({
@@ -350253,7 +351396,7 @@ var init_dist6 = __esm(() => {
 });
 
 // ../api/src/services/a2a-discovery.ts
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringOverride(value) {
@@ -350262,10 +351405,10 @@ function stringOverride(value) {
 function stringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
 }
-function normalizeBaseUrl(baseUrl) {
+function normalizeBaseUrl2(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
 }
-function buildDefaultSkills(capabilities3) {
+function buildDefaultSkills2(capabilities3) {
   const skills = [
     {
       id: "messaging",
@@ -350300,9 +351443,9 @@ function buildDefaultSkills(capabilities3) {
 }
 function buildA2AAgentCard(params) {
   const { baseUrl, agent: agent3, instance: instance4 } = params;
-  const override = isRecord2(agent3.agentCard) ? agent3.agentCard : {};
+  const override = isRecord3(agent3.agentCard) ? agent3.agentCard : {};
   const capabilities3 = agent3.capabilities ?? [];
-  const endpointUrl = `${normalizeBaseUrl(baseUrl)}/a2a/${instance4.id}`;
+  const endpointUrl = `${normalizeBaseUrl2(baseUrl)}/a2a/${instance4.id}`;
   const card = {
     name: stringOverride(override.name) ?? agent3.name,
     description: stringOverride(override.description) ?? `Omni agent ${agent3.name}`,
@@ -350318,7 +351461,7 @@ function buildA2AAgentCard(params) {
       streaming: true,
       pushNotifications: false,
       extendedAgentCard: false,
-      ...isRecord2(override.capabilities) ? override.capabilities : {}
+      ...isRecord3(override.capabilities) ? override.capabilities : {}
     },
     extensions: Array.isArray(override.extensions) ? override.extensions : [
       {
@@ -350330,7 +351473,7 @@ function buildA2AAgentCard(params) {
     ],
     defaultInputModes: stringArray(override.defaultInputModes) ?? ["text/plain"],
     defaultOutputModes: stringArray(override.defaultOutputModes) ?? ["text/plain"],
-    skills: Array.isArray(override.skills) ? override.skills : buildDefaultSkills(capabilities3),
+    skills: Array.isArray(override.skills) ? override.skills : buildDefaultSkills2(capabilities3),
     securitySchemes: {
       bearerAuth: {
         httpAuthSecurityScheme: {
@@ -350346,14 +351489,14 @@ function buildA2AAgentCard(params) {
           description: "Legacy Omni API key header."
         }
       },
-      ...isRecord2(override.securitySchemes) ? override.securitySchemes : {}
+      ...isRecord3(override.securitySchemes) ? override.securitySchemes : {}
     },
     securityRequirements: [{ schemes: { bearerAuth: { list: [] } } }, { schemes: { apiKeyHeader: { list: [] } } }]
   };
-  const providerOverride = isRecord2(override.provider) ? override.provider : undefined;
+  const providerOverride = isRecord3(override.provider) ? override.provider : undefined;
   if (providerOverride)
     card.provider = providerOverride;
-  const metadataOverride = isRecord2(override.metadata) ? override.metadata : undefined;
+  const metadataOverride = isRecord3(override.metadata) ? override.metadata : undefined;
   if (metadataOverride)
     card.metadata = metadataOverride;
   const iconUrl = stringOverride(override.iconUrl);
@@ -350394,7 +351537,7 @@ async function listA2ADiscoverableAgents(params) {
       capabilities: agent3.capabilities,
       configured: Boolean(instance4),
       instanceId: instance4?.id ?? null,
-      endpointUrl: instance4 ? `${normalizeBaseUrl(baseUrl)}/a2a/${instance4.id}` : null,
+      endpointUrl: instance4 ? `${normalizeBaseUrl2(baseUrl)}/a2a/${instance4.id}` : null,
       parameters: {
         agentType: agent3.agentType,
         providerId: agent3.agentProviderId,
@@ -351507,9 +352650,9 @@ function isTrashEmojiOnly2(text3) {
 async function sendMessage(services, instanceId, chatId, text3) {
   const instance4 = await services.instances.getById(instanceId);
   const channel5 = instance4.channel;
-  const plugin7 = await getPlugin(channel5);
-  if (plugin7) {
-    await plugin7.sendMessage(instanceId, {
+  const plugin8 = await getPlugin(channel5);
+  if (plugin8) {
+    await plugin8.sendMessage(instanceId, {
       to: chatId,
       content: { type: "text", text: text3 }
     });
@@ -351687,7 +352830,7 @@ async function setupSessionCleaner(eventBus, services, db2) {
 var log107;
 var init_session_cleaner = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_idempotency();
   init_agent_dispatcher();
@@ -351745,8 +352888,8 @@ async function getPluginForInstance(services, channelRegistry2, instanceId, requ
       recoverable: false
     });
   }
-  const plugin7 = channelRegistry2.get(instance4.channel);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(instance4.channel);
+  if (!plugin8) {
     throw new OmniError({
       code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
       message: `No plugin found for channel: ${instance4.channel}`,
@@ -351754,7 +352897,7 @@ async function getPluginForInstance(services, channelRegistry2, instanceId, requ
       recoverable: false
     });
   }
-  if (requiredCapability && !plugin7.capabilities[requiredCapability]) {
+  if (requiredCapability && !plugin8.capabilities[requiredCapability]) {
     throw new OmniError({
       code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
       message: `Channel ${instance4.channel} does not support read receipts`,
@@ -351762,7 +352905,7 @@ async function getPluginForInstance(services, channelRegistry2, instanceId, requ
       recoverable: false
     });
   }
-  return { instance: instance4, plugin: plugin7 };
+  return { instance: instance4, plugin: plugin8 };
 }
 async function getLastMessageKey(services, chatId) {
   try {
@@ -351787,11 +352930,11 @@ async function applyChatModifyOnChannel(services, channelRegistry2, instanceId,
   if (!channelRegistry2)
     return;
   const instance4 = await services.instances.getById(instanceId);
-  const plugin7 = channelRegistry2.get(instance4.channel);
-  if (!plugin7)
+  const plugin8 = channelRegistry2.get(instance4.channel);
+  if (!plugin8)
     return;
-  if ("chatModifyAction" in plugin7 && typeof plugin7.chatModifyAction === "function") {
-    await plugin7.chatModifyAction(instanceId, chatExternalId, action, value, lastMessageKey);
+  if ("chatModifyAction" in plugin8 && typeof plugin8.chatModifyAction === "function") {
+    await plugin8.chatModifyAction(instanceId, chatExternalId, action, value, lastMessageKey);
   }
 }
 function resolveContactName2(chat2, contactNames) {
@@ -352163,12 +353306,12 @@ var init_chats2 = __esm(() => {
         recoverable: false
       });
     }
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
     const readReceiptMode = instance4.readReceipts ?? "on";
-    if ("markChatAsRead" in plugin7 && typeof plugin7.markChatAsRead === "function") {
-      await plugin7.markChatAsRead(instanceId, chat2.externalId, readReceiptMode);
-    } else if ("markAsRead" in plugin7 && typeof plugin7.markAsRead === "function") {
-      await plugin7.markAsRead(instanceId, chat2.externalId, ["all"], undefined, readReceiptMode);
+    if ("markChatAsRead" in plugin8 && typeof plugin8.markChatAsRead === "function") {
+      await plugin8.markChatAsRead(instanceId, chat2.externalId, readReceiptMode);
+    } else if ("markAsRead" in plugin8 && typeof plugin8.markAsRead === "function") {
+      await plugin8.markAsRead(instanceId, chat2.externalId, ["all"], undefined, readReceiptMode);
     } else {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
@@ -352223,8 +353366,8 @@ var init_chats2 = __esm(() => {
       });
     }
     const instance4 = await services.instances.getById(instanceId);
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -352232,7 +353375,7 @@ var init_chats2 = __esm(() => {
         recoverable: false
       });
     }
-    if (!("setDisappearing" in plugin7) || typeof plugin7.setDisappearing !== "function") {
+    if (!("setDisappearing" in plugin8) || typeof plugin8.setDisappearing !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Plugin ${instance4.channel} does not support disappearing messages`,
@@ -352241,7 +353384,7 @@ var init_chats2 = __esm(() => {
       });
     }
     const durationSeconds = DISAPPEARING_DURATIONS[duration] ?? 0;
-    await plugin7.setDisappearing(instanceId, chat2.externalId, durationSeconds);
+    await plugin8.setDisappearing(instanceId, chat2.externalId, durationSeconds);
     return c.json({
       success: true,
       data: {
@@ -352261,15 +353404,15 @@ var init_chats2 = __esm(() => {
     const services = c.get("services");
     const channelRegistry2 = c.get("channelRegistry");
     checkInstanceAccess(c.get("apiKey"), instanceId);
-    const { plugin: plugin7 } = await getPluginForInstance(services, channelRegistry2, instanceId);
-    if (!("fetchContacts" in plugin7) || typeof plugin7.fetchContacts !== "function") {
+    const { plugin: plugin8 } = await getPluginForInstance(services, channelRegistry2, instanceId);
+    if (!("fetchContacts" in plugin8) || typeof plugin8.fetchContacts !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: "Plugin does not support fetchContacts",
         recoverable: false
       });
     }
-    const pluginWithContacts = plugin7;
+    const pluginWithContacts = plugin8;
     const { contacts } = await pluginWithContacts.fetchContacts(instanceId);
     const contactNames = new Map;
     for (const contact of contacts) {
@@ -353028,7 +354171,7 @@ var init_follow_up3 = __esm(() => {
 var handoffsRoutes, listQuerySchema11;
 var init_handoffs = __esm(() => {
   init_dist6();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_dist2();
   init_zod();
@@ -354314,7 +355457,7 @@ function mapMessageTypeToContentType(messageType) {
 var log109, MAX_REPLAY_WINDOW_MS;
 var init_agent_replay = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log109 = createLogger("agent-replay");
   MAX_REPLAY_WINDOW_MS = 24 * 60 * 60 * 1000;
@@ -354471,9 +355614,9 @@ function buildInstanceConnectionOptions(input) {
 function getPluginFromRegistry(channelRegistry2, channel5) {
   return channelRegistry2?.get(channel5);
 }
-async function connectInstanceWithPlugin(plugin7, instanceId, options) {
+async function connectInstanceWithPlugin(plugin8, instanceId, options) {
   try {
-    await plugin7.connect(instanceId, {
+    await plugin8.connect(instanceId, {
       instanceId,
       credentials: {},
       options
@@ -354484,12 +355627,12 @@ async function connectInstanceWithPlugin(plugin7, instanceId, options) {
   }
 }
 async function triggerCreateConnection(channelRegistry2, channel5, instanceId, options) {
-  const plugin7 = getPluginFromRegistry(channelRegistry2, channel5);
-  if (!plugin7) {
+  const plugin8 = getPluginFromRegistry(channelRegistry2, channel5);
+  if (!plugin8) {
     log110.warn("No plugin found for channel", { channel: channel5 });
     return;
   }
-  const errorMessage = await connectInstanceWithPlugin(plugin7, instanceId, options);
+  const errorMessage = await connectInstanceWithPlugin(plugin8, instanceId, options);
   if (errorMessage) {
     log110.error("Failed to connect instance", { instanceId, error: errorMessage });
     return;
@@ -354586,9 +355729,9 @@ function buildConnectConnectionOptions(instance4, body, forceNewQr) {
     twilioValidateSignature: body.twilioValidateSignature ?? instance4.twilioValidateSignature
   });
 }
-function hydrateConnectionOptionsForInstance(plugin7, instance4, options) {
-  if ("loadGuildConfigs" in plugin7 && instance4.guildConfigOverrides) {
-    plugin7.loadGuildConfigs(instance4.id, instance4.guildConfigOverrides);
+function hydrateConnectionOptionsForInstance(plugin8, instance4, options) {
+  if ("loadGuildConfigs" in plugin8 && instance4.guildConfigOverrides) {
+    plugin8.loadGuildConfigs(instance4.id, instance4.guildConfigOverrides);
   }
   if (instance4.discordPresence) {
     options.presence = instance4.discordPresence;
@@ -354658,15 +355801,15 @@ async function resolveInstancePlugin(services, channelRegistry2, instanceId) {
   if (!channelRegistry2) {
     return { ok: false, status: 503, error: { code: "NO_REGISTRY", message: "Channel registry not available" } };
   }
-  const plugin7 = channelRegistry2.get(instance4.channel);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(instance4.channel);
+  if (!plugin8) {
     return {
       ok: false,
       status: 400,
       error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` }
     };
   }
-  return { ok: true, plugin: plugin7 };
+  return { ok: true, plugin: plugin8 };
 }
 function participantUpdateResponse(result) {
   return {
@@ -354869,12 +356012,12 @@ var init_instances3 = __esm(() => {
   instancesRoutes.get("/supported-channels", async (c) => {
     const channelRegistry2 = c.get("channelRegistry");
     const loadedPlugins = channelRegistry2 ? channelRegistry2.getAll() : [];
-    const loadedChannels = loadedPlugins.map((plugin7) => ({
-      id: plugin7.id,
-      name: plugin7.name,
-      version: plugin7.version,
+    const loadedChannels = loadedPlugins.map((plugin8) => ({
+      id: plugin8.id,
+      name: plugin8.name,
+      version: plugin8.version,
       loaded: true,
-      capabilities: plugin7.capabilities
+      capabilities: plugin8.capabilities
     }));
     const loadedIds = new Set(loadedPlugins.map((p2) => p2.id));
     const staticChannels = [
@@ -354997,18 +356140,18 @@ var init_instances3 = __esm(() => {
     const services = c.get("services");
     const channelRegistry2 = c.get("channelRegistry");
     const instance4 = await services.instances.getById(id);
-    const plugin7 = channelRegistry2?.get(instance4.channel);
-    if (plugin7) {
+    const plugin8 = channelRegistry2?.get(instance4.channel);
+    if (plugin8) {
       try {
-        await plugin7.disconnect(id);
+        await plugin8.disconnect(id);
       } catch (error3) {
         log110.error("Failed to disconnect instance before delete", { instanceId: id, error: String(error3) });
       }
     }
     await services.instances.delete(id);
-    if (plugin7 && "logout" in plugin7 && typeof plugin7.logout === "function") {
+    if (plugin8 && "logout" in plugin8 && typeof plugin8.logout === "function") {
       try {
-        await plugin7.logout(id);
+        await plugin8.logout(id);
       } catch (error3) {
         log110.error("Failed to clear channel auth after delete", { instanceId: id, error: String(error3) });
       }
@@ -355023,10 +356166,10 @@ var init_instances3 = __esm(() => {
     let connectionState = "unknown";
     let statusMessage;
     if (channelRegistry2) {
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (plugin7) {
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (plugin8) {
         try {
-          const status = await plugin7.getStatus(id);
+          const status = await plugin8.getStatus(id);
           connectionState = status.state;
           statusMessage = status.message;
         } catch {
@@ -355088,15 +356231,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("requestPairingCode" in plugin7)) {
+    if (!("requestPairingCode" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "This plugin does not support pairing codes" } }, 400);
     }
     try {
-      const code = await plugin7.requestPairingCode(id, phoneNumber);
+      const code = await plugin8.requestPairingCode(id, phoneNumber);
       const formattedCode = code.length === 8 ? `${code.slice(0, 4)}-${code.slice(4)}` : code;
       return c.json({
         data: {
@@ -355140,12 +356283,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = getPluginFromRegistry(channelRegistry2, instance4.channel);
-    if (!plugin7) {
+    const plugin8 = getPluginFromRegistry(channelRegistry2, instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    hydrateConnectionOptionsForInstance(plugin7, instance4, connectionOptions);
-    const errorMessage = await connectInstanceWithPlugin(plugin7, id, connectionOptions);
+    hydrateConnectionOptionsForInstance(plugin8, instance4, connectionOptions);
+    const errorMessage = await connectInstanceWithPlugin(plugin8, id, connectionOptions);
     if (errorMessage) {
       return c.json({
         error: {
@@ -355169,10 +356312,10 @@ var init_instances3 = __esm(() => {
     const channelRegistry2 = c.get("channelRegistry");
     const instance4 = await services.instances.getById(id);
     if (channelRegistry2) {
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (plugin7) {
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (plugin8) {
         try {
-          await plugin7.disconnect(id);
+          await plugin8.disconnect(id);
         } catch (error3) {
           log110.error("Failed to disconnect instance", { instanceId: id, error: String(error3) });
         }
@@ -355190,12 +356333,12 @@ var init_instances3 = __esm(() => {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
     const instance4 = await services.instances.getById(id);
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
     try {
-      await plugin7.disconnect(id);
+      await plugin8.disconnect(id);
       const restartOptions = { forceNewQr };
       const restartToken = persistedTokenForChannel(instance4);
       if (restartToken)
@@ -355226,7 +356369,7 @@ var init_instances3 = __esm(() => {
           markOnlineOnConnect: instance4.markOnlineOnConnect
         };
       }
-      await plugin7.connect(id, { instanceId: id, credentials: {}, options: restartOptions });
+      await plugin8.connect(id, { instanceId: id, credentials: {}, options: restartOptions });
     } catch (error3) {
       return c.json({
         error: {
@@ -355249,16 +356392,16 @@ var init_instances3 = __esm(() => {
     const channelRegistry2 = c.get("channelRegistry");
     const instance4 = await services.instances.getById(id);
     if (channelRegistry2) {
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (plugin7 && "logout" in plugin7 && typeof plugin7.logout === "function") {
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (plugin8 && "logout" in plugin8 && typeof plugin8.logout === "function") {
         try {
-          await plugin7.logout(id);
+          await plugin8.logout(id);
         } catch (error3) {
           log110.error("Failed to logout instance", { instanceId: id, error: String(error3) });
         }
-      } else if (plugin7) {
+      } else if (plugin8) {
         try {
-          await plugin7.disconnect(id);
+          await plugin8.disconnect(id);
         } catch (error3) {
           log110.error("Failed to disconnect instance during logout", { instanceId: id, error: String(error3) });
         }
@@ -355285,15 +356428,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("getProfile" in plugin7) || typeof plugin7.getProfile !== "function") {
+    if (!("getProfile" in plugin8) || typeof plugin8.getProfile !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support profile sync` } }, 400);
     }
     try {
-      const profile = await plugin7.getProfile(id);
+      const profile = await plugin8.getProfile(id);
       const updated = await services.instances.update(id, {
         profileName: profile.name,
         profilePicUrl: profile.avatarUrl,
@@ -355324,12 +356467,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("updateProfileName" in plugin7) || typeof plugin7.updateProfileName !== "function") {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("updateProfileName" in plugin8) || typeof plugin8.updateProfileName !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support profile name update" } }, 400);
     }
     try {
-      await plugin7.updateProfileName(id, name);
+      await plugin8.updateProfileName(id, name);
       await services.instances.update(id, { profileName: name });
       return c.json({ success: true, data: { instanceId: id, action: "profile_name_updated", name } });
     } catch (error3) {
@@ -355347,11 +356490,11 @@ var init_instances3 = __esm(() => {
       if (!channelRegistry2) {
         return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
       }
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (!plugin7 || !("getProfile" in plugin7)) {
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (!plugin8 || !("getProfile" in plugin8)) {
         return c.json({ error: { code: "NOT_SUPPORTED", message: "Profile sync not supported" } }, 400);
       }
-      const profile = await plugin7.getProfile(id);
+      const profile = await plugin8.getProfile(id);
       const updated = await services.instances.update(id, {
         profileName: profile.name,
         profilePicUrl: profile.avatarUrl,
@@ -355463,17 +356606,17 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("fetchUserProfile" in plugin7) || typeof plugin7.fetchUserProfile !== "function") {
+    if (!("fetchUserProfile" in plugin8) || typeof plugin8.fetchUserProfile !== "function") {
       return c.json({
         error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support user profile fetching` }
       }, 400);
     }
     try {
-      const profile = await plugin7.fetchUserProfile(id, userId);
+      const profile = await plugin8.fetchUserProfile(id, userId);
       return c.json({
         data: {
           platformUserId: userId,
@@ -355505,11 +356648,11 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("fetchContacts" in plugin7) || typeof plugin7.fetchContacts !== "function") {
+    if (!("fetchContacts" in plugin8) || typeof plugin8.fetchContacts !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support contacts fetching` } }, 400);
     }
     try {
@@ -355521,7 +356664,7 @@ var init_instances3 = __esm(() => {
         fetchOptions.guildId = guildId;
         fetchOptions.limit = limit2;
       }
-      const result = await plugin7.fetchContacts(id, fetchOptions);
+      const result = await plugin8.fetchContacts(id, fetchOptions);
       if (result.contacts.length > 0) {
         await enrichContactNames(result.contacts, services, id);
         let filtered = result.contacts;
@@ -355587,15 +356730,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("fetchGroups" in plugin7) || typeof plugin7.fetchGroups !== "function") {
+    if (!("fetchGroups" in plugin8) || typeof plugin8.fetchGroups !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support groups fetching` } }, 400);
     }
     try {
-      const result = await plugin7.fetchGroups(id, {});
+      const result = await plugin8.fetchGroups(id, {});
       let filtered = result.groups;
       if (search) {
         const q = search.toLowerCase();
@@ -355634,15 +356777,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("fetchGroupMembers" in plugin7) || typeof plugin7.fetchGroupMembers !== "function") {
+    if (!("fetchGroupMembers" in plugin8) || typeof plugin8.fetchGroupMembers !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support group member listing` } }, 501);
     }
     try {
-      const result = await plugin7.fetchGroupMembers(id, jid);
+      const result = await plugin8.fetchGroupMembers(id, jid);
       return c.json({ members: result.members });
     } catch (error3) {
       const message2 = `Failed to fetch group members: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355661,15 +356804,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("checkNumber" in plugin7) || typeof plugin7.checkNumber !== "function") {
+    if (!("checkNumber" in plugin8) || typeof plugin8.checkNumber !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support number checking` } }, 400);
     }
     try {
-      const results = await plugin7.checkNumber(id, phones);
+      const results = await plugin8.checkNumber(id, phones);
       return c.json({ data: { results } });
     } catch (error3) {
       const message2 = `Failed to check numbers: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355688,15 +356831,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("updateBio" in plugin7) || typeof plugin7.updateBio !== "function") {
+    if (!("updateBio" in plugin8) || typeof plugin8.updateBio !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support bio updates` } }, 400);
     }
     try {
-      await plugin7.updateBio(id, status);
+      await plugin8.updateBio(id, status);
       return c.json({ success: true, data: { status } });
     } catch (error3) {
       const message2 = `Failed to update bio: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355715,15 +356858,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("blockContact" in plugin7) || typeof plugin7.blockContact !== "function") {
+    if (!("blockContact" in plugin8) || typeof plugin8.blockContact !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support blocking` } }, 400);
     }
     try {
-      await plugin7.blockContact(id, contactId);
+      await plugin8.blockContact(id, contactId);
       return c.json({ success: true, data: { contactId, action: "blocked" } });
     } catch (error3) {
       const message2 = `Failed to block contact: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355739,15 +356882,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("unblockContact" in plugin7) || typeof plugin7.unblockContact !== "function") {
+    if (!("unblockContact" in plugin8) || typeof plugin8.unblockContact !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support unblocking` } }, 400);
     }
     try {
-      await plugin7.unblockContact(id, contactId);
+      await plugin8.unblockContact(id, contactId);
       return c.json({ success: true, data: { contactId, action: "unblocked" } });
     } catch (error3) {
       const message2 = `Failed to unblock contact: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355762,15 +356905,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: `No plugin for channel: ${instance4.channel}` } }, 400);
     }
-    if (!("fetchBlocklist" in plugin7) || typeof plugin7.fetchBlocklist !== "function") {
+    if (!("fetchBlocklist" in plugin8) || typeof plugin8.fetchBlocklist !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: `Plugin ${instance4.channel} does not support blocklist` } }, 400);
     }
     try {
-      const blocklist = await plugin7.fetchBlocklist(id);
+      const blocklist = await plugin8.fetchBlocklist(id);
       return c.json({ data: { blocklist, count: blocklist.length } });
     } catch (error3) {
       const message2 = `Failed to fetch blocklist: ${error3 instanceof Error ? error3.message : "Unknown error"}`;
@@ -355786,13 +356929,13 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("updateProfilePicture" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("updateProfilePicture" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support profile picture update" } }, 400);
     }
     try {
       const imageBuffer = Buffer.from(base64, "base64");
-      await plugin7.updateProfilePicture(id, imageBuffer);
+      await plugin8.updateProfilePicture(id, imageBuffer);
       return c.json({ success: true, data: { instanceId: id, action: "profile_picture_updated" } });
     } catch (error3) {
       const message2 = error3 instanceof Error ? error3.message : "Unknown error";
@@ -355807,12 +356950,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("removeProfilePicture" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("removeProfilePicture" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support profile picture removal" } }, 400);
     }
     try {
-      await plugin7.removeProfilePicture(id);
+      await plugin8.removeProfilePicture(id);
       return c.json({ success: true, data: { instanceId: id, action: "profile_picture_removed" } });
     } catch (error3) {
       const message2 = error3 instanceof Error ? error3.message : "Unknown error";
@@ -355855,11 +356998,11 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("groupCreate" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("groupCreate" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support group creation" } }, 400);
     }
-    const result = await plugin7.groupCreate(id, subject, participants);
+    const result = await plugin8.groupCreate(id, subject, participants);
     return c.json({ data: result }, 201);
   });
   instancesRoutes.post("/:id/groups/:groupJid/participants", instanceAccess2, zValidator("json", groupParticipantsSchema), async (c) => {
@@ -356083,13 +357226,13 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin not available" } }, 400);
     }
-    if ("getGroupInviteCode" in plugin7) {
+    if ("getGroupInviteCode" in plugin8) {
       try {
-        const code = await plugin7.getGroupInviteCode(id, chatId);
+        const code = await plugin8.getGroupInviteCode(id, chatId);
         return c.json({
           data: {
             chatId,
@@ -356102,9 +357245,9 @@ var init_instances3 = __esm(() => {
         return c.json({ error: { code: "INVITE_FAILED", message: message2 } }, 500);
       }
     }
-    if ("exportChatInviteLink" in plugin7) {
+    if ("exportChatInviteLink" in plugin8) {
       try {
-        const inviteLink = await plugin7.exportChatInviteLink(id, chatId);
+        const inviteLink = await plugin8.exportChatInviteLink(id, chatId);
         return c.json({
           data: {
             chatId,
@@ -356127,12 +357270,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("getGroupInviteCode" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("getGroupInviteCode" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support group invites" } }, 400);
     }
     try {
-      const code = await plugin7.getGroupInviteCode(id, groupJid);
+      const code = await plugin8.getGroupInviteCode(id, groupJid);
       return c.json({
         data: {
           groupJid,
@@ -356154,12 +357297,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("revokeGroupInvite" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("revokeGroupInvite" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support group invite revocation" } }, 400);
     }
     try {
-      const newCode = await plugin7.revokeGroupInvite(id, groupJid);
+      const newCode = await plugin8.revokeGroupInvite(id, groupJid);
       return c.json({
         data: {
           groupJid,
@@ -356181,12 +357324,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("joinGroup" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("joinGroup" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support joining groups" } }, 400);
     }
     try {
-      const groupJid = await plugin7.joinGroup(id, code);
+      const groupJid = await plugin8.joinGroup(id, code);
       return c.json({ data: { groupJid, joined: true } });
     } catch (error3) {
       const message2 = error3 instanceof Error ? error3.message : "Unknown error";
@@ -356203,12 +357346,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("updateGroupPicture" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("updateGroupPicture" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support group picture update" } }, 400);
     }
     const imageBuffer = Buffer.from(base64, "base64");
-    await plugin7.updateGroupPicture(id, groupJid, imageBuffer);
+    await plugin8.updateGroupPicture(id, groupJid, imageBuffer);
     return c.json({ success: true, data: { instanceId: id, groupJid, action: "group_picture_updated" } });
   });
   instancesRoutes.get("/:id/privacy", instanceAccess2, async (c) => {
@@ -356219,12 +357362,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("fetchPrivacySettings" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("fetchPrivacySettings" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support privacy settings" } }, 400);
     }
     try {
-      const settings = await plugin7.fetchPrivacySettings(id);
+      const settings = await plugin8.fetchPrivacySettings(id);
       return c.json({ data: settings });
     } catch (error3) {
       const message2 = error3 instanceof Error ? error3.message : "Unknown error";
@@ -356243,12 +357386,12 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7 || !("rejectCall" in plugin7)) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8 || !("rejectCall" in plugin8)) {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support call rejection" } }, 400);
     }
     try {
-      await plugin7.rejectCall(id, callId, callFrom);
+      await plugin8.rejectCall(id, callId, callFrom);
       return c.json({ success: true, data: { callId, callFrom, rejected: true } });
     } catch (error3) {
       const message2 = error3 instanceof Error ? error3.message : "Unknown error";
@@ -356477,9 +357620,9 @@ var init_instances3 = __esm(() => {
     invalidateGuildCache(id, guildId);
     const channelRegistry2 = c.get("channelRegistry");
     if (channelRegistry2) {
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (plugin7 && "setGuildConfig" in plugin7) {
-        plugin7.setGuildConfig(id, guildId, newConfig);
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (plugin8 && "setGuildConfig" in plugin8) {
+        plugin8.setGuildConfig(id, guildId, newConfig);
       }
     }
     log110.info("Guild config updated", {
@@ -356506,9 +357649,9 @@ var init_instances3 = __esm(() => {
     invalidateGuildCache(id, guildId);
     const channelRegistry2 = c.get("channelRegistry");
     if (channelRegistry2) {
-      const plugin7 = channelRegistry2.get(instance4.channel);
-      if (plugin7 && "removeGuildConfig" in plugin7) {
-        plugin7.removeGuildConfig(id, guildId);
+      const plugin8 = channelRegistry2.get(instance4.channel);
+      if (plugin8 && "removeGuildConfig" in plugin8) {
+        plugin8.removeGuildConfig(id, guildId);
       }
     }
     log110.info("Guild config deleted", {
@@ -356543,15 +357686,15 @@ var init_instances3 = __esm(() => {
     if (!channelRegistry2) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry2.get("discord");
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get("discord");
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: "Discord plugin not loaded" } }, 400);
     }
-    if (!("setPresence" in plugin7) || typeof plugin7.setPresence !== "function") {
+    if (!("setPresence" in plugin8) || typeof plugin8.setPresence !== "function") {
       return c.json({ error: { code: "NOT_SUPPORTED", message: "Plugin does not support setPresence" } }, 400);
     }
     try {
-      await plugin7.setPresence(id, presenceData);
+      await plugin8.setPresence(id, presenceData);
       await services.instances.update(id, { discordPresence: presenceData });
       return c.json({ success: true, data: { instanceId: id, presence: presenceData } });
     } catch (error3) {
@@ -357899,8 +359042,8 @@ async function getPluginForInstance2(services, channelRegistry2, instanceId, req
       recoverable: false
     });
   }
-  const plugin7 = channelRegistry2.get(instance4.channel);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(instance4.channel);
+  if (!plugin8) {
     throw new OmniError({
       code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
       message: `No plugin found for channel: ${instance4.channel}`,
@@ -357908,7 +359051,7 @@ async function getPluginForInstance2(services, channelRegistry2, instanceId, req
       recoverable: false
     });
   }
-  if (requiredCapability && !plugin7.capabilities[requiredCapability]) {
+  if (requiredCapability && !plugin8.capabilities[requiredCapability]) {
     const capabilityNames = {
       canSendText: "sending text messages",
       canSendMedia: "sending media",
@@ -357927,7 +359070,7 @@ async function getPluginForInstance2(services, channelRegistry2, instanceId, req
       recoverable: false
     });
   }
-  return { instance: instance4, plugin: plugin7 };
+  return { instance: instance4, plugin: plugin8 };
 }
 async function getReplyContext(services, instanceId, chatExternalId, replyToId) {
   const chat2 = await services.chats.findByExternalIdSmart(instanceId, chatExternalId);
@@ -358054,8 +359197,8 @@ async function computeCloseContactTerminalState(db2, chatUuid, outcome, auditRow
   const closeUntil = cfg.cooldownMs !== null ? new Date(Date.now() + cfg.cooldownMs) : null;
   return { terminal: false, escalated: false, closeUntil };
 }
-function hasPresenceStatusSender(plugin7) {
-  return typeof plugin7 === "object" && plugin7 !== null && "sendPresenceStatus" in plugin7 && typeof plugin7.sendPresenceStatus === "function";
+function hasPresenceStatusSender(plugin8) {
+  return typeof plugin8 === "object" && plugin8 !== null && "sendPresenceStatus" in plugin8 && typeof plugin8.sendPresenceStatus === "function";
 }
 async function verifyMessageInstanceOwnership(services, message2, instanceId) {
   if (!message2.chatId)
@@ -358083,7 +359226,7 @@ var init_messages5 = __esm(() => {
   init_dist6();
   init_src2();
   init_src();
-  init_src5();
+  init_src6();
   init_esm5();
   init_drizzle_orm();
   init_dist2();
@@ -358525,7 +359668,7 @@ var init_messages5 = __esm(() => {
     if (correlationId && tracker.isTracking(correlationId)) {
       tracker.recordCheckpoint(correlationId, "T7", JOURNEY_STAGES.T7);
     }
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, c.get("channelRegistry"), instanceId, "canSendText");
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, c.get("channelRegistry"), instanceId, "canSendText");
     const resolvedTo = await resolveRecipient(to, instance4.channel, services);
     const replyContext = replyTo ? await getReplyContext(services, instanceId, resolvedTo, replyTo) : {};
     const outgoingMessage = {
@@ -358538,7 +359681,7 @@ var init_messages5 = __esm(() => {
     if (correlationId && tracker.isTracking(correlationId)) {
       tracker.recordCheckpoint(correlationId, "T8", JOURNEY_STAGES.T8);
     }
-    const result = await plugin7.sendMessage(instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(instanceId, outgoingMessage);
     handleSendResult(result, { channelType: instance4.channel, instanceId, operation: "send message" });
     if (sentryEnabled()) {
       exports_public_api2.count("messages.sent", 1, { attributes: { channel_type: instance4.channel } });
@@ -358578,8 +359721,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358587,7 +359730,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendMedia) {
+    if (!plugin8.capabilities.canSendMedia) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending media`,
@@ -358612,7 +359755,7 @@ var init_messages5 = __esm(() => {
     if (correlationId && tracker.isTracking(correlationId)) {
       tracker.recordCheckpoint(correlationId, "T8", JOURNEY_STAGES.T8);
     }
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -358658,8 +359801,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358667,7 +359810,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendReaction) {
+    if (!plugin8.capabilities.canSendReaction) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending reactions`,
@@ -358686,7 +359829,7 @@ var init_messages5 = __esm(() => {
       },
       metadata: reactionMetadata
     };
-    const result = await plugin7.sendMessage(instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -358724,8 +359867,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358733,7 +359876,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendSticker) {
+    if (!plugin8.capabilities.canSendSticker) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending stickers`,
@@ -358752,7 +359895,7 @@ var init_messages5 = __esm(() => {
         base64: data.base64
       }
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -358788,8 +359931,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358797,7 +359940,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendContact) {
+    if (!plugin8.capabilities.canSendContact) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending contacts`,
@@ -358813,7 +359956,7 @@ var init_messages5 = __esm(() => {
         contact: data.contact
       }
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -358849,8 +359992,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358858,7 +360001,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendLocation) {
+    if (!plugin8.capabilities.canSendLocation) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending locations`,
@@ -358879,7 +360022,7 @@ var init_messages5 = __esm(() => {
         }
       }
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -358916,8 +360059,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -358926,7 +360069,7 @@ var init_messages5 = __esm(() => {
       });
     }
     const resolvedTo = await resolveRecipient(data.to, instance4.channel, services);
-    const hasNativeHandoff = plugin7.capabilities?.canHandoff === true;
+    const hasNativeHandoff = plugin8.capabilities?.canHandoff === true;
     let channelSendResult = null;
     if (hasNativeHandoff) {
       const outgoingMessage = {
@@ -358939,7 +360082,7 @@ var init_messages5 = __esm(() => {
           handoffFields: data.handoffFields
         }
       };
-      channelSendResult = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+      channelSendResult = await plugin8.sendMessage(data.instanceId, outgoingMessage);
       handleSendResult(channelSendResult, {
         channelType: instance4.channel,
         instanceId: data.instanceId,
@@ -358994,8 +360137,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359004,7 +360147,7 @@ var init_messages5 = __esm(() => {
       });
     }
     const resolvedTo = await resolveRecipient(data.to, instance4.channel, services);
-    const hasNativeClose = plugin7.capabilities?.canCloseContact === true;
+    const hasNativeClose = plugin8.capabilities?.canCloseContact === true;
     const outcome = data.outcome;
     let channelSendResult = null;
     if (hasNativeClose) {
@@ -359018,7 +360161,7 @@ var init_messages5 = __esm(() => {
           closeFields: data.closeFields
         }
       };
-      channelSendResult = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+      channelSendResult = await plugin8.sendMessage(data.instanceId, outgoingMessage);
       handleSendResult(channelSendResult, {
         channelType: instance4.channel,
         instanceId: data.instanceId,
@@ -359107,7 +360250,7 @@ var init_messages5 = __esm(() => {
     const data = c.req.valid("json");
     const services = c.get("services");
     checkInstanceAccess2(c.get("apiKey"), data.instanceId);
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, c.get("channelRegistry"), data.instanceId, "canSendMedia");
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, c.get("channelRegistry"), data.instanceId, "canSendMedia");
     const resolvedTo = await resolveRecipient(data.to, instance4.channel, services);
     const ttsResult = await services.tts.synthesize(data.text, {
       voiceId: data.voiceId || instance4.ttsVoiceId || undefined,
@@ -359115,10 +360258,10 @@ var init_messages5 = __esm(() => {
       stability: data.stability,
       similarityBoost: data.similarityBoost
     });
-    if ("sendTyping" in plugin7 && typeof plugin7.sendTyping === "function") {
+    if ("sendTyping" in plugin8 && typeof plugin8.sendTyping === "function") {
       const presenceDuration = data.presenceDelay ?? Math.min(ttsResult.durationMs, 15000);
       try {
-        await plugin7.sendTyping(data.instanceId, resolvedTo, presenceDuration);
+        await plugin8.sendTyping(data.instanceId, resolvedTo, presenceDuration);
         if (presenceDuration > 0) {
           await new Promise((resolve4) => setTimeout(resolve4, presenceDuration));
         }
@@ -359135,7 +360278,7 @@ var init_messages5 = __esm(() => {
         ptt: true
       }
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -359181,8 +360324,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359190,7 +360333,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canForwardMessage) {
+    if (!plugin8.capabilities.canForwardMessage) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support forwarding messages`,
@@ -359239,7 +360382,7 @@ var init_messages5 = __esm(() => {
         }
       }
     };
-    const result = await plugin7.sendMessage(instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -359274,10 +360417,10 @@ var init_messages5 = __esm(() => {
     const { instanceId, to, type, duration, threadId: threadId2, status, loadingMessages } = c.req.valid("json");
     const services = c.get("services");
     checkInstanceAccess2(c.get("apiKey"), instanceId);
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, c.get("channelRegistry"), instanceId);
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, c.get("channelRegistry"), instanceId);
     const resolvedTo = await resolveRecipient(to, instance4.channel, services);
-    const canSendNativeTyping = plugin7.capabilities.canSendTyping === true;
-    const canSendThreadStatus = hasPresenceStatusSender(plugin7);
+    const canSendNativeTyping = plugin8.capabilities.canSendTyping === true;
+    const canSendThreadStatus = hasPresenceStatusSender(plugin8);
     if (!canSendNativeTyping && !canSendThreadStatus) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
@@ -359287,12 +360430,12 @@ var init_messages5 = __esm(() => {
       });
     }
     const effectiveDuration = type === "paused" ? 0 : duration ?? (canSendThreadStatus ? 0 : 5000);
-    const presenceResult = canSendThreadStatus ? await plugin7.sendPresenceStatus(instanceId, resolvedTo, type, effectiveDuration, {
+    const presenceResult = canSendThreadStatus ? await plugin8.sendPresenceStatus(instanceId, resolvedTo, type, effectiveDuration, {
       threadId: threadId2,
       status,
       loadingMessages
     }) : await (async () => {
-      if (!("sendTyping" in plugin7) || typeof plugin7.sendTyping !== "function") {
+      if (!("sendTyping" in plugin8) || typeof plugin8.sendTyping !== "function") {
         throw new OmniError({
           code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
           message: `Channel ${instance4.channel} plugin does not implement sendTyping`,
@@ -359300,7 +360443,7 @@ var init_messages5 = __esm(() => {
           recoverable: false
         });
       }
-      await plugin7.sendTyping(instanceId, resolvedTo, effectiveDuration);
+      await plugin8.sendTyping(instanceId, resolvedTo, effectiveDuration);
       return { delivered: true, method: "typing_indicator" };
     })();
     return c.json({
@@ -359343,8 +360486,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
-    if (!("markAsRead" in plugin7) || typeof plugin7.markAsRead !== "function") {
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
+    if (!("markAsRead" in plugin8) || typeof plugin8.markAsRead !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} plugin does not implement markAsRead`,
@@ -359354,7 +360497,7 @@ var init_messages5 = __esm(() => {
     }
     const messageData = [{ externalId: message2.externalId, rawPayload: message2.rawPayload ?? null }];
     const readReceiptMode = instance4.readReceipts ?? "on";
-    await plugin7.markAsRead(instanceId, chat2.externalId, [message2.externalId], messageData, readReceiptMode);
+    await plugin8.markAsRead(instanceId, chat2.externalId, [message2.externalId], messageData, readReceiptMode);
     return c.json({
       success: true,
       data: {
@@ -359369,8 +360512,8 @@ var init_messages5 = __esm(() => {
     const services = c.get("services");
     const channelRegistry2 = c.get("channelRegistry");
     checkInstanceAccess2(c.get("apiKey"), instanceId);
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
-    if (!("markAsRead" in plugin7) || typeof plugin7.markAsRead !== "function") {
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, channelRegistry2, instanceId, "canReceiveReadReceipts");
+    if (!("markAsRead" in plugin8) || typeof plugin8.markAsRead !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} plugin does not implement markAsRead`,
@@ -359405,7 +360548,7 @@ var init_messages5 = __esm(() => {
       messageData = msgs.map((m2) => ({ externalId: m2.externalId, rawPayload: m2.rawPayload ?? null }));
     }
     const readReceiptMode = instance4.readReceipts ?? "on";
-    await plugin7.markAsRead(instanceId, externalChatId, messageIds, messageData, readReceiptMode);
+    await plugin8.markAsRead(instanceId, externalChatId, messageIds, messageData, readReceiptMode);
     return c.json({
       success: true,
       data: {
@@ -359466,7 +360609,7 @@ var init_messages5 = __esm(() => {
     const data = c.req.valid("json");
     const services = c.get("services");
     checkInstanceAccess2(c.get("apiKey"), data.instanceId);
-    const { instance: instance4, plugin: plugin7 } = await getPluginForInstance2(services, c.get("channelRegistry"), data.instanceId, "canSendPoll");
+    const { instance: instance4, plugin: plugin8 } = await getPluginForInstance2(services, c.get("channelRegistry"), data.instanceId, "canSendPoll");
     const resolvedTo = await resolveRecipient(data.to, instance4.channel, services);
     const replyContext = data.replyTo ? await getReplyContext(services, data.instanceId, resolvedTo, data.replyTo) : {};
     const outgoingMessage = {
@@ -359483,7 +360626,7 @@ var init_messages5 = __esm(() => {
       },
       replyTo: data.replyTo
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     handleSendResult(result, { channelType: instance4.channel, instanceId: data.instanceId, operation: "send poll" });
     return c.json({ data: { messageId: result.messageId, status: "sent", timestamp: result.timestamp } }, 201);
   });
@@ -359500,8 +360643,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359509,7 +360652,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canSendEmbed) {
+    if (!plugin8.capabilities.canSendEmbed) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support sending embeds`,
@@ -359554,7 +360697,7 @@ var init_messages5 = __esm(() => {
       },
       replyTo: data.replyTo
     };
-    const result = await plugin7.sendMessage(data.instanceId, outgoingMessage);
+    const result = await plugin8.sendMessage(data.instanceId, outgoingMessage);
     if (!result.success) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_SEND_FAILED,
@@ -359589,8 +360732,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359598,7 +360741,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canEditMessage) {
+    if (!plugin8.capabilities.canEditMessage) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support editing messages`,
@@ -359606,7 +360749,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!("editMessage" in plugin7) || typeof plugin7.editMessage !== "function") {
+    if (!("editMessage" in plugin8) || typeof plugin8.editMessage !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} plugin does not implement editMessage`,
@@ -359616,7 +360759,7 @@ var init_messages5 = __esm(() => {
     }
     const resolvedMessageId = await resolveChannelMessageId(services, messageId, instanceId);
     try {
-      await plugin7.editMessage(instanceId, channelId, resolvedMessageId, text3);
+      await plugin8.editMessage(instanceId, channelId, resolvedMessageId, text3);
     } catch (error3) {
       if (error3 instanceof OmniError)
         throw error3;
@@ -359645,8 +360788,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359654,7 +360797,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!plugin7.capabilities.canDeleteMessage) {
+    if (!plugin8.capabilities.canDeleteMessage) {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support deleting messages`,
@@ -359662,7 +360805,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!("deleteMessage" in plugin7) || typeof plugin7.deleteMessage !== "function") {
+    if (!("deleteMessage" in plugin8) || typeof plugin8.deleteMessage !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} plugin does not implement deleteMessage`,
@@ -359671,7 +360814,7 @@ var init_messages5 = __esm(() => {
       });
     }
     const resolvedMessageId = await resolveChannelMessageId(services, messageId, instanceId);
-    await plugin7.deleteMessage(instanceId, channelId, resolvedMessageId, fromMe);
+    await plugin8.deleteMessage(instanceId, channelId, resolvedMessageId, fromMe);
     return c.json({
       success: true,
       data: { messageId, externalId: resolvedMessageId, deleted: true }
@@ -359696,8 +360839,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359705,7 +360848,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!("starMessage" in plugin7) || typeof plugin7.starMessage !== "function") {
+    if (!("starMessage" in plugin8) || typeof plugin8.starMessage !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support starring messages`,
@@ -359713,7 +360856,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    await plugin7.starMessage(instanceId, channelId, messageId, true, fromMe);
+    await plugin8.starMessage(instanceId, channelId, messageId, true, fromMe);
     return c.json({
       success: true,
       data: { messageId, starred: true }
@@ -359733,8 +360876,8 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    const plugin7 = channelRegistry2.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = channelRegistry2.get(instance4.channel);
+    if (!plugin8) {
       throw new OmniError({
         code: ERROR_CODES.CHANNEL_NOT_CONNECTED,
         message: `No plugin found for channel: ${instance4.channel}`,
@@ -359742,7 +360885,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    if (!("starMessage" in plugin7) || typeof plugin7.starMessage !== "function") {
+    if (!("starMessage" in plugin8) || typeof plugin8.starMessage !== "function") {
       throw new OmniError({
         code: ERROR_CODES.CAPABILITY_NOT_SUPPORTED,
         message: `Channel ${instance4.channel} does not support starring messages`,
@@ -359750,7 +360893,7 @@ var init_messages5 = __esm(() => {
         recoverable: false
       });
     }
-    await plugin7.starMessage(instanceId, channelId, messageId, false, fromMe);
+    await plugin8.starMessage(instanceId, channelId, messageId, false, fromMe);
     return c.json({
       success: true,
       data: { messageId, starred: false }
@@ -360614,9 +361757,9 @@ var init_turns2 = __esm(() => {
 function findVoicePlugin(channelRegistry2) {
   if (!channelRegistry2)
     return null;
-  for (const plugin7 of channelRegistry2.getAll()) {
-    if (isVoiceCapable(plugin7))
-      return plugin7;
+  for (const plugin8 of channelRegistry2.getAll()) {
+    if (isVoiceCapable(plugin8))
+      return plugin8;
   }
   return null;
 }
@@ -360640,12 +361783,12 @@ var init_voice2 = __esm(() => {
   });
   voiceRoutes.post("/join", zValidator("json", joinSchema), async (c) => {
     const { instanceId, channelId, guildId } = c.req.valid("json");
-    const plugin7 = findVoicePlugin(c.get("channelRegistry"));
-    if (!plugin7) {
+    const plugin8 = findVoicePlugin(c.get("channelRegistry"));
+    if (!plugin8) {
       return c.json({ error: { code: "NOT_AVAILABLE", message: "No voice-capable channel plugin found" } }, 400);
     }
     try {
-      const session3 = await plugin7.voiceJoin(channelId, { instanceId, guildId });
+      const session3 = await plugin8.voiceJoin(channelId, { instanceId, guildId });
       const eventBus = c.get("eventBus");
       if (eventBus) {
         eventBus.publish("voice.session_started", { sessionId: session3.id, channelId, instanceId, guildId }).catch(() => {});
@@ -360666,12 +361809,12 @@ var init_voice2 = __esm(() => {
   });
   voiceRoutes.post("/leave", zValidator("json", leaveSchema), async (c) => {
     const { sessionId } = c.req.valid("json");
-    const plugin7 = findVoicePlugin(c.get("channelRegistry"));
-    if (!plugin7) {
+    const plugin8 = findVoicePlugin(c.get("channelRegistry"));
+    if (!plugin8) {
       return c.json({ error: { code: "NOT_AVAILABLE", message: "No voice-capable plugin" } }, 400);
     }
     try {
-      await plugin7.voiceLeave(sessionId);
+      await plugin8.voiceLeave(sessionId);
       const eventBus = c.get("eventBus");
       if (eventBus) {
         eventBus.publish("voice.session_ended", { sessionId, reason: "manual" }).catch(() => {});
@@ -360682,10 +361825,10 @@ var init_voice2 = __esm(() => {
     }
   });
   voiceRoutes.get("/sessions", async (c) => {
-    const plugin7 = findVoicePlugin(c.get("channelRegistry"));
-    if (!plugin7)
+    const plugin8 = findVoicePlugin(c.get("channelRegistry"));
+    if (!plugin8)
       return c.json({ items: [] });
-    const sessions = plugin7.voiceSessions().map((s) => ({
+    const sessions = plugin8.voiceSessions().map((s) => ({
       sessionId: s.id,
       instanceId: s.instanceId,
       channelId: s.channelId,
@@ -360697,11 +361840,11 @@ var init_voice2 = __esm(() => {
   });
   voiceRoutes.get("/sessions/:id", zValidator("param", sessionIdParamSchema), async (c) => {
     const { id } = c.req.valid("param");
-    const plugin7 = findVoicePlugin(c.get("channelRegistry"));
-    if (!plugin7) {
+    const plugin8 = findVoicePlugin(c.get("channelRegistry"));
+    if (!plugin8) {
       return c.json({ error: { code: "NOT_AVAILABLE", message: "No voice-capable plugin" } }, 400);
     }
-    const session3 = plugin7.voiceSession(id);
+    const session3 = plugin8.voiceSession(id);
     if (!session3) {
       return c.json({ error: { code: "NOT_FOUND", message: `Voice session ${id} not found` } }, 404);
     }
@@ -360978,8 +362121,8 @@ function createApp(db2, eventBus = null, channelRegistry2 = null) {
         return c.json(validationError.body, validationError.status);
       }
       const channelRegistry3 = c.get("channelRegistry");
-      const plugin7 = channelRegistry3?.get("a2a");
-      if (!plugin7?.handleWebhook) {
+      const plugin8 = channelRegistry3?.get("a2a");
+      if (!plugin8?.handleWebhook) {
         return c.json({ error: "A2A channel not available" }, 503);
       }
       const headers = new Headers(c.req.raw.headers);
@@ -360987,7 +362130,7 @@ function createApp(db2, eventBus = null, channelRegistry2 = null) {
       if (apiKey?.id) {
         headers.set("x-omni-api-key-id", apiKey.id);
       }
-      return plugin7.handleWebhook(new Request(c.req.raw, { headers }));
+      return plugin8.handleWebhook(new Request(c.req.raw, { headers }));
     });
   } else {
     app.all("/a2a/*", (c) => c.json({ error: "A2A channel not enabled. Set A2A_ENABLED=true." }, 503));
@@ -361000,11 +362143,11 @@ function createApp(db2, eventBus = null, channelRegistry2 = null) {
     if (!channelRegistry3) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry3.get("telegram");
-    if (!plugin7) {
+    const plugin8 = channelRegistry3.get("telegram");
+    if (!plugin8) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: "Telegram plugin not loaded" } }, 503);
     }
-    const telegramPlugin = plugin7;
+    const telegramPlugin = plugin8;
     const webhookSecret = telegramPlugin.getWebhookSecret(id);
     let authPassed = false;
     await createWebhookAuthMiddleware({ webhookSecret })(c, async () => {
@@ -361030,22 +362173,22 @@ function createApp(db2, eventBus = null, channelRegistry2 = null) {
     if (!channelRegistry3) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry3.get("gupshup");
-    if (!plugin7?.handleWebhook) {
+    const plugin8 = channelRegistry3.get("gupshup");
+    if (!plugin8?.handleWebhook) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: "Gupshup plugin not loaded" } }, 503);
     }
-    return plugin7.handleWebhook(c.req.raw);
+    return plugin8.handleWebhook(c.req.raw);
   });
   app.post("/api/v2/channels/twilio-whatsapp/:instanceId/webhook", async (c) => {
     const channelRegistry3 = c.get("channelRegistry");
     if (!channelRegistry3) {
       return c.json({ error: { code: "NO_REGISTRY", message: "Channel registry not available" } }, 503);
     }
-    const plugin7 = channelRegistry3.get("twilio-whatsapp");
-    if (!plugin7?.handleWebhook) {
+    const plugin8 = channelRegistry3.get("twilio-whatsapp");
+    if (!plugin8?.handleWebhook) {
       return c.json({ error: { code: "PLUGIN_NOT_FOUND", message: "Twilio WhatsApp plugin not loaded" } }, 503);
     }
-    return plugin7.handleWebhook(c.req.raw);
+    return plugin8.handleWebhook(c.req.raw);
   });
   const protectedApp = new Hono2;
   protectedApp.use("*", authMiddleware);
@@ -361304,7 +362447,7 @@ async function setupChatUnreadListener(eventBus, db2) {
 var instanceLog, messageLog, lidLog, contactsLog, unreadLog;
 var init_event_listeners = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_esm5();
   init_drizzle_orm();
   init_sentry_scrub();
@@ -361579,7 +362722,7 @@ async function setupEventPersistence(eventBus, db2) {
 var log113, CONSUMER_OPTIONS;
 var init_event_persistence = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log113 = createLogger("event-persistence");
   CONSUMER_OPTIONS = {
@@ -361975,8 +363118,8 @@ async function setupMediaProcessor(eventBus, db2, services) {
 var log114, PROCESSABLE_MEDIA_TYPES;
 var init_media_processor = __esm(() => {
   init_src();
-  init_src5();
   init_src6();
+  init_src7();
   init_drizzle_orm();
   init_media_storage();
   log114 = createLogger("media-processor");
@@ -362157,13 +363300,13 @@ function buildAnchorsForExplicitChatJids(jobId, chatJids, dbAnchors) {
   }
   return anchors;
 }
-function hasKnownChatJids(plugin7) {
-  return typeof plugin7 === "object" && plugin7 !== null && "getKnownChatJids" in plugin7 && typeof plugin7.getKnownChatJids === "function";
+function hasKnownChatJids(plugin8) {
+  return typeof plugin8 === "object" && plugin8 !== null && "getKnownChatJids" in plugin8 && typeof plugin8.getKnownChatJids === "function";
 }
-async function discoverAnchorsFromPlugin(jobId, instanceId, plugin7, dbAnchors, services) {
+async function discoverAnchorsFromPlugin(jobId, instanceId, plugin8, dbAnchors, services) {
   const anchoredJids = new Set(dbAnchors.map((a) => a.chatJid));
   const dbExternalIds = await services.chats.getAllExternalIds(instanceId);
-  const baileysJids = hasKnownChatJids(plugin7) ? plugin7.getKnownChatJids(instanceId) : [];
+  const baileysJids = hasKnownChatJids(plugin8) ? plugin8.getKnownChatJids(instanceId) : [];
   const allJids = new Set([...dbExternalIds, ...baileysJids]);
   const discovered = [];
   for (const jid of allJids) {
@@ -362183,18 +363326,18 @@ async function discoverAnchorsFromPlugin(jobId, instanceId, plugin7, dbAnchors,
   }
   return discovered;
 }
-async function resolveWhatsAppAnchors(jobId, instanceId, config4, plugin7, dbAnchors, services) {
+async function resolveWhatsAppAnchors(jobId, instanceId, config4, plugin8, dbAnchors, services) {
   if (config4.chatJids?.length) {
     return buildAnchorsForExplicitChatJids(jobId, config4.chatJids, dbAnchors);
   }
-  return [...dbAnchors, ...await discoverAnchorsFromPlugin(jobId, instanceId, plugin7, dbAnchors, services)];
+  return [...dbAnchors, ...await discoverAnchorsFromPlugin(jobId, instanceId, plugin8, dbAnchors, services)];
 }
 async function processMessageSync(jobId, instanceId, channelType, config4, services, channelRegistry2) {
-  const plugin7 = channelRegistry2.get(channelType);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(channelType);
+  if (!plugin8) {
     throw new Error(`No plugin found for channel type: ${channelType}`);
   }
-  if (!("fetchHistory" in plugin7) || typeof plugin7.fetchHistory !== "function") {
+  if (!("fetchHistory" in plugin8) || typeof plugin8.fetchHistory !== "function") {
     log115.warn("Plugin does not support fetchHistory", { channelType });
     await services.syncJobs.complete(jobId);
     return;
@@ -362213,11 +363356,11 @@ async function processMessageSync(jobId, instanceId, channelType, config4, servi
   let anchors = [];
   if (channelType === "whatsapp-baileys" && config4.chatJids?.length) {
     const dbAnchors = await buildWhatsAppAnchors(instanceId, services);
-    anchors = await resolveWhatsAppAnchors(jobId, instanceId, config4, plugin7, dbAnchors, services);
+    anchors = await resolveWhatsAppAnchors(jobId, instanceId, config4, plugin8, dbAnchors, services);
     log115.info("WhatsApp per-chat active sync", { jobId, anchorCount: anchors.length, chatJids: config4.chatJids });
   } else if (channelType === "whatsapp-baileys") {
     const dbAnchors = await buildWhatsAppAnchors(instanceId, services);
-    const discoveredAnchors = await discoverAnchorsFromPlugin(jobId, instanceId, plugin7, dbAnchors, services);
+    const discoveredAnchors = await discoverAnchorsFromPlugin(jobId, instanceId, plugin8, dbAnchors, services);
     anchors = [...dbAnchors, ...discoveredAnchors];
     if (anchors.length > 0) {
       log115.info("WhatsApp default sync with DB+cache discovery", {
@@ -362284,7 +363427,7 @@ async function processMessageSync(jobId, instanceId, channelType, config4, servi
   if (channelType === "discord" && config4.channelId) {
     fetchOptions.channelId = config4.channelId;
   }
-  await plugin7.fetchHistory(instanceId, fetchOptions);
+  await plugin8.fetchHistory(instanceId, fetchOptions);
   await services.syncJobs.updateProgress(jobId, {
     fetched,
     stored,
@@ -362354,11 +363497,11 @@ async function updateDmChatName(services, instanceId, jid, name) {
   } catch {}
 }
 async function processContactsSync(jobId, instanceId, channelType, config4, services, channelRegistry2) {
-  const plugin7 = channelRegistry2.get(channelType);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(channelType);
+  if (!plugin8) {
     throw new Error(`No plugin found for channel type: ${channelType}`);
   }
-  if (!("fetchContacts" in plugin7) || typeof plugin7.fetchContacts !== "function") {
+  if (!("fetchContacts" in plugin8) || typeof plugin8.fetchContacts !== "function") {
     log115.warn("Plugin does not support fetchContacts", { channelType });
     await services.syncJobs.complete(jobId);
     return;
@@ -362415,7 +363558,7 @@ async function processContactsSync(jobId, instanceId, channelType, config4, serv
   if (channelType === "discord" && config4.channelId) {
     fetchOptions.guildId = config4.channelId;
   }
-  await plugin7.fetchContacts(instanceId, fetchOptions);
+  await plugin8.fetchContacts(instanceId, fetchOptions);
   await services.syncJobs.updateProgress(jobId, {
     fetched,
     stored,
@@ -362430,12 +363573,12 @@ async function processContactsSync(jobId, instanceId, channelType, config4, serv
   });
 }
 async function processGroupsSync(jobId, instanceId, channelType, _config, services, channelRegistry2) {
-  const plugin7 = channelRegistry2.get(channelType);
-  if (!plugin7) {
+  const plugin8 = channelRegistry2.get(channelType);
+  if (!plugin8) {
     throw new Error(`No plugin found for channel type: ${channelType}`);
   }
   const fetchMethod = channelType === "discord" ? "fetchGuilds" : "fetchGroups";
-  if (!(fetchMethod in plugin7) || typeof plugin7[fetchMethod] !== "function") {
+  if (!(fetchMethod in plugin8) || typeof plugin8[fetchMethod] !== "function") {
     log115.warn(`Plugin does not support ${fetchMethod}`, { channelType });
     await services.syncJobs.complete(jobId);
     return;
@@ -362545,8 +363688,8 @@ async function processGroupsSync(jobId, instanceId, channelType, _config, servic
       }
     }
   };
-  const fetchFn = plugin7[fetchMethod];
-  await fetchFn.call(plugin7, instanceId, fetchOptions);
+  const fetchFn = plugin8[fetchMethod];
+  await fetchFn.call(plugin8, instanceId, fetchOptions);
   await services.syncJobs.updateProgress(jobId, {
     fetched,
     stored,
@@ -362676,7 +363819,7 @@ async function setupHistoryPushTracker(eventBus, services) {
 var log115, RATE_LIMITS2, db2 = null, historyPushLog;
 var init_sync_worker = __esm(() => {
   init_src();
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   log115 = createLogger("sync-worker");
   RATE_LIMITS2 = {
@@ -362895,18 +364038,18 @@ function applyTwilioWhatsAppOptions(options, instance4) {
   }
 }
 async function connectInstance(instance4, registry5) {
-  const plugin7 = registry5.get(instance4.channel);
-  if (!plugin7) {
+  const plugin8 = registry5.get(instance4.channel);
+  if (!plugin8) {
     throw new Error(`No plugin for channel: ${instance4.channel}`);
   }
-  if ("loadGuildConfigs" in plugin7 && instance4.guildConfigOverrides) {
-    plugin7.loadGuildConfigs(instance4.id, instance4.guildConfigOverrides);
+  if ("loadGuildConfigs" in plugin8 && instance4.guildConfigOverrides) {
+    plugin8.loadGuildConfigs(instance4.id, instance4.guildConfigOverrides);
   }
   const options = buildInstanceConnectOptions(instance4);
   if (instance4.discordPresence) {
     options.presence = instance4.discordPresence;
   }
-  await plugin7.connect(instance4.id, {
+  await plugin8.connect(instance4.id, {
     instanceId: instance4.id,
     credentials: {},
     options
@@ -362994,11 +364137,11 @@ class InstanceMonitor {
     }).from(instances).where(eq(instances.isActive, true));
   }
   async checkInstanceHealth(instance4) {
-    const plugin7 = this.getPluginForInstance(instance4);
-    if (!plugin7)
+    const plugin8 = this.getPluginForInstance(instance4);
+    if (!plugin8)
       return;
     try {
-      const status = await plugin7.getStatus(instance4.id);
+      const status = await plugin8.getStatus(instance4.id);
       if (needsReconnect(status)) {
         this.handleUnhealthyInstance(instance4, status.state, status.message);
       }
@@ -363008,11 +364151,11 @@ class InstanceMonitor {
     }
   }
   getPluginForInstance(instance4) {
-    const plugin7 = this.registry.get(instance4.channel);
-    if (!plugin7) {
+    const plugin8 = this.registry.get(instance4.channel);
+    if (!plugin8) {
       logger7.warn("No plugin for instance", { instanceId: instance4.id, channel: instance4.channel });
     }
-    return plugin7 ?? null;
+    return plugin8 ?? null;
   }
   handleUnhealthyInstance(instance4, state, message2) {
     if (!wasAuthenticated(instance4)) {
@@ -363188,7 +364331,7 @@ async function processSingleBatch(batch, registry5, db3, results) {
 }
 var logger7, DEFAULT_CONFIG3, STALE_TRANSITION_MAX_AGE_MS;
 var init_instance_monitor = __esm(() => {
-  init_src5();
+  init_src6();
   init_drizzle_orm();
   init_logger4();
   logger7 = createLogger3({ module: "instance-monitor" });
@@ -363859,8 +365002,8 @@ var init_voice3 = __esm(() => {
 });
 
 // ../api/src/index.ts
-var exports_src2 = {};
-__export(exports_src2, {
+var exports_src3 = {};
+__export(exports_src3, {
   voiceStreamRegistry: () => voiceStreamRegistry,
   getInstanceMonitor: () => getInstanceMonitor,
   getEventBus: () => getEventBus,
@@ -363904,10 +365047,10 @@ async function initializeChannelPlugins(db3, eventBus) {
   pluginLog.info("Loading channel plugins");
   const result = await loadChannelPlugins2({ eventBus, db: db3 });
   globalChannelRegistry = result.registry;
-  for (const plugin7 of result.registry.getAll()) {
-    if (isVoiceCapable(plugin7) && "voiceStreamSink" in plugin7) {
-      Object.assign(plugin7, { voiceStreamSink: voiceStreamRegistry });
-      pluginLog.info("Voice stream registry wired to plugin", { pluginId: plugin7.id });
+  for (const plugin8 of result.registry.getAll()) {
+    if (isVoiceCapable(plugin8) && "voiceStreamSink" in plugin8) {
+      Object.assign(plugin8, { voiceStreamSink: voiceStreamRegistry });
+      pluginLog.info("Voice stream registry wired to plugin", { pluginId: plugin8.id });
     }
   }
   if (result.loaded > 0) {
@@ -364123,8 +365266,8 @@ async function setupEventBusServices(eventBus, services, db3) {
         const instance4 = await services.instances.getById(instanceId);
         if (!instance4)
           throw new Error(`Instance not found: ${instanceId}`);
-        const plugin7 = await getPlugin(instance4.channel);
-        if (!plugin7)
+        const plugin8 = await getPlugin(instance4.channel);
+        if (!plugin8)
           throw new Error(`No plugin for channel: ${instance4.channel}`);
         let recipient = to;
         if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(to)) {
@@ -364135,7 +365278,7 @@ async function setupEventBusServices(eventBus, services, db3) {
             throw new Error(`Chat not found for UUID: ${to}`);
           }
         }
-        await plugin7.sendMessage(instanceId, { to: recipient, content: { type: "text", text: content } });
+        await plugin8.sendMessage(instanceId, { to: recipient, content: { type: "text", text: content } });
       },
       callAgent: async (ctx, cfg) => {
         const instance4 = await services.instances.getById(ctx.instanceId);
@@ -364373,12 +365516,12 @@ async function main() {
   setupShutdownHandlers(server, earlyShutdown);
 }
 var import__package3, log122, natsLog, pluginLog, shutdownLog, PORT, HOST, NATS_URL, voiceStreamRegistry, globalEventBus = null, globalChannelRegistry = null, globalInstanceMonitor = null, globalDispatcherCleanup = null, globalTurnMonitor = null, globalDbRef = null, UUID_RE3;
-var init_src7 = __esm(() => {
+var init_src8 = __esm(() => {
   init_instrument2();
   init_tracing4();
   init_src2();
   init_src();
-  init_src5();
+  init_src6();
   init_esm5();
   init_drizzle_orm();
   init_app();
@@ -489742,7 +490885,11 @@ var plugin6 = new WhatsAppPlugin;
 var src_default5 = plugin6;
 
 // src/bundled-server-entry.ts
-for (const plugin7 of [src_default4, src_default, src_default5, src_default3, src_default2]) {
-  channelRegistry.register(plugin7);
+for (const plugin8 of [src_default4, src_default, src_default5, src_default3, src_default2]) {
+  channelRegistry.register(plugin8);
+}
+if (process.env.A2A_ENABLED === "true") {
+  const { default: a2aPlugin } = await Promise.resolve().then(() => (init_src4(), exports_src2));
+  channelRegistry.register(a2aPlugin);
 }
-await Promise.resolve().then(() => (init_src7(), exports_src2));
+await Promise.resolve().then(() => (init_src8(), exports_src3));