@vornrun/connector-sdk 0.7.0-beta.7 → 0.7.0

package/dist/chunk-457KOZUU.js

@@ -1,773 +0,0 @@
-// src/normalize.ts
-var RESERVED_KEYS = [
-  "externalId",
-  "title",
-  "url",
-  "description",
-  "status",
-  "labels",
-  "assignee",
-  "updatedAt"
-];
-var UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
-function itemExternalId(item) {
-  return String(item.externalId ?? "").trim();
-}
-function itemTimestamp(item, fallback) {
-  return isoTimestamp(item.updatedAt, fallback);
-}
-function isoTimestamp(value, fallback) {
-  if (value === void 0) return fallback;
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid updatedAt: ${String(value)}`);
-  }
-  return date.toISOString();
-}
-function normalizeItem(item, polledAt) {
-  const externalId = itemExternalId(item);
-  if (!externalId) {
-    throw new Error("Connector item is missing externalId");
-  }
-  if (!item.title || !item.title.trim()) {
-    throw new Error(`Connector item ${externalId} is missing title`);
-  }
-  const extra = {};
-  for (const [key, value] of Object.entries(item.data ?? {})) {
-    if (RESERVED_KEYS.includes(key)) continue;
-    if (UNSAFE_KEYS.includes(key)) continue;
-    extra[key] = value;
-  }
-  return {
-    ...extra,
-    externalId,
-    title: item.title,
-    url: item.url ?? "",
-    description: item.description ?? "",
-    status: item.status ?? "open",
-    labels: item.labels ?? [],
-    ...item.assignee !== void 0 && { assignee: item.assignee },
-    updatedAt: isoTimestamp(item.updatedAt, polledAt)
-  };
-}
-function normalizeItems(items, polledAt) {
-  const seen = /* @__PURE__ */ new Set();
-  return items.map((item) => {
-    const normalized = normalizeItem(item, polledAt);
-    if (seen.has(normalized.externalId)) {
-      throw new Error(`Duplicate externalId "${normalized.externalId}" in one poll page`);
-    }
-    seen.add(normalized.externalId);
-    return normalized;
-  });
-}
-
-// src/dedupe.ts
-var MAX_BOUNDARY_IDS = 500;
-function decodeCursor(cursor, strategy) {
-  if (!cursor) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(cursor);
-  } catch (error) {
-    throw new Error(`Cursor is not valid SDK cursor JSON: ${cursor}`, { cause: error });
-  }
-  const state = parsed;
-  if (!state || typeof state !== "object" || state.v !== 1 || state.s !== strategy) {
-    throw new Error(`Cursor does not belong to the "${strategy}" strategy: ${cursor}`);
-  }
-  const wellFormed = state.s === "timestamp" ? typeof state.t === "string" && Array.isArray(state.ids) && state.ids.every((id) => typeof id === "string") : typeof state.id === "string";
-  if (!wellFormed) {
-    throw new Error(`Cursor is missing the fields the "${strategy}" strategy needs: ${cursor}`);
-  }
-  return state;
-}
-function compare(left, right) {
-  if (left === right) return 0;
-  return left < right ? -1 : 1;
-}
-function page(chronological, context, hadCursor, nextCursor) {
-  const delivered = context.limit === void 0 ? chronological : chronological.slice(0, context.limit);
-  if (delivered.length === 0) {
-    return { items: [], ...context.cursor !== void 0 && { nextCursor: context.cursor } };
-  }
-  return {
-    items: delivered.map((entry) => entry.item),
-    nextCursor: JSON.stringify(nextCursor(delivered)),
-    // Only drain a backlog we know we truncated, and only once a cursor
-    // exists — a first poll should not pull the source's entire history.
-    hasMore: chronological.length > delivered.length && hadCursor
-  };
-}
-function timestampPoll(fetched, state, context, polledAt) {
-  const boundary = state?.t ?? context.since;
-  const seen = new Set(state?.ids ?? []);
-  const fresh = [];
-  const pinnedAlreadySeen = [];
-  for (const item of fetched) {
-    const id = itemExternalId(item);
-    const pinned = item.updatedAt === void 0 && boundary !== void 0;
-    const at = pinned ? boundary : itemTimestamp(item, polledAt);
-    const isNew = boundary === void 0 || at > boundary || at === boundary && !seen.has(id);
-    if (isNew) fresh.push({ item, at, id, ...pinned && { pinned: true } });
-    else if (pinned) pinnedAlreadySeen.push(id);
-  }
-  fresh.sort((left, right) => compare(left.at, right.at) || compare(left.id, right.id));
-  return page(fresh, context, state !== void 0, (delivered) => {
-    const newest = delivered[delivered.length - 1].at;
-    const atNewest = [];
-    for (let i = delivered.length - 1; i >= 0 && delivered[i].at === newest; i -= 1) {
-      atNewest.push(delivered[i].id);
-    }
-    const carried = newest === boundary ? [...seen, ...atNewest] : [
-      ...pinnedAlreadySeen,
-      ...delivered.filter((entry) => entry.pinned).map((entry) => entry.id),
-      ...atNewest
-    ];
-    return { v: 1, s: "timestamp", t: newest, ids: carried.slice(-MAX_BOUNDARY_IDS) };
-  });
-}
-function lastItemPoll(fetched, state, context, polledAt) {
-  const keyed = fetched.map((item) => ({
-    item,
-    at: itemTimestamp(item, polledAt),
-    id: itemExternalId(item)
-  }));
-  const stopAt = state ? keyed.findIndex((entry) => entry.id === state.id) : -1;
-  const chronological = (stopAt === -1 ? keyed : keyed.slice(0, stopAt)).reverse();
-  return page(chronological, context, state !== void 0, (delivered) => ({
-    v: 1,
-    s: "lastItem",
-    id: delivered[delivered.length - 1].id
-  }));
-}
-async function pollWithDedupe(trigger, context) {
-  const strategy = trigger.dedupe;
-  const fetchItems = trigger.fetch;
-  if (!strategy || !fetchItems) {
-    throw new Error(`Trigger ${trigger.type} is not a declarative trigger`);
-  }
-  const polledAt = context.now();
-  if (strategy === "lastItem") {
-    const state2 = decodeCursor(context.cursor, "lastItem");
-    const fetched2 = await runFetch(trigger.type, fetchItems, {
-      config: context.config,
-      ...state2 && { lastItemId: state2.id },
-      ...context.limit !== void 0 && { limit: context.limit },
-      now: context.now
-    });
-    return lastItemPoll(fetched2, state2, context, polledAt);
-  }
-  const state = decodeCursor(context.cursor, "timestamp");
-  const since = state?.t ?? context.since;
-  const fetched = await runFetch(trigger.type, fetchItems, {
-    config: context.config,
-    ...since !== void 0 && { since },
-    ...context.limit !== void 0 && { limit: context.limit },
-    now: context.now
-  });
-  return timestampPoll(fetched, state, context, polledAt);
-}
-async function runFetch(type, fetchItems, context) {
-  const fetched = await fetchItems(context);
-  if (!Array.isArray(fetched)) {
-    throw new Error(`Trigger ${type} fetch() did not return an array`);
-  }
-  return fetched;
-}
-
-// src/runtime.ts
-var MAX_POLL_PAGES = 1e3;
-async function runPoll(connector, triggerType, options = {}) {
-  const trigger = connector.triggers.find((entry) => entry.type === triggerType);
-  if (!trigger) {
-    throw new Error(`Connector ${connector.id} has no trigger "${triggerType}"`);
-  }
-  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const polledAt = now();
-  const context = {
-    config: options.config ?? {},
-    ...options.since !== void 0 && { since: options.since },
-    ...options.cursor !== void 0 && { cursor: options.cursor },
-    ...options.limit !== void 0 && { limit: options.limit },
-    now
-  };
-  const outcome = typeof trigger.poll === "function" ? await trigger.poll(context) : await pollWithDedupe(trigger, context);
-  if (!outcome || !Array.isArray(outcome.items)) {
-    throw new Error(`Trigger ${triggerType} did not return an items array`);
-  }
-  if (outcome.hasMore && !outcome.nextCursor) {
-    throw new Error(`Trigger ${triggerType} reported more pages without a nextCursor`);
-  }
-  return {
-    items: normalizeItems(outcome.items, polledAt),
-    ...outcome.nextCursor !== void 0 && { nextCursor: outcome.nextCursor },
-    hasMore: outcome.hasMore === true
-  };
-}
-async function drainPoll(connector, triggerType, options = {}) {
-  const collected = [];
-  let cursor = options.cursor;
-  for (let page2 = 0; page2 < MAX_POLL_PAGES; page2++) {
-    const result = await runPoll(connector, triggerType, {
-      ...options,
-      ...cursor !== void 0 && { cursor }
-    });
-    collected.push(...result.items);
-    if (!result.hasMore) return collected;
-    if (result.nextCursor === cursor) {
-      throw new Error(`Trigger ${triggerType} did not advance its cursor`);
-    }
-    cursor = result.nextCursor;
-  }
-  throw new Error(`Trigger ${triggerType} exceeded ${MAX_POLL_PAGES} pages`);
-}
-function coerceArg(value, type) {
-  if (typeof value !== "string") return value;
-  if (type === "number") {
-    const parsed = Number(value);
-    if (Number.isNaN(parsed)) throw new Error(`Expected a number, got "${value}"`);
-    return parsed;
-  }
-  if (type === "boolean") {
-    if (value === "true") return true;
-    if (value === "false") return false;
-    throw new Error(`Expected a boolean, got "${value}"`);
-  }
-  return value;
-}
-async function runAction(connector, actionType, args, options = {}) {
-  const action = connector.actions.find((entry) => entry.type === actionType);
-  if (!action) {
-    throw new Error(`Connector ${connector.id} has no action "${actionType}"`);
-  }
-  const coerced = { ...args };
-  for (const input of action.inputs ?? []) {
-    const value = coerced[input.key];
-    if (value === void 0 || value === "") {
-      if (input.required) throw new Error(`Action ${actionType} requires "${input.key}"`);
-      delete coerced[input.key];
-      continue;
-    }
-    try {
-      coerced[input.key] = coerceArg(value, input.type);
-    } catch (error) {
-      throw new Error(
-        `Action ${actionType} argument "${input.key}": ${error instanceof Error ? error.message : String(error)}`,
-        { cause: error }
-      );
-    }
-  }
-  const output = await action.run(coerced, {
-    config: options.config ?? {},
-    now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString())
-  });
-  return output ?? {};
-}
-
-// src/check.ts
-function finding(level, code, target, message) {
-  return { level, code, target, message };
-}
-function sampleTrigger(trigger) {
-  return { ...trigger, poll: void 0, fetch: () => trigger.sample ?? [] };
-}
-async function checkPollBehaviour(connector, trigger, options) {
-  const found = [];
-  const probe = { ...connector, triggers: [trigger] };
-  const target = `trigger ${trigger.type}`;
-  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
-  const attempt = async (cursor, code, what) => {
-    try {
-      return await runPoll(probe, trigger.type, {
-        config: options.config ?? {},
-        ...cursor !== void 0 && { cursor },
-        now
-      });
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      return finding("error", code, target, `${what} threw: ${reason}`);
-    }
-  };
-  const first = await attempt(void 0, "poll-failed", "first poll");
-  if ("level" in first) return [first];
-  if (first.items.length === 0) {
-    found.push(
-      finding("warn", "no-items", target, "returned nothing, so delivery could not be verified")
-    );
-    return found;
-  }
-  if (first.nextCursor === void 0) {
-    found.push(
-      finding(
-        "error",
-        "no-cursor",
-        target,
-        "returned items but no nextCursor, so every poll will redeliver them"
-      )
-    );
-    return found;
-  }
-  const second = await attempt(
-    first.nextCursor,
-    "cursor-rejected",
-    "re-polling with its own nextCursor"
-  );
-  if ("level" in second) return [...found, second];
-  const delivered = new Set(first.items.map((item) => item.externalId));
-  const repeated = second.items.filter((item) => delivered.has(item.externalId));
-  if (repeated.length > 0) {
-    found.push(
-      finding(
-        "error",
-        "redelivers-items",
-        target,
-        `re-polling with its own nextCursor returned ${repeated.length} already-delivered item(s), starting with "${repeated[0].externalId}"`
-      )
-    );
-  }
-  if (second.hasMore && second.nextCursor === first.nextCursor) {
-    found.push(
-      finding("error", "stuck-cursor", target, "reports more pages but its cursor never advances")
-    );
-  }
-  return found;
-}
-async function checkConnector(connector, options = {}) {
-  const found = [];
-  if (!connector.description?.trim()) {
-    found.push(
-      finding(
-        "warn",
-        "missing-description",
-        connector.id,
-        "has no description; agents use it to decide when the connector applies"
-      )
-    );
-  }
-  const perTrigger = await Promise.all(
-    connector.triggers.map(async (trigger) => {
-      const target = `trigger ${trigger.type}`;
-      const triggerFindings = [];
-      if (!trigger.description?.trim()) {
-        triggerFindings.push(finding("warn", "missing-description", target, "has no description"));
-      }
-      if (options.live) {
-        triggerFindings.push(...await checkPollBehaviour(connector, trigger, options));
-      } else if (!trigger.sample?.length) {
-        triggerFindings.push(
-          finding(
-            "warn",
-            "unverifiable",
-            target,
-            "has no sample items and no credentials were supplied, so nothing could be verified"
-          )
-        );
-      } else if (!trigger.dedupe) {
-        triggerFindings.push(
-          finding(
-            "warn",
-            "sample-unusable",
-            target,
-            "declares sample items but implements poll() directly, so they cannot be replayed; re-run with --live"
-          )
-        );
-      } else {
-        triggerFindings.push(
-          ...await checkPollBehaviour(connector, sampleTrigger(trigger), options)
-        );
-      }
-      return triggerFindings;
-    })
-  );
-  found.push(...perTrigger.flat());
-  for (const action of connector.actions) {
-    const target = `action ${action.type}`;
-    if (!action.description?.trim()) {
-      found.push(
-        finding("warn", "missing-description", target, "has no description for the agent to read")
-      );
-    }
-    if (action.idempotent === void 0) {
-      found.push(
-        finding(
-          "warn",
-          "missing-idempotent",
-          target,
-          "does not declare `idempotent`, so an agent cannot tell whether retrying is safe"
-        )
-      );
-    }
-    for (const input of action.inputs ?? []) {
-      if (!input.description?.trim()) {
-        found.push(
-          finding(
-            "warn",
-            "missing-description",
-            `${target} input ${input.key}`,
-            "has no description"
-          )
-        );
-      }
-    }
-  }
-  return found;
-}
-function formatFindings(findings) {
-  return findings.map((item) => `${item.level.padEnd(5)}  ${item.target}: ${item.message} [${item.code}]`).join("\n");
-}
-
-// src/define.ts
-var KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-var PATH_DATA_PATTERN = /^[MmZzLlHhVvCcSsQqTtAa0-9\s,.\-+eE]+$/;
-var VIEW_BOX_PATTERN = /^-?[\d.]+\s+-?[\d.]+\s+-?[\d.]+\s+-?[\d.]+$/;
-var DEDUPE_STRATEGIES = ["timestamp", "lastItem"];
-function assertUnique(kind, keys) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const key of keys) {
-    if (seen.has(key)) throw new Error(`Duplicate ${kind} "${key}"`);
-    seen.add(key);
-  }
-}
-function envNameFor(key, explicit) {
-  if (explicit) return explicit;
-  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toUpperCase();
-}
-function defineConnector(definition) {
-  if (!KEY_PATTERN.test(definition.id ?? "")) {
-    throw new Error(`Connector id "${definition.id}" must start with a letter and be url-safe`);
-  }
-  if (!definition.name?.trim()) {
-    throw new Error(`Connector ${definition.id} is missing a name`);
-  }
-  if (definition.icon) {
-    const { viewBox, paths } = definition.icon;
-    if (!Array.isArray(paths) || paths.length === 0) {
-      throw new Error(`Connector ${definition.id} has an icon with no paths`);
-    }
-    for (const path of paths) {
-      if (typeof path !== "string" || !PATH_DATA_PATTERN.test(path)) {
-        throw new Error(
-          `Connector ${definition.id} has an icon path that is not SVG path data. Only path data is accepted, not markup.`
-        );
-      }
-    }
-    if (viewBox !== void 0 && !VIEW_BOX_PATTERN.test(viewBox)) {
-      throw new Error(`Connector ${definition.id} has an icon viewBox that is not four numbers`);
-    }
-  }
-  const triggers = definition.triggers ?? [];
-  const actions = definition.actions ?? [];
-  if (triggers.length === 0 && actions.length === 0) {
-    throw new Error(`Connector ${definition.id} declares no triggers and no actions`);
-  }
-  for (const trigger of triggers) {
-    if (!KEY_PATTERN.test(trigger.type ?? "")) {
-      throw new Error(`Trigger type "${trigger.type}" must start with a letter and be url-safe`);
-    }
-    const loose = trigger;
-    const declarative = typeof loose.fetch === "function";
-    const imperative = typeof loose.poll === "function";
-    if (declarative && imperative) {
-      throw new Error(`Trigger ${trigger.type} declares both fetch() and poll(); pick one`);
-    }
-    if (declarative !== (loose.dedupe !== void 0)) {
-      throw new Error(
-        `Trigger ${trigger.type} needs fetch() and a dedupe strategy together, not one alone`
-      );
-    }
-    if (loose.dedupe !== void 0 && !DEDUPE_STRATEGIES.includes(loose.dedupe)) {
-      throw new Error(
-        `Trigger ${trigger.type} has unknown dedupe strategy ${JSON.stringify(loose.dedupe)}; expected ${DEDUPE_STRATEGIES.join(" or ")}`
-      );
-    }
-    if (loose.poll !== void 0 && !imperative) {
-      throw new Error(`Trigger ${trigger.type} declares poll but it is not a function`);
-    }
-    if (!declarative && !imperative) {
-      throw new Error(`Trigger ${trigger.type} is missing a fetch() or poll() implementation`);
-    }
-  }
-  for (const action of actions) {
-    if (!KEY_PATTERN.test(action.type ?? "")) {
-      throw new Error(`Action type "${action.type}" must start with a letter and be url-safe`);
-    }
-    if (typeof action.run !== "function") {
-      throw new Error(`Action ${action.type} is missing a run() implementation`);
-    }
-  }
-  assertUnique(
-    "trigger",
-    triggers.map((trigger) => trigger.type)
-  );
-  assertUnique(
-    "action",
-    actions.map((action) => action.type)
-  );
-  assertUnique(
-    "config field",
-    (definition.config ?? []).map((field) => field.key)
-  );
-  return {
-    ...definition,
-    version: definition.version ?? "0.0.0",
-    config: definition.config ?? [],
-    triggers,
-    actions
-  };
-}
-function resolveConfig(connector, env = process.env) {
-  const config = {};
-  const missing = [];
-  for (const field of connector.config) {
-    const name = envNameFor(field.key, field.env);
-    const value = env[name] ?? field.default;
-    if (value === void 0 || value === "") {
-      if (field.required) missing.push(`${field.key} (${name})`);
-      continue;
-    }
-    config[field.key] = value;
-  }
-  if (missing.length > 0) {
-    throw new Error(
-      `Connector ${connector.id} is missing required configuration: ${missing.join(", ")}`
-    );
-  }
-  return config;
-}
-
-// src/setup.ts
-function pollToolName(triggerType) {
-  return `poll_${triggerType}`;
-}
-var MANIFEST_TOOL = "vorn_connector_manifest";
-var PREFLIGHT_TOOL = "vorn_connector_preflight";
-function connectionSetup(connector, triggerType) {
-  const trigger = connector.triggers.find((entry) => entry.type === triggerType);
-  if (!trigger) {
-    throw new Error(`Connector ${connector.id} has no trigger "${triggerType}"`);
-  }
-  return {
-    connectorId: connector.id,
-    triggerType,
-    filters: {
-      pollTool: pollToolName(triggerType),
-      itemsPath: "items",
-      idField: "externalId",
-      timestampField: "updatedAt",
-      titleField: "title",
-      urlField: "url",
-      cursorArg: "cursor",
-      cursorPath: "nextCursor"
-    },
-    env: connector.config.map((field) => ({
-      name: envNameFor(field.key, field.env),
-      required: field.required === true,
-      secret: field.secret === true,
-      ...field.description !== void 0 && { description: field.description }
-    }))
-  };
-}
-function connectorManifest(connector) {
-  return {
-    id: connector.id,
-    name: connector.name,
-    version: connector.version,
-    ...connector.description !== void 0 && { description: connector.description },
-    ...connector.icon !== void 0 && { icon: connector.icon },
-    triggers: connector.triggers.map((trigger) => ({
-      type: trigger.type,
-      label: trigger.label,
-      ...trigger.description !== void 0 && { description: trigger.description },
-      // Carried through so the app can seed a connection's status mapping and
-      // its polling workflow. Absent when the connector said nothing, which is
-      // different from saying there is nothing.
-      ...trigger.statusMapping !== void 0 && { statusMapping: trigger.statusMapping },
-      ...trigger.defaultWorkflow !== void 0 && { defaultWorkflow: trigger.defaultWorkflow },
-      setup: connectionSetup(connector, trigger.type)
-    })),
-    actions: connector.actions.map((action) => ({
-      type: action.type,
-      label: action.label,
-      ...action.description !== void 0 && { description: action.description },
-      inputs: (action.inputs ?? []).map((input) => ({
-        key: input.key,
-        label: input.label,
-        type: input.type ?? "string",
-        required: input.required === true
-      }))
-    }))
-  };
-}
-
-// src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-function json(value) {
-  return {
-    // Vorn reads `structuredContent` to build step output and to find the
-    // `items` array a poll returned; the text block keeps the result readable
-    // in any generic MCP client.
-    content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
-    structuredContent: value
-  };
-}
-function failure(error) {
-  return {
-    content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
-    isError: true
-  };
-}
-function inputShape(inputs) {
-  const shape = {};
-  for (const input of inputs) {
-    const base = z.string().describe(input.description ?? input.label);
-    shape[input.key] = input.required ? base : base.optional();
-  }
-  return shape;
-}
-function scalar(type) {
-  if (type === "number") return z.number();
-  if (type === "boolean") return z.boolean();
-  return z.string();
-}
-function outputSchema(outputs) {
-  const shape = {};
-  for (const output of outputs) {
-    shape[output.key] = scalar(output.type).optional().describe(output.description ?? output.key);
-  }
-  return z.looseObject(shape);
-}
-function createConnectorServer(connector, options = {}) {
-  const server = new McpServer(
-    { name: connector.id, version: connector.version },
-    { capabilities: { tools: {} } }
-  );
-  let cached = options.config;
-  const config = () => cached ??= resolveConfig(connector);
-  server.registerTool(
-    MANIFEST_TOOL,
-    {
-      description: `Describe the ${connector.name} connector and how to configure it`,
-      inputSchema: {},
-      outputSchema: z.looseObject({})
-    },
-    () => json(connectorManifest(connector))
-  );
-  if (connector.preflight) {
-    const preflight = connector.preflight.bind(connector);
-    server.registerTool(
-      PREFLIGHT_TOOL,
-      {
-        description: `Check whether ${connector.name} can run right now`,
-        inputSchema: {},
-        // Declared rather than left open like the manifest's: this shape is
-        // fixed, so a caller can validate against it. Still loose, because a
-        // connector adding a field of its own should not fail the call.
-        outputSchema: z.looseObject({
-          ok: z.boolean().describe("Whether the connector could run right now"),
-          message: z.string().optional().describe("What to do about it, when it could not")
-        })
-      },
-      async () => {
-        try {
-          return json({ ...await preflight() });
-        } catch (error) {
-          return json({
-            ok: false,
-            message: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-    );
-  }
-  for (const trigger of connector.triggers) {
-    server.registerTool(
-      pollToolName(trigger.type),
-      {
-        description: trigger.description ?? `Poll ${connector.name} for ${trigger.label}`,
-        inputSchema: {
-          since: z.string().optional().describe("Only return items changed after this ISO timestamp"),
-          cursor: z.string().optional().describe("Opaque cursor from a previous page"),
-          limit: z.string().optional().describe("Maximum number of items to return")
-        },
-        outputSchema: z.looseObject({
-          items: z.array(z.looseObject({})).describe("Normalized items"),
-          nextCursor: z.string().optional().describe("Cursor for the next page"),
-          hasMore: z.boolean().describe("Whether another page is immediately available")
-        })
-      },
-      async (args) => {
-        try {
-          const limit = args.limit === void 0 ? void 0 : Number(args.limit);
-          if (limit !== void 0 && !Number.isFinite(limit)) {
-            throw new Error(`Invalid limit "${args.limit}"`);
-          }
-          return json(
-            await runPoll(connector, trigger.type, {
-              config: config(),
-              ...args.since !== void 0 && { since: args.since },
-              ...args.cursor !== void 0 && { cursor: args.cursor },
-              ...limit !== void 0 && { limit },
-              ...options.now && { now: options.now }
-            })
-          );
-        } catch (error) {
-          return failure(error);
-        }
-      }
-    );
-  }
-  for (const action of connector.actions) {
-    const base = action.description ?? `${action.label} in ${connector.name}`;
-    const retryHint = action.idempotent === void 0 ? "" : action.idempotent ? " Safe to retry: repeating this call with the same arguments has no additional effect." : " Not idempotent: repeating this call performs the operation again.";
-    server.registerTool(
-      action.type,
-      {
-        description: `${base}${retryHint}`,
-        inputSchema: inputShape(action.inputs ?? []),
-        outputSchema: outputSchema(action.outputs ?? [])
-      },
-      async (args) => {
-        try {
-          return json(
-            await runAction(connector, action.type, args, {
-              config: config(),
-              ...options.now && { now: options.now }
-            })
-          );
-        } catch (error) {
-          return failure(error);
-        }
-      }
-    );
-  }
-  return server;
-}
-async function serveConnector(connector, options = {}) {
-  const server = createConnectorServer(connector, options);
-  await server.connect(new StdioServerTransport());
-}
-
-export {
-  normalizeItem,
-  normalizeItems,
-  pollWithDedupe,
-  MAX_POLL_PAGES,
-  runPoll,
-  drainPoll,
-  runAction,
-  checkConnector,
-  formatFindings,
-  envNameFor,
-  defineConnector,
-  resolveConfig,
-  pollToolName,
-  MANIFEST_TOOL,
-  PREFLIGHT_TOOL,
-  connectionSetup,
-  connectorManifest,
-  createConnectorServer,
-  serveConnector
-};