@creatornader/agent-bridge 0.2.0

package/dist/chunk-4KAOBC5X.js

@@ -0,0 +1,773 @@
+#!/usr/bin/env node
+import {
+  readClientConfigFile,
+  resolveClientConfig
+} from "./chunk-KVR4JBRF.js";
+import {
+  createStore
+} from "./chunk-JTC5YURG.js";
+import {
+  legacyContextMetadata,
+  legacyNumericMessageId
+} from "./chunk-AXL2I7FH.js";
+import {
+  BridgeService
+} from "./chunk-CKSKUBDQ.js";
+import {
+  BridgeValidationError,
+  normalizeReceiptId
+} from "./chunk-BV6W4AJK.js";
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+import { homedir } from "os";
+import { createRequire } from "module";
+import { join } from "path";
+
+// src/message-envelope.ts
+import { randomUUID } from "crypto";
+var MESSAGE_ENVELOPE_SCHEMA = "agent-bridge.message-envelope.v1";
+var RECORD_HASH_RE = /^sha256:[a-f0-9]{64}$/i;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function normalizeStringList(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const normalized = normalizeString(item);
+    if (normalized) seen.add(normalized);
+  }
+  return seen.size ? [...seen] : void 0;
+}
+function normalizeRecordHashes(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of raw) {
+    const normalized = normalizeString(item);
+    if (normalized && RECORD_HASH_RE.test(normalized)) {
+      seen.add(normalized.toLowerCase());
+    }
+  }
+  return seen.size ? [...seen] : void 0;
+}
+function normalizeIsoTimestamp(value) {
+  const text = normalizeString(value);
+  if (!text) return void 0;
+  const parsed = Date.parse(text);
+  if (Number.isNaN(parsed)) return void 0;
+  return new Date(parsed).toISOString();
+}
+function normalizeMetadata(value) {
+  return isRecord(value) ? { ...value } : {};
+}
+function buildMessageEnvelope(args, receiptId) {
+  const source = normalizeString(args?.source) ?? "unknown";
+  const category = normalizeString(args?.category);
+  const kind = normalizeString(args?.kind) ?? category ?? "operational";
+  const messageId = normalizeString(args?.message_id) ?? randomUUID();
+  const envelope = {
+    schema: MESSAGE_ENVELOPE_SCHEMA,
+    message_id: messageId,
+    source_agent: source,
+    kind,
+    priority: normalizeString(args?.priority) ?? "info",
+    payload_mime: normalizeString(args?.payload_mime) ?? "text/plain"
+  };
+  const targetAgents = normalizeStringList(args?.target_agents);
+  if (targetAgents) envelope.target_agents = targetAgents;
+  const project = normalizeString(args?.project);
+  if (project) envelope.project = project;
+  const threadId = normalizeString(args?.thread_id);
+  if (threadId) envelope.thread_id = threadId;
+  const replyToId = normalizeString(args?.reply_to_id);
+  if (replyToId) envelope.reply_to_id = replyToId;
+  if (Object.prototype.hasOwnProperty.call(args ?? {}, "payload")) {
+    envelope.payload = args?.payload;
+  }
+  const payloadRef = normalizeString(args?.payload_ref);
+  if (payloadRef) envelope.payload_ref = payloadRef;
+  const payloadCiphertext = normalizeString(args?.payload_ciphertext);
+  if (payloadCiphertext) envelope.payload_ciphertext = payloadCiphertext;
+  if (receiptId) envelope.atrib_receipt_id = receiptId;
+  const informedBy = normalizeRecordHashes(args?.informed_by);
+  if (informedBy) envelope.informed_by = informedBy;
+  const expiresAt = normalizeIsoTimestamp(args?.expires_at);
+  if (expiresAt) envelope.expires_at = expiresAt;
+  return envelope;
+}
+function mergeEnvelopeMetadata(metadataInput, envelope) {
+  return {
+    ...normalizeMetadata(metadataInput),
+    message_envelope: envelope
+  };
+}
+function getEnvelope(row) {
+  if (!isRecord(row)) return void 0;
+  const metadata = row.metadata;
+  if (!isRecord(metadata)) return void 0;
+  const envelope = metadata.message_envelope;
+  return isRecord(envelope) ? envelope : void 0;
+}
+function rowMatchesMessageFilters(row, filters) {
+  const targetAgent = normalizeString(filters?.target_agent);
+  const threadId = normalizeString(filters?.thread_id);
+  const kind = normalizeString(filters?.kind);
+  if (!targetAgent && !threadId && !kind) return true;
+  const envelope = getEnvelope(row);
+  if (!envelope) {
+    return !threadId && !kind;
+  }
+  if (targetAgent) {
+    const targets = normalizeStringList(envelope.target_agents);
+    if (targets && !targets.includes(targetAgent)) return false;
+  }
+  if (threadId && normalizeString(envelope.thread_id) !== threadId) {
+    return false;
+  }
+  if (kind && normalizeString(envelope.kind) !== kind) {
+    return false;
+  }
+  return true;
+}
+function filterContextRows(rows, filters, limit) {
+  if (!Array.isArray(rows)) return rows;
+  return rows.filter((row) => rowMatchesMessageFilters(row, filters)).slice(0, limit);
+}
+
+// src/source-identity.ts
+function normalizeSource(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function resolveAgentIdentity(requestedAgent, configuredAgent, field = "agent") {
+  const requested = normalizeSource(requestedAgent);
+  const configured = normalizeSource(configuredAgent);
+  if (requested && configured && requested !== configured) {
+    throw new Error(
+      `${field} must match AGENT_BRIDGE_AGENT (${configured}); got ${requested}`
+    );
+  }
+  return requested ?? configured;
+}
+function resolvePostSource(requestedSource, configuredAgent) {
+  return resolveAgentIdentity(requestedSource, configuredAgent, "source");
+}
+
+// src/server.ts
+var packageVersion = createRequire(import.meta.url)("../package.json").version;
+function normalizedConfigValue(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function defaultConfigPath(env) {
+  return normalizedConfigValue(env.AGENT_BRIDGE_CONFIG) ?? join(normalizedConfigValue(env.HOME) ?? homedir(), ".agent-bridge", "config");
+}
+function configFromEnv(env = process.env) {
+  const sharedFile = readClientConfigFile(defaultConfigPath(env));
+  const value = (key) => normalizedConfigValue(env[key]) ?? normalizedConfigValue(sharedFile[key]);
+  const runtimeAgent = normalizedConfigValue(env.AGENT_BRIDGE_AGENT);
+  const rawProvider = normalizedConfigValue(env.AGENT_BRIDGE_PROVIDER) ?? normalizedConfigValue(sharedFile.AGENT_BRIDGE_PROVIDER);
+  const provider = rawProvider === "legacy" || rawProvider === "supabase" ? "legacy-supabase" : rawProvider ?? (value("AGENT_BRIDGE_TOKEN") ? "gateway" : "legacy-supabase");
+  if (!["local", "gateway", "legacy-supabase"].includes(provider)) {
+    throw new Error(`Unsupported AGENT_BRIDGE_PROVIDER: ${rawProvider}`);
+  }
+  if (provider === "local" || provider === "gateway") {
+    const client = resolveClientConfig(env);
+    return {
+      provider: client.provider,
+      agent: client.principal.agent,
+      workspace: client.principal.workspace,
+      instance: client.principal.instance,
+      databasePath: client.databasePath,
+      edgeDatabasePath: client.edgeDatabasePath,
+      cursorPath: client.cursorPath,
+      gatewayUrl: client.provider === "gateway" ? client.url : void 0,
+      gatewayToken: client.provider === "gateway" ? client.credential : void 0
+    };
+  }
+  const supabaseUrl = value("AGENT_BRIDGE_URL");
+  const supabaseKey = value("AGENT_BRIDGE_KEY");
+  if (!supabaseUrl || !supabaseKey) {
+    throw new Error(
+      "Missing AGENT_BRIDGE_URL or AGENT_BRIDGE_KEY environment variables or ~/.agent-bridge/config"
+    );
+  }
+  return {
+    supabaseUrl,
+    supabaseKey,
+    agent: runtimeAgent,
+    provider,
+    workspace: value("AGENT_BRIDGE_WORKSPACE") ?? "*",
+    instance: normalizedConfigValue(env.AGENT_BRIDGE_INSTANCE)
+  };
+}
+function buildSupabaseRequest(config) {
+  const parsed = new URL(config.supabaseUrl);
+  const loopback = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]";
+  if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && loopback)) {
+    throw new Error("Agent Bridge requires HTTPS for non-loopback legacy providers");
+  }
+  const restUrl = `${config.supabaseUrl.replace(/\/$/, "")}/rest/v1`;
+  const headers = {
+    apikey: config.supabaseKey,
+    Authorization: `Bearer ${config.supabaseKey}`,
+    "Content-Type": "application/json",
+    Prefer: "return=representation"
+  };
+  return async function supabaseRequest(path, options = {}) {
+    const url = `${restUrl}${path}`;
+    const res = await fetch(url, {
+      ...options,
+      signal: options.signal ?? AbortSignal.timeout(1e4),
+      headers: { ...headers, ...options.headers }
+    });
+    if (!res.ok) {
+      throw new Error(`Supabase request failed (${res.status})`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : null;
+  };
+}
+function createAgentBridgeServer(config) {
+  const supabaseRequest = config.supabaseUrl && config.supabaseKey ? buildSupabaseRequest(config) : void 0;
+  const principal = config.agent ? { workspace: config.workspace ?? "default", agent: config.agent, instance: config.instance } : void 0;
+  const clientConfig = principal ? {
+    provider: config.provider ?? (config.gatewayToken ? "gateway" : config.supabaseUrl ? "legacy-supabase" : "local"),
+    principal,
+    url: config.gatewayUrl ?? config.supabaseUrl,
+    credential: config.gatewayToken ?? config.supabaseKey,
+    databasePath: config.databasePath ?? ":memory:",
+    edgeDatabasePath: config.edgeDatabasePath ?? config.databasePath ?? ":memory:",
+    cursorPath: config.cursorPath ?? "",
+    configPath: ""
+  } : void 0;
+  const store = clientConfig ? createStore(clientConfig) : void 0;
+  const service = store ? new BridgeService(store) : void 0;
+  const deliveryToolsAvailable = Boolean(
+    service && clientConfig?.provider !== "legacy-supabase"
+  );
+  const server = new Server(
+    { name: "agent-bridge", version: packageVersion },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "post_context",
+        description: "Post a shared context entry visible to all agents. Categories: operational, config-change, goal-update, flag, bridge-meta (for suggesting improvements to the Agent Bridge itself).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: "Optional posting agent. Defaults to AGENT_BRIDGE_AGENT when configured; an explicit value must match it."
+            },
+            category: {
+              type: "string",
+              description: "Entry type: operational | config-change | goal-update | flag | bridge-meta"
+            },
+            content: {
+              type: "string",
+              description: "The context message"
+            },
+            priority: {
+              type: "string",
+              description: "info (default) | high | urgent"
+            },
+            project: {
+              type: "string",
+              description: "Scope to a project (e.g. project-a, project-b). Omit for cross-project."
+            },
+            metadata: {
+              type: "object",
+              description: "Arbitrary structured data"
+            },
+            message_id: {
+              type: "string",
+              description: "Stable message id. Generated by the bridge when omitted."
+            },
+            target_agents: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional target agent names. Empty or omitted means broadcast."
+            },
+            thread_id: {
+              type: "string",
+              description: "Optional conversation/thread id."
+            },
+            reply_to_id: {
+              type: "string",
+              description: "Optional parent message id for reply threading."
+            },
+            kind: {
+              type: "string",
+              description: "Message kind: operational | config-change | goal-update | flag | bridge-meta | handoff | request | result"
+            },
+            payload_mime: {
+              type: "string",
+              description: "Payload MIME type. Defaults to text/plain for the content column."
+            },
+            payload: {
+              anyOf: [
+                { type: "object" },
+                { type: "array" },
+                { type: "string" },
+                { type: "number" },
+                { type: "boolean" },
+                { type: "null" }
+              ],
+              description: "Optional structured payload stored in metadata.message_envelope."
+            },
+            payload_ref: {
+              type: "string",
+              description: "Optional external blob pointer for large payloads."
+            },
+            payload_ciphertext: {
+              type: "string",
+              description: "Optional inline encrypted payload for small encrypted messages."
+            },
+            informed_by: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional atrib record hashes (sha256:<64-hex>) this message depends on."
+            },
+            expires_at: {
+              type: "string",
+              description: "Optional ISO timestamp retention boundary."
+            },
+            atrib_receipt_id: {
+              type: "string",
+              description: "Optional. Signed atrib record receipt_id for the wrapper that signed this post_context call. Set automatically by an atrib-signing wrapper; consumers reading the row use this as the informed_by anchor for cross-process causal edges."
+            }
+          },
+          required: ["category", "content"]
+        }
+      },
+      {
+        name: "get_context",
+        description: "Read shared context entries, newest first. Filter by source, category, project, or unacknowledged entries.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            since: {
+              type: "string",
+              description: "ISO timestamp. Only entries after this time"
+            },
+            source: {
+              type: "string",
+              description: "Filter by posting agent"
+            },
+            category: {
+              type: "string",
+              description: "Filter by category"
+            },
+            project: {
+              type: "string",
+              description: "Filter by project scope"
+            },
+            unacked_by: {
+              type: "string",
+              description: "Only entries NOT yet acknowledged by this agent name. Defaults to AGENT_BRIDGE_AGENT when configured."
+            },
+            limit: {
+              type: "number",
+              description: "Max entries to return (default 20)",
+              minimum: 1,
+              maximum: 200
+            },
+            target_agent: {
+              type: "string",
+              description: "Return broadcast entries plus entries targeted to this agent."
+            },
+            thread_id: {
+              type: "string",
+              description: "Filter by metadata.message_envelope.thread_id."
+            },
+            kind: {
+              type: "string",
+              description: "Filter by metadata.message_envelope.kind."
+            }
+          }
+        }
+      },
+      {
+        name: "ack_context",
+        description: "Acknowledge context entries so they won't appear in unacked queries for this agent.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            ids: {
+              type: "array",
+              items: { anyOf: [{ type: "number" }, { type: "string" }] },
+              description: "Legacy numeric entry IDs or v2 UUID message IDs to acknowledge"
+            },
+            agent: {
+              type: "string",
+              description: "Optional acknowledging agent. Defaults to AGENT_BRIDGE_AGENT when configured; an explicit value must match it."
+            }
+          },
+          required: ["ids"]
+        }
+      },
+      ...service ? [
+        {
+          name: "send",
+          description: "Create an immutable Agent Bridge v2 message.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              source: { type: "string", description: "Optional identity assertion; must match AGENT_BRIDGE_AGENT." },
+              type: { type: "string" },
+              content: { type: "string" },
+              contentType: { type: "string" },
+              data: {},
+              targets: { type: "array", items: { type: "string" } },
+              threadId: { type: "string" },
+              replyToId: { type: "string" },
+              correlationId: { type: "string" },
+              causationId: { type: "string" },
+              priority: { type: "string", enum: ["info", "high", "urgent"] },
+              expiresAt: { type: "string" },
+              idempotencyKey: { type: "string" },
+              atribReceiptId: { type: "string" },
+              informedBy: { type: "array", items: { type: "string" } },
+              metadata: {}
+            },
+            required: ["type", "content"],
+            additionalProperties: false
+          },
+          outputSchema: { type: "object", properties: { created: { type: "boolean" }, message: { type: "object", additionalProperties: true } }, required: ["created", "message"] }
+        },
+        {
+          name: "history",
+          description: "Read visible Agent Bridge v2 messages after an opaque cursor.",
+          inputSchema: { type: "object", properties: {
+            cursor: { type: "string" },
+            limit: { type: "number", minimum: 1, maximum: 200 },
+            types: { type: "array", items: { type: "string" } },
+            includeExpired: { type: "boolean" },
+            source: { type: "string" },
+            since: { type: "string" },
+            unacknowledgedBy: { type: "string" },
+            threadId: { type: "string" },
+            latest: { type: "boolean" }
+          }, additionalProperties: false },
+          outputSchema: { type: "object", properties: { messages: { type: "array", items: { type: "object", additionalProperties: true } }, cursor: { type: "string" } }, required: ["messages"] }
+        }
+      ] : [],
+      ...deliveryToolsAvailable ? [
+        {
+          name: "claim",
+          description: "Atomically claim the next targeted delivery.",
+          inputSchema: { type: "object", properties: { leaseMs: { type: "number" }, maxAttempts: { type: "number" } }, additionalProperties: false },
+          outputSchema: { type: "object", additionalProperties: true }
+        },
+        ...["extend", "acknowledge", "negative_acknowledge"].map((name) => ({
+          name,
+          description: `Agent Bridge v2 ${name.replace(/_/g, " ")} delivery operation.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              deliveryId: { type: "string" },
+              leaseToken: { type: "string" },
+              ...name === "extend" ? { leaseMs: { type: "number" } } : {},
+              ...name === "negative_acknowledge" ? { error: { type: "string" }, dead: { type: "boolean" }, retryPolicy: { type: "object", additionalProperties: true } } : {}
+            },
+            required: ["deliveryId", "leaseToken"],
+            additionalProperties: false
+          },
+          outputSchema: { type: "object", additionalProperties: true }
+        })),
+        {
+          name: "heartbeat",
+          description: "Publish a leased runtime presence record and capabilities.",
+          inputSchema: { type: "object", properties: {
+            leaseMs: { type: "number", minimum: 1e3, maximum: 9e5 },
+            runtimeType: { type: "string" },
+            capabilities: { type: "array", items: { type: "string" } }
+          }, additionalProperties: false },
+          outputSchema: { type: "object", additionalProperties: true }
+        },
+        {
+          name: "presence",
+          description: "List active agent runtime instances in this workspace.",
+          inputSchema: { type: "object", properties: {}, additionalProperties: false },
+          outputSchema: { type: "object", properties: { agents: { type: "array", items: { type: "object", additionalProperties: true } } }, required: ["agents"] }
+        }
+      ] : []
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "post_context": {
+          let source;
+          try {
+            source = resolvePostSource(args?.source, config.agent);
+            if (!source) {
+              throw new Error(
+                "source is required when AGENT_BRIDGE_AGENT is not configured"
+              );
+            }
+          } catch (e) {
+            throw new McpError(
+              ErrorCode.InvalidParams,
+              e instanceof Error ? e.message : "source identity mismatch"
+            );
+          }
+          const postArgs = { ...args ?? {}, source };
+          const receiptId = normalizeReceiptId(args?.atrib_receipt_id);
+          const envelope = buildMessageEnvelope(postArgs, receiptId);
+          const body = {
+            source,
+            category: args?.category,
+            content: args?.content,
+            priority: args?.priority || "info",
+            project: args?.project || null,
+            metadata: mergeEnvelopeMetadata(args?.metadata, envelope)
+          };
+          if (receiptId) {
+            body.atrib_receipt_id = receiptId;
+          }
+          if (!supabaseRequest) {
+            if (!service || !principal) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+            if (args?.project && String(args.project) !== principal.workspace) {
+              throw new McpError(ErrorCode.InvalidParams, "project must match AGENT_BRIDGE_WORKSPACE");
+            }
+            const result = await service.publish(principal, {
+              id: String(envelope.message_id),
+              type: String(args?.kind ?? args?.category),
+              content: String(args?.content ?? ""),
+              contentType: String(args?.payload_mime ?? "text/plain"),
+              data: args?.payload,
+              targets: Array.isArray(args?.target_agents) ? args.target_agents.map(String) : [],
+              threadId: args?.thread_id,
+              replyToId: args?.reply_to_id,
+              priority: args?.priority ?? "info",
+              expiresAt: args?.expires_at,
+              atribReceiptId: receiptId,
+              informedBy: Array.isArray(args?.informed_by) ? args.informed_by.map(String) : [],
+              metadata: body.metadata
+            });
+            return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+          }
+          if (!supabaseRequest) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+          const data = await supabaseRequest("/shared_context", {
+            method: "POST",
+            body: JSON.stringify(body)
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+          };
+        }
+        case "get_context": {
+          const rawLimit = args?.limit;
+          if (rawLimit !== void 0 && (typeof rawLimit !== "number" || !Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > 200)) {
+            throw new McpError(ErrorCode.InvalidParams, "limit must be between 1 and 200");
+          }
+          const requestedLimit = rawLimit ?? 20;
+          if (service && principal) {
+            if (!service || !principal) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+            if (args?.project && String(args.project) !== principal.workspace) {
+              return { content: [{ type: "text", text: "[]" }], structuredContent: { entries: [] } };
+            }
+            if (args?.target_agent && String(args.target_agent) !== principal.agent) {
+              return { content: [{ type: "text", text: "[]" }], structuredContent: { entries: [] } };
+            }
+            const result = await service.history(principal, {
+              limit: requestedLimit,
+              types: args?.kind ? [String(args.kind)] : args?.category ? [String(args.category)] : void 0,
+              source: args?.source ? String(args.source) : void 0,
+              since: args?.since ? String(args.since) : void 0,
+              unacknowledgedBy: args?.unacked_by ? String(args.unacked_by) : config.agent,
+              threadId: args?.thread_id ? String(args.thread_id) : void 0,
+              latest: true
+            });
+            const entries = result.messages.slice(0, requestedLimit).map((message) => ({
+              id: clientConfig?.provider === "legacy-supabase" && /^\d+$/.test(message.sequence) ? Number.isSafeInteger(Number(message.sequence)) ? Number(message.sequence) : message.sequence : message.id,
+              source: message.source,
+              category: message.type,
+              content: message.content,
+              priority: message.priority,
+              project: message.workspace,
+              metadata: legacyContextMetadata(message),
+              atrib_receipt_id: message.atribReceiptId ?? null,
+              created_at: message.createdAt
+            }));
+            const cachedResult = result;
+            const cacheMetadata = cachedResult.source ? {
+              source: cachedResult.source,
+              stale: Boolean(cachedResult.stale),
+              lastSyncedAt: cachedResult.lastSyncedAt ?? null
+            } : {};
+            return {
+              content: [{ type: "text", text: JSON.stringify(entries, null, 2) }],
+              structuredContent: { entries, ...cacheMetadata }
+            };
+          }
+          const hasEnvelopeFilter = Boolean(
+            args?.target_agent || args?.thread_id || args?.kind
+          );
+          const fetchLimit = hasEnvelopeFilter ? Math.min(Math.max(requestedLimit * 5, 50), 200) : requestedLimit;
+          const params = [
+            "order=created_at.desc",
+            `limit=${fetchLimit}`
+          ];
+          if (args?.since)
+            params.push(
+              `created_at=gte.${encodeURIComponent(String(args.since))}`
+            );
+          if (args?.source)
+            params.push(`source=eq.${encodeURIComponent(String(args.source))}`);
+          if (args?.category)
+            params.push(
+              `category=eq.${encodeURIComponent(String(args.category))}`
+            );
+          if (args?.project)
+            params.push(`project=eq.${encodeURIComponent(String(args.project))}`);
+          const unackedBy = args?.unacked_by ?? config.agent;
+          if (unackedBy)
+            params.push(
+              `acked_by=not.cs.%7B${encodeURIComponent(String(unackedBy))}%7D`
+            );
+          if (!supabaseRequest) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+          const data = await supabaseRequest(
+            `/shared_context?${params.join("&")}`
+          );
+          const filtered = filterContextRows(data, args, requestedLimit);
+          return {
+            content: [{ type: "text", text: JSON.stringify(filtered, null, 2) }]
+          };
+        }
+        case "ack_context": {
+          const ids = args?.ids;
+          let agent;
+          try {
+            agent = resolveAgentIdentity(args?.agent, config.agent);
+          } catch (e) {
+            throw new McpError(
+              ErrorCode.InvalidParams,
+              e instanceof Error ? e.message : "agent identity mismatch"
+            );
+          }
+          if (!ids?.length || !agent) {
+            throw new McpError(
+              ErrorCode.InvalidParams,
+              "ids are required; agent is required when AGENT_BRIDGE_AGENT is not configured"
+            );
+          }
+          if (service && principal) {
+            if (!service || !principal) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+            const rawIds = ids.map(String);
+            const acknowledged = clientConfig?.provider === "legacy-supabase" && store?.recordLegacyReceipt && rawIds.every((id) => /^\d+$/.test(id)) ? await store.recordLegacyReceipt(rawIds, principal.agent) : await service.acknowledge(
+              principal,
+              ids.map((id) => legacyNumericMessageId(id))
+            );
+            return { content: [{ type: "text", text: JSON.stringify({ acknowledged, agent }) }], structuredContent: { acknowledged, agent } };
+          }
+          if (!supabaseRequest) throw new McpError(ErrorCode.InternalError, "bridge provider is not configured");
+          const data = await supabaseRequest("/rpc/ack_context", {
+            method: "POST",
+            body: JSON.stringify({ entry_ids: ids.map(String), agent_name: agent })
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ acknowledged: data, agent })
+              }
+            ]
+          };
+        }
+        case "send": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          try {
+            resolvePostSource(args?.source, principal.agent);
+          } catch (error) {
+            throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : "source identity mismatch");
+          }
+          const result = await service.publish(principal, args);
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+        }
+        case "history": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const result = await service.history(principal, args ?? {});
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+        }
+        case "claim": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const result = await service.claim(principal, { leaseMs: args?.leaseMs, maxAttempts: args?.maxAttempts });
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result ?? { delivery: null } };
+        }
+        case "extend":
+        case "acknowledge":
+        case "negative_acknowledge": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const id = String(args?.deliveryId ?? ""), token = String(args?.leaseToken ?? "");
+          const result = name === "extend" ? await service.extend(principal, id, token, args?.leaseMs) : name === "acknowledge" ? await service.ack(principal, id, token) : await service.nack(
+            principal,
+            id,
+            token,
+            args?.error ?? "negative acknowledgment",
+            args?.dead ?? false,
+            args?.retryPolicy
+          );
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result ?? { delivery: null } };
+        }
+        case "heartbeat": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const result = await service.heartbeat(principal, {
+            leaseMs: args?.leaseMs,
+            runtimeType: args?.runtimeType,
+            capabilities: args?.capabilities
+          });
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+        }
+        case "presence": {
+          if (!service || !principal) throw new McpError(ErrorCode.InvalidParams, "AGENT_BRIDGE_AGENT is required");
+          const result = { agents: await service.presence(principal) };
+          return { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result };
+        }
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      if (error instanceof McpError) throw error;
+      if (error instanceof BridgeValidationError) {
+        throw new McpError(ErrorCode.InvalidParams, error.message);
+      }
+      throw error;
+    }
+  });
+  server.onclose = () => {
+    void store?.close?.();
+  };
+  return server;
+}
+async function startServer(config = configFromEnv()) {
+  const server = createAgentBridgeServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  configFromEnv,
+  createAgentBridgeServer,
+  startServer
+};
+//# sourceMappingURL=chunk-4KAOBC5X.js.map