@zackbart/connecta 0.28.0 → 0.28.1

package/dist/connectors/api-connector.js

@@ -0,0 +1,127 @@
+import { ConnectorCallError, networkErrorCode, unavailableCallError, } from "../errors.js";
+import { compileValidator, validateToolInput } from "../validate.js";
+export function defined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+/**
+ * Three things a hand-written surface is refused for at construction rather
+ * than in production (#340): no description (discovery has nothing to route on
+ * and a guess costs a call), no explicit `readOnlyHint` (connecta never infers
+ * the safety class, so an unclassified tool is a deployment bug), and an
+ * `inputSchema` the validator cannot compile (declaring one is optional;
+ * declaring an unenforceable one is not). None of this reaches a proxied
+ * catalog — the contract binds the surfaces we write, not the ones we relay.
+ */
+function checkToolContract(id, tool) {
+    const address = `${id}.${tool.name}`;
+    if (typeof tool.description !== "string" || tool.description.trim() === "") {
+        throw new Error(`api() tool "${address}" needs a non-empty description — it is what an ` +
+            "agent reads to choose the tool (convention: imperative one-liner, " +
+            'e.g. "Send an email via Resend").');
+    }
+    if (typeof tool.annotations?.readOnlyHint !== "boolean") {
+        throw new Error(`api() tool "${address}" needs an explicit annotations.readOnlyHint: ` +
+            "true for a read, false for work that must cross " +
+            "call_destructive_tool. Connecta never infers the classification " +
+            "from a tool name, description, schema, or other annotations.");
+    }
+    if (tool.inputSchema)
+        compileValidator(tool.inputSchema, { address });
+}
+/**
+ * A static connector; every tool passes {@link checkToolContract} first.
+ *
+ * The builder behind `api()`, without the downstream OAuth machinery: a
+ * module that only ever builds credential-free connectors (the artifacts
+ * connector) imports this and pays nothing for a grant it cannot declare.
+ */
+export function apiConnector(id, opts, oauth) {
+    if (opts.oauth !== undefined && oauth === undefined) {
+        throw new Error(`api() connector "${id}" declares oauth but was built without its grant; construct it with api().`);
+    }
+    const names = new Set();
+    for (const tool of opts.tools) {
+        if (names.has(tool.name)) {
+            throw new Error(`api() tool "${id}.${tool.name}" is declared more than once; discovery and dispatch must use one definition.`);
+        }
+        names.add(tool.name);
+        checkToolContract(id, tool);
+    }
+    const defs = opts.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        ...defined({
+            inputSchema: t.inputSchema,
+            outputSchema: t.outputSchema,
+        }),
+        annotations: t.annotations,
+    }));
+    const byName = new Map(opts.tools.map((t) => [t.name, t]));
+    const validateArgs = opts.validateArgs ?? true;
+    return {
+        id,
+        ...defined({ title: opts.title }),
+        kind: "api",
+        ...defined({
+            description: opts.description,
+            authScope: opts.authScope,
+            maxResultBytes: opts.maxResultBytes,
+            callAdmission: opts.callAdmission,
+            usageGuide: opts.usageGuide,
+            credential: opts.credential,
+            testCredential: opts.testCredential,
+            testCredentials: opts.testCredentials,
+        }),
+        ...(oauth
+            ? {
+                status: oauth.status,
+                startAuth: oauth.startAuth,
+                disconnectAuth: oauth.disconnectAuth,
+                verifyState: oauth.verifyState,
+                finishAuth: oauth.finishAuth,
+            }
+            : {}),
+        staticTools: defs,
+        async listTools() {
+            return defs;
+        },
+        async callTool(name, args, ctx) {
+            const tool = byName.get(name);
+            if (!tool) {
+                throw new Error(`Unknown tool "${name}" on connector "${id}"`);
+            }
+            const input = args ?? {};
+            if (validateArgs && tool.inputSchema) {
+                const invalid = validateToolInput(tool.inputSchema, input, {
+                    address: `${id}.${name}`,
+                    logger: ctx.logger,
+                    // Always: the schema compiled at construction, so anything that
+                    // fails here is a schema that cannot be enforced, and a surface we
+                    // wrote ourselves does not get to admit unvalidated input quietly.
+                    failClosed: true,
+                });
+                if (invalid)
+                    throw invalid;
+            }
+            // `await` (not a bare promise return) so a handler that throws before
+            // its first await never sits handler-less for the thenable-adoption
+            // microtask — workerd and vitest both report that gap as an unhandled
+            // rejection even though the caller catches the failure.
+            // The accessor closes over the registry's own context, not this copy,
+            // so the grant it reaches is the one that context's owner holds.
+            const handlerCtx = oauth
+                ? { ...ctx, oauth: oauth.access(ctx) }
+                : ctx;
+            try {
+                return await tool.handler(input, handlerCtx);
+            }
+            catch (error) {
+                // A handler owns its destinations. ctx.baseUrl is Connecta's inbound
+                // URL, so it must never masquerade as the failed downstream host.
+                if (error instanceof ConnectorCallError || !networkErrorCode(error))
+                    throw error;
+                throw unavailableCallError(error);
+            }
+        },
+    };
+}

