@zackbart/connecta 0.18.2 → 0.18.3

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to this package are documented here.
 
+## 0.18.3 — 2026-08-25
+
+This change gives code mode memory where downstream MCP catalogs are usually
+silent: after a successful call with no declared output schema, Connecta keeps
+only the result's field names and broad JSON types and shows that open shape on
+later discovery. Nothing breaks, no deployment option changes, and providers
+that already declare outputs are untouched. The bounded cache lives only in the
+current process or Worker isolate and forgets each shape after 24 hours.
+Discovery still never executes a tool, and
+the new `outputSchemaSource: "observed"` marker is the warning label that keeps
+one or several real results from masquerading as a provider contract.
+
+### Added
+
+- **Passive observed output schemas.** Successful explicitly read-only calls
+  whose provider declared no `outputSchema` infer and merge an open
+  optional-field schema of names and broad JSON types. The inference retains no
+  arguments, scalar values, raw results, code, credentials, or errors. Property
+  names may be user-authored. It bounds depth, breadth, names, nodes, definition
+  size, and schema bytes; keeps at most 256 runtime entries; ties each entry to
+  the exact tool definition; and expires it after 24 hours.
+  Search and describe return it with `outputSchemaSource: "observed"`; a
+  declared schema always wins. Observation is synchronous, storage-free, and
+  unable to fail the call. The design follows new warm-cache evidence and two
+  live deployment audits: BePresent had 246/378 tools without output schemas,
+  while OneMany's maintained connectors declared all 90 (#442).
+
 ## 0.18.2 — 2026-08-18
 
 This patch closes the gap the RevenueCat rollout exposed on the same day 0.18.1

package/README.md

@@ -67,6 +67,10 @@ Fifty issues in, one small object out. Your context window notices.
   classifications, imported one at a time.
 - **Let the agent work in code.** Search, chain, filter, join, and reduce
   inside the sandbox instead of round-tripping every call through the model.
+- **Teach undeclared result shapes by using them.** Successful read-only calls
+  retain field names and broad types in bounded runtime memory, never scalar
+  values, so later programs can project a remote MCP result its provider never
+  documented.
 - **Keep writes deliberate.** Only tools marked read-only run in a program.
   Everything else is a separate, visible call your client can gate.
 - **Run it where you like.** Node, a Docker container, or a Cloudflare Worker,

package/dist/catalog-service.d.ts

@@ -49,6 +49,7 @@ interface CatalogSearchEntry {
         description?: string;
         inputSchema?: unknown;
         outputSchema?: unknown;
+        outputSchemaSource?: "observed";
         inputSchemaTruncated?: true;
         outputSchemaTruncated?: true;
         inputKeys?: string[];
@@ -112,6 +113,7 @@ export interface CatalogDescription {
     guideRequiredReasons?: GuideRequiredReason[];
     inputSchema?: unknown;
     outputSchema?: unknown;
+    outputSchemaSource?: "observed";
     annotations?: ToolDef["annotations"];
     error?: string;
     errorDetails?: CatalogDescriptionFailureDetail;
@@ -174,6 +176,7 @@ export declare class CatalogService {
     }, purpose: string): NonNullable<CallErrorDetails["nextAction"]>;
     loadConnector(id: string, callOptions?: ConnectorOperationOptions): Promise<ToolDef[]>;
     private loadForDiscovery;
+    private outputSchema;
     resolveTool(address: string, callOptions?: ConnectorOperationOptions): Promise<CatalogResolution>;
     /**
      * Resolve the JavaScript-safe property used by a lazy code-mode namespace
@@ -242,6 +245,7 @@ export declare function flatSearchResult(page: CatalogSearchPage): {
         description?: string;
         inputSchema?: unknown;
         outputSchema?: unknown;
+        outputSchemaSource?: "observed";
         inputSchemaTruncated?: true;
         outputSchemaTruncated?: true;
         inputKeys?: string[];

package/dist/catalog-service.js

@@ -266,6 +266,14 @@ export class CatalogService {
             timeoutMs: this.probeTimeoutMs,
         }), this.probeTimeoutMs, label);
     }
+    outputSchema(connectorId, tool) {
+        if (tool.outputSchema)
+            return { schema: tool.outputSchema };
+        const observed = this.registry.observedOutputSchema(connectorId, tool);
+        return observed
+            ? { schema: observed, source: "observed" }
+            : {};
+    }
     async resolveTool(address, callOptions = {}) {
         const resolved = this.registry.resolveAddress(address);
         if (!resolved) {
@@ -487,15 +495,18 @@ export class CatalogService {
         });
         const pageMatches = matches.slice(offset, offset + limit);
         const entries = pageMatches.map((match) => {
+            const output = args.includeSchemas
+                ? this.outputSchema(match.connector.id, match.tool)
+                : {};
             const input = match.tool.inputSchema ?? { type: "object" };
             const renderedInput = args.includeSchemas
                 ? renderSearchSchema(input, args.includeSchemas)
                 : undefined;
-            const renderedOutput = args.includeSchemas && match.tool.outputSchema
-                ? renderSearchSchema(match.tool.outputSchema, args.includeSchemas)
+            const renderedOutput = args.includeSchemas && output.schema
+                ? renderSearchSchema(output.schema, args.includeSchemas)
                 : undefined;
             const schemaKeys = args.includeSchemas && args.includeSchemaKeys
-                ? schemaKeyMetadata(input, match.tool.outputSchema)
+                ? schemaKeyMetadata(input, output.schema)
                 : undefined;
             const description = summarizeDiscoveryDescription(match.tool.description, args.fullDescriptions === true);
             const requiredReasons = guideRequiredReasons(match.connector, match.tool, renderedInput?.truncated === true || renderedOutput?.truncated === true);
@@ -520,11 +531,14 @@ export class CatalogService {
                     ...(renderedInput?.truncated
                         ? { inputSchemaTruncated: true }
                         : {}),
-                    ...(args.includeSchemas && match.tool.outputSchema
+                    ...(args.includeSchemas && output.schema
                         ? {
                             outputSchema: renderedOutput?.schema,
                         }
                         : {}),
+                    ...(args.includeSchemas && output.source
+                        ? { outputSchemaSource: output.source }
+                        : {}),
                     ...(renderedOutput?.truncated
                         ? { outputSchemaTruncated: true }
                         : {}),
@@ -813,6 +827,7 @@ export class CatalogService {
                 };
             }
             const input = tool.inputSchema ?? { type: "object" };
+            const output = this.outputSchema(addressResolution.connector.id, tool);
             const description = summarizeDescription(tool.description, args.fullDescriptions === true);
             const requiredReasons = guideRequiredReasons(addressResolution.connector, tool, false);
             const guideSummary = connectorGuideSummary(addressResolution.connector);
@@ -833,11 +848,12 @@ export class CatalogService {
                     }
                     : {}),
                 inputSchema: renderSchema(input, format),
-                ...(tool.outputSchema
+                ...(output.schema
                     ? {
-                        outputSchema: renderSchema(tool.outputSchema, format),
+                        outputSchema: renderSchema(output.schema, format),
                     }
                     : {}),
+                ...(output.source ? { outputSchemaSource: output.source } : {}),
                 ...(tool.annotations ? { annotations: tool.annotations } : {}),
             };
         });

package/dist/invocation.js

@@ -288,6 +288,7 @@ export class InvocationService {
         }
         const maxRetries = Math.min(2, Math.max(0, Math.trunc(context.maxRetries ?? 0)));
         let result;
+        let observedResult;
         while (true) {
             attempts++;
             let permit;
@@ -362,9 +363,8 @@ export class InvocationService {
                     // reports the same downstream-failure wording, and the throw lands
                     // inside the attempt where it stays retry-eligible and feeds health.
                     assertRawMcpSuccess(resolved.connector.kind, raw);
-                    result = context.unwrapResult
-                        ? unwrapMcpResult(resolved.connector.kind, raw)
-                        : raw;
+                    observedResult = unwrapMcpResult(resolved.connector.kind, raw);
+                    result = context.unwrapResult ? observedResult : raw;
                 }
                 finally {
                     connectorMs += Date.now() - connectorStarted;
@@ -440,6 +440,12 @@ export class InvocationService {
             const value = context.processResult
                 ? await context.processResult(result, resolved)
                 : result;
+            try {
+                this.registry.observeOutputShape(resolved.connector.id, resolved.definition, observedResult);
+            }
+            catch {
+                // Shape learning is advisory. It cannot change a completed call.
+            }
             resultProcessingMs += Date.now() - processingStarted;
             const diagnostics = timing();
             const friction = context.activityFriction?.(value);

package/dist/registry.d.ts

@@ -113,6 +113,10 @@ export interface RegistryView {
     observedSuccessAt(id: string): string | undefined;
     /** Local declared-vs-stored credential mismatch, with no downstream I/O. */
     credentialDriftFor(id: string): Promise<string | undefined>;
+    /** Value-free shape learned from successful calls, never a provider declaration. */
+    observedOutputSchema(connectorId: string, definition: ToolDef): ToolDef["outputSchema"] | undefined;
+    /** Passively learn one successful unwrapped result; failures stay isolated. */
+    observeOutputShape(connectorId: string, definition: ToolDef, value: unknown): void;
     statusFor(id: string, baseUrl: string, requestScope?: object, callOptions?: ConnectorOperationOptions): Promise<ConnectorStatus>;
     invalidateStored(id: string): Promise<void>;
 }
