@vornrun/connector-sdk 0.7.1-beta.2 → 0.7.1-beta.3

package/dist/{chunk-C2WRZCMZ.js → chunk-727CYX57.js}

@@ -21,7 +21,6 @@ function loopbackEndpoint(env, names, fail = (message) => new Error(message)) {
 // src/session.ts
 var BROWSER_HOST_ENV = "VORN_BROWSER_HOST";
 var BROWSER_TOKEN_ENV = "VORN_BROWSER_TOKEN";
-var SESSION_CALL_META = "vorn/sessionCall";
 var SESSION_CALL_HEADER = "x-vorn-session-call";
 var SessionUnavailableError = class extends Error {
   /** Asking again cannot bring the window back, so the SDK's retries let this through at once. */
@@ -40,10 +39,10 @@ var SessionRefusedError = class extends Error {
 };
 var SESSION_TIMEOUT_MS = 45e3;
 var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
-function readReply(text) {
+function readReply(text2) {
   let parsed;
   try {
-    parsed = JSON.parse(text);
+    parsed = JSON.parse(text2);
   } catch {
     throw new Error("The signed-in window answered with a body that is not JSON");
   }
@@ -53,7 +52,7 @@ function readReply(text) {
   }
   return reply2;
 }
-var refusal = (text) => text.trim() || void 0;
+var refusal = (text2) => text2.trim() || void 0;
 function createSessionFetch(options = {}) {
   const env = options.env ?? process.env;
   const call = options.fetchImpl ?? fetch;
@@ -85,18 +84,18 @@ function createSessionFetch(options = {}) {
       }),
       signal: AbortSignal.any([request.signal, AbortSignal.timeout(SESSION_TIMEOUT_MS)])
     });
-    const text = await answer.text();
+    const text2 = await answer.text();
     if (answer.status === 503) {
       throw new SessionUnavailableError(
-        refusal(text) ?? "Vorn could not reach the signed-in window"
+        refusal(text2) ?? "Vorn could not reach the signed-in window"
       );
     }
     if (!answer.ok) {
       throw new SessionRefusedError(
-        refusal(text) ?? `The signed-in window refused the call with HTTP ${answer.status}`
+        refusal(text2) ?? `The signed-in window refused the call with HTTP ${answer.status}`
       );
     }
-    const reply2 = readReply(text);
+    const reply2 = readReply(text2);
     return new Response(NULL_BODY_STATUSES.has(reply2.status) ? null : reply2.body ?? "", {
       status: reply2.status,
       ...reply2.headers && { headers: reply2.headers }
@@ -104,6 +103,148 @@ function createSessionFetch(options = {}) {
   });
 }
 
+// src/protocol.ts
+var PROTOCOL_VERSION = 1;
+var SUPPORTED_PROTOCOLS = [PROTOCOL_VERSION];
+var MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var PROTOCOL_METHODS = {
+  hello: "vorn/hello",
+  manifest: "connector/manifest",
+  preflight: "connector/preflight",
+  options: "connector/options",
+  poll: "trigger/poll",
+  action: "action/run",
+  footer: "extension/footer",
+  handler: "extension/handler"
+};
+var PROTOCOL_ERROR_CODES = {
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  connectorError: -32e3,
+  unsupportedProtocol: -32001,
+  beforeHello: -32002
+};
+var PROTOCOL_ERROR_KINDS = [
+  "validation",
+  "app-offline",
+  "signed-out",
+  "upstream",
+  "internal"
+];
+
+// src/resilience.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var DEFAULT_ATTEMPTS = 3;
+var DEFAULT_BASE_DELAY_MS = 250;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+var MAX_ATTEMPTS = 10;
+var MAX_TOTAL_WAIT_MS = 12e4;
+var wait = (ms) => new Promise((resolve4) => {
+  setTimeout(resolve4, ms);
+});
+function retryAfterMs(header, now) {
+  if (!header) return void 0;
+  const trimmed = header.trim();
+  if (trimmed === "") return void 0;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return void 0;
+  return Math.max(0, at - now);
+}
+function backoffMs(attempt, policy = {}) {
+  const base = policy.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+  const max = policy.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  return Math.min(max, base * 2 ** attempt);
+}
+function isFinal(error) {
+  return error?.retryable === false;
+}
+function resilientFetch(options) {
+  const attempts = Math.min(MAX_ATTEMPTS, Math.max(1, options.retry?.attempts ?? DEFAULT_ATTEMPTS));
+  const sleep = options.sleep ?? wait;
+  const ceiling = options.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const send = async (input, init) => {
+    let waited = 0;
+    const pause = async (ms) => {
+      if (waited + ms > MAX_TOTAL_WAIT_MS) return false;
+      waited += ms;
+      await sleep(ms);
+      return true;
+    };
+    for (let attempt = 0; attempt < attempts; attempt++) {
+      const last = attempt === attempts - 1;
+      try {
+        const response = await options.fetchImpl(input, init);
+        if (!RETRYABLE_STATUS.has(response.status)) return response;
+        if (!options.retryable || last) return response;
+        const asked = retryAfterMs(response.headers.get("retry-after"), Date.now());
+        const delay = asked === void 0 ? backoffMs(attempt, options.retry) : Math.min(asked, ceiling);
+        if (!await pause(delay)) return response;
+      } catch (error) {
+        if (!options.retryable || last || isFinal(error)) throw error;
+        if (!await pause(backoffMs(attempt, options.retry))) throw error;
+      }
+    }
+    throw new Error("Request was never attempted");
+  };
+  return send;
+}
+
+// src/errors.ts
+var ActionArgumentError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(message);
+    this.name = "ActionArgumentError";
+    this.field = field;
+  }
+};
+var UpstreamStatusError = class extends Error {
+  status;
+  viaSession;
+  constructor(status, message, viaSession = false) {
+    super(message);
+    this.name = "UpstreamStatusError";
+    this.status = status;
+    this.viaSession = viaSession;
+  }
+};
+var UnknownNameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnknownNameError";
+  }
+};
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+function* causes(error) {
+  let at = error;
+  for (let depth = 0; at !== void 0 && depth < 8; depth++) {
+    yield at;
+    at = at instanceof Error ? at.cause : void 0;
+  }
+}
+function protocolError(error) {
+  const failed = (data) => ({
+    code: PROTOCOL_ERROR_CODES.connectorError,
+    message: messageOf(error),
+    data
+  });
+  for (const at of causes(error)) {
+    if (at instanceof ActionArgumentError) return failed({ kind: "validation", field: at.field });
+    if (at instanceof SessionUnavailableError) {
+      return failed({ kind: "app-offline", retryable: false });
+    }
+    if (at instanceof UpstreamStatusError) {
+      if (at.viaSession && (at.status === 401 || at.status === 403)) {
+        return failed({ kind: "signed-out", retryable: false });
+      }
+      return failed({ kind: "upstream", retryable: RETRYABLE_STATUS.has(at.status) });
+    }
+  }
+  return failed({ kind: "internal" });
+}
+
 // src/origins.ts
 var ORIGIN_PATTERN = /^https:\/\/(\*\.)?[a-z0-9-]+(\.[a-z0-9-]+)+$/i;
 function withinOrigins(origins, url) {
@@ -697,18 +838,6 @@ function resolveConfig(connector, env = process.env) {
 }
 
 // src/setup.ts
-function pollToolName(triggerType) {
-  return `poll_${triggerType}`;
-}
-function footerToolName(footerId) {
-  return `vorn_footer_${footerId}`;
-}
-function handlerToolName(handlerId) {
-  return `vorn_handler_${handlerId}`;
-}
-var MANIFEST_TOOL = "vorn_connector_manifest";
-var PREFLIGHT_TOOL = "vorn_connector_preflight";
-var OPTIONS_TOOL = "vorn_connector_options";
 function connectionSetup(connector, triggerType) {
   const trigger = connector.triggers.find((entry) => entry.type === triggerType);
   if (!trigger) {
@@ -717,16 +846,6 @@ function connectionSetup(connector, 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,
@@ -769,6 +888,7 @@ function manifestContributions(connector) {
 function connectorManifest(connector) {
   const contributes = manifestContributions(connector);
   return {
+    protocol: PROTOCOL_VERSION,
     id: connector.id,
     name: connector.name,
     version: connector.version,
@@ -794,11 +914,13 @@ function connectorManifest(connector) {
       type: action.type,
       label: action.label,
       ...action.description !== void 0 && { description: action.description },
+      ...action.idempotent !== void 0 && { idempotent: action.idempotent },
       inputs: (action.inputs ?? []).map((input) => ({
         key: input.key,
         label: input.label,
         type: input.type ?? "string",
         required: input.required === true,
+        ...input.description !== void 0 && { description: input.description },
         ...input.options !== void 0 && { options: input.options },
         ...input.loadOptions !== void 0 && { loadOptions: input.loadOptions },
         ...input.builderHint !== void 0 && { builderHint: input.builderHint }
@@ -810,11 +932,37 @@ function connectorManifest(connector) {
 }
 
 // src/packaging.ts
+import { spawn } from "child_process";
 import { builtinModules } from "module";
 import { existsSync, readFileSync } from "fs";
 import { cp, mkdtemp, readdir, stat, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { dirname, isAbsolute, join, resolve } from "path";
+
+// src/lines.ts
+function lineReader(onLine, overflow) {
+  let pending = [];
+  let size = 0;
+  return (chunk) => {
+    let start = 0;
+    for (let end = chunk.indexOf(10); end !== -1; end = chunk.indexOf(10, start)) {
+      const part = chunk.subarray(start, end);
+      if (size + part.length > MAX_FRAME_BYTES) return overflow();
+      const whole = pending.length === 0 ? part : Buffer.concat([...pending, part], size + part.length);
+      const line = whole.toString("utf8");
+      pending = [];
+      size = 0;
+      start = end + 1;
+      onLine(line.endsWith("\r") ? line.slice(0, -1) : line);
+    }
+    const rest = chunk.subarray(start);
+    size += rest.length;
+    if (size > MAX_FRAME_BYTES) return overflow();
+    if (rest.length > 0) pending.push(rest);
+  };
+}
+
+// src/packaging.ts
 var MAX_PACK_BYTES = 8 * 1024 * 1024;
 var MAX_UNPACKED_BYTES = 32 * 1024 * 1024;
 var LIFECYCLE_SCRIPTS = [
@@ -1075,8 +1223,8 @@ function launchEnv() {
   }
   return env;
 }
-function errorLine(text) {
-  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "");
+function errorLine(text2) {
+  const lines = text2.split("\n").map((line) => line.trim()).filter((line) => line !== "");
   return [...lines].reverse().find((line) => /Error\b/.test(line)) ?? lines[lines.length - 1];
 }
 function withTimeout(promise, ms, message) {
@@ -1088,24 +1236,50 @@ function withTimeout(promise, ms, message) {
     })
   ]);
 }
-async function packLaunchFindings(dir) {
-  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
-  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
-  const transport = new StdioClientTransport({
-    command: process.execPath,
-    args: ["index.js"],
-    cwd: dir,
-    env: launchEnv(),
-    stderr: "pipe"
+function helloAnswer(child) {
+  return new Promise((resolve4, reject) => {
+    const onLine = (line) => {
+      let reply2;
+      try {
+        reply2 = JSON.parse(line);
+      } catch {
+        return;
+      }
+      if (reply2?.id !== 1) return;
+      if (typeof reply2.result?.protocol === "number") return resolve4();
+      reject(
+        new Error(
+          `answered ${PROTOCOL_METHODS.hello} with ${String(reply2.error?.message ?? "no protocol")}`
+        )
+      );
+    };
+    child.stdout.on(
+      "data",
+      lineReader(onLine, () => reject(new Error(`wrote a line over ${MAX_FRAME_BYTES} bytes`)))
+    );
+    child.once("error", reject);
+    child.once("exit", (code) => reject(new Error(`exited with code ${code} before answering`)));
+    child.stdin.on("error", () => {
+    });
+    const params = {
+      protocols: [...SUPPORTED_PROTOCOLS],
+      host: { name: "vorn-connector-check", version: "1" }
+    };
+    child.stdin.write(
+      `${JSON.stringify({ jsonrpc: "2.0", id: 1, method: PROTOCOL_METHODS.hello, params })}
+`
+    );
   });
-  const client = new Client({ name: "vorn-connector-check", version: "1" }, { capabilities: {} });
+}
+async function packLaunchFindings(dir) {
+  const child = spawn(process.execPath, ["index.js"], { cwd: dir, env: launchEnv() });
   let stderr = "";
-  transport.stderr?.on("data", (chunk) => {
+  child.stderr.on("data", (chunk) => {
     stderr += chunk.toString();
   });
   try {
     await withTimeout(
-      client.connect(transport),
+      helloAnswer(child),
       LAUNCH_TIMEOUT_MS,
       `did not answer within ${LAUNCH_TIMEOUT_MS / 1e3}s of starting`
     );
@@ -1116,10 +1290,7 @@ async function packLaunchFindings(dir) {
       finding("pack-launch", "bundle", `did not start as a pack: ${errorLine(stderr) ?? said}`)
     ];
   } finally {
-    await client.close().catch(() => {
-    });
-    await transport.close().catch(() => {
-    });
+    child.kill("SIGKILL");
   }
 }
 async function esbuildBundle(request) {
@@ -1189,13 +1360,13 @@ function createExtensionHost(options) {
       body: JSON.stringify({ sessionId: options.sessionId, ...params }),
       signal: AbortSignal.timeout(HOST_TIMEOUT_MS)
     });
-    const text = await response.text();
-    if (response.status === 403) throw new PermissionDeniedError(method, text || "not granted");
+    const text2 = await response.text();
+    if (response.status === 403) throw new PermissionDeniedError(method, text2 || "not granted");
     if (!response.ok) throw new Error(`The host answered ${method} with HTTP ${response.status}`);
-    if (text === "") return void 0;
+    if (text2 === "") return void 0;
     let parsed;
     try {
-      parsed = JSON.parse(text);
+      parsed = JSON.parse(text2);
     } catch {
       throw new HostReplyError(method, "a body that is not JSON");
     }
@@ -1209,7 +1380,7 @@ function createExtensionHost(options) {
     status: () => ask("status", {}),
     output: (opts) => ask("output", { ...opts?.lines !== void 0 && { lines: opts.lines } }),
     selection: () => ask("selection", {}),
-    send: (text) => ask("send", { text }),
+    send: (text2) => ask("send", { text: text2 }),
     rename: (name) => ask("rename", { name }),
     usage: () => ask("usage", {})
   };
@@ -1424,8 +1595,8 @@ function resolveTemplates(value, scope, substitute) {
     return value.replace(PLACEHOLDER, (_match, source, path) => {
       const resolved = lookup(source, path, scope);
       if (resolved === void 0 || resolved === null) return "";
-      const text = String(resolved);
-      return substitute === void 0 ? text : substitute(text, source);
+      const text2 = String(resolved);
+      return substitute === void 0 ? text2 : substitute(text2, source);
     });
   }
   if (Array.isArray(value)) return value.map((entry) => resolveTemplates(entry, scope, substitute));
@@ -1485,14 +1656,14 @@ function resolveRequest(request, scope) {
   return resolved;
 }
 async function readBody(response) {
-  const text = await response.text();
-  if (text === "") return void 0;
+  const text2 = await response.text();
+  if (text2 === "") return void 0;
   const type = response.headers.get("content-type") ?? "";
-  if (!type.includes("json")) return text;
+  if (!type.includes("json")) return text2;
   try {
-    return JSON.parse(text);
+    return JSON.parse(text2);
   } catch {
-    return text;
+    return text2;
   }
 }
 function describeFailure(response, body) {
@@ -1507,7 +1678,13 @@ async function sendRequest(resolved, options) {
     ...resolved.body !== void 0 && { body: resolved.body }
   });
   const body = await readBody(response);
-  if (!response.ok) throw new Error(describeFailure(response, body));
+  if (!response.ok) {
+    throw new UpstreamStatusError(
+      response.status,
+      describeFailure(response, body),
+      options.viaSession
+    );
+  }
   return { response, body };
 }
 function asOutput(value) {
@@ -1583,65 +1760,6 @@ async function executeRequest(request, postReceive, scope, options) {
   return asOutput(applyPostReceive(body, postReceive));
 }
 
-// src/resilience.ts
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
-var DEFAULT_ATTEMPTS = 3;
-var DEFAULT_BASE_DELAY_MS = 250;
-var DEFAULT_MAX_DELAY_MS = 3e4;
-var MAX_ATTEMPTS = 10;
-var MAX_TOTAL_WAIT_MS = 12e4;
-var wait = (ms) => new Promise((resolve4) => {
-  setTimeout(resolve4, ms);
-});
-function retryAfterMs(header, now) {
-  if (!header) return void 0;
-  const trimmed = header.trim();
-  if (trimmed === "") return void 0;
-  const seconds = Number(trimmed);
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
-  const at = Date.parse(trimmed);
-  if (Number.isNaN(at)) return void 0;
-  return Math.max(0, at - now);
-}
-function backoffMs(attempt, policy = {}) {
-  const base = policy.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-  const max = policy.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  return Math.min(max, base * 2 ** attempt);
-}
-function isFinal(error) {
-  return error?.retryable === false;
-}
-function resilientFetch(options) {
-  const attempts = Math.min(MAX_ATTEMPTS, Math.max(1, options.retry?.attempts ?? DEFAULT_ATTEMPTS));
-  const sleep = options.sleep ?? wait;
-  const ceiling = options.retry?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  const send = async (input, init) => {
-    let waited = 0;
-    const pause = async (ms) => {
-      if (waited + ms > MAX_TOTAL_WAIT_MS) return false;
-      waited += ms;
-      await sleep(ms);
-      return true;
-    };
-    for (let attempt = 0; attempt < attempts; attempt++) {
-      const last = attempt === attempts - 1;
-      try {
-        const response = await options.fetchImpl(input, init);
-        if (!RETRYABLE_STATUS.has(response.status)) return response;
-        if (!options.retryable || last) return response;
-        const asked = retryAfterMs(response.headers.get("retry-after"), Date.now());
-        const delay = asked === void 0 ? backoffMs(attempt, options.retry) : Math.min(asked, ceiling);
-        if (!await pause(delay)) return response;
-      } catch (error) {
-        if (!options.retryable || last || isFinal(error)) throw error;
-        if (!await pause(backoffMs(attempt, options.retry))) throw error;
-      }
-    }
-    throw new Error("Request was never attempted");
-  };
-  return send;
-}
-
 // src/runtime.ts
 function wrap(fetchImpl, options, retryable) {
   return resilientFetch({
@@ -1660,7 +1778,7 @@ 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}"`);
+    throw new UnknownNameError(`${connector.id} has no trigger "${triggerType}"`);
   }
   const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const polledAt = now();
@@ -1709,7 +1827,7 @@ var SAFE_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 async function runOptions(connector, name, options = {}) {
   const loader = connector.options?.[name];
   if (!loader) {
-    throw new Error(`Connector ${connector.id} serves no options set "${name}"`);
+    throw new UnknownNameError(`${connector.id} serves no options set "${name}"`);
   }
   const session = sessionFor(connector, options, true);
   const loaded = await loader({
@@ -1729,46 +1847,52 @@ var MAX_QUOTED_VALUE = 80;
 function quote(value) {
   return value.length > MAX_QUOTED_VALUE ? `${value.slice(0, MAX_QUOTED_VALUE)}\u2026` : value;
 }
+var shown = (value) => typeof value === "string" ? `"${quote(value)}"` : quote(JSON.stringify(value) ?? String(value));
 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 "${quote(value)}"`);
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    const parsed = typeof value === "string" ? Number(value) : Number.NaN;
+    if (Number.isNaN(parsed)) throw new Error(`Expected a number, got ${shown(value)}`);
     return parsed;
   }
   if (type === "boolean") {
+    if (typeof value === "boolean") return value;
     if (value === "true") return true;
     if (value === "false") return false;
-    throw new Error(`Expected a boolean, got "${quote(value)}"`);
+    throw new Error(`Expected a boolean, got ${shown(value)}`);
   }
   if (type === "json") {
+    if (typeof value !== "string") return value;
     try {
       return JSON.parse(value);
     } catch {
-      throw new Error(`Expected JSON, got "${quote(value)}"`);
+      throw new Error(`Expected JSON, got ${shown(value)}`);
     }
   }
-  return value;
+  if (typeof value === "string") return value;
+  return typeof value === "object" ? JSON.stringify(value) : String(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}"`);
+    throw new UnknownNameError(`${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}"`);
+    if (value === void 0 || value === null || value === "") {
+      if (input.required) {
+        throw new ActionArgumentError(input.key, `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 }
+      throw new ActionArgumentError(
+        input.key,
+        `Action ${actionType} argument "${input.key}": ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
@@ -1783,7 +1907,7 @@ async function runAction(connector, actionType, args, options = {}) {
         action.request,
         action.postReceive,
         { args: coerced, config },
-        { fetchImpl: session?.fetch ?? fetchImpl }
+        { fetchImpl: session?.fetch ?? fetchImpl, viaSession: session !== void 0 }
       );
     } catch (error) {
       throw new Error(
@@ -1830,9 +1954,9 @@ var MockRouteMissError = class extends Error {
   }
 };
 function escapedMockHttp(error) {
-  for (let current = error; current instanceof Error; current = current.cause) {
-    if (current instanceof MockRouteMissError) return true;
-    if (current.message.includes("No mock route for ")) return true;
+  for (const at of causes(error)) {
+    if (at instanceof MockRouteMissError) return true;
+    if (at instanceof Error && at.message.includes("No mock route for ")) return true;
   }
   return false;
 }
@@ -2091,6 +2215,26 @@ function mockConfig(connector) {
   }
   return config;
 }
+function outputTypeOf(value) {
+  if (Array.isArray(value)) return "array";
+  return value === null ? "null" : typeof value;
+}
+function outputTypeFindings(action, output) {
+  return (action.outputs ?? []).flatMap((field) => {
+    const value = output[field.key];
+    if (field.type === void 0 || value === void 0 || value === null) return [];
+    const actual = outputTypeOf(value);
+    if (actual === field.type) return [];
+    return [
+      finding2(
+        "warn",
+        "mock-output-type",
+        `action ${action.type}`,
+        `returned "${field.key}" as ${actual}, but declares it ${field.type}`
+      )
+    ];
+  });
+}
 async function mockFindings(connector, options) {
   if (!options.mock) return [];
   const config = options.config ?? mockConfig(connector);
@@ -2101,19 +2245,20 @@ async function mockFindings(connector, options) {
     const args = Object.fromEntries(
       (action.inputs ?? []).map((input) => [input.key, sampleArg(input)])
     );
-    const { result: thrown, calls } = await withMockHttp(routes, async () => {
+    const { result: ran, calls } = await withMockHttp(routes, async () => {
       try {
-        await runAction(connector, action.type, args, {
+        const output = await runAction(connector, action.type, args, {
           config,
           ...options.now && { now: options.now },
           sessionFetchImpl: globalThis.fetch
         });
-        return void 0;
+        return { output };
       } catch (error) {
-        return error;
+        return { thrown: error };
       }
     });
-    if (thrown !== void 0) {
+    if ("thrown" in ran) {
+      const { thrown } = ran;
       const reason = thrown instanceof Error ? thrown.message : String(thrown);
       const escaped = escapedMockHttp(thrown);
       found.push(
@@ -2136,6 +2281,7 @@ async function mockFindings(connector, options) {
         )
       );
     }
+    found.push(...outputTypeFindings(action, ran.output));
   }
   return found;
 }
@@ -2296,7 +2442,7 @@ function liveExamines(connector) {
   return connector.preflight !== void 0 || connector.actions.some(liveRunnable);
 }
 function needsWindow(error) {
-  return error instanceof SessionUnavailableError || error instanceof Error && error.cause instanceof SessionUnavailableError;
+  return [...causes(error)].some((at) => at instanceof SessionUnavailableError);
 }
 async function liveFindings(connector, options) {
   if (!options.live) return [];
@@ -2517,6 +2663,7 @@ var CHECK_OWNERS = {
   "mock-action-failed": "mock",
   "mock-network-escape": "mock",
   "mock-not-observed": "mock",
+  "mock-output-type": "mock",
   "preflight-failed": "live",
   "live-action-failed": "live",
   "pack-launch": "launch",
@@ -2643,7 +2790,7 @@ async function packConnector(connector, options) {
 
 // src/scaffold.ts
 var ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-var SDK_DEPENDENCY_RANGE = "^0.7.0-beta.14";
+var SDK_DEPENDENCY_RANGE = "^0.7.1-beta.3";
 var SCAFFOLD_VERSION = "0.1.0";
 var VITEST_RANGE = "^4.1.10";
 function jsonFile(value) {
@@ -3208,271 +3355,228 @@ function scaffoldFiles(options) {
 }
 
 // src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-function sessionCallOf(extra) {
-  const key = extra._meta?.[SESSION_CALL_META];
-  return typeof key === "string" ? { sessionCall: key } : {};
-}
-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 describeInput(input) {
-  const base = input.description ?? input.label;
-  if (input.loadOptions !== void 0) {
-    return `${base}. Choices come from this connector's "${input.loadOptions}" list.`;
+var SDK_VERSION = true ? "0.7.1-beta.3" : "0.0.0-source";
+var InvalidParams = class extends Error {
+};
+function text(params, key) {
+  const value = params[key];
+  if (typeof value !== "string" || value === "") {
+    throw new InvalidParams(`"${key}" must be a non-empty string`);
   }
-  if (input.type === "json") return `${base}. Takes JSON.`;
-  const choices = (input.options ?? []).map((option) => option.value).filter((value) => typeof value === "string" && value !== "");
-  if (choices.length > 0) return `${base}. Suggested values: ${choices.join(", ")}.`;
-  return base;
+  return value;
+}
+function optionalText(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new InvalidParams(`"${key}" must be a string`);
+  return value;
 }
-function inputShape(inputs) {
-  const shape = {};
-  for (const input of inputs) {
-    const base = z.string().describe(describeInput(input));
-    shape[input.key] = input.required ? base : base.optional();
+function optionalNumber(params, key) {
+  const value = params[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new InvalidParams(`"${key}" must be a number`);
   }
-  return shape;
+  return value;
 }
-function scalar(type) {
-  if (type === "number") return z.number();
-  if (type === "boolean") return z.boolean();
-  if (type === "string") return z.string();
-  return z.unknown();
+function failure(id, error) {
+  return { jsonrpc: "2.0", id, error };
 }
-function outputSchema(outputs) {
-  const shape = {};
-  for (const output of outputs) {
-    shape[output.key] = scalar(output.type).nullish().describe(output.description ?? output.key);
-  }
-  return z.looseObject(shape);
+function refusal2(id, code, message) {
+  return failure(id, { code, message });
 }
 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)
-          });
-        }
-      }
-    );
-  }
-  const optionSets = Object.keys(connector.options ?? {});
-  if (optionSets.length > 0) {
-    server.registerTool(
-      OPTIONS_TOOL,
-      {
-        description: `List what one of ${connector.name}'s fields can be set to`,
-        inputSchema: {
-          name: z.enum(optionSets).describe("Which options set to list")
-        },
-        outputSchema: z.looseObject({
-          options: z.array(z.looseObject({ value: z.string(), label: z.string().optional() })).describe("The choices, each a value to send and words to show")
-        })
-      },
-      async (args, extra) => {
-        try {
-          return json({
-            options: await runOptions(connector, args.name, {
-              config: config(),
-              ...options.now && { now: options.now },
-              ...sessionCallOf(extra)
-            })
-          });
-        } catch (error) {
-          return failure(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, extra) => {
-        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 },
-              ...sessionCallOf(extra)
-            })
-          );
-        } catch (error) {
-          return failure(error);
-        }
-      }
-    );
-  }
-  const sessionShape = {
-    sessionId: z.string().describe("The session this is being computed for"),
-    worktreePath: z.string().describe("Where the session's work is"),
-    agent: z.enum(EXTENSION_AGENTS).describe("Which agent runs in the session")
-  };
-  const sessionContext = (args, host) => ({
-    sessionId: args.sessionId,
-    worktreePath: args.worktreePath,
-    agent: args.agent,
-    host,
-    now: options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString())
+  const now = options.now;
+  let greeted = false;
+  const runtime = (params) => ({
+    config: config(),
+    now,
+    sessionCall: optionalText(params, "sessionCall")
   });
   const hostFor = (sessionId) => options.host?.(sessionId) ?? createExtensionHost({ sessionId });
-  for (const footer of connector.contributes?.footers ?? []) {
-    server.registerTool(
-      footerToolName(footer.id),
-      {
-        title: footer.title,
-        description: footer.description ?? `Recompute ${footer.title} for one session`,
-        inputSchema: sessionShape,
-        outputSchema: z.looseObject({
-          items: z.array(z.looseObject({ label: z.string(), value: z.string() })).describe("The readings to show in the band")
-        })
-      },
-      async (args) => {
-        try {
-          const items = await footer.run(sessionContext(args, hostFor(args.sessionId)));
-          return json({ items });
-        } catch (error) {
-          return failure(error);
-        }
+  const sessionContext = (params) => {
+    const agent = text(params, "agent");
+    if (!EXTENSION_AGENTS.includes(agent)) {
+      throw new InvalidParams(`"agent" must be one of ${EXTENSION_AGENTS.join(", ")}`);
+    }
+    const sessionId = text(params, "sessionId");
+    return {
+      sessionId,
+      worktreePath: text(params, "worktreePath"),
+      agent,
+      host: hostFor(sessionId),
+      now: now ?? (() => (/* @__PURE__ */ new Date()).toISOString())
+    };
+  };
+  const methods = {
+    [PROTOCOL_METHODS.manifest]: () => connectorManifest(connector),
+    // A throw is the connector saying "broken", which must not read as a passing check.
+    [PROTOCOL_METHODS.preflight]: async () => {
+      if (!connector.preflight) return { ok: null };
+      try {
+        return { ...await connector.preflight() };
+      } catch (error) {
+        return { ok: false, message: messageOf(error) };
       }
-    );
-  }
-  for (const handler of connector.contributes?.linkHandlers ?? []) {
-    server.registerTool(
-      handlerToolName(handler.id),
-      {
-        title: handler.title,
-        description: handler.description ?? `Open ${handler.title} for a clicked link`,
-        inputSchema: {
-          ...sessionShape,
-          url: z.string().describe("The clicked text, which matched this handler")
-        },
-        outputSchema: z.looseObject({
-          openPane: z.string().optional().describe("Id of one of this extension's panes to open")
-        })
-      },
-      async (args) => {
-        try {
-          const handled = await handler.run({
-            ...sessionContext(args, hostFor(args.sessionId)),
-            url: args.url
-          });
-          return json({ ...handled ?? {} });
-        } catch (error) {
-          return failure(error);
-        }
+    },
+    [PROTOCOL_METHODS.options]: async (params) => ({
+      options: await runOptions(connector, text(params, "name"), runtime(params))
+    }),
+    [PROTOCOL_METHODS.poll]: (params) => runPoll(connector, text(params, "trigger"), {
+      ...runtime(params),
+      cursor: optionalText(params, "cursor"),
+      since: optionalText(params, "since"),
+      limit: optionalNumber(params, "limit")
+    }),
+    [PROTOCOL_METHODS.action]: (params) => {
+      const action = text(params, "action");
+      const args = params.args ?? {};
+      if (!isRecord(args)) throw new InvalidParams('"args" must be an object');
+      return runAction(connector, action, args, runtime(params));
+    },
+    [PROTOCOL_METHODS.footer]: async (params) => {
+      const id = text(params, "footer");
+      const footer = connector.contributes?.footers?.find((entry) => entry.id === id);
+      if (!footer) throw new InvalidParams(`${connector.id} contributes no footer "${id}"`);
+      return { items: await footer.run(sessionContext(params)) };
+    },
+    [PROTOCOL_METHODS.handler]: async (params) => {
+      const id = text(params, "handler");
+      const handler = connector.contributes?.linkHandlers?.find((entry) => entry.id === id);
+      if (!handler) throw new InvalidParams(`${connector.id} contributes no link handler "${id}"`);
+      const context = { ...sessionContext(params), url: text(params, "url") };
+      return { ...await handler.run(context) ?? {} };
+    }
+  };
+  const hello = (id, params) => {
+    const offered = params.protocols;
+    if (!Array.isArray(offered)) {
+      return refusal2(id, PROTOCOL_ERROR_CODES.invalidParams, '"protocols" must be a list');
+    }
+    if (!offered.includes(PROTOCOL_VERSION)) {
+      return refusal2(
+        id,
+        PROTOCOL_ERROR_CODES.unsupportedProtocol,
+        `Vorn offers connector protocol ${offered.join(", ") || "none"}; ${connector.id} speaks ${PROTOCOL_VERSION}`
+      );
+    }
+    greeted = true;
+    const result = {
+      protocol: PROTOCOL_VERSION,
+      sdk: { name: "@vornrun/connector-sdk", version: SDK_VERSION },
+      connector: { id: connector.id, version: connector.version, kind: connector.kind }
+    };
+    return { jsonrpc: "2.0", id, result };
+  };
+  return {
+    async handle(message) {
+      if (!isRecord(message) || typeof message.id !== "number") return void 0;
+      const { id, method } = message;
+      if (typeof method !== "string") {
+        return refusal2(id, PROTOCOL_ERROR_CODES.invalidParams, "A request names its method");
       }
-    );
-  }
-  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,
-      {
-        // Carries the authored label, so a picker can name the action rather than its tool.
-        title: action.label,
-        description: `${base}${retryHint}`,
-        inputSchema: inputShape(action.inputs ?? []),
-        outputSchema: outputSchema(action.outputs ?? [])
-      },
-      async (args, extra) => {
-        try {
-          return json(
-            await runAction(connector, action.type, args, {
-              config: config(),
-              ...options.now && { now: options.now },
-              ...sessionCallOf(extra)
-            })
-          );
-        } catch (error) {
-          return failure(error);
+      const params = message.params ?? {};
+      if (!isRecord(params)) {
+        return refusal2(id, PROTOCOL_ERROR_CODES.invalidParams, '"params" must be an object');
+      }
+      if (method === PROTOCOL_METHODS.hello) return hello(id, params);
+      const run = Object.hasOwn(methods, method) ? methods[method] : void 0;
+      if (!run) return refusal2(id, PROTOCOL_ERROR_CODES.methodNotFound, "Method not found");
+      if (!greeted) {
+        return refusal2(
+          id,
+          PROTOCOL_ERROR_CODES.beforeHello,
+          `Call ${PROTOCOL_METHODS.hello} before ${method}`
+        );
+      }
+      try {
+        return { jsonrpc: "2.0", id, result: await run(params) };
+      } catch (error) {
+        if (error instanceof InvalidParams || error instanceof UnknownNameError) {
+          return refusal2(id, PROTOCOL_ERROR_CODES.invalidParams, error.message);
         }
+        return failure(id, protocolError(error));
       }
-    );
+    }
+  };
+}
+function frame(response) {
+  try {
+    const line = JSON.stringify(response);
+    if (Buffer.byteLength(line) > MAX_FRAME_BYTES) {
+      throw new Error(`The answer is over ${MAX_FRAME_BYTES} bytes`);
+    }
+    return line;
+  } catch (error) {
+    return JSON.stringify(failure(response.id, protocolError(error)));
   }
-  return server;
 }
+var SERVING = /* @__PURE__ */ Symbol.for("@vornrun/connector-sdk/serving");
 async function serveConnector(connector, options = {}) {
+  const shared = globalThis;
+  if (shared[SERVING]) return;
+  shared[SERVING] = true;
+  const reply2 = process.stdout.write.bind(process.stdout);
+  process.stdout.write = process.stderr.write.bind(process.stderr);
   const server = createConnectorServer(connector, options);
-  await server.connect(new StdioServerTransport());
+  let inFlight = 0;
+  let ended = false;
+  const finish = () => {
+    if (ended && inFlight === 0) reply2("", () => process.exit(0));
+  };
+  const onLine = (line) => {
+    if (line.trim() === "") return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      process.stderr.write(`${connector.id}: skipped a line that is not JSON
+`);
+      return;
+    }
+    inFlight++;
+    void server.handle(message).then((response) => {
+      if (response) reply2(`${frame(response)}
+`);
+    }).finally(() => {
+      inFlight--;
+      finish();
+    });
+  };
+  process.stdin.on(
+    "data",
+    lineReader(onLine, () => {
+      process.stderr.write(`${connector.id}: a message was over ${MAX_FRAME_BYTES} bytes
+`);
+      process.exit(1);
+    })
+  );
+  process.stdin.on("end", () => {
+    ended = true;
+    finish();
+  });
 }
 
 export {
   BROWSER_HOST_ENV,
   BROWSER_TOKEN_ENV,
-  SESSION_CALL_META,
   SESSION_CALL_HEADER,
   SessionUnavailableError,
   SessionRefusedError,
   createSessionFetch,
+  PROTOCOL_VERSION,
+  SUPPORTED_PROTOCOLS,
+  MAX_FRAME_BYTES,
+  PROTOCOL_METHODS,
+  PROTOCOL_ERROR_CODES,
+  PROTOCOL_ERROR_KINDS,
+  retryAfterMs,
+  backoffMs,
+  resilientFetch,
+  ActionArgumentError,
+  UpstreamStatusError,
   ORIGIN_PATTERN,
   withinOrigins,
   valueAt,
@@ -3483,12 +3587,6 @@ export {
   defineConnector,
   defineExtension,
   resolveConfig,
-  pollToolName,
-  footerToolName,
-  handlerToolName,
-  MANIFEST_TOOL,
-  PREFLIGHT_TOOL,
-  OPTIONS_TOOL,
   connectionSetup,
   connectorManifest,
   MAX_PACK_BYTES,
@@ -3510,9 +3608,6 @@ export {
   MAX_REQUEST_PAGES,
   nextLink,
   executeRequest,
-  retryAfterMs,
-  backoffMs,
-  resilientFetch,
   MAX_POLL_PAGES,
   runPoll,
   drainPoll,