@zackbart/connecta 0.4.0 → 0.5.0

package/dist/registry.d.ts

@@ -1,5 +1,36 @@
 import type { Connector, ConnectorContext, ConnectorStatus, KVStorage, Logger, ToolDef } from "./types.js";
 import type { CredentialVault } from "./credentials.js";
+import { type Toolkit } from "./toolkits.js";
+export declare const DEFAULT_MAX_RESULT_BYTES = 50000;
+/**
+ * Smallest accepted inline-result cap. One byte is pathological but harmless:
+ * `alignEndToCharBoundary` widens a window narrower than the codepoint at the
+ * offset, so even a 1-byte cap still truncates sanely and still pages. Caps
+ * that small already ship in the test suite (4 and 5), so the floor is placed
+ * where it excludes only values that are *broken* rather than merely tiny.
+ */
+export declare const MIN_MAX_RESULT_BYTES = 1;
+/**
+ * The one definition of a usable `maxResultBytes`: a finite whole number of at
+ * least {@link MIN_MAX_RESULT_BYTES} bytes. Shared by all three intake points
+ * — deployment config, the per-connector override, and `get_result`'s
+ * `maxBytes` argument — so a value that is valid at one is valid at all.
+ *
+ * Everything else is rejected rather than coerced, because each rejected shape
+ * silently does something *worse* than the default: `0`/`NaN` serve an empty
+ * head (`slice(0, 0)`) and make paging fail to advance, negatives serve a
+ * LARGER head than asked for (`slice(0, -1)` counts from the end) while still
+ * claiming truncation, and `Infinity` disables the guard with no notice.
+ */
+export declare function isValidMaxResultBytes(value: number): boolean;
+/**
+ * Resolve a configured cap against the value it inherits, dropping anything
+ * `isValidMaxResultBytes` rejects. Operator-facing surfaces pair this with a
+ * startup warning (see `Registry.checkResultCaps`) so the fallback is never
+ * silent; the resolution itself stays total so no call site has to cope with
+ * a broken cap.
+ */
+export declare function resolveMaxResultBytes(value: number | undefined, inherited: number): number;
 export interface HealthObservation {
     lastSuccessAt?: string;
     lastFailureAt?: string;
@@ -7,6 +38,23 @@ export interface HealthObservation {
     consecutiveFailures: number;
     lastError?: string;
 }
+/**
+ * Recent real-call outcomes per connector, as observed by ONE view.
+ *
+ * The deployment keeps one log, and each toolkit keeps its own. That split is a
+ * scope boundary, not bookkeeping: `lastError` is a downstream error string
+ * that routinely names the tool that failed, and `list_connectors` returns the
+ * observation verbatim. Sharing one log would let a toolkit read back the tools
+ * and failures of a sibling toolkit through a connector they happen to share —
+ * and let a sibling's failures flip this view's reported status. A scoped view
+ * reads back only the calls it made itself.
+ */
+export declare class HealthLog {
+    private readonly observations;
+    recordSuccess(id: string, latencyMs: number): void;
+    recordFailure(id: string, latencyMs: number, error: unknown): void;
+    get(id: string): HealthObservation | undefined;
+}
 export interface RegistryOptions {
     storage: KVStorage;
     logger: Logger;
@@ -14,19 +62,60 @@ export interface RegistryOptions {
     toolCacheTtlSeconds?: number;
     persistToolCatalog?: boolean;
     toolCatalogStaleSeconds?: number;
-    /** Cap on inline result size before truncation + get_result paging. Default 50_000. */
+    /**
+     * Cap on inline result size before truncation + get_result paging. Must be a
+     * whole number of bytes >= 1; anything else warns at startup and falls back
+     * to the default 50_000.
+     */
     maxResultBytes?: number;
 }
+/**
+ * The registry surface a per-connection MCP server consumes: every meta-tool
+ * (`src/meta-tools.ts`) and the `execute_code` sandbox bridge (`src/execute.ts`)
+ * is typed against THIS, never against the concrete `Registry`.
+ *
+ * That indirection is the toolkit boundary (issue #22): a scoped connection is
+ * handed a `ScopedRegistry` instead of the registry, and every meta-tool
+ * inherits the scope from one place. Reaching for a registry method that isn't
+ * here is a compile error, and adding one here is a compile error until
+ * `ScopedRegistry` filters it — so a new meta-tool cannot quietly step around
+ * the boundary.
+ */
+export interface RegistryView {
+    /** Deployment-wide result-size cap threaded to the meta-tools. */
+    readonly maxResultBytes: number;
+    listConnectors(): Connector[];
+    getConnector(id: string): Connector | undefined;
+    resolveAddress(address: string): {
+        connector: Connector;
+        toolName: string;
+    } | null;
+    getTools(id: string, baseUrl: string, requestScope?: object): Promise<ToolDef[]>;
+    refreshTools(id: string, baseUrl: string, requestScope?: object): Promise<ToolDef[]>;
+    peekTools(id: string): ToolDef[] | undefined;
+    contextFor(id: string, baseUrl: string, requestScope?: object, callOptions?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): ConnectorContext;
+    resultsStorage(): KVStorage;
+    recordSuccess(id: string, latencyMs: number): void;
+    recordFailure(id: string, latencyMs: number, error: unknown): void;
+    healthFor(id: string): HealthObservation | undefined;
+    hasObservedSuccess(id: string): boolean;
+    statusFor(id: string, baseUrl: string, requestScope?: object): Promise<ConnectorStatus>;
+    invalidateStored(id: string): Promise<void>;
+}
 /**
  * Holds the connector set, resolves addresses, and caches per-connector tool
  * lists in memory with a TTL. Connector failures are isolated: a broken
  * connector surfaces status "error"; the rest keep working.
  */
-export declare class Registry {
+export declare class Registry implements RegistryView {
     private readonly opts;
     private readonly connectors;
     private readonly cache;
     private readonly invalidated;
+    /** Deployment-wide observations — every call, whatever view made it. */
     private readonly health;
     private readonly ttlMs;
     private readonly staleMs;
@@ -34,6 +123,15 @@ export declare class Registry {
     /** Result-size guard cap threaded to the meta-tools. */
     readonly maxResultBytes: number;
     constructor(connectors: Connector[], opts: RegistryOptions);
+    /**
+     * Warn once per unusable result cap, at construction time — the same
+     * "runs fine but is surely unintended" channel as the insecure-config
+     * warnings in `createConnecta`. A rejected cap can't be honoured, and
+     * honouring it *approximately* is exactly the inversion issue #32 is about,
+     * so the value is dropped in favour of what it inherits and the operator is
+     * told which one is actually in force.
+     */
+    private checkResultCaps;
     /**
      * Warn once per convention violation at construction time. Static only —
      * never calls listTools() (remote connectors are lazy/network); tool-level
@@ -68,6 +166,15 @@ export declare class Registry {
     recordSuccess(id: string, latencyMs: number): void;
     recordFailure(id: string, latencyMs: number, error: unknown): void;
     healthFor(id: string): HealthObservation | undefined;
+    /**
+     * Whether ANY view of this deployment has seen a successful call to `id` —
+     * a bare boolean, never the observation. Connector liveness (reachable,
+     * credentials still valid) is a deployment-level fact, not a per-view one, so
+     * `list_connectors` may classify a connector as ok/unknown from it. The
+     * observation itself — `lastError` above all, which names the tool that
+     * failed — stays strictly per view.
+     */
+    hasObservedSuccess(id: string): boolean;
     /** Best-effort connector status for list_connectors. */
     statusFor(id: string, baseUrl: string, requestScope?: object): Promise<ConnectorStatus>;
     /** Drop a connector's cached tool list (e.g. after auth completes). */
@@ -75,4 +182,78 @@ export declare class Registry {
     /** Drop both in-memory and persisted tool catalogs. */
     invalidateStored(id: string): Promise<void>;
 }
+/**
+ * THE toolkit enforcement point (issue #22).
+ *
+ * A filtered VIEW of one long-lived `Registry`: same connectors, same tool
+ * caches, same health — narrowed to the connectors and tool addresses one
+ * toolkit selects. `serveMcp` builds it once per scoped connection and hands it
+ * to `registerMetaTools`/`registerExecuteTool`, so `list_connectors`,
+ * `search_tools`, `describe_tools`, `call_tool`, `call_destructive_tool`,
+ * `batch_call`, `authorize_connector`, `get_result`, `skills`, and the
+ * `execute_code` host bridge all inherit the boundary from here instead of
+ * re-implementing nine checks.
+ *
+ * Two invariants make it reviewable:
+ *
+ * 1. **Indistinguishability.** Out-of-scope input fails through the SAME code
+ *    path, with the same error class and message, as input naming something
+ *    that does not exist at all. An out-of-scope CONNECTOR disappears from
+ *    `resolveAddress`/`getConnector` (→ `Unknown address` / `Unknown
+ *    connector`); an out-of-scope TOOL disappears from the catalog this view
+ *    returns (→ `Unknown tool "<t>" on connector "<c>"`), which is exactly the
+ *    error a misspelled tool name already produced. Scoping deliberately does
+ *    NOT reject at `resolveAddress` for tools: that would answer with the
+ *    connector-level message and make "hidden here" distinguishable from
+ *    "never existed".
+ * 2. **It filters views, never state.** Every read delegates to the shared
+ *    registry and filters the returned array, so the tool cache, the persisted
+ *    catalog, and the health map stay whole and shared across scopes.
+ */
+export declare class ScopedRegistry implements RegistryView {
+    private readonly base;
+    private readonly toolkit;
+    /** This toolkit's own health observations — see HealthLog. */
+    private readonly health;
+    constructor(base: Registry, toolkit: Toolkit);
+    get maxResultBytes(): number;
+    /** In scope AND actually registered. */
+    private visible;
+    /** Byte-identical to what the unscoped registry throws for an unknown id. */
+    private unknownConnector;
+    private inScopeTools;
+    listConnectors(): Connector[];
+    getConnector(id: string): Connector | undefined;
+    resolveAddress(address: string): {
+        connector: Connector;
+        toolName: string;
+    } | null;
+    getTools(id: string, baseUrl: string, requestScope?: object): Promise<ToolDef[]>;
+    refreshTools(id: string, baseUrl: string, requestScope?: object): Promise<ToolDef[]>;
+    peekTools(id: string): ToolDef[] | undefined;
+    contextFor(id: string, baseUrl: string, requestScope?: object, callOptions?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): ConnectorContext;
+    /**
+     * Stashed oversized results are bound to the scope that produced them: a
+     * scoped session cannot page a result it could not have produced, and an id
+     * from another scope reads back as the ordinary "Unknown or expired result
+     * id". Unscoped sessions keep the historical `results:` prefix untouched.
+     */
+    resultsStorage(): KVStorage;
+    recordSuccess(id: string, latencyMs: number): void;
+    recordFailure(id: string, latencyMs: number, error: unknown): void;
+    healthFor(id: string): HealthObservation | undefined;
+    /**
+     * Deliberately NOT per view: whether the connector has ever answered is a
+     * fact about the connector, not about a team's traffic, and withholding it
+     * would report every remote connector as "unknown" to a scoped session that
+     * has not called it yet. It carries no tool name, error text, or count — the
+     * per-view isolation of those, above, is unchanged.
+     */
+    hasObservedSuccess(id: string): boolean;
+    statusFor(id: string, baseUrl: string, requestScope?: object): Promise<ConnectorStatus>;
+    invalidateStored(id: string): Promise<void>;
+}
 //# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}

package/dist/registry.js

@@ -1,7 +1,81 @@
+import { splitAddress } from "./toolkits.js";
 const ID_RE = /^[a-z0-9_-]+$/;
 const DEFAULT_TTL_SECONDS = 300;
 const DEFAULT_STALE_SECONDS = 3600;
-const DEFAULT_MAX_RESULT_BYTES = 50_000;
+export const DEFAULT_MAX_RESULT_BYTES = 50_000;
+/**
+ * Smallest accepted inline-result cap. One byte is pathological but harmless:
+ * `alignEndToCharBoundary` widens a window narrower than the codepoint at the
+ * offset, so even a 1-byte cap still truncates sanely and still pages. Caps
+ * that small already ship in the test suite (4 and 5), so the floor is placed
+ * where it excludes only values that are *broken* rather than merely tiny.
+ */
+export const MIN_MAX_RESULT_BYTES = 1;
+/**
+ * The one definition of a usable `maxResultBytes`: a finite whole number of at
+ * least {@link MIN_MAX_RESULT_BYTES} bytes. Shared by all three intake points
+ * — deployment config, the per-connector override, and `get_result`'s
+ * `maxBytes` argument — so a value that is valid at one is valid at all.
+ *
+ * Everything else is rejected rather than coerced, because each rejected shape
+ * silently does something *worse* than the default: `0`/`NaN` serve an empty
+ * head (`slice(0, 0)`) and make paging fail to advance, negatives serve a
+ * LARGER head than asked for (`slice(0, -1)` counts from the end) while still
+ * claiming truncation, and `Infinity` disables the guard with no notice.
+ */
+export function isValidMaxResultBytes(value) {
+    return Number.isInteger(value) && value >= MIN_MAX_RESULT_BYTES;
+}
+/**
+ * Resolve a configured cap against the value it inherits, dropping anything
+ * `isValidMaxResultBytes` rejects. Operator-facing surfaces pair this with a
+ * startup warning (see `Registry.checkResultCaps`) so the fallback is never
+ * silent; the resolution itself stays total so no call site has to cope with
+ * a broken cap.
+ */
+export function resolveMaxResultBytes(value, inherited) {
+    return value !== undefined && isValidMaxResultBytes(value)
+        ? value
+        : inherited;
+}
+/**
+ * Recent real-call outcomes per connector, as observed by ONE view.
+ *
+ * The deployment keeps one log, and each toolkit keeps its own. That split is a
+ * scope boundary, not bookkeeping: `lastError` is a downstream error string
+ * that routinely names the tool that failed, and `list_connectors` returns the
+ * observation verbatim. Sharing one log would let a toolkit read back the tools
+ * and failures of a sibling toolkit through a connector they happen to share —
+ * and let a sibling's failures flip this view's reported status. A scoped view
+ * reads back only the calls it made itself.
+ */
+export class HealthLog {
+    observations = new Map();
+    recordSuccess(id, latencyMs) {
+        const previous = this.observations.get(id);
+        this.observations.set(id, {
+            ...previous,
+            lastSuccessAt: new Date().toISOString(),
+            lastLatencyMs: latencyMs,
+            consecutiveFailures: 0,
+            lastError: undefined,
+        });
+    }
+    recordFailure(id, latencyMs, error) {
+        const previous = this.observations.get(id);
+        this.observations.set(id, {
+            ...previous,
+            lastFailureAt: new Date().toISOString(),
+            lastLatencyMs: latencyMs,
+            consecutiveFailures: (previous?.consecutiveFailures ?? 0) + 1,
+            lastError: msg(error),
+        });
+    }
+    get(id) {
+        const observation = this.observations.get(id);
+        return observation ? { ...observation } : undefined;
+    }
+}
 function namespaced(storage, prefix) {
     return {
         get: (k) => storage.get(prefix + k),
@@ -22,7 +96,8 @@ export class Registry {
     connectors = new Map();
     cache = new Map();
     invalidated = new Set();
-    health = new Map();
+    /** Deployment-wide observations — every call, whatever view made it. */
+    health = new HealthLog();
     ttlMs;
     staleMs;
     persistToolCatalog;
@@ -35,7 +110,7 @@ export class Registry {
         this.staleMs =
             (opts.toolCatalogStaleSeconds ?? DEFAULT_STALE_SECONDS) * 1000;
         this.persistToolCatalog = opts.persistToolCatalog ?? true;
-        this.maxResultBytes = opts.maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES;
+        this.maxResultBytes = resolveMaxResultBytes(opts.maxResultBytes, DEFAULT_MAX_RESULT_BYTES);
         for (const c of connectors) {
             if (!ID_RE.test(c.id)) {
                 throw new Error(`Invalid connector id "${c.id}": must match ${ID_RE.source}`);
@@ -46,6 +121,37 @@ export class Registry {
             this.connectors.set(c.id, c);
         }
         this.checkConventions(opts.logger);
+        this.checkResultCaps(opts.logger, opts.maxResultBytes);
+    }
+    /**
+     * Warn once per unusable result cap, at construction time — the same
+     * "runs fine but is surely unintended" channel as the insecure-config
+     * warnings in `createConnecta`. A rejected cap can't be honoured, and
+     * honouring it *approximately* is exactly the inversion issue #32 is about,
+     * so the value is dropped in favour of what it inherits and the operator is
+     * told which one is actually in force.
+     */
+    checkResultCaps(logger, configured) {
+        if (configured !== undefined && !isValidMaxResultBytes(configured)) {
+            logger.warn(`[connecta] maxResultBytes ${configured} is not a whole number of ` +
+                `bytes >= ${MIN_MAX_RESULT_BYTES}: it would serve an empty, ` +
+                "oversized, or unguarded result instead of truncating. Using the " +
+                `default ${DEFAULT_MAX_RESULT_BYTES} instead.`);
+        }
+        for (const c of this.connectors.values()) {
+            if (c.maxResultBytes !== undefined &&
+                !isValidMaxResultBytes(c.maxResultBytes)) {
+                // The number quoted here is `this.maxResultBytes` because that is
+                // literally what a call falls back to: meta-tools reads the inherited
+                // cap off `RegistryView.maxResultBytes`, so the warned value and the
+                // runtime value are the same field rather than two copies of it.
+                logger.warn(`[connecta] connector "${c.id}" sets maxResultBytes ` +
+                    `${c.maxResultBytes}, which is not a whole number of bytes >= ` +
+                    `${MIN_MAX_RESULT_BYTES}. Ignoring the override — the connector ` +
+                    `inherits the deployment-wide cap calls fall back to ` +
+                    `(${this.maxResultBytes}).`);
+            }
+        }
     }
     /**
      * Warn once per convention violation at construction time. Static only —
@@ -100,15 +206,13 @@ export class Registry {
     }
     /** Resolve "<connectorId>.<toolName>" → connector + tool name. */
     resolveAddress(address) {
-        const dot = address.indexOf(".");
-        if (dot <= 0 || dot === address.length - 1)
+        const parts = splitAddress(address);
+        if (!parts)
             return null;
-        const id = address.slice(0, dot);
-        const toolName = address.slice(dot + 1);
-        const connector = this.connectors.get(id);
+        const connector = this.connectors.get(parts.connectorId);
         if (!connector)
             return null;
-        return { connector, toolName };
+        return { connector, toolName: parts.toolName };
     }
     catalogKey(id) {
         return `catalog:${id}`;
@@ -227,28 +331,24 @@ export class Registry {
         return hit && hit.staleUntil > Date.now() ? hit.tools : undefined;
     }
     recordSuccess(id, latencyMs) {
-        const previous = this.health.get(id);
-        this.health.set(id, {
-            ...previous,
-            lastSuccessAt: new Date().toISOString(),
-            lastLatencyMs: latencyMs,
-            consecutiveFailures: 0,
-            lastError: undefined,
-        });
+        this.health.recordSuccess(id, latencyMs);
     }
     recordFailure(id, latencyMs, error) {
-        const previous = this.health.get(id);
-        this.health.set(id, {
-            ...previous,
-            lastFailureAt: new Date().toISOString(),
-            lastLatencyMs: latencyMs,
-            consecutiveFailures: (previous?.consecutiveFailures ?? 0) + 1,
-            lastError: msg(error),
-        });
+        this.health.recordFailure(id, latencyMs, error);
     }
     healthFor(id) {
-        const observation = this.health.get(id);
-        return observation ? { ...observation } : undefined;
+        return this.health.get(id);
+    }
+    /**
+     * Whether ANY view of this deployment has seen a successful call to `id` —
+     * a bare boolean, never the observation. Connector liveness (reachable,
+     * credentials still valid) is a deployment-level fact, not a per-view one, so
+     * `list_connectors` may classify a connector as ok/unknown from it. The
+     * observation itself — `lastError` above all, which names the tool that
+     * failed — stays strictly per view.
+     */
+    hasObservedSuccess(id) {
+        return this.health.get(id)?.lastSuccessAt !== undefined;
     }
     /** Best-effort connector status for list_connectors. */
     async statusFor(id, baseUrl, requestScope = {}) {
@@ -296,4 +396,170 @@ export class Registry {
         }
     }
 }
+/**
+ * Per-toolkit HealthLogs, keyed by registry and then by toolkit name.
+ *
+ * Module-scoped rather than a `Registry` member on purpose: `Registry`'s type
+ * is part of the public API surface (`Connecta.registry`), and this is internal
+ * factoring only `ScopedRegistry` may touch. The WeakMap keeps the logs alive
+ * exactly as long as their registry, and the inner map is bounded by the
+ * number of configured toolkits.
+ */
+const toolkitHealthLogs = new WeakMap();
+/** The long-lived log one toolkit records into; created on first use. */
+function toolkitHealthLog(base, toolkitName) {
+    let logs = toolkitHealthLogs.get(base);
+    if (!logs) {
+        logs = new Map();
+        toolkitHealthLogs.set(base, logs);
+    }
+    let log = logs.get(toolkitName);
+    if (!log) {
+        log = new HealthLog();
+        logs.set(toolkitName, log);
+    }
+    return log;
+}
+/**
+ * THE toolkit enforcement point (issue #22).
+ *
+ * A filtered VIEW of one long-lived `Registry`: same connectors, same tool
+ * caches, same health — narrowed to the connectors and tool addresses one
+ * toolkit selects. `serveMcp` builds it once per scoped connection and hands it
+ * to `registerMetaTools`/`registerExecuteTool`, so `list_connectors`,
+ * `search_tools`, `describe_tools`, `call_tool`, `call_destructive_tool`,
+ * `batch_call`, `authorize_connector`, `get_result`, `skills`, and the
+ * `execute_code` host bridge all inherit the boundary from here instead of
+ * re-implementing nine checks.
+ *
+ * Two invariants make it reviewable:
+ *
+ * 1. **Indistinguishability.** Out-of-scope input fails through the SAME code
+ *    path, with the same error class and message, as input naming something
+ *    that does not exist at all. An out-of-scope CONNECTOR disappears from
+ *    `resolveAddress`/`getConnector` (→ `Unknown address` / `Unknown
+ *    connector`); an out-of-scope TOOL disappears from the catalog this view
+ *    returns (→ `Unknown tool "<t>" on connector "<c>"`), which is exactly the
+ *    error a misspelled tool name already produced. Scoping deliberately does
+ *    NOT reject at `resolveAddress` for tools: that would answer with the
+ *    connector-level message and make "hidden here" distinguishable from
+ *    "never existed".
+ * 2. **It filters views, never state.** Every read delegates to the shared
+ *    registry and filters the returned array, so the tool cache, the persisted
+ *    catalog, and the health map stay whole and shared across scopes.
+ */
+export class ScopedRegistry {
+    base;
+    toolkit;
+    /** This toolkit's own health observations — see HealthLog. */
+    health;
+    constructor(base, toolkit) {
+        this.base = base;
+        this.toolkit = toolkit;
+        this.health = toolkitHealthLog(base, toolkit.name);
+    }
+    get maxResultBytes() {
+        return this.base.maxResultBytes;
+    }
+    /** In scope AND actually registered. */
+    visible(id) {
+        return (this.toolkit.hasConnector(id) && this.base.getConnector(id) !== undefined);
+    }
+    /** Byte-identical to what the unscoped registry throws for an unknown id. */
+    unknownConnector(id) {
+        return new Error(`Unknown connector "${id}"`);
+    }
+    inScopeTools(id, tools) {
+        return tools.filter((tool) => this.toolkit.hasTool(id, tool.name));
+    }
+    listConnectors() {
+        return this.base
+            .listConnectors()
+            .filter((connector) => this.toolkit.hasConnector(connector.id));
+    }
+    getConnector(id) {
+        return this.visible(id) ? this.base.getConnector(id) : undefined;
+    }
+    resolveAddress(address) {
+        const resolved = this.base.resolveAddress(address);
+        if (!resolved)
+            return null;
+        // Connector-level only — see invariant 1 above.
+        return this.toolkit.hasConnector(resolved.connector.id) ? resolved : null;
+    }
+    async getTools(id, baseUrl, requestScope) {
+        if (!this.visible(id))
+            throw this.unknownConnector(id);
+        return this.inScopeTools(id, await this.base.getTools(id, baseUrl, requestScope));
+    }
+    async refreshTools(id, baseUrl, requestScope) {
+        if (!this.visible(id))
+            throw this.unknownConnector(id);
+        return this.inScopeTools(id, await this.base.refreshTools(id, baseUrl, requestScope));
+    }
+    peekTools(id) {
+        if (!this.visible(id))
+            return undefined;
+        const tools = this.base.peekTools(id);
+        return tools ? this.inScopeTools(id, tools) : undefined;
+    }
+    contextFor(id, baseUrl, requestScope = {}, callOptions = {}) {
+        // Unreachable through the meta-tools (they resolve first), so a throw here
+        // is a loud backstop rather than a silent grant of connector storage and
+        // credentials to a scope that may not see the connector.
+        if (!this.visible(id))
+            throw this.unknownConnector(id);
+        return this.base.contextFor(id, baseUrl, requestScope, callOptions);
+    }
+    /**
+     * Stashed oversized results are bound to the scope that produced them: a
+     * scoped session cannot page a result it could not have produced, and an id
+     * from another scope reads back as the ordinary "Unknown or expired result
+     * id". Unscoped sessions keep the historical `results:` prefix untouched.
+     */
+    resultsStorage() {
+        return namespaced(this.base.resultsStorage(), `toolkit:${this.toolkit.name}:`);
+    }
+    // Outcomes are recorded twice on purpose: the deployment-wide log keeps the
+    // operator surfaces complete, while the toolkit's own log is the ONLY one
+    // this view reads back — so `list_connectors` here never reports a sibling
+    // toolkit's failures, or the tool names their error strings carry.
+    recordSuccess(id, latencyMs) {
+        if (!this.visible(id))
+            return;
+        this.base.recordSuccess(id, latencyMs);
+        this.health.recordSuccess(id, latencyMs);
+    }
+    recordFailure(id, latencyMs, error) {
+        if (!this.visible(id))
+            return;
+        this.base.recordFailure(id, latencyMs, error);
+        this.health.recordFailure(id, latencyMs, error);
+    }
+    healthFor(id) {
+        return this.visible(id) ? this.health.get(id) : undefined;
+    }
+    /**
+     * Deliberately NOT per view: whether the connector has ever answered is a
+     * fact about the connector, not about a team's traffic, and withholding it
+     * would report every remote connector as "unknown" to a scoped session that
+     * has not called it yet. It carries no tool name, error text, or count — the
+     * per-view isolation of those, above, is unchanged.
+     */
+    hasObservedSuccess(id) {
+        return this.visible(id) ? this.base.hasObservedSuccess(id) : false;
+    }
+    async statusFor(id, baseUrl, requestScope = {}) {
+        // Same shape the unscoped registry returns for an unregistered id.
+        if (!this.visible(id)) {
+            return { state: "error", message: "Unknown connector" };
+        }
+        return this.base.statusFor(id, baseUrl, requestScope);
+    }
+    async invalidateStored(id) {
+        if (!this.visible(id))
+            return;
+        await this.base.invalidateStored(id);
+    }
+}
 //# sourceMappingURL=registry.js.map