@@ -141,6 +145,7 @@ export declare class Registry implements RegistryView {
     private readonly health;
     /** Last drift counts reported to activity, per connector, in this runtime. */
     private readonly reportedDrift;
+    private readonly observedOutputSchemas;
     private readonly ttlMs;
     private readonly staleMs;
     private readonly persistToolCatalog;
@@ -203,6 +208,8 @@ export declare class Registry implements RegistryView {
      * separate from any connector's `conn:<id>:` namespace. Backs get_result.
      */
     resultsStorage(): KVStorage;
+    observedOutputSchema(connectorId: string, definition: ToolDef): ToolDef["outputSchema"] | undefined;
+    observeOutputShape(connectorId: string, definition: ToolDef, value: unknown): void;
     /** Resolve "<connectorId>.<toolName>" → connector + tool name. */
     resolveAddress(address: string): {
         connector: Connector;

package/dist/registry.js

@@ -7,6 +7,7 @@ import { boundedCatalogDrift } from "./catalog-drift.js";
 import { fingerprintSerializedCatalog, snapshotCatalog, } from "./catalog-fingerprint.js";
 import { MAX_CATALOG_CHUNK_BYTES, MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES, } from "./catalog-limits.js";
 import { mapSettledWithConcurrency } from "./concurrency.js";
+import { ObservedOutputSchemas } from "./result-shapes.js";
 import { GUIDE_SUMMARY_LENGTH, normalizeGuideSummary, } from "./skills.js";
 import { withAbortableTimeout } from "./timeout.js";
 const ID_RE = /^[a-z0-9_-]+$/;
@@ -133,6 +134,7 @@ export class Registry {
     health = new HealthLog();
     /** Last drift counts reported to activity, per connector, in this runtime. */
     reportedDrift = new Map();
+    observedOutputSchemas;
     ttlMs;
     staleMs;
     persistToolCatalog;
@@ -140,6 +142,7 @@ export class Registry {
     maxResultBytes;
     constructor(connectors, opts) {
         this.opts = opts;
+        this.observedOutputSchemas = new ObservedOutputSchemas();
         this.ttlMs =
             (opts.toolCacheTtlSeconds ?? DEFAULT_TTL_SECONDS) * 1000;
         this.staleMs =
@@ -342,6 +345,12 @@ export class Registry {
     resultsStorage() {
         return namespaced(this.opts.storage, "results:");
     }
+    observedOutputSchema(connectorId, definition) {
+        return this.observedOutputSchemas.get(connectorId, definition);
+    }
+    observeOutputShape(connectorId, definition, value) {
+        this.observedOutputSchemas.observe(connectorId, definition, value);
+    }
     /** Resolve "<connectorId>.<toolName>" → connector + tool name. */
     resolveAddress(address) {
         const parts = splitAddress(address);

package/dist/result-shapes.d.ts

@@ -0,0 +1,13 @@
+import type { JsonSchema, ToolDef } from "./types.js";
+/**
+ * Passive, process-local output-shape learning. Provider declarations always
+ * win; observations are an open, optional-field routing aid and never a
+ * replacement contract.
+ */
+export declare class ObservedOutputSchemas {
+    private readonly entries;
+    private cacheKey;
+    private set;
+    get(connectorId: string, definition: ToolDef): JsonSchema | undefined;
+    observe(connectorId: string, definition: ToolDef, value: unknown): void;
+}

package/dist/result-shapes.js

@@ -0,0 +1,331 @@
+import { isExplicitlyReadOnly } from "./tool-safety.js";
+const OBSERVATION_TTL_MS = 24 * 60 * 60 * 1000;
+const MAX_CACHED_SHAPES = 256;
+const MAX_DEFINITION_BYTES = 64 * 1024;
+const MAX_SCHEMA_BYTES = 16 * 1024;
+const MAX_SCHEMA_DEPTH = 6;
+const MAX_SCHEMA_NODES = 128;
+const MAX_OBJECT_PROPERTIES = 48;
+const MAX_ARRAY_ITEMS = 32;
+const MAX_PROPERTY_NAME_BYTES = 128;
+const UNSAFE_PROPERTY_NAMES = new Set([
+    "__proto__",
+    "constructor",
+    "prototype",
+]);
+const encoder = new TextEncoder();
+function broadType(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    switch (typeof value) {
+        case "string":
+        case "boolean":
+            return typeof value;
+        case "number":
+            return Number.isFinite(value) ? "number" : undefined;
+        case "object":
+            return "object";
+        default:
+            return undefined;
+    }
+}
+function serializedSchema(schema) {
+    try {
+        const text = JSON.stringify(schema);
+        return encoder.encode(text).byteLength <= MAX_SCHEMA_BYTES
+            ? text
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function cloneSchema(schema) {
+    const serialized = serializedSchema(schema);
+    if (!serialized)
+        return undefined;
+    try {
+        return JSON.parse(serialized);
+    }
+    catch {
+        return undefined;
+    }
+}
+function definitionIdentity(definition) {
+    try {
+        const serialized = JSON.stringify(definition);
+        return encoder.encode(serialized).byteLength <= MAX_DEFINITION_BYTES
+            ? serialized
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function schemaType(schema) {
+    return typeof schema.type === "string" ? schema.type : undefined;
+}
+function safePropertyName(name) {
+    return (!UNSAFE_PROPERTY_NAMES.has(name) &&
+        encoder.encode(name).byteLength <= MAX_PROPERTY_NAME_BYTES);
+}
+function boundedPropertyNames(value) {
+    const names = [];
+    for (const name in value) {
+        if (!Object.hasOwn(value, name) || !safePropertyName(name))
+            continue;
+        names.push(name);
+        if (names.length >= MAX_OBJECT_PROPERTIES)
+            break;
+    }
+    return names.sort();
+}
+function unionBranches(schema) {
+    return Array.isArray(schema.anyOf)
+        ? schema.anyOf
+        : [schema];
+}
+function branchOrder(schema) {
+    return ["null", "boolean", "number", "string", "array", "object"].indexOf(schemaType(schema) ?? "");
+}
+function mergeSchemas(left, right) {
+    const leftType = schemaType(left);
+    const rightType = schemaType(right);
+    if (leftType === "object" && rightType === "object") {
+        const leftProperties = left.properties && typeof left.properties === "object"
+            ? left.properties
+            : {};
+        const rightProperties = right.properties && typeof right.properties === "object"
+            ? right.properties
+            : {};
+        const properties = Object.create(null);
+        for (const key of [...new Set([
+                ...Object.keys(leftProperties),
+                ...Object.keys(rightProperties),
+            ])].sort()) {
+            const leftProperty = leftProperties[key];
+            const rightProperty = rightProperties[key];
+            properties[key] =
+                leftProperty && rightProperty
+                    ? mergeSchemas(leftProperty, rightProperty)
+                    : (leftProperty ?? rightProperty);
+        }
+        return { type: "object", properties };
+    }
+    if (leftType === "array" && rightType === "array") {
+        const leftItems = left.items && typeof left.items === "object"
+            ? left.items
+            : undefined;
+        const rightItems = right.items && typeof right.items === "object"
+            ? right.items
+            : undefined;
+        return {
+            type: "array",
+            ...(leftItems || rightItems
+                ? {
+                    items: leftItems && rightItems
+                        ? mergeSchemas(leftItems, rightItems)
+                        : (leftItems ?? rightItems),
+                }
+                : {}),
+        };
+    }
+    if (leftType && leftType === rightType)
+        return left;
+    const byType = new Map();
+    for (const branch of [...unionBranches(left), ...unionBranches(right)]) {
+        const type = schemaType(branch);
+        if (!type)
+            continue;
+        const existing = byType.get(type);
+        byType.set(type, existing ? mergeSchemas(existing, branch) : branch);
+    }
+    const branches = [...byType.values()].sort((a, b) => branchOrder(a) - branchOrder(b));
+    return branches.length === 1 ? branches[0] : { anyOf: branches };
+}
+function inferSchema(value, budget, depth = 0) {
+    const type = broadType(value);
+    if (!type || depth > MAX_SCHEMA_DEPTH || budget.nodes >= MAX_SCHEMA_NODES) {
+        return undefined;
+    }
+    budget.nodes++;
+    if (type !== "object" && type !== "array")
+        return { type };
+    const object = value;
+    if (budget.seen.has(object))
+        return undefined;
+    budget.seen.add(object);
+    try {
+        if (type === "array") {
+            let items;
+            for (const item of value.slice(0, MAX_ARRAY_ITEMS)) {
+                const inferred = inferSchema(item, budget, depth + 1);
+                if (inferred)
+                    items = items ? mergeSchemas(items, inferred) : inferred;
+                if (budget.nodes >= MAX_SCHEMA_NODES)
+                    break;
+            }
+            return { type: "array", ...(items ? { items } : {}) };
+        }
+        const properties = Object.create(null);
+        const record = value;
+        for (const key of boundedPropertyNames(record)) {
+            const inferred = inferSchema(record[key], budget, depth + 1);
+            if (inferred)
+                properties[key] = inferred;
+            if (budget.nodes >= MAX_SCHEMA_NODES)
+                break;
+        }
+        return { type: "object", properties };
+    }
+    finally {
+        budget.seen.delete(object);
+    }
+}
+function boundSchema(schema, budget, depth = 0) {
+    if (depth > MAX_SCHEMA_DEPTH || budget.nodes >= MAX_SCHEMA_NODES) {
+        return undefined;
+    }
+    budget.nodes++;
+    if (Array.isArray(schema.anyOf)) {
+        const branches = schema.anyOf
+            .slice(0, 6)
+            .map((branch) => boundSchema(branch, budget, depth + 1))
+            .filter((branch) => Boolean(branch));
+        return branches.length >= 2 ? { anyOf: branches } : branches[0];
+    }
+    const type = schemaType(schema);
+    if (!type)
+        return undefined;
+    if (type === "array") {
+        const items = schema.items && typeof schema.items === "object"
+            ? boundSchema(schema.items, budget, depth + 1)
+            : undefined;
+        return { type: "array", ...(items ? { items } : {}) };
+    }
+    if (type === "object") {
+        const source = schema.properties && typeof schema.properties === "object"
+            ? schema.properties
+            : {};
+        const properties = Object.create(null);
+        let included = 0;
+        for (const key of Object.keys(source).sort()) {
+            if (included >= MAX_OBJECT_PROPERTIES ||
+                !safePropertyName(key)) {
+                continue;
+            }
+            const property = boundSchema(source[key], budget, depth + 1);
+            if (property) {
+                properties[key] = property;
+                included++;
+            }
+            if (budget.nodes >= MAX_SCHEMA_NODES)
+                break;
+        }
+        return { type: "object", properties };
+    }
+    return { type };
+}
+function observedSchema(value) {
+    try {
+        const inferred = inferSchema(value, { nodes: 0, seen: new WeakSet() });
+        const schema = inferred
+            ? boundSchema(inferred, { nodes: 0 })
+            : undefined;
+        return schema && serializedSchema(schema) ? schema : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Passive, process-local output-shape learning. Provider declarations always
+ * win; observations are an open, optional-field routing aid and never a
+ * replacement contract.
+ */
+export class ObservedOutputSchemas {
+    entries = new Map();
+    cacheKey(connectorId, definition) {
+        return JSON.stringify([connectorId, definition.name]);
+    }
+    set(key, entry) {
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        while (this.entries.size > MAX_CACHED_SHAPES) {
+            const oldest = this.entries.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.entries.delete(oldest);
+        }
+    }
+    get(connectorId, definition) {
+        try {
+            const key = this.cacheKey(connectorId, definition);
+            if (definition.outputSchema) {
+                this.entries.delete(key);
+                return undefined;
+            }
+            if (!isExplicitlyReadOnly(definition)) {
+                this.entries.delete(key);
+                return undefined;
+            }
+            const identity = definitionIdentity(definition);
+            if (!identity) {
+                this.entries.delete(key);
+                return undefined;
+            }
+            const entry = this.entries.get(key);
+            if (!entry)
+                return undefined;
+            if (entry.definition !== identity || entry.expiresAt <= Date.now()) {
+                this.entries.delete(key);
+                return undefined;
+            }
+            this.entries.delete(key);
+            this.entries.set(key, entry);
+            return cloneSchema(entry.schema);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    observe(connectorId, definition, value) {
+        try {
+            const key = this.cacheKey(connectorId, definition);
+            if (definition.outputSchema) {
+                this.entries.delete(key);
+                return;
+            }
+            if (!isExplicitlyReadOnly(definition)) {
+                this.entries.delete(key);
+                return;
+            }
+            const identity = definitionIdentity(definition);
+            const inferred = observedSchema(value);
+            if (!identity) {
+                this.entries.delete(key);
+                return;
+            }
+            if (!inferred)
+                return;
+            const current = this.entries.get(key);
+            const merged = boundSchema(current &&
+                current.definition === identity &&
+                current.expiresAt > Date.now()
+                ? mergeSchemas(current.schema, inferred)
+                : inferred, { nodes: 0 });
+            if (!merged || !serializedSchema(merged))
+                return;
+            this.set(key, {
+                definition: identity,
+                expiresAt: Date.now() + OBSERVATION_TTL_MS,
+                schema: merged,
+            });
+        }
+        catch {
+            // Observation is an optimization. A provider success stays successful.
+        }
+    }
+}

package/dist/skills.js

@@ -23,13 +23,13 @@ The minimum guest API is:
 
 Search inside the run and finish the task there. A discovery-only program wastes a round trip. Use 2–4 distinctive action/object terms, not the full request. Use separate short searches for distinct operations.
 
-For top-level \`search_tools\`, omit \`limit\` initially (the default is 10), then page with a limit up to 50 if needed. Empty or whitespace-only queries browse all tools. A non-empty query with no ASCII terms returns no matches; mixed input searches with its ASCII terms. \`includeSchemas: "compact"\` adds bounded input and declared output shapes. Plain objects expose \`inputKeys\`, \`requiredInputKeys\`, and \`outputKeys\`; truncation flags mark incomplete shapes; matches also carry declared annotations.
+For top-level \`search_tools\`, omit \`limit\` initially (the default is 10), then page with a limit up to 50 if needed. Empty or whitespace-only queries browse all tools. A non-empty query with no ASCII terms returns no matches; mixed input searches with its ASCII terms. \`includeSchemas: "compact"\` adds bounded input and available output shapes. An observed shape carries \`outputSchemaSource: "observed"\`; treat it as routing evidence rather than a provider contract. Plain objects expose \`inputKeys\`, \`requiredInputKeys\`, and \`outputKeys\`; truncation flags mark incomplete shapes; matches also carry declared annotations.
 
 - \`connecta.search({})\` loads all catalogs. Pass \`connector: "<id>"\` when the integration is obvious. Use \`safety: "readOnly"\` for program calls. These inputs filter discovery; they grant no authority.
-- Request \`includeSchemas: "compact"\`. Check address, purpose, annotations, required inputs, truncation, safety, and declared outputs. Never select only because a result ranks first or has fewer required inputs.
+- Request \`includeSchemas: "compact"\`. Check address, purpose, annotations, required inputs, truncation, safety, and available outputs. Never select only because a result ranks first or has fewer required inputs.
 - Supply every \`requiredInputKey\` from the task or a prior result. For dependencies, match the earlier \`outputKey\` to the later required key. An empty required-key list does not permit invented arguments. Missing \`outputKeys\` means inspect \`outputSchema\`.
 - Use \`connecta.describe({ address })\` or \`{ addresses }\` when a compact schema is truncated or insufficient. Use \`format: "json"\` only for exact constraints. Write the property names the schema displays; never guess positions or aliases.
-- Reduce through declared output keys. Do not guess collection roots such as \`items\` or \`results\`. If a match or result key is missing, inspect, re-search, or describe inside the same run instead of returning discovery for another call.
+- Reduce through available output keys. Treat an observed key as a hint, since later results may omit it or add others. Do not guess collection roots such as \`items\` or \`results\`. If a match or result key is missing, inspect, re-search, or describe inside the same run instead of returning discovery for another call.
 
 Only tools explicitly annotated \`readOnlyHint: true\` are reachable. The catalog, credential, admission, and read-only gates run below the sandbox; code cannot widen its authority.
 

package/dist/version.d.ts

@@ -4,4 +4,4 @@
  * a bump that forgets this file fails the build rather than shipping a stale
  * version to `/health` and to downstream MCP handshakes.
  */
-export declare const CONNECTA_VERSION = "0.18.2";
+export declare const CONNECTA_VERSION = "0.18.3";

package/dist/version.js

@@ -4,4 +4,4 @@
  * a bump that forgets this file fails the build rather than shipping a stale
  * version to `/health` and to downstream MCP handshakes.
  */
-export const CONNECTA_VERSION = "0.18.2";
+export const CONNECTA_VERSION = "0.18.3";

package/documentation/architecture.md

@@ -14,8 +14,9 @@ stating before anything else.
 
 **Per isolate, built once.** `createConnecta(config)` returns
 `{ fetch, registry, close }`. The `Registry` owns the connector set, address
-resolution, catalog caches, connector health, and the per-connector call
-limiters. It is constructed once and lives as long as the isolate or process —
+resolution, catalog caches, observed output schemas, connector health, and the
+per-connector call limiters. It is constructed once and lives as long as the
+isolate or process —
 on Workers that means a lazy module-scope singleton, which is why both
 deployment shapes build it outside the request handler.
 
@@ -94,6 +95,7 @@ owns or hands out, and a change usually belongs in exactly one of them:
 | `src/catalog-service.ts` | Request-local tool listing, search, and describe. It coalesces reads inside one request and opts agent reads into the runtime's deferred catalog channel when one exists. |
 | `src/invocation.ts` | One tool call: argument validation, call admission, per-attempt timeout, retry with the connector's own `Retry-After` honoured exactly or declined, result unwrapping, size capping, and the activity record. |
 | `src/catalog.ts` | Ranking, description summarizing, and the compact schema renderer discovery shows. |
+| `src/result-shapes.ts` | Bounded runtime-only inference and merging for output shapes learned from successful read-only calls whose providers declared none. |
 
 `src/meta-tools.ts` and `src/execute.ts` are two front doors onto the same
 three services. That is the point: a program's `connecta.call` and a top-level
@@ -142,6 +144,7 @@ src/
   registry.ts         connector set, addresses, health, call limiters
   catalog-service.ts  request-local catalog access, search, and describe
   catalog.ts          ranking, summaries, compact schema rendering
+  result-shapes.ts    passive runtime-only observed output schemas
   invocation.ts       one tool call, end to end
   catalog-drift.ts    vetted manifests and the counts a refresh produces
   credentials.ts      the AES-GCM connector vault over KVStorage

package/documentation/code-mode.md

@@ -149,10 +149,7 @@ a cycle, a `BigInt`, a function, a class instance — never round-trips: it eith
 ends the run with an error or is converted lossily, executor's choice (`X9`).
 Return JSON-shaped data and the question does not arise.
 
-**P4.** Nothing survives an execution. There is no module scope, cache, or
-scratch storage carried to the next program, and no request-bound object outlives
-the request that created it. Within one execution, host calls share one
-downstream request scope.
+**P4.** Nothing survives an execution. There is no module scope, cache, or scratch storage carried to the next program, and no request-bound object outlives the request that created it. Within one execution, host calls share one downstream request scope. `S9`'s host-owned output observation is catalog metadata, not guest memory: a later program receives no prior value or object, only a labeled field/type schema through discovery.
 
 **P5.** Plain JavaScript only. TypeScript syntax is a syntax error. Portable code
 does not import: QuickJS blocks imports, while Dynamic Workers expose the `X5`
@@ -223,7 +220,7 @@ const page = await connecta.search({
 });
 ```
 
-**S1.** Returns one flat page: `{ tools, total, offset, limit, hasMore }`, plus `nextOffset` when more remains and `matchMode: "partial"` when no tool matched every term. Top-level `search_tools` is different: it returns `{ connectors: [{ id, tools }], total, offset, limit, hasMore }`. Complete matches normally precede partial matches, but a partial candidate whose complete normalized tool name occurs in the normalized raw query competes by score; conversational cleanup applies only to scoring terms. Other candidates covering at least two terms fill the page after every complete match; when no complete match exists, the existing any-term fallback remains. Each entry in `tools` carries `address`, `name`, and — when requested — `description`, `inputSchema`, `outputSchema`, `annotations`, and the connector's `guide`. Tool rows expose neither lexical scores nor per-result coverage. An empty or whitespace-only query browses. Non-empty input with no ASCII lexical terms returns no tools and bounded no-match analysis; mixed input searches with its ASCII terms. Compact shapes omit property prose, put required fields first, and cap each shape at 1,024 UTF-8 bytes. Each enum node gets 256 of those bytes. About three near-cap enum nodes can therefore coexist while leaving the final quarter for surrounding syntax; the unchanged global fallback still applies above 1,024 bytes. A capped enum preserves whole values before `unknown` and an exact omitted-value count, while an empty enum renders as `never`. Either cap carries `inputSchemaTruncated` or `outputSchemaTruncated`; a shape-wide cap remains structurally valid with `unknown` types plus `/* truncated */`. Small enums remain complete. Use `connecta.describe` (or JSON search) for omitted exact constraints.
+**S1.** Returns one flat page: `{ tools, total, offset, limit, hasMore }`, plus `nextOffset` when more remains and `matchMode: "partial"` when no tool matched every term. Top-level `search_tools` is different: it returns `{ connectors: [{ id, tools }], total, offset, limit, hasMore }`. Complete matches normally precede partial matches, but a partial candidate whose complete normalized tool name occurs in the normalized raw query competes by score; conversational cleanup applies only to scoring terms. Other candidates covering at least two terms fill the page after every complete match; when no complete match exists, the existing any-term fallback remains. Each entry in `tools` carries `address`, `name`, and — when requested — `description`, `inputSchema`, `outputSchema`, `annotations`, and the connector's `guide`. An output shape learned under `S9` also carries `outputSchemaSource: "observed"`; provider declarations carry no source marker. Tool rows expose neither lexical scores nor per-result coverage. An empty or whitespace-only query browses. Non-empty input with no ASCII lexical terms returns no tools and bounded no-match analysis; mixed input searches with its ASCII terms. Compact shapes omit property prose, put required fields first, and cap each shape at 1,024 UTF-8 bytes. Each enum node gets 256 of those bytes. About three near-cap enum nodes can therefore coexist while leaving the final quarter for surrounding syntax; the unchanged global fallback still applies above 1,024 bytes. A capped enum preserves whole values before `unknown` and an exact omitted-value count, while an empty enum renders as `never`. Either cap carries `inputSchemaTruncated` or `outputSchemaTruncated`; a shape-wide cap remains structurally valid with `unknown` types plus `/* truncated */`. Small enums remain complete. Use `connecta.describe` (or JSON search) for omitted exact constraints.
 
 **S1a.** `connector` loads only the named catalog; omit it only when the integration is ambiguous, because an unscoped search fans out across every configured connector. `safety: "readOnly"` returns exactly the tools available through `connecta.call`, connector shortcuts, and `connecta.batch`; `"approvalRequired"` returns the complementary fail-closed class, including false, missing, and contradictory annotations. Omitted or `"all"` preserves the complete catalog. These filters grant no authority and change no admission decision.
 
@@ -265,7 +262,7 @@ carry a route-aware `nextAction`; a close miss may add three canonical `suggesti
 Catalog failures add only `retryAfterMs` when known. One bad address never fails the whole call. Each failed entry clamps its
 caller-authored `address` to 512 UTF-8 bytes with an `…` marker. Entry order
 correlates a clipped address with its request; successes keep canonical addresses. More than 100
-addresses is `invalid_args`; the same 256,000-byte ceiling applies.
+addresses is `invalid_args`; the same 256,000-byte ceiling applies. A success whose output shape came from `S9` carries `outputSchemaSource: "observed"` beside the rendered schema.
 
 ### connecta.call
 
@@ -304,6 +301,8 @@ the batch, and more than ten calls throws.
 
 **S8.** Batch and thrown failures share one vocabulary (`E1`): an entry's `errorDetails.code` and `retryable` equal the fields on the error the same call would throw. Use batch for independent concurrency, not to recover lost type.
 
+**S9.** A successful explicitly read-only call whose provider declared no `outputSchema` passively learns one from the unwrapped result. The observation retains field names and broad JSON types only: no arguments, scalar values, raw results, code, credentials, or errors. Property names may be user-authored. Objects stay open, every field stays optional, and search or describe labels the shape `outputSchemaSource: "observed"` so a model cannot mistake runtime evidence for a provider contract. Later observations merge fields and types in a process-local 256-entry LRU; a provider declaration always wins. Inference stops at depth 6, 128 schema nodes, 48 properties per object, 32 inspected array items, and 128 UTF-8 bytes per property name; `__proto__`, `constructor`, and `prototype` names are discarded. A tool definition over 64 KiB or an observed schema over 16 KiB is ignored. An entry expires after 24 hours and carries the exact serialized tool definition, so a changed catalog entry, process restart, or Worker isolate eviction starts cold. A failed call or failed result-processing step learns nothing, and any observation failure is discarded without changing a successful call. No discovery read, timer, refresh, background job, or storage adapter executes or persists work for this cache: the result-sampling refusal in [#282](https://github.com/zackbart/connecta/issues/282) stands.
+
 ### connecta.emit
 
 ```js
@@ -847,6 +846,7 @@ the upstream `Executor` shape assignable.
 | `S6` | `test/execute.test.ts` (fail-closed annotations, activity parity) |
 | `S7` | `test/guest-api-contract.test.ts`, `test/execute.test.ts` (batch cap) |
 | `S8`, `E1`, `X11` | both guest-contract executors (caught call, namespace, discovery, utility, batch-validation, budget, and forgery cases; typed batch equivalence) |
+| `S9` | `test/result-shapes.test.ts` (value exclusion, bounds, merging, LRU and time expiry, runtime isolation, read-only admission, declared precedence, definition invalidation, unwrapped MCP results, discovery provenance, copy isolation, and failure isolation) |
 | `E2`, `E8` | `test/guest-api-contract.test.ts` (code → `retryable`, caught, batch, and uncaught validation recovery), `test/meta-tools.test.ts` (direct, destructive, batch, provider fallback), `test/validate.test.ts` (bounded payload-free findings), `test/errors.test.ts` |
 | `E3` | `test/guest-api-contract.test.ts`, `test/execute.test.ts` (`auth_required`) |
 | `E4` | `test/guest-api-contract.test.ts`, `test/execute.test.ts` (destructive) |

package/documentation/connectors.md

@@ -268,6 +268,16 @@ Tool calls must use the shared invocation path. That keeps direct calls, batch
 children, and code-mode host calls aligned on safety, retries, admission,
 timeouts, validation, result guards, and typed failures.
 
+That path also learns an observed output schema after a successful explicitly
+read-only call when the catalog declared none. The observation retains field
+names and broad JSON types rather than a result. Object fields stay optional,
+additional fields stay allowed, discovery labels the source `observed`, and any
+later provider declaration wins. Property names can be user-authored data, so
+the bounded cache stays in this process or Worker isolate and expires entries
+after 24 hours. An exact tool-definition comparison rejects stale shapes. This
+does not weaken the catalog completeness rule or the refusal of result sampling:
+no catalog read executes a tool.
+
 Connector usage guides are configuration too. `usageGuide` accepts the
 historical markdown string or `{ content, summary?, required? }`; the latter
 lets discovery explain what the guide covers without loading it. The summary

package/documentation/meta-tools.md

@@ -78,21 +78,35 @@ headed to `call_tool` or generated code; `safety: "approvalRequired"` finds the
 complementary set that must cross `call_destructive_tool`. Omitting `safety`,
 or setting it to `"all"`, preserves the complete configured catalog. This is
 only a discovery filter: it neither grants authority nor changes invocation admission.
-`includeSchemas: "compact"` adds each match's input and any declared output
-shape. Bounded plain-object schemas also expose `inputKeys`,
+`includeSchemas: "compact"` adds each match's input and any provider-declared
+output shape. When the provider declared none but an earlier successful call
+learned one, the same field carries the open observed schema beside
+`outputSchemaSource: "observed"`. That marker matters: observed fields and broad
+JSON types are routing evidence, not a provider contract, and every object field
+remains optional and open to unseen names. A provider declaration always wins.
+Bounded plain-object schemas also expose `inputKeys`,
 `requiredInputKeys`, and `outputKeys`; a zero-input object keeps
 `requiredInputKeys: []`, while an output object with no declared properties
 omits `outputKeys`. A truncated shape omits its corresponding list rather than
 repeating a large partial inventory. Matches carry declared
 behavior annotations. Lexical rank is only one signal: select a candidate whose
 required inputs are available, whose schema is complete enough for the call,
-and whose safety and declared outputs fit the work. A reducer uses `outputKeys`
+and whose safety and available outputs fit the work. A reducer uses `outputKeys`
 before inspecting the value; it does not assume a collection is named `items`
 or `results`. When that shape is sufficient, call the returned address directly. Reserve schema
 expansion through `connecta.describe` for a search without schemas, an
 ambiguous compact shape, or exact
 constraints that require `format: "json"`.
 
+Observed schemas originate no provider traffic. A successful explicitly
+read-only call the user already made contributes names and broad types after
+Connecta unwraps the result. Arguments, scalar values, raw results, code,
+credentials, and errors are not retained, though property names may themselves
+be user-authored. Shapes merge in a 256-entry runtime cache for 24 hours under
+the exact tool definition that produced them. A changed definition, process
+restart, or Worker isolate eviction starts cold. Observation cannot fail the
+call, and the declared catalog remains the fallback.
+
 Compact search is deliberately a routing view, not a second copy of connector
 documentation. Tool purposes are capped at 160 characters, connector
 descriptions and property prose are omitted, required input fields render

package/documentation/operations.md

@@ -75,7 +75,7 @@ optional.
 | `connectors` | — (required) | the connector set ([connectors](./connectors.md)) |
 | `executor` | — (required) | the sandbox `execute_code` runs in ([code mode](./code-mode.md#what-an-executor-must-implement)) |
 | `auth?` | none ⇒ open (dev only) | one `InboundAuth` or an array; bearer providers are checked before Clerk ([inbound auth](./auth.md)) |
-| `storage?` | `memoryStorage()` | the one state seam ([storage](./storage-and-credentials.md)) |
+| `storage?` | `memoryStorage()` | the one state seam for catalogs, result paging, credentials, and access tokens ([storage](./storage-and-credentials.md)) |
 | `publicUrl?` | per-request origin | public base URL; an HTTPS value also redirects inbound HTTP |
 | `logger?` | `console`, prefixed `[connecta]` | `{ debug, info, warn, error }` |
 | `branding?` | neutral Connecta defaults | operator-page and OAuth result-page labels and marks |
@@ -250,6 +250,7 @@ in.
 | `remote-mcp-credential.test.ts` | `remoteMcp()` drawing a static key from `/credentials`: the declared slot and its refusal of named fields and bad header names, header framing (bearer, bare, and the two `Basic` forms) observed on the wire, an empty slot failing as `auth_required` rather than reaching the downstream, a value carrying a control character refused before framing and absent from every surface — `call_tool`, `status`, the Test result, `lastError`, and the thrown error — rotation replacing the cached client and a connect already in flight while a wiped value fails the next call, the Test action's catalog probe and scope close, the cleartext-destination warning, and the vault and `authorize_connector` handoff end to end |
 | `remote-mcp-pagination.test.ts` | the `tools/list` cursor chain in both directions — exact cursor handoff, first-wins dedup, a failed later page rejecting rather than returning its prefix, the runaway backstops, the tool-metadata re-prime across pages, and paginated catalogs reaching the discovery path |
 | `request-admission.test.ts` | `/mcp` bounded before auth, the stable 503 and `Retry-After`, health and operator responsiveness under saturation, payload-free counters, queued cancellation, shutdown rejection while active work drains, and the separate fallback code pool |
+| `result-shapes.test.ts` | passive output-shape learning: value-free bounded inference, merging, 256-entry LRU eviction, 24-hour expiry, runtime isolation, read-only admission, declared-schema precedence, definition-change invalidation, discovery provenance, and failure isolation |
 | `revenuecat-provider.test.ts` / `revenuecat-registry.test.ts` | the RevenueCat proxy's per-project key scoping and account-wide OAuth guides, its purpose-bearing summary, the argued borderline verdicts in its digest-free manifest, and the deliberately unclassified `render-paywall-screenshot`; then two project-scoped keys as two connectors in a real deployment |
 | `server.test.ts` | end-to-end `/mcp` (401 → compact initialize instructions → seven compact definitions with bounded connector inventory → complete usage skill → `call_tool`), conditional guide pointers, open routes, Clerk `.well-known` metadata without network, code mode, and deferred catalog reads through both discovery surfaces |
 | `server-route-contracts.test.ts` | the route contracts `server.ts` must keep byte-identical: every built-in answered ahead of connector routes inside the security wrapper, open data-free shells with framing denied, per-route auth and same-origin requirements with exact 401/403/405 bodies, and OAuth `verifyState`-before-`finishAuth` ordering |

package/documentation/upgrading.md

@@ -57,7 +57,7 @@ exist so far:
 | --- | --- | --- |
 | **pre-template** | before 0.10.2 | no `connecta init` existed; hand-written, or copied from the retired `examples/node` |
 | **A** | 0.10.2 – 0.15.1 | `.env.example`, `.gitignore`, `AGENTS.md`, `CLAUDE.md`, `README.md`, `package.json`, `src/index.ts`, `tsconfig.json` |
-| **B** | 0.16.0 – 0.18.2 | adds `.dockerignore`, `Dockerfile`, `docker-compose.yml`, and `src/file-activity.ts`; `src/index.ts` grows the four commented operator blocks; `.env.example` ships `CONNECTA_TOKEN=` empty |
+| **B** | 0.16.0 – 0.18.3 | adds `.dockerignore`, `Dockerfile`, `docker-compose.yml`, and `src/file-activity.ts`; `src/index.ts` grows the four commented operator blocks; `.env.example` ships `CONNECTA_TOKEN=` empty |
 
 Generation A is a decade in template years and identifying it precisely does
 not matter, because you are about to reconstruct it exactly rather than guess
@@ -106,7 +106,7 @@ know what to preserve, once to know what to re-verify at the end.
 ### Bump the pin and install
 
 ```sh
-npm pkg set dependencies.@zackbart/connecta=0.18.2
+npm pkg set dependencies.@zackbart/connecta=0.18.3
 npm install
 ```
 
@@ -130,7 +130,7 @@ Generate the *current* template beside the base you already made, into the same
 `$SCRATCH`:
 
 ```sh
-(cd "$SCRATCH" && npx @zackbart/connecta@0.18.2 init current)
+(cd "$SCRATCH" && npx @zackbart/connecta@0.18.3 init current)
 ```
 
 You now have a three-way merge with a real base: `$SCRATCH/base` is what this
@@ -186,7 +186,7 @@ A deployment older than 0.10.2 has no base to diff against. Do not try to
 manufacture one. Instead:
 
 1. `SCRATCH=$(mktemp -d)`, then
-   `(cd "$SCRATCH" && npx @zackbart/connecta@0.18.2 init current)` — there is no
+   `(cd "$SCRATCH" && npx @zackbart/connecta@0.18.3 init current)` — there is no
    `base` leg here, only the current template to read from.
 2. Copy `$SCRATCH/current` into the deployment file by file, **skipping
    `src/index.ts`**.
@@ -207,6 +207,17 @@ first, so cross them bottom-up: start at the oldest one still above this
 deployment's pin and work back up the page, because each boundary assumes the
 older ones are already done.
 
+### 0.18.2 → 0.18.3
+
+Nothing throws for an existing deployment, and the version bump alone crosses
+this boundary. Successful explicitly read-only calls whose provider declares
+no output schema now teach later discovery the result's field names and broad
+JSON types. The open optional-field shape is labeled
+`outputSchemaSource: "observed"`, lives only in a bounded runtime cache, and
+starts cold after 24 hours, a process restart, or Worker isolate eviction. No
+configuration or storage migration is involved, and discovery still never
+executes a tool.
+
 ### 0.18.1 → 0.18.2
 
 Nothing throws for an existing deployment, and the version bump alone crosses

package/ethos.md

@@ -111,11 +111,11 @@ proposing one without a new argument is not.
 | View-initiated read calls from program UI | accepted | named bindings materially improve refresh, cursor pagination, and drill-down without persistence or a new tool; the trusted shell delegates only to the existing fail-closed `call_tool`, and the one-string UI remains display-only ([evidence](./documentation/program-ui-read-calls.md), [#287](https://github.com/zackbart/connecta/issues/287), [#289](https://github.com/zackbart/connecta/issues/289)) |
 | View-initiated mutation calls from program UI | gated | live-read utility says nothing about write consent: a click is not approval, stale/replayed effects need a host-tested story, and the ordinary destructive path keeps the action in the transcript ([#287](https://github.com/zackbart/connecta/issues/287)) |
 | Result sampling on the catalog surface (`sample` / `dryRun`) | refused | sampling is execution and cannot ride a catalog read; most tools carry required arguments no sampler can invent, and undeclared `outputSchema` (measured 0/30 and 3/30 on real deployments) is a real gap that is not a sampleable one — a program that checks the shape before rendering already hands back the first record inside the run it was going to make anyway, at zero new surface ([#282](https://github.com/zackbart/connecta/issues/282)) |
+| Passive observed output schemas | accepted | the sampling refusal stands: discovery originates no call and invents no arguments; instead, a successful explicitly read-only call whose provider declared no `outputSchema` records field names and broad JSON types only, under strict depth, breadth, property-name, node, and byte bounds, then merges that open optional-field shape in a 256-entry process-local cache for 24 hours; property names may be user-authored, search and describe label the shape `outputSchemaSource: "observed"`, a materially changed tool definition cannot inherit it, a provider declaration always wins, and no argument, scalar value, raw result, code, credential, or error is retained; this is new evidence rather than a rewrite of #282's facts: Blacksmith measured a value-free warm shape cache cutting one Linear code-mode task from 116.6 s / $1.91 to 56.6 s / $1.06, while live Connecta catalogs measured 246/378 missing on BePresent and 0/90 missing on OneMany ([study](https://www.blacksmith.sh/blog/code-smith-code-mode), [#442](https://github.com/zackbart/connecta/issues/442)) |
 | Legacy embedded `UIResource` delivery | refused | superseded upstream and rendered by none of the clients connecta faces; per-request minted URIs also fight the caching the Apps spec assumes ([#266](https://github.com/zackbart/connecta/issues/266)) |
 ## Invariants
 
-One line each; the enforcing tests live beside the subsystem documentation.
-Breaking one is not a bug fix — it is a design change wearing a disguise.
+One line each; the enforcing tests live beside the subsystem documentation. Breaking one is not a bug fix — it is a design change wearing a disguise.
 
 - **Fail-closed read-only.** A missing, false, or contradictory annotation
   never gets the benefit of the doubt.
@@ -131,6 +131,7 @@ Breaking one is not a bug fix — it is a design change wearing a disguise.
   is never cached, persisted, or served as if it were small.
 - **Activity is payload-free by construction.** The event type has nowhere to
   put arguments, results, code, or raw error text.
+- **An observed shape is never a declaration.** It contains field names and broad JSON types only, remains open and optional, is labeled on discovery, and disappears behind any provider-declared output schema.
 - **Credentials never leave the host.** Encrypted at rest, readable only by
   the owning connector, never rendered by any surface.
 - **Import-graph purity.** Nothing reachable from the root entry imports a
@@ -145,5 +146,4 @@ Breaking one is not a bug fix — it is a design change wearing a disguise.
 - **Structural mistakes throw at construction.** A deployment that boots into
   the wrong shape is worse than one that refuses to boot.
 
----
 Connecta began as a radical simplification of [executor](https://github.com/UsefulSoftwareCo/executor); the table above is the record of that simplification holding.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zackbart/connecta",
-  "version": "0.18.2",
+  "version": "0.18.3",
   "type": "module",
   "sideEffects": false,
   "description": "One MCP to rule them all — a single MCP endpoint aggregating many downstream connectors behind a code-first surface of seven meta-tools.",

package/templates/node/package.json

@@ -15,7 +15,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zackbart/connecta": "0.18.2",
+    "@zackbart/connecta": "0.18.3",
     "quickjs-emscripten": "0.32.0"
   },
   "devDependencies": {