@agentproto/connector 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy André and agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/descriptor.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ConnectorMcpDescriptor — the portable, host-agnostic description of an MCP
+ * connector: how its MCP server runs / is reached. Lifted out of guilde (where
+ * it lived as a private flat-bag interface) so ANYONE — not just guilde — can
+ * describe an MCP connector against the open standard.
+ *
+ * It is a discriminated union over `kind` so each kind carries only its valid
+ * fields (the guilde original was a flat optional-bag where every field could
+ * appear on any kind). The four kinds:
+ *
+ *   - `hosted`        — the platform runs the MCP server; creds passed in.
+ *   - `sandbox`       — ephemeral per-install process spawned from a package /
+ *                       entry point (DXT-parallel).
+ *   - `external`      — the user points the platform at their own MCP URL.
+ *   - `local-daemon`  — the MCP server runs on the user's own agentproto daemon
+ *                       and is reached over a reverse tunnel. No URL / no creds
+ *                       on the descriptor — dispatch is pinned to a daemon
+ *                       identity and routed by `importAlias`.
+ *
+ * What does NOT live here: catalog/marketplace metadata (category, logo,
+ * vendor, billing, auth-method UI), vault wiring, DB persistence, and any
+ * host-specific resolution (e.g. guilde's bureau device-link). Those stay in
+ * the consumer (guilde's `ConnectorProviderConfig` wraps this via its `mcp`
+ * field). This type is just the runnable description.
+ */
+/** Fields common to every connector kind. */
+interface ConnectorMcpBase {
+    /** URL-safe slug used when assigning this connector to agents / operators. */
+    slug: string;
+    /** Set when auth is delegated to an OAuth provider (provider slug). */
+    oauthProvider?: string;
+}
+/** The platform runs the MCP server at a known URL; credentials are injected. */
+interface HostedConnectorMcp extends ConnectorMcpBase {
+    kind: "hosted";
+    /**
+     * MCP endpoint URL. A host MAY template this (e.g. guilde injects its
+     * public base URL) — the descriptor carries the resolved-or-templated value.
+     */
+    serverUrl: string;
+}
+/**
+ * Ephemeral per-install process spawned from a package / entry point — the
+ * DXT-parallel local-process model. Fields mirror a minimal process spec.
+ */
+interface SandboxConnectorMcp extends ConnectorMcpBase {
+    kind: "sandbox";
+    /** Runtime the entry point targets. */
+    runtime?: "node" | "python";
+    /** Entry point (file / module) the runtime executes. */
+    entryPoint?: string;
+    /** Extra arguments passed to the entry point. */
+    args?: string[];
+    /** Static (non-secret) environment for the spawned process. Secrets reach
+     *  the process via the connector's credential requirements, not here. */
+    env?: Record<string, string>;
+    /** npm/PyPI package the entry point lives in, when applicable. */
+    packageName?: string;
+}
+/** The user points the platform at their own already-running MCP server. */
+interface ExternalConnectorMcp extends ConnectorMcpBase {
+    kind: "external";
+    /** Optional default; usually supplied by the user at install time. */
+    serverUrl?: string;
+}
+/**
+ * The MCP server runs on the user's own agentproto daemon and is reached over
+ * a reverse tunnel. No URL / creds on the descriptor — dispatch is pinned to a
+ * daemon identity and routed by `importAlias`.
+ */
+interface LocalDaemonConnectorMcp extends ConnectorMcpBase {
+    kind: "local-daemon";
+    /** Alias the user's daemon imports this MCP under (e.g. "bureau"). */
+    importAlias: string;
+    /**
+     * Tunnel provider this connector rides on — referenced BY SLUG only (one of
+     * `@agentproto/runtime`'s built-in tunnel slugs, e.g. `cloudflare-quick` /
+     * `cloudflare-named` / `ngrok`, or any third-party
+     * `@scope/agentproto-adapter-<slug>`). Resolution to a live provider is the
+     * consumer's runtime concern (`resolveTunnelProvider`) — keeping this type
+     * out of the runtime layer. Optional: hosts that run a single shared reverse
+     * tunnel for all local-daemon connectors leave it unset.
+     */
+    tunnelProvider?: string;
+}
+/** Discriminated union over the four connector kinds. */
+type ConnectorMcpDescriptor = HostedConnectorMcp | SandboxConnectorMcp | ExternalConnectorMcp | LocalDaemonConnectorMcp;
+/** All connector kind discriminants. */
+type ConnectorMcpKind = ConnectorMcpDescriptor["kind"];
+
+export type { ConnectorMcpDescriptor, ConnectorMcpKind, ExternalConnectorMcp, HostedConnectorMcp, LocalDaemonConnectorMcp, SandboxConnectorMcp };

package/dist/descriptor.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=descriptor.mjs.map
+//# sourceMappingURL=descriptor.mjs.map

package/dist/descriptor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"descriptor.mjs"}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { ConnectorMcpDescriptor, ExternalConnectorMcp, HostedConnectorMcp, LocalDaemonConnectorMcp, SandboxConnectorMcp } from './descriptor.js';
+export { ConnectorMcpKind } from './descriptor.js';
+export { ConnectorCredentialRequirement, ConnectorSecretKind } from './requirements.js';
+import { z } from 'zod';
+import '@agentproto/adapter-kit';
+import '@agentproto/secrets/exposure';
+
+/**
+ * Type guards + a zod schema for {@link ConnectorMcpDescriptor}. The guards are
+ * the ergonomic narrowing path in TS; the schema is for runtime validation at
+ * trust boundaries (parsing a descriptor from JSON / an API / a config file).
+ */
+
+declare const isHostedConnector: (d: ConnectorMcpDescriptor) => d is HostedConnectorMcp;
+declare const isSandboxConnector: (d: ConnectorMcpDescriptor) => d is SandboxConnectorMcp;
+declare const isExternalConnector: (d: ConnectorMcpDescriptor) => d is ExternalConnectorMcp;
+declare const isLocalDaemonConnector: (d: ConnectorMcpDescriptor) => d is LocalDaemonConnectorMcp;
+/** Runtime validator for a {@link ConnectorMcpDescriptor}. */
+declare const connectorMcpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"hosted">;
+    slug: z.ZodString;
+    oauthProvider: z.ZodOptional<z.ZodString>;
+    serverUrl: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"sandbox">;
+    slug: z.ZodString;
+    oauthProvider: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodOptional<z.ZodEnum<{
+        node: "node";
+        python: "python";
+    }>>;
+    entryPoint: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    packageName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    slug: z.ZodString;
+    oauthProvider: z.ZodOptional<z.ZodString>;
+    serverUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"local-daemon">;
+    slug: z.ZodString;
+    oauthProvider: z.ZodOptional<z.ZodString>;
+    importAlias: z.ZodString;
+    tunnelProvider: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+/** Parse + validate an unknown value as a {@link ConnectorMcpDescriptor}.
+ *  Throws (zod error) on mismatch. */
+declare function parseConnectorMcp(value: unknown): ConnectorMcpDescriptor;
+/** Non-throwing variant — returns null on mismatch. */
+declare function safeParseConnectorMcp(value: unknown): ConnectorMcpDescriptor | null;
+
+export { ConnectorMcpDescriptor, ExternalConnectorMcp, HostedConnectorMcp, LocalDaemonConnectorMcp, SandboxConnectorMcp, connectorMcpSchema, isExternalConnector, isHostedConnector, isLocalDaemonConnector, isSandboxConnector, parseConnectorMcp, safeParseConnectorMcp };

package/dist/index.mjs

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+
+/**
+ * @agentproto/connector v0.1.0-alpha
+ * ConnectorMcpDescriptor — portable description of an MCP connector.
+ */
+
+var isKind = (d, kind) => d.kind === kind;
+var isHostedConnector = (d) => isKind(d, "hosted");
+var isSandboxConnector = (d) => isKind(d, "sandbox");
+var isExternalConnector = (d) => isKind(d, "external");
+var isLocalDaemonConnector = (d) => isKind(d, "local-daemon");
+var hostedSchema = z.object({
+  kind: z.literal("hosted"),
+  slug: z.string().min(1),
+  oauthProvider: z.string().optional(),
+  serverUrl: z.string().min(1)
+});
+var sandboxSchema = z.object({
+  kind: z.literal("sandbox"),
+  slug: z.string().min(1),
+  oauthProvider: z.string().optional(),
+  runtime: z.enum(["node", "python"]).optional(),
+  entryPoint: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  packageName: z.string().optional()
+});
+var externalSchema = z.object({
+  kind: z.literal("external"),
+  slug: z.string().min(1),
+  oauthProvider: z.string().optional(),
+  serverUrl: z.string().optional()
+});
+var localDaemonSchema = z.object({
+  kind: z.literal("local-daemon"),
+  slug: z.string().min(1),
+  oauthProvider: z.string().optional(),
+  importAlias: z.string().min(1),
+  tunnelProvider: z.string().optional()
+});
+var connectorMcpSchema = z.discriminatedUnion("kind", [
+  hostedSchema,
+  sandboxSchema,
+  externalSchema,
+  localDaemonSchema
+]);
+function parseConnectorMcp(value) {
+  return connectorMcpSchema.parse(value);
+}
+function safeParseConnectorMcp(value) {
+  const result = connectorMcpSchema.safeParse(value);
+  return result.success ? result.data : null;
+}
+
+export { connectorMcpSchema, isExternalConnector, isHostedConnector, isLocalDaemonConnector, isSandboxConnector, parseConnectorMcp, safeParseConnectorMcp };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/guards.ts"],"names":[],"mappings":"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","file":"index.mjs","sourcesContent":["/**\n * Type guards + a zod schema for {@link ConnectorMcpDescriptor}. The guards are\n * the ergonomic narrowing path in TS; the schema is for runtime validation at\n * trust boundaries (parsing a descriptor from JSON / an API / a config file).\n */\n\nimport { z } from \"zod\"\nimport type {\n  ConnectorMcpDescriptor,\n  ConnectorMcpKind,\n  HostedConnectorMcp,\n  SandboxConnectorMcp,\n  ExternalConnectorMcp,\n  LocalDaemonConnectorMcp,\n} from \"./descriptor.js\"\n\n// ── type guards ────────────────────────────────────────────────────────────\n\nconst isKind = <K extends ConnectorMcpKind>(\n  d: ConnectorMcpDescriptor,\n  kind: K,\n): d is Extract<ConnectorMcpDescriptor, { kind: K }> => d.kind === kind\n\nexport const isHostedConnector = (\n  d: ConnectorMcpDescriptor,\n): d is HostedConnectorMcp => isKind(d, \"hosted\")\n\nexport const isSandboxConnector = (\n  d: ConnectorMcpDescriptor,\n): d is SandboxConnectorMcp => isKind(d, \"sandbox\")\n\nexport const isExternalConnector = (\n  d: ConnectorMcpDescriptor,\n): d is ExternalConnectorMcp => isKind(d, \"external\")\n\nexport const isLocalDaemonConnector = (\n  d: ConnectorMcpDescriptor,\n): d is LocalDaemonConnectorMcp => isKind(d, \"local-daemon\")\n\n// ── zod schema ───────────────────────────────────────────────────────────────\n\nconst hostedSchema = z.object({\n  kind: z.literal(\"hosted\"),\n  slug: z.string().min(1),\n  oauthProvider: z.string().optional(),\n  serverUrl: z.string().min(1),\n})\n\nconst sandboxSchema = z.object({\n  kind: z.literal(\"sandbox\"),\n  slug: z.string().min(1),\n  oauthProvider: z.string().optional(),\n  runtime: z.enum([\"node\", \"python\"]).optional(),\n  entryPoint: z.string().optional(),\n  args: z.array(z.string()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  packageName: z.string().optional(),\n})\n\nconst externalSchema = z.object({\n  kind: z.literal(\"external\"),\n  slug: z.string().min(1),\n  oauthProvider: z.string().optional(),\n  serverUrl: z.string().optional(),\n})\n\nconst localDaemonSchema = z.object({\n  kind: z.literal(\"local-daemon\"),\n  slug: z.string().min(1),\n  oauthProvider: z.string().optional(),\n  importAlias: z.string().min(1),\n  tunnelProvider: z.string().optional(),\n})\n\n/** Runtime validator for a {@link ConnectorMcpDescriptor}. */\nexport const connectorMcpSchema = z.discriminatedUnion(\"kind\", [\n  hostedSchema,\n  sandboxSchema,\n  externalSchema,\n  localDaemonSchema,\n])\n\n// Compile-time proof that the zod schema and the hand-written union stay in\n// sync: if either drifts, one of these assertions stops being `true` and the\n// build fails. It also means `schema.parse()` already returns a value\n// assignable to ConnectorMcpDescriptor — so the parse helpers need no cast.\ntype Expect<T extends true> = T\ntype _SchemaInfersType = Expect<\n  z.infer<typeof connectorMcpSchema> extends ConnectorMcpDescriptor ? true : false\n>\ntype _TypeMatchesSchema = Expect<\n  ConnectorMcpDescriptor extends z.infer<typeof connectorMcpSchema> ? true : false\n>\n\n/** Parse + validate an unknown value as a {@link ConnectorMcpDescriptor}.\n *  Throws (zod error) on mismatch. */\nexport function parseConnectorMcp(value: unknown): ConnectorMcpDescriptor {\n  return connectorMcpSchema.parse(value)\n}\n\n/** Non-throwing variant — returns null on mismatch. */\nexport function safeParseConnectorMcp(\n  value: unknown,\n): ConnectorMcpDescriptor | null {\n  const result = connectorMcpSchema.safeParse(value)\n  return result.success ? result.data : null\n}\n"]}

package/dist/requirements.d.ts

@@ -0,0 +1,30 @@
+import { SetupField } from '@agentproto/adapter-kit';
+import { SecretExposure } from '@agentproto/secrets/exposure';
+
+/**
+ * Credential requirements for a connector — what the user must supply and how
+ * each value reaches the runtime that needs it.
+ *
+ * Deliberately reuses two existing agentproto vocabularies rather than
+ * inventing a third:
+ *   - `SetupField` (`@agentproto/adapter-kit`) — the same "field to collect"
+ *     shape the tunnel-provider setup flow uses (name / description / required /
+ *     sensitive). One vocabulary for every credential input across the project.
+ *   - `SecretExposure` (`@agentproto/secrets`) — how a collected value is
+ *     exposed to the runtime (env var / file / egress placeholder).
+ */
+
+/** Coarse classification of a credential — informs storage / UI affordances. */
+type ConnectorSecretKind = "api_key" | "oauth_token" | "json_cred" | "cert" | "signing_key";
+/** One credential a connector needs + how it is exposed to the runtime. */
+interface ConnectorCredentialRequirement {
+    /** The field the user fills (reuses the tunnel-setup field vocabulary). */
+    field: SetupField;
+    /** Coarse kind hint for storage / UI. */
+    secretKind?: ConnectorSecretKind;
+    /** How the collected value reaches the runtime (env / file / egress).
+     *  Omit when the host derives exposure from `secretKind` / context. */
+    exposures?: SecretExposure[];
+}
+
+export type { ConnectorCredentialRequirement, ConnectorSecretKind };

package/dist/requirements.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=requirements.mjs.map
+//# sourceMappingURL=requirements.mjs.map

package/dist/requirements.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"requirements.mjs"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@agentproto/connector",
+  "version": "0.1.0",
+  "description": "@agentproto/connector — ConnectorMcpDescriptor: the portable, host-agnostic description of an MCP connector (how its server runs / is reached + what credentials it needs).",
+  "keywords": [
+    "agentproto",
+    "connector",
+    "mcp",
+    "descriptor"
+  ],
+  "homepage": "https://agentproto.sh",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/connector"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./descriptor": {
+      "types": "./dist/descriptor.d.ts",
+      "import": "./dist/descriptor.mjs",
+      "default": "./dist/descriptor.mjs"
+    },
+    "./requirements": {
+      "types": "./dist/requirements.d.ts",
+      "import": "./dist/requirements.mjs",
+      "default": "./dist/requirements.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agentproto/adapter-kit": "0.1.0",
+    "@agentproto/secrets": "0.1.0-alpha.0"
+  },
+  "peerDependencies": {
+    "zod": ">=3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.4.3",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}