@zackbart/connecta 0.22.2 → 0.23.0

package/CHANGELOG.md

@@ -2,6 +2,65 @@
 
 All notable changes to this package are documented here.
 
+## 0.23.0 — 2026-09-07
+
+This release removes server-owned program views, connector HTTP routes, and
+three convenience APIs. It also exposes configured account titles during
+discovery and clarifies schema inspection and dependent calls.
+Programs use canonical tool addresses and JavaScript promises; callers own
+retry timing. Stored programs using shortcut globals, `connecta.batch`, or
+`connecta.ui` need migration. Direct calls must omit `maxRetries`. Deployments
+using none of these need no configuration or storage changes. The seven tools,
+operator pages, credentials, and emitted media remain. Cloudflare Global API
+Key authentication and multi-field credentials remain supported.
+
+### Added
+
+- Optional `investigate` guidance for purchase verification, experiments, and
+  customer or deployment investigations. It explains account selection,
+  evidence requirements, and when to stop with an unresolved gap (#527).
+- Bounded configured account titles in the initial connector inventory and
+  program search results, without provider calls or changes to ranking (#527).
+
+### Changed
+
+- Remove connector `handleRequest` routes. Stale declarations fail at
+  construction; custom routes belong to the existing deployment fetch handler.
+- Remove MCP Apps rendering, its HTML shell, resource handlers, extension
+  declaration, and tool UI metadata. Clients render returned data.
+- Remove connector shortcut globals and their sanitization and collision rules.
+  Programs call the canonical address through `connecta.call`.
+- Remove `connecta.batch`. Use `Promise.all` or `Promise.allSettled` under the
+  same host-call and connector admission limits.
+- Remove automatic retries and backoff timing from direct calls. Failures keep
+  their classification and provider retry hint. Direct-call schemas reject
+  unknown arguments, including the removed `maxRetries` option.
+- Clarify JSON schema inspection, provider result shapes, and promise failures.
+  Keep discovery and calls together when schemas suffice; allow a small sample
+  for unfamiliar results before continuing in another program (#527).
+
+### Fixed
+
+- Remove the stale CI invocation of the retired evaluation `audit` script.
+  The benchmark self-tests remain in CI; whole-agent comparisons run locally.
+
+## 0.22.3 — 2026-09-03
+
+This patch carries OAuth discovery across the browser redirect. It matters for
+downstream MCP servers whose authentication challenge names a protected-resource
+metadata URL outside the RFC 9728 default path, including Cloudflare Access
+Managed OAuth. Existing grants and connectors using the default path require no
+configuration or storage migration.
+
+### Fixed
+
+- **Non-default OAuth discovery survives callbacks.** The KV OAuth provider now
+  persists the SDK's discovery state in the authorization generation, restores
+  it in the callback's fresh request scope, and deletes it through discovery,
+  all-credential, and generation cleanup. A callback therefore exchanges its
+  code against the same validated authorization-server issuer that registered
+  the client instead of invalidating that client after rediscovery (#523).
+
 ## 0.22.2 — 2026-09-01
 
 This patch makes the maintained-provider release check credential-free and

package/README.md

@@ -45,7 +45,7 @@ This is the kind of thing the agent writes, not you:
 
 ```js
 async () => {
-  const { nodes } = await tracker.list_issues({ state: "started" });
+  const { nodes } = await connecta.call("tracker.list_issues", { state: "started" });
   const byOwner = {};
   for (const issue of nodes) {
     (byOwner[issue.assignee?.name ?? "unassigned"] ??= []).push(issue.identifier);

package/dist/auth/downstream-oauth.d.ts

@@ -1,4 +1,4 @@
-import type { FetchLike, OAuthClientInformationContext, OAuthClientInformationMixed, OAuthClientMetadata, OAuthClientProvider, OAuthTokens } from "@modelcontextprotocol/client";
+import type { FetchLike, OAuthClientInformationContext, OAuthClientInformationMixed, OAuthClientMetadata, OAuthClientProvider, OAuthDiscoveryState, OAuthTokens } from "@modelcontextprotocol/client";
 import type { KVStorage } from "../types.js";
 type OAuthRefreshFlightOutcome = {
     status: "refreshed";
@@ -134,6 +134,8 @@ export declare class KvOAuthProvider implements OAuthClientProvider {
     get clientMetadata(): OAuthClientMetadata;
     clientInformation(ctx?: OAuthClientInformationContext): Promise<OAuthClientInformationMixed | undefined>;
     saveClientInformation(info: OAuthClientInformationMixed, ctx?: OAuthClientInformationContext): Promise<void>;
+    discoveryState(): Promise<OAuthDiscoveryState | undefined>;
+    saveDiscoveryState(state: OAuthDiscoveryState): Promise<void>;
     tokens(ctx?: OAuthClientInformationContext): Promise<OAuthTokens | undefined>;
     saveTokens(tokens: OAuthTokens, ctx?: OAuthClientInformationContext): Promise<void>;
     /**

package/dist/auth/downstream-oauth.js

@@ -24,6 +24,7 @@ const OAUTH_VALUE_KEYS = [
     "oauth:pending",
     "oauth:verifier",
     "oauth:state",
+    "oauth:discovery",
 ];
 const MAX_CLEANUP_BACKLOG = 1_000;
 function isRefreshTokenRequest(init) {
@@ -621,6 +622,12 @@ export class KvOAuthProvider {
     async saveClientInformation(info, ctx) {
         await this.writeValue("oauth:client", info, (value) => JSON.stringify(value), ctx?.issuer);
     }
+    async discoveryState() {
+        return (await this.readValue("oauth:discovery", (raw) => JSON.parse(raw)))?.value;
+    }
+    async saveDiscoveryState(state) {
+        await this.writeValue("oauth:discovery", state, (value) => JSON.stringify(value));
+    }
     async tokens(ctx) {
         const refreshGeneration = ctx ? await this.flowGeneration() : undefined;
         const successIdentity = refreshGeneration !== undefined
@@ -800,6 +807,7 @@ export class KvOAuthProvider {
                     oauthValueStorageKey("oauth:client", generation),
                     oauthValueStorageKey("oauth:tokens", generation),
                     oauthValueStorageKey("oauth:verifier", generation),
+                    oauthValueStorageKey("oauth:discovery", generation),
                 ]);
             }
             else if (scope === "client") {
@@ -811,6 +819,9 @@ export class KvOAuthProvider {
             else if (scope === "verifier") {
                 await this.storage.delete(oauthValueStorageKey("oauth:verifier", generation));
             }
+            else if (scope === "discovery") {
+                await this.storage.delete(oauthValueStorageKey("oauth:discovery", generation));
+            }
             if (endsRefresh) {
                 this.failRefreshFlight(new Error("OAuth refresh invalidated credentials before tokens were saved."));
             }

package/dist/catalog-service.d.ts

@@ -181,12 +181,6 @@ export declare class CatalogService {
     private catalogLoadFailure;
     private unknownToolFailure;
     resolveTool(address: string, callOptions?: ConnectorOperationOptions): Promise<CatalogResolution>;
-    /**
-     * Resolve the JavaScript-safe property used by a lazy code-mode namespace
-     * back to exactly one catalog tool. Ambiguous aliases fail with an explicit
-     * escape hatch instead of silently choosing the first tool.
-     */
-    resolveToolAlias(connectorId: string, alias: string, aliasFor: (toolName: string) => string, callOptions?: ConnectorOperationOptions): Promise<CatalogResolution>;
     search(args: CatalogSearchArgs): Promise<CatalogSearchPage>;
     describe(args: CatalogDescribeArgs): Promise<CatalogDescription[]>;
 }
@@ -247,6 +241,7 @@ export declare function flatSearchResult(page: CatalogSearchPage): {
     tools: {
         guideSummary?: string;
         guide?: string;
+        connectorTitle?: string;
         name: string;
         address: string;
         description?: string;

package/dist/catalog-service.js

@@ -336,59 +336,6 @@ export class CatalogService {
             catalogMs: Date.now() - started,
         };
     }
-    /**
-     * Resolve the JavaScript-safe property used by a lazy code-mode namespace
-     * back to exactly one catalog tool. Ambiguous aliases fail with an explicit
-     * escape hatch instead of silently choosing the first tool.
-     */
-    async resolveToolAlias(connectorId, alias, aliasFor, callOptions = {}) {
-        const connector = this.registry.getConnector(connectorId);
-        if (!connector) {
-            return this.unknownAddressFailure(`${connectorId}.${alias}`, alias);
-        }
-        const started = Date.now();
-        let tools;
-        try {
-            tools = await this.loadConnector(connector.id, callOptions);
-        }
-        catch (cause) {
-            return this.catalogLoadFailure(cause, started, connector, alias);
-        }
-        const [definition, ...collisions] = tools.filter((tool) => aliasFor(tool.name) === alias);
-        if (!definition) {
-            return this.unknownToolFailure(alias, connector, started);
-        }
-        if (collisions.length > 0) {
-            const names = [definition, ...collisions]
-                .map((tool) => `"${tool.name}"`)
-                .join(", ");
-            return {
-                ok: false,
-                error: {
-                    code: "ambiguous_tool_alias",
-                    message: `Tool alias "${boundedEchoText(alias)}" is ambiguous on connector "${connector.id}" because ${names} sanitize to the same name. Use connecta.call with an exact address.`,
-                    retryable: false,
-                    nextAction: {
-                        function: "connecta.call",
-                        addresses: [definition, ...collisions].map((tool) => `${connector.id}.${tool.name}`),
-                        purpose: "Choose the intended canonical address and call it with the original arguments.",
-                    },
-                },
-                catalogMs: Date.now() - started,
-                connector,
-                toolName: alias,
-            };
-        }
-        return {
-            ok: true,
-            resolved: {
-                connector,
-                toolName: definition.name,
-                definition,
-            },
-            catalogMs: Date.now() - started,
-        };
-    }
     async search(args) {
         const query = args.query ?? "";
         const retrievalQuery = lexicalSearchQuery(query);
@@ -894,6 +841,9 @@ export function flatSearchResult(page) {
     return {
         tools: page.entries.map((entry) => ({
             ...entry.tool,
+            ...(entry.connector.title
+                ? { connectorTitle: boundedEchoText(entry.connector.title.replace(/\s+/g, " ").trim(), 117) }
+                : {}),
             ...(entry.guide ? { guide: entry.guide } : {}),
             ...(entry.guideSummary
                 ? { guideSummary: entry.guideSummary }

package/dist/errors.d.ts

@@ -74,7 +74,7 @@ export declare class ConnectorCallError extends Error {
         validation?: ArgumentValidationDetails;
     });
 }
-/** The `error` object surfaced in value-mode call results and connecta.batch entries. */
+/** The `error` object surfaced in value-mode call results and rejected promises. */
 export interface CallErrorDetails {
     code: string;
     message: string;

package/dist/execute.d.ts

@@ -5,7 +5,6 @@ import { type ToolResult } from "./meta-tools.js";
 import { InvocationFailure } from "./invocation.js";
 import type { RegistryView } from "./registry.js";
 import type { Executor, ExecutorProvider, Logger } from "./types.js";
-export declare const EXECUTE_MAX_BATCH_CALLS = 10;
 /** Complete entries plus an exact omission count, all inside this byte cap. */
 export declare const CONNECTOR_INVENTORY_MAX_BYTES = 256;
 /**
@@ -17,7 +16,7 @@ export declare const CONNECTOR_INVENTORY_MAX_BYTES = 256;
  */
 export declare const EXECUTE_MAX_EMITTED_BYTES = 4000000;
 export declare const EXECUTE_MAX_EMITTED_BLOCKS = 32;
-type ExecuteDiagnosticOperation = "search" | "describe" | "call" | "batch";
+type ExecuteDiagnosticOperation = "search" | "describe" | "call";
 interface ExecuteOperationDiagnostics {
     operation: ExecuteDiagnosticOperation;
     count: number;
@@ -26,7 +25,6 @@ interface ExecuteOperationDiagnostics {
     resultBytes: number;
     catalogMs: number;
     connectorMs: number;
-    calls?: number;
 }
 declare class ExecuteDiagnostics {
     private readonly started;
@@ -35,19 +33,12 @@ declare class ExecuteDiagnostics {
     setupMs: number;
     executorWallMs: number;
     private emitted?;
-    private ui?;
     /** Numbers only, per R8 — and only once something was emitted, so a
      * non-emitting run's diagnostics stay byte-for-byte what they were. */
     recordEmitted(count: number, bytes: number): void;
-    /**
-     * U9: the UI payload gets its own aggregate — one number, the payload's
-     * serialized size. Folding it into `emitted` would desync that aggregate's
-     * pair, which reports the bytes a specific block count cost.
-     */
-    recordUi(bytes: number): void;
     private stats;
     recordCatalog(operation: "search" | "describe", durationMs: number, ok: boolean, result?: unknown): void;
-    recordCall(operation: "call" | "batch", outcome: {
+    recordCall(outcome: {
         ok: boolean;
         durationMs: number;
         timing: {
@@ -56,7 +47,6 @@ declare class ExecuteDiagnostics {
         };
         value?: unknown;
     }): void;
-    recordBatch(durationMs: number, ok: boolean, calls: number, result?: unknown): void;
     finish(): {
         timing: {
             totalMs: number;
@@ -71,7 +61,6 @@ declare class ExecuteDiagnostics {
             count: number;
             bytes: number;
         };
-        ui?: number;
     };
 }
 /**
@@ -91,56 +80,20 @@ export type EmittedBlock = {
     data: string;
     mimeType: string;
 };
-interface UiPayload {
-    html: string;
-}
-/**
- * Request-local collection for `connecta.emit` and `connecta.ui`. Budgets fail
- * loudly at the crossing call — nothing is partially accepted and prior blocks
- * are unaffected — so a program learns it is over budget while it can still
- * choose differently (M5, U4). Accepted output never rides `ExecuteResult`; the
- * handler that owns this collector delivers it on the final tool result.
- *
- * The two channels share the byte aggregate and nothing else: a UI payload is
- * not a block, so it spends no block count, and at most one is ever accepted.
- */
 export declare class EmitCollector {
     private readonly maxBytes;
     private readonly maxBlocks;
     private readonly diagnostics?;
     readonly blocks: EmittedBlock[];
-    /** The shared transport aggregate: emitted blocks plus the UI payload. */
     bytes: number;
-    /** The one accepted UI payload (U2), delivered in result `_meta` on success. */
-    ui?: UiPayload;
-    /** What the blocks alone cost, so the `emitted` aggregate stays a true pair. */
-    private blockBytes;
     constructor(maxBytes: number, maxBlocks: number, diagnostics?: ExecuteDiagnostics | undefined);
     accept(raw: unknown): void;
-    /**
-     * U2 and U4: one payload per run, measured as the serialized bytes of
-     * `{ html }` against the same aggregate emit spends. A second call throws
-     * naming the constraint rather than replacing the first — one tool result
-     * renders one view, and last-wins would silently discard a payload the
-     * program deliberately supplied.
-     *
-     * Multiplicity is checked before shape, so the second call is told what it
-     * actually broke. A program whose second payload is also malformed has one
-     * problem worth naming — that there is a second payload at all — and a
-     * complaint about its type would send the author to fix the wrong thing.
-     */
-    acceptUi(...values: unknown[]): void;
-    private assertUiVacant;
-    private acceptUiPayload;
 }
-/** Convert a connector/tool name into a valid JS identifier. */
-export declare function sanitizeIdentifier(name: string): string;
 /**
- * Expose one fixed host provider plus trusted sandbox setup that creates a
- * lazy proxy global per connector. No connector catalog is touched until code
- * calls that namespace or explicitly asks search/describe.
+ * Expose one host provider and typed guest errors. Catalogs load only when
+ * the program calls a tool or asks search/describe.
  */
-export declare function buildSandboxProviders(registry: RegistryView, baseUrl: string, logger: Logger, activity?: ActivityRequestContext, limits?: {
+export declare function buildSandboxProviders(registry: RegistryView, baseUrl: string, _logger: Logger, activity?: ActivityRequestContext, limits?: {
     signal?: AbortSignal | undefined;
     maxHostCalls?: number | undefined;
     hostCallTimeoutMs?: number | undefined;