@zackbart/connecta 0.16.1 → 0.17.0

package/dist/invocation.js

@@ -282,7 +282,9 @@ export class InvocationService {
             context.beforeDispatch?.();
         }
         catch (error) {
-            return failed(classifyCallError(error));
+            return failed(error instanceof InvocationFailure
+                ? error.details
+                : classifyCallError(error));
         }
         const maxRetries = Math.min(2, Math.max(0, Math.trunc(context.maxRetries ?? 0)));
         let result;

package/dist/meta-tools.d.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/server";
 import type { ActivityRequestContext } from "./activity.js";
 import { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_SEARCH_LIMIT } from "./catalog-service.js";
+import type { DeferredWork } from "./connector-scope.js";
 import { MAX_RETRY_BACKOFF_MS, retryBackoffMs } from "./invocation.js";
 import { type RegistryView } from "./registry.js";
 export { MAX_DESCRIBE_ADDRESSES, MAX_DISCOVERY_RESULT_BYTES, MAX_RETRY_BACKOFF_MS, MAX_SEARCH_LIMIT, retryBackoffMs, };
@@ -112,6 +113,8 @@ export declare function createMetaTools(registry: RegistryView, baseUrl: string,
     activity?: ActivityRequestContext;
     /** Inbound request cancellation shared by every call this request makes. */
     requestSignal?: AbortSignal;
+    /** Runtime-owned tail for stale catalog refreshes. */
+    defer?: DeferredWork;
 }): {
     skills(args?: SkillArgs): Promise<ToolResult>;
     searchTools(args: SearchArgs): Promise<ToolResult>;
@@ -135,4 +138,5 @@ export declare function registerMetaTools(server: McpServer, registry: RegistryV
     discoveryConcurrency?: number;
     activity?: ActivityRequestContext;
     requestSignal?: AbortSignal;
+    defer?: DeferredWork;
 }): void;

package/dist/meta-tools.js

@@ -125,25 +125,41 @@ export function alignEndToCharBoundary(bytes, offset, end, total) {
     }
     return e;
 }
-// --- fields selection (feature 2) -----------------------------------------
-/** Resolve a dot-path (segments) against a value; `key[]` maps the tail over an array. */
+/** Resolve a dot-path and retain misses below every `[]` boundary. */
 function resolvePath(value, segments) {
     const seg = segments[0];
-    if (seg === undefined)
-        return value;
+    if (seg === undefined) {
+        return value === undefined
+            ? { status: "unmatched" }
+            : { status: "matched", value };
+    }
     const rest = segments.slice(1);
     const isArr = seg.endsWith("[]");
     const key = isArr ? seg.slice(0, -2) : seg;
     let next = value;
     if (key !== "") {
-        if (value === null || typeof value !== "object")
-            return undefined;
+        if (value === null || typeof value !== "object") {
+            return { status: "unmatched" };
+        }
         next = value[key];
     }
     if (isArr) {
         if (!Array.isArray(next))
-            return undefined;
-        return next.map((el) => resolvePath(el, rest));
+            return { status: "unmatched" };
+        if (next.length === 0)
+            return { status: "matched", value: [] };
+        const elements = next.map((el) => resolvePath(el, rest));
+        const matched = elements.some((element) => element.status !== "unmatched");
+        const missed = elements.some((element) => element.status !== "matched");
+        if (!matched)
+            return { status: "unmatched" };
+        return {
+            status: missed ? "partial" : "matched",
+            // Undefined placeholders retain the historical array positions in the
+            // partial value. JSON renders them as null; partialFields says they are
+            // unresolved rather than genuine downstream nulls.
+            value: elements.map((element) => element.status === "unmatched" ? undefined : element.value),
+        };
     }
     return resolvePath(next, rest);
 }
@@ -517,14 +533,19 @@ function schemaProjectionFeedback(outputSchema, unmatchedFields) {
 function applyFields(value, fields) {
     const out = {};
     const unmatchedFields = [];
+    const partialFields = [];
     for (const path of fields) {
         const resolved = resolvePath(value, path.split("."));
-        if (resolved === undefined)
+        if (resolved.status === "unmatched") {
             unmatchedFields.push(path);
-        else
-            out[path] = resolved;
+        }
+        else {
+            out[path] = resolved.value;
+            if (resolved.status === "partial")
+                partialFields.push(path);
+        }
     }
-    return { data: out, unmatchedFields };
+    return { data: out, unmatchedFields, partialFields };
 }
 /**
  * Keep the historical flat projection when every path resolves. A miss gets a
@@ -537,16 +558,25 @@ function projectionValue(value, fields, outputSchema) {
     // matched downstream field with that exact name is escaped below `data`, so
     // no user-controlled value can impersonate Connecta's discriminator.
     const reservedCollision = Object.prototype.hasOwnProperty.call(projected.data, "$connecta");
-    if (projected.unmatchedFields.length === 0 && !reservedCollision) {
+    if (projected.unmatchedFields.length === 0 &&
+        projected.partialFields.length === 0 &&
+        !reservedCollision) {
         return projected.data;
     }
+    const problemFields = [
+        ...projected.unmatchedFields,
+        ...projected.partialFields,
+    ];
     return {
         data: projected.data,
         $connecta: {
             type: "field_projection",
             unmatchedFields: projected.unmatchedFields,
+            ...(projected.partialFields.length > 0
+                ? { partialFields: projected.partialFields }
+                : {}),
             ...(outputSchema
-                ? schemaProjectionFeedback(outputSchema, projected.unmatchedFields)
+                ? schemaProjectionFeedback(outputSchema, problemFields)
                 : {}),
         },
     };
@@ -731,6 +761,7 @@ export function createMetaTools(registry, baseUrl, opts = {}) {
         requestScope,
         probeTimeoutMs,
         concurrency: discoveryConcurrency,
+        ...(opts.defer ? { defer: opts.defer } : {}),
         // searchRoute keeps its top-level default. In-program callers use a
         // separate CatalogService configured for connecta.search.
     });
@@ -1089,6 +1120,7 @@ export function registerMetaTools(server, registry, ctx) {
         ...(ctx.requestSignal !== undefined
             ? { requestSignal: ctx.requestSignal }
             : {}),
+        ...(ctx.defer !== undefined ? { defer: ctx.defer } : {}),
     });
     server.registerTool("skills", {
         description: describedFor(registry, SKILLS_DESC, "skills"),