@zackbart/connecta 0.7.9 → 0.8.0

package/src/connectors/remote-mcp.ts

@@ -9,6 +9,7 @@ import { ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
 import { z } from "zod";
 import { KvOAuthProvider } from "../auth/downstream-oauth.js";
+import { MAX_CATALOG_TOOLS } from "../catalog-limits.js";
 import { ConnectorCallError } from "../errors.js";
 import { CONNECTA_VERSION } from "../version.js";
 import type {
@@ -109,18 +110,16 @@ const TERMINATE_SESSION_BUDGET_MS = 1_000;
  * cap the bytes a caller can be made to hold, not the number of round trips it
  * took to get them.
  */
-const MAX_TOOLS = 100_000;
-
 /**
  * Absolute backstop on `tools/list` pages in one refresh — a runaway guard, not
  * the primary defense.
  *
  * The walk terminates on its own well before this: a cursor handed back twice
  * is a definite loop, two consecutive pages that add no new tools are a server
- * going nowhere, and MAX_TOOLS caps what any of it can accumulate. This exists
- * only so the loop is finite even if a downstream somehow satisfies all three
- * forever on a path with no discovery deadline. Set high enough that no honest
- * server reaches it.
+ * going nowhere, and MAX_CATALOG_TOOLS caps what any of it can accumulate.
+ * This exists only so the loop is finite even if a downstream somehow
+ * satisfies all three forever on a path with no discovery deadline. Set high
+ * enough that no honest server reaches it.
  */
 const MAX_TOOL_PAGES = 10_000;
 
@@ -298,7 +297,9 @@ function redirectedInit(init: RequestInit, status: number): RequestInit {
   if (!becomesGet) return init;
   const headers = new Headers(init.headers);
   for (const name of BODY_HEADERS) headers.delete(name);
-  return { ...init, method: "GET", body: undefined, headers };
+  const redirected = { ...init, method: "GET", headers };
+  delete redirected.body;
+  return redirected;
 }
 
 /**
@@ -546,10 +547,14 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
     const url = new URL(opts.url);
     const guardedFetch = redirectSafeFetch(id, opts.redirects);
     if (opts.auth?.type === "oauth") {
+      // The SDK class declares `sessionId` as an own `string | undefined`
+      // property while its Transport interface declares it optional. They are
+      // runtime-compatible; exact optional types only exposes that declaration
+      // mismatch at this boundary.
       return new StreamableHTTPClientTransport(url, {
         authProvider: provider ?? newProvider(ctx),
         fetch: guardedFetch,
-      });
+      }) as unknown as Transport;
     }
     const headers =
       opts.auth?.type === "headers" ? opts.auth.headers : undefined;
@@ -559,7 +564,7 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
         ...(headers ? { requestInit: { headers } } : {}),
         fetch: guardedFetch,
       },
-    );
+    ) as unknown as Transport;
   };
 
   const reset = (state: ConnectionState) => {
@@ -742,12 +747,18 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
 
   const connector: Connector = {
     id,
-    title: opts.title,
+    ...(opts.title !== undefined ? { title: opts.title } : {}),
     kind: "mcp",
-    description: opts.description,
-    maxResultBytes: opts.maxResultBytes,
-    callAdmission: opts.callAdmission,
-    usageGuide: opts.usageGuide,
+    ...(opts.description !== undefined
+      ? { description: opts.description }
+      : {}),
+    ...(opts.maxResultBytes !== undefined
+      ? { maxResultBytes: opts.maxResultBytes }
+      : {}),
+    ...(opts.callAdmission !== undefined
+      ? { callAdmission: opts.callAdmission }
+      : {}),
+    ...(opts.usageGuide !== undefined ? { usageGuide: opts.usageGuide } : {}),
 
     // `tools/list` is cursor-paginated: the server chooses the page size and
     // signals "there is more" with a `nextCursor`, which the SDK's
@@ -830,9 +841,9 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
           }
           // Checked here rather than on arrival: this bounds what a *walk* may
           // accumulate; a one-page server was always free to send its page.
-          if (listed.length > MAX_TOOLS) {
+          if (listed.length > MAX_CATALOG_TOOLS) {
             throw new Error(
-              `Connector "${id}" advertised further tools/list pages past ${listed.length} tools, over the ${MAX_TOOLS}-tool ceiling one catalog refresh will collect.`,
+              `Connector "${id}" advertised further tools/list pages past ${listed.length} tools, over the ${MAX_CATALOG_TOOLS}-tool ceiling one catalog refresh will collect.`,
             );
           }
           // Opaque by contract: handed straight back, never parsed, rewritten,
@@ -863,10 +874,28 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
       primeToolMetadata(client, listed);
       return listed.map((t) => ({
         name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema as ToolDef["inputSchema"],
-        outputSchema: t.outputSchema as ToolDef["outputSchema"],
-        annotations: t.annotations as ToolDef["annotations"],
+        ...(t.description !== undefined ? { description: t.description } : {}),
+        ...(t.inputSchema !== undefined
+          ? {
+              inputSchema: t.inputSchema as NonNullable<
+                ToolDef["inputSchema"]
+              >,
+            }
+          : {}),
+        ...(t.outputSchema !== undefined
+          ? {
+              outputSchema: t.outputSchema as NonNullable<
+                ToolDef["outputSchema"]
+              >,
+            }
+          : {}),
+        ...(t.annotations !== undefined
+          ? {
+              annotations: t.annotations as NonNullable<
+                ToolDef["annotations"]
+              >,
+            }
+          : {}),
       }));
     },
 
@@ -942,7 +971,7 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
           const url = await getProvider(ctx, state).pendingAuthorizationUrl();
           return {
             state: "auth_required",
-            authorizationUrl: url,
+            ...(url !== undefined ? { authorizationUrl: url } : {}),
             message: "Authorization required — open the URL to connect.",
           };
         }
@@ -1013,9 +1042,10 @@ export function remoteMcp(id: string, opts: RemoteMcpOptions): Connector {
         };
       } catch (err) {
         if (state.authRequired) {
+          const authorizationUrl = await p.pendingAuthorizationUrl();
           return {
             state: "auth_required",
-            authorizationUrl: await p.pendingAuthorizationUrl(),
+            ...(authorizationUrl !== undefined ? { authorizationUrl } : {}),
             message: "Authorization required — open the URL to connect.",
           };
         }

package/src/credential-health.ts

@@ -117,8 +117,8 @@ export interface CredentialHealthConfig {
   onRequest?: boolean;
 }
 
-export const DEFAULT_CREDENTIAL_CHECK_INTERVAL_SECONDS = 900;
-export const DEFAULT_CREDENTIAL_CHECK_CONCURRENCY = 4;
+const DEFAULT_CREDENTIAL_CHECK_INTERVAL_SECONDS = 900;
+const DEFAULT_CREDENTIAL_CHECK_CONCURRENCY = 4;
 
 /**
  * How long a read of one connector's record is served from memory before going
@@ -362,7 +362,7 @@ export interface CredentialCheckOptions {
  * their back. A connector whose only hook cannot test its declared shape is
  * checkable only if it also implements `status()`.
  */
-export function isCheckableConnector(connector: Connector): boolean {
+function isCheckableConnector(connector: Connector): boolean {
   const hasCredentialStore = Boolean(
     connector.credential || connector.hasStoredCredential,
   );
@@ -408,8 +408,9 @@ function testHookFor(
   }
   // A single-value shape with nothing under the reserved field is still nothing
   // to test, so the stored value gets the last word even when the rule fits.
-  if (mode === "single" && typeof storedValues.value === "string") {
-    return (ctx) => connector.testCredential!(storedValues.value, ctx);
+  const storedValue = storedValues.value;
+  if (mode === "single" && typeof storedValue === "string") {
+    return (ctx) => connector.testCredential!(storedValue, ctx);
   }
   return undefined;
 }
@@ -420,14 +421,16 @@ async function mapWithConcurrency<T, R>(
   limit: number,
   fn: (item: T) => Promise<R>,
 ): Promise<R[]> {
-  const out = new Array<R>(items.length);
-  let next = 0;
+  const out = Array<R>(items.length);
+  const remaining = items.entries();
   const workers = Array.from(
     { length: Math.min(limit, items.length) },
     async () => {
-      while (next < items.length) {
-        const index = next++;
-        out[index] = await fn(items[index]);
+      for (;;) {
+        const next = remaining.next();
+        if (next.done) return;
+        const [index, item] = next.value;
+        out[index] = await fn(item);
       }
     },
   );

package/src/credentials.ts

@@ -24,7 +24,7 @@ interface CredentialPlaintext {
   updatedBy: string;
 }
 
-export interface CredentialFieldMetadata {
+interface CredentialFieldMetadata {
   configured: true;
   /** Only emitted when the value is long enough that four chars don't leak much. */
   lastFour?: string;
@@ -41,7 +41,7 @@ export interface CredentialMetadata {
 }
 
 /** Which hook a testable credential is checked with. */
-export type CredentialTestMode = "single" | "multiple";
+type CredentialTestMode = "single" | "multiple";
 
 /** Operator-safe explanation shared by every surface that detects shape drift. */
 export const STORED_CREDENTIAL_SHAPE_MISMATCH_ERROR =

package/src/errors.ts

@@ -49,7 +49,7 @@ export class ConnectorCallError extends Error {
    * the assignment would not keep it off the instance. Keeping the window out
    * of the wire format is `classifyCallError`'s job, not this constructor's.
    */
-  readonly retryAfterMs?: number;
+  readonly retryAfterMs: number | undefined;
 
   constructor(
     code: ConnectorCallErrorCode,