package/dist/connectors/api.d.ts

@@ -1,72 +1,9 @@
-import type { Connector, ConnectorCallAdmissionPolicy, ConnectorCredentialConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, CredentialTestResult, JsonSchema, ToolAnnotations } from "../types.js";
-export declare function defined<T extends object>(value: T): {
-    [K in keyof T]?: Exclude<T[K], undefined>;
-};
-export interface ApiTool {
-    name: string;
-    /**
-     * Required, non-empty. Discovery has nothing else to go on: a nameless
-     * capability costs the agent a guess, and a guess costs a wrong call.
-     */
-    description: string;
-    /**
-     * A plain JSON Schema object describing the tool input. Optional, but what
-     * you supply must be a schema the validator can compile — `api()` refuses to
-     * construct otherwise.
-     */
-    inputSchema?: JsonSchema;
-    /** A plain JSON Schema object describing the tool's structured output. */
-    outputSchema?: JsonSchema;
-    /**
-     * Standard MCP-style behavior hints, with an explicit `readOnlyHint`
-     * required: `true` declares a read and admits the tool to call_tool and
-     * execute_code, `false` declares work that must cross
-     * `call_destructive_tool` where a host can ask a human. Connecta never
-     * infers the classification from a name, a description, a schema, or the
-     * other annotations.
-     */
-    annotations: ToolAnnotations & {
-        readOnlyHint: boolean;
-    };
-    handler: (args: any, ctx: ConnectorContext) => Promise<unknown> | unknown;
-}
-export interface ApiOptions {
-    /** Human-readable display name; the connector id remains the address prefix. */
-    title?: string;
-    description?: string;
-    /** Downstream auth ownership. Defaults to one shared deployment grant. */
-    authScope?: "shared" | "personal";
-    /**
-     * Max inline result size (bytes) for this connector's tools before
-     * call_tool truncates and stashes the full text for get_result
-     * paging. Overrides the deployment's `calls.maxResultBytes`; omit to inherit
-     * it. Must be a whole number of bytes >= 1; anything else warns at startup
-     * and is ignored.
-     */
-    maxResultBytes?: number;
-    /** Optional per-runtime downstream call-admission policy. */
-    callAdmission?: ConnectorCallAdmissionPolicy;
-    /**
-     * Optional agent-facing usage guide served by `skills` as
-     * `connector:<id>`. A string is markdown; the structured form adds bounded
-     * discovery metadata. See `Connector.usageGuide`.
-     */
-    usageGuide?: string | ConnectorUsageGuide;
-    /** Optional operator-managed credential exposed through ctx.credential and the connection in the operator UI. */
-    credential?: ConnectorCredentialConfig;
-    /** Optional validation behind the connection's Test action in the operator UI. */
-    testCredential?: (value: string, ctx: ConnectorContext) => Promise<CredentialTestResult>;
-    /** Optional validation for named multi-field credentials. */
-    testCredentials?: (values: ConnectorCredentialValues, ctx: ConnectorContext) => Promise<CredentialTestResult>;
-    /**
-     * Validate call arguments against each tool's `inputSchema` before invoking
-     * the handler (default true). Mismatches fail with a non-retryable
-     * `invalid_args` ConnectorCallError instead of reaching the handler. Set
-     * false to restore the pre-validation pass-through for deployments relying
-     * on loose coercion.
-     */
-    validateArgs?: boolean;
-    tools: ApiTool[];
-}
-/** A static connector; every tool passes {@link checkToolContract} first. */
+import type { Connector } from "../types.js";
+import type { ApiOptions } from "./api-connector.js";
+export type { ApiHandlerContext, ApiOAuthAccess, ApiOAuthClientAuthentication, ApiOAuthConfig, ApiOptions, ApiTool, } from "./api-connector.js";
+/**
+ * A hand-written connector: static tools, each with a handler. With `oauth`,
+ * its handlers reach the API through the calling owner's downstream grant
+ * (`ctx.oauth`), managed exactly like a `remoteMcp()` grant.
+ */
 export declare function api(id: string, opts: ApiOptions): Connector;

package/dist/connectors/api.js

@@ -1,104 +1,15 @@
-import { ConnectorCallError, networkErrorCode, unavailableCallError, } from "../errors.js";
-import { compileValidator, validateToolInput } from "../validate.js";
-export function defined(value) {
-    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
-}
+import { staticOAuth } from "../auth/static-oauth.js";
+import { apiConnector } from "./api-connector.js";
 /**
- * Three things a hand-written surface is refused for at construction rather
- * than in production (#340): no description (discovery has nothing to route on
- * and a guess costs a call), no explicit `readOnlyHint` (connecta never infers
- * the safety class, so an unclassified tool is a deployment bug), and an
- * `inputSchema` the validator cannot compile (declaring one is optional;
- * declaring an unenforceable one is not). None of this reaches a proxied
- * catalog — the contract binds the surfaces we write, not the ones we relay.
+ * A hand-written connector: static tools, each with a handler. With `oauth`,
+ * its handlers reach the API through the calling owner's downstream grant
+ * (`ctx.oauth`), managed exactly like a `remoteMcp()` grant.
  */
-function checkToolContract(id, tool) {
-    const address = `${id}.${tool.name}`;
-    if (typeof tool.description !== "string" || tool.description.trim() === "") {
-        throw new Error(`api() tool "${address}" needs a non-empty description — it is what an ` +
-            "agent reads to choose the tool (convention: imperative one-liner, " +
-            'e.g. "Send an email via Resend").');
-    }
-    if (typeof tool.annotations?.readOnlyHint !== "boolean") {
-        throw new Error(`api() tool "${address}" needs an explicit annotations.readOnlyHint: ` +
-            "true for a read, false for work that must cross " +
-            "call_destructive_tool. Connecta never infers the classification " +
-            "from a tool name, description, schema, or other annotations.");
-    }
-    if (tool.inputSchema)
-        compileValidator(tool.inputSchema, { address });
-}
-/** A static connector; every tool passes {@link checkToolContract} first. */
 export function api(id, opts) {
-    const names = new Set();
-    for (const tool of opts.tools) {
-        if (names.has(tool.name)) {
-            throw new Error(`api() tool "${id}.${tool.name}" is declared more than once; discovery and dispatch must use one definition.`);
-        }
-        names.add(tool.name);
-        checkToolContract(id, tool);
+    if (opts.oauth !== undefined && opts.credential !== undefined) {
+        throw new Error(`api() connector "${id}" declares both oauth and credential. Declare ` +
+            "one: auth_required must name a single recovery. A provider offering " +
+            "both lets the deployment choose which one to pass.");
     }
-    const defs = opts.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        ...defined({
-            inputSchema: t.inputSchema,
-            outputSchema: t.outputSchema,
-        }),
-        annotations: t.annotations,
-    }));
-    const byName = new Map(opts.tools.map((t) => [t.name, t]));
-    const validateArgs = opts.validateArgs ?? true;
-    return {
-        id,
-        ...defined({ title: opts.title }),
-        kind: "api",
-        ...defined({
-            description: opts.description,
-            authScope: opts.authScope,
-            maxResultBytes: opts.maxResultBytes,
-            callAdmission: opts.callAdmission,
-            usageGuide: opts.usageGuide,
-            credential: opts.credential,
-            testCredential: opts.testCredential,
-            testCredentials: opts.testCredentials,
-        }),
-        staticTools: defs,
-        async listTools() {
-            return defs;
-        },
-        async callTool(name, args, ctx) {
-            const tool = byName.get(name);
-            if (!tool) {
-                throw new Error(`Unknown tool "${name}" on connector "${id}"`);
-            }
-            const input = args ?? {};
-            if (validateArgs && tool.inputSchema) {
-                const invalid = validateToolInput(tool.inputSchema, input, {
-                    address: `${id}.${name}`,
-                    logger: ctx.logger,
-                    // Always: the schema compiled at construction, so anything that
-                    // fails here is a schema that cannot be enforced, and a surface we
-                    // wrote ourselves does not get to admit unvalidated input quietly.
-                    failClosed: true,
-                });
-                if (invalid)
-                    throw invalid;
-            }
-            // `await` (not a bare promise return) so a handler that throws before
-            // its first await never sits handler-less for the thenable-adoption
-            // microtask — workerd and vitest both report that gap as an unhandled
-            // rejection even though the caller catches the failure.
-            try {
-                return await tool.handler(input, ctx);
-            }
-            catch (error) {
-                // A handler owns its destinations. ctx.baseUrl is Connecta's inbound
-                // URL, so it must never masquerade as the failed downstream host.
-                if (error instanceof ConnectorCallError || !networkErrorCode(error))
-                    throw error;
-                throw unavailableCallError(error);
-            }
-        },
-    };
+    return apiConnector(id, opts, opts.oauth !== undefined ? staticOAuth(id, opts.oauth) : undefined);
 }

package/dist/connectors/guarded-fetch.js

@@ -29,6 +29,33 @@ export function retryAfterMs(headers) {
     const date = Date.parse(raw);
     return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
 }
+/**
+ * The transport half of a guarded connector that authenticates through its
+ * own `api()` OAuth grant: no header of the helper's making, and every request
+ * sent through `ctx.oauth.fetch`, which adds the calling owner's bearer token,
+ * refuses any origin outside the grant's `apiOrigins`, and spends one
+ * coordinated refresh and one replay on a 401 before answering
+ * `auth_required`. Spread it into the options:
+ * `guardedFetch({ provider, baseUrl, maxResponseBytes, ...oauthBearer(provider) })`.
+ *
+ * Confinement still happens here first, so a request reaches the grant only
+ * once it is provably beneath `baseUrl`; the grant's origin check is the second
+ * fence, not the only one.
+ */
+export function oauthBearer(provider) {
+    return {
+        authenticate: () => ({}),
+        fetch: (url, init, ctx) => {
+            const grant = ctx.oauth;
+            if (!grant) {
+                // A wiring bug, not an outage: the transport was built for a grant the
+                // connector does not have, so no request can be authenticated.
+                throw new ConnectorCallError("connector_call_failed", `The ${provider} transport authenticates through the connector's OAuth grant, and this call's context carries none.`, { retryable: false });
+            }
+            return grant.fetch(url, init);
+        },
+    };
+}
 /** Statuses that instruct a client to re-send somewhere else. Never followed. */
 const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 /** Statuses the HTTP spec defines as carrying no body at all. */
@@ -91,6 +118,12 @@ function confinedUrl(provider, base, basePath, request) {
     for (const [key, value] of Object.entries(request.query ?? {})) {
         if (value === undefined)
             continue;
+        if (Array.isArray(value)) {
+            url.searchParams.delete(key);
+            for (const item of value)
+                url.searchParams.append(key, String(item));
+            continue;
+        }
         url.searchParams.set(key, String(value));
     }
     return url;
@@ -224,7 +257,8 @@ export function guardedFetch(options) {
     // "" for a root base, so joining never doubles the separator.
     const basePath = base.pathname.replace(/\/+$/, "");
     const constantHeaders = { ...options.headers };
-    return async function send(request, ctx, map) {
+    const send = options.fetch ?? ((url, init) => fetch(url, init));
+    return async function guarded(request, ctx, map) {
         if (request.body !== undefined && request.rawBody !== undefined) {
             throw new Error(`A ${provider} request cannot carry both a JSON body and a raw body.`);
         }
@@ -249,7 +283,7 @@ export function guardedFetch(options) {
         }
         let response;
         try {
-            response = await fetch(url.toString(), {
+            response = await send(url.toString(), {
                 method: request.method,
                 headers,
                 ...(request.body !== undefined
@@ -262,7 +296,7 @@ export function guardedFetch(options) {
                 // never one. Refused below rather than followed.
                 redirect: "manual",
                 ...(ctx.signal ? { signal: ctx.signal } : {}),
-            });
+            }, ctx);
         }
         catch (cause) {
             if (cause instanceof ConnectorCallError)

package/dist/connectors/remote-mcp.js

@@ -1,14 +1,14 @@
 import { Client, ProtocolError, SdkHttpError, isInputRequiredResult, specTypeSchemas, StreamableHTTPClientTransport, UnauthorizedError, } from "@modelcontextprotocol/client";
 import { Deferred, Duration, Effect, Exit, Scope } from "effect";
-import { KvOAuthProvider, OAuthRefreshCoordinator, } from "../auth/downstream-oauth.js";
+import { assertOAuthScope, authorizingContext, KvOAuthProvider, refreshCoordinatorsByPartition, } from "../auth/downstream-oauth.js";
 import { trackOAuthStartReset } from "../auth/oauth-start-reset.js";
 import { MAX_CATALOG_TOOLS } from "../catalog-limits.js";
 import { connectorScopeCleanupClaimed } from "../connector-scope.js";
 import { boundedEchoText, ConnectorCallError, msg, unavailableCallError, } from "../errors.js";
 import { CONNECTA_VERSION } from "../version.js";
 import { learnedUrlRefusal } from "../url-safety.js";
-import { inheritOAuthSealer, oauthSealerFor } from "../oauth-sealing.js";
-import { attachOAuthPartition, oauthPartitionFor, retainOAuthPartition } from "../oauth-partition.js";
+import { oauthSealerFor } from "../oauth-sealing.js";
+import { retainingOAuthPartition } from "../oauth-partition.js";
 import { detach, runEdge } from "../runtime/run.js";
 /**
  * Apply a maintained provider's slot copy and header framing to credential
@@ -400,9 +400,7 @@ function learnedUrlSafeFetch(connectorId, configured, baseFetch) {
 export function remoteMcp(id, opts) {
     const clientMetadataUrl = opts.auth?.type === "oauth" ? opts.auth.clientMetadataUrl : undefined;
     const oauthScope = opts.auth?.type === "oauth" ? opts.auth.scope : undefined;
-    if (oauthScope !== undefined && !/^[\x21\x23-\x5B\x5D-\x7E]+(?: [\x21\x23-\x5B\x5D-\x7E]+)*$/.test(oauthScope)) {
-        throw new Error(`[connecta] connector "${id}" OAuth scope must contain space-separated scope tokens.`);
-    }
+    assertOAuthScope(id, oauthScope);
     if (clientMetadataUrl !== undefined) {
         let valid = false;
         try {
@@ -428,18 +426,7 @@ export function remoteMcp(id, opts) {
     const isOauth = opts.auth?.type === "oauth";
     // Long-lived enough for distinct request scopes in this connector runtime to
     // join one token redemption. It owns no client, transport, or request state.
-    const refreshCoordinators = new WeakMap();
-    const refreshCoordinatorFor = (ctx) => {
-        // Production contexts carry a stable registry partition. Hand-written
-        // contexts can coordinate by their shared storage object instead.
-        const partition = oauthPartitionFor(ctx) ?? ctx.storage;
-        let coordinator = refreshCoordinators.get(partition);
-        if (!coordinator) {
-            coordinator = new OAuthRefreshCoordinator(() => retainOAuthPartition(partition));
-            refreshCoordinators.set(partition, coordinator);
-        }
-        return coordinator;
-    };
+    const refreshCoordinatorFor = refreshCoordinatorsByPartition();
     const logger = opts.logger ?? console;
     const credentialAuth = opts.auth?.type === "credential" ? opts.auth : undefined;
     if (credentialAuth?.credential?.fields?.length) {
@@ -1240,11 +1227,7 @@ export function remoteMcp(id, opts) {
             await disconnectAuthorization(ctx, stateFor(ctx), true);
         };
         connector.startAuth = async (ctx, startOpts) => {
-            ctx = attachOAuthPartition(inheritOAuthSealer(ctx, {
-                ...ctx,
-                requestScope: ctx.requestScope ?? ctx,
-                allowAuthorization: true,
-            }), oauthPartitionFor(ctx));
+            ctx = authorizingContext(ctx);
             const state = stateFor(ctx);
             state.provider = null;
             const p = newProvider(ctx, state);
@@ -1297,15 +1280,7 @@ export function remoteMcp(id, opts) {
     if (isOauth) {
         // Pin before the first asynchronous storage/discovery read, not only once
         // a refresh flight exists. These operations do not take call admission.
-        const retain = (operation, contextIndex) => async (...args) => {
-            const release = retainOAuthPartition(oauthPartitionFor(args[contextIndex]));
-            try {
-                return await operation(...args);
-            }
-            finally {
-                release();
-            }
-        };
+        const retain = retainingOAuthPartition;
         connector.listTools = retain(connector.listTools, 0);
         connector.callTool = retain(connector.callTool, 2);
         connector.status = retain(connector.status, 0);

package/dist/index.d.ts

@@ -271,6 +271,6 @@ export { memoryStorage } from "./storage/memory.js";
 export { CONNECTA_VERSION } from "./version.js";
 export type { Registry } from "./registry.js";
 export type { RemoteMcpOptions, RemoteMcpAuth, RemoteMcpRedirectPolicy, } from "./connectors/remote-mcp.js";
-export type { ApiOptions, ApiTool } from "./connectors/api.js";
+export type { ApiHandlerContext, ApiOAuthAccess, ApiOAuthClientAuthentication, ApiOAuthConfig, ApiOptions, ApiTool, } from "./connectors/api.js";
 export type { CatalogDriftCounts, CatalogDriftReport, ConnectaBranding, ConnectaTheme, Connector, ConnectorCallAdmissionInput, ConnectorCallAdmissionPolicy, ConnectorCallAdmissionRule, ConnectorRollingWindowBudget, ConnectorCredentialAccess, ConnectorCredentialConfig, ConnectorCredentialFieldConfig, ConnectorCredentialValues, ConnectorContext, ConnectorUsageGuide, ConnectorStatus, CredentialTestResult, AdmittingExecutor, AdmissionSnapshot, ExecuteResult, Executor, ExecutorLease, ExecutorProvider, InboundAuth, InboundAuthRuntimeContext, UiAuthConfig, AuthResult, AuthenticatedIdentity, IdentityReference, JsonSchema, KVStorage, Logger, ToolDef, ToolAnnotations, } from "./types.js";
 export type { ActivityActor, ActivityCallSource, ActivityOutcome, ActivityPage, ActivityReadActor, ActivityReadEvent, ActivityReader, ActivityReadGate, ActivityReadPage, ActivitySink, ActivityStore, AgentFriction, CatalogDriftActivityEvent, ToolCallActivityEvent, } from "./activity.js";

package/dist/oauth-partition.js

@@ -19,6 +19,23 @@ export function retainOAuthPartition(partition) {
             activeWork.set(partition, remaining);
     };
 }
+/**
+ * Wrap one connector operation so its owner partition stays pinned from the
+ * first asynchronous storage read to the end, not only once a refresh flight
+ * exists: an idle personal registry can otherwise be evicted mid-flow. Status
+ * and auth operations take no call admission, so nothing else holds it.
+ */
+export function retainingOAuthPartition(operation, contextIndex) {
+    return async (...args) => {
+        const release = retainOAuthPartition(oauthPartitionFor(args[contextIndex]));
+        try {
+            return await operation(...args);
+        }
+        finally {
+            release();
+        }
+    };
+}
 export function oauthPartitionIdle(partition) {
     return !activeWork.has(partition);
 }

package/dist/providers/basecamp.d.ts

@@ -0,0 +1,65 @@
+import type { Connector, ConnectorCallAdmissionPolicy } from "../types.js";
+/**
+ * Basecamp's one hosted MCP endpoint, streamable HTTP.
+ *
+ * Live but undocumented: as of 2026-10-05 37signals has announced no MCP
+ * server, and basecamp.com/agents (where the endpoint's own 401 body points)
+ * describes the CLI and SDKs without naming it. What the server does publish is
+ * its OAuth discovery — protected-resource metadata naming
+ * `https://app.basecamp.com` as the authorization server — and that is what
+ * this provider is written against, beside a captured live `tools/list`.
+ */
+export declare const BASECAMP_MCP_ENDPOINT = "https://mcp.basecamp.com/mcp";
+export interface BasecampOptions {
+    /** Human-readable display name; defaults to "Basecamp". */
+    title?: string;
+    /**
+     * Downstream auth ownership. Defaults to one shared deployment grant. With
+     * `"personal"` each principal authorizes separately and may pick a
+     * different Basecamp account at consent, which the guide says.
+     */
+    authScope?: "shared" | "personal";
+    /** Which Basecamp account this is and what decisions it answers. */
+    purpose: string;
+    /**
+     * Required. The HTTPS URL of a Client ID Metadata Document this deployment
+     * controls: a public JSON document whose `client_id` is its own URL, whose
+     * `redirect_uris` include `<publicUrl>/oauth/callback/<connector id>`, with
+     * `token_endpoint_auth_method: "none"` and the `authorization_code` and
+     * `refresh_token` grants. Basecamp advertises dynamic client registration
+     * but restricts it for HTTPS redirect URIs, which every deployed connecta
+     * has; its authorization server accepts a metadata-document client id
+     * instead (`client_id_metadata_document_supported: true`). Connecta does not
+     * serve one of its own yet, so the deployment hosts it.
+     */
+    clientMetadataUrl: string;
+    /** Account-specific conventions appended to the maintained provider guide. */
+    instructions?: string;
+    /** Connector-specific inline result limit; omit to inherit the deployment. */
+    maxResultBytes?: number;
+    /**
+     * Optional per-runtime policy. There is no default: Basecamp's API documents
+     * several dynamically adjusted limits (GET versus POST, per second, hour,
+     * and day) and quotes only "currently 50 requests per 10 second period per
+     * IP address" for scale — metered at the IP that calls the API, which is
+     * Basecamp's own MCP server rather than this runtime. A per-runtime counter
+     * approximates none of that, so the operator picks (P12).
+     */
+    callAdmission?: ConnectorCallAdmissionPolicy;
+}
+/**
+ * One release-reviewed manifest, used both to classify a live tool and as the
+ * baseline the runtime drift check compares against, so the annotation a
+ * caller gets and the verdict a check reads can never disagree (P13). Names
+ * and verdicts only — no schemas are vendored; the live `tools/list` response
+ * stays authoritative.
+ *
+ * Basecamp publishes no tool inventory, so this list has no public document
+ * to be checked against before a release. Catalog drift is visible at runtime
+ * only — as unclassified-tool and unserved-name counts on connector status and
+ * `/health` — and the credential-free provider check reads the OAuth
+ * discovery metadata the server does publish instead.
+ */
+export declare const BASECAMP_VETTED_CATALOG: import("../catalog-drift.js").VettedCatalog;
+/** A maintained Basecamp hosted-MCP connection. */
+export declare function basecamp(id: string, options: BasecampOptions): Connector;