@zackbart/connecta 0.40.0 → 0.42.0

package/dist/invocation.js

@@ -1,13 +1,15 @@
+import { utilityRecovery } from "./utility-recovery.js";
+import { traceFor } from "./timing-trace.js";
 import { routePhrases } from "./agent-routes.js";
 import { authCall, registerAuthMethod } from "./auth/native.js";
 import { withAuthorizationHandoffEffect } from "./authorization-handoff.js";
 import { hasControlCharacters } from "./tool-name.js";
-import { cloneTool, isWriteLike, writeRefusal } from "./tool-safety.js";
+import { cloneTool, isWriteLike, READ_PROGRAM_SOURCE, readProgramRefuses, writeRefusal } from "./tool-safety.js";
 import { Cause, Context, Effect, Exit } from "effect";
 import { CallAdmissionError, isCallAdmissionError } from "./call-admission.js";
-import { boundedEchoText, classificationCode, classifyCallError, classifyWithoutAdvice, ConnectorCallError, echoedCallArgs, framingError, keyResendAdviceOf, resendAdviceOf, withResendAdvice, } from "./errors.js";
+import { boundedEchoText, clipText, classificationCode, classifyCallError, classifyWithoutAdvice, ConnectorCallError, echoedCallArgs, framingError, keyResendAdviceOf, resendAdviceOf, withResendAdvice, } from "./errors.js";
 import { downstreamValue } from "./mcp-result.js";
-import { carryFailureFacts, classifiedFailure, failureRecord, logFailure, recordedToolName, } from "./operator-record.js";
+import { carryFailureFacts, classifiedFailure, failureRecord, logFailure, recordedToolName, labelErrorClass, } from "./operator-record.js";
 import { splitAddress } from "./registry.js";
 import { causeError, runEdge, withDeadlineEffect } from "./runtime/run.js";
 import { schemaExample, validateCatalogToolInput } from "./validate.js";
@@ -20,7 +22,6 @@ import { forgetProviderFailure, isKnownProviderFailure, isSettledWrite, keyProte
 import { classifyWriteOutcome, settleWrite, settleWriteResult } from "./write-outcome.js";
 import { classificationDigest, recordAuthFailure, recordCallEntry, replayClassificationDigest, resolveInvocationAuthEffect, } from "./invocation-auth.js";
 import { downstreamContinuation, recordDownstreamArgumentEcho, isDownstreamInputResult, assertDownstreamOutputSafe, } from "./downstream-input-context.js";
-import { keepErrorName } from "./redaction-identity.js";
 function defined(values) {
     return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined));
 }
@@ -83,7 +84,18 @@ function isCallerCancellation(error, signal) {
  * write it is a 2xx reply after which the handler may have applied it.
  */
 class DownstreamToolError extends Error {
+    /** Everything it said, kept for a program's report; the message is what fits a result. */
+    #text;
+    constructor(text) {
+        super(clipText(text));
+        this.#text = text;
+    }
+    fullText() {
+        return this.#text;
+    }
 }
+// Records tell the tool's own answer from a transport or runtime failure.
+labelErrorClass(DownstreamToolError, "DownstreamToolError");
 function isTimeoutFailure(error) {
     const code = error.details?.code;
     return (error.code === "timeout" ||
@@ -96,10 +108,10 @@ function assertRawMcpSuccess(kind, result) {
     const mcpResult = result;
     if (!mcpResult.isError)
         return;
-    throw new DownstreamToolError(boundedEchoText(mcpResult.content
+    throw new DownstreamToolError(mcpResult.content
         ?.filter((block) => block.type === "text")
         .map((block) => block.text ?? "")
-        .join("") || "Downstream tool call failed"));
+        .join("\n") || "Downstream tool call failed");
 }
 /**
  * Whether a failed attempt is the downstream tool's own answer. For a read:
@@ -115,33 +127,15 @@ function answeredFailure(error, write, call) {
         return error instanceof DownstreamToolError || isKnownProviderFailure(error);
     return knownCallFailure(call, error);
 }
-export class InvocationFailure extends Error {
-    details;
-    code;
-    retryable;
-    retryAfterMs;
-    connector;
-    operation;
-    recovery;
-    nextAction;
-    retry;
-    data;
-    constructor(details) {
-        super(details.message);
-        this.details = details;
-        this.name = "InvocationFailure";
-        this.code = details.code;
-        this.retryable = details.retryable;
-        this.retryAfterMs = details.retryAfterMs;
-        this.connector = details.connector;
-        this.operation = details.operation;
-        this.recovery = details.recovery;
-        this.nextAction = details.nextAction;
-        this.retry = details.retry;
-        this.data = details;
-    }
-}
-keepErrorName(InvocationFailure, "InvocationFailure");
+/**
+ * What a write gate decided about one consequential call. A dispatch goes on
+ * to admission and the connector; a refusal ends the call with `error`,
+ * recorded as an ordinary failed attempt unless `unrecorded` — a write
+ * refused only because its program already returned was never an attempt.
+ */
+/** Both program routes: no direct-call continuation applies to their calls. */
+const isProgram = (source) => source === "execute_code" || source === READ_PROGRAM_SOURCE;
+export { InvocationFailure } from "./invocation-failure.js";
 const withoutExample = ({ example: _example, ...stated }) => stated;
 /**
  * Shared downstream invocation engine. Address/catalog resolution is delegated
@@ -190,6 +184,7 @@ export class InvocationService {
             const recoveryState = recoveryRecord();
             let preInvocationAuthFailure = false;
             let answered = false;
+            let failureText;
             // A dispatched failure's advice to send it again, composed by enrich
             // only once the outcome allows it (resendAdvice), and its advice to
             // reuse an idempotency key, only where that key protects the whole
@@ -200,6 +195,10 @@ export class InvocationService {
             context.sentSecrets?.include(sentSecrets);
             // A write gate's refusal that is no attempt; see WriteGateDecision.
             let unrecorded = false;
+            // The gate's refusal states its own deadline facts; nothing timed out here.
+            let gateRefused = false;
+            // The deadline this call runs under, once its classification is known.
+            let timeoutMs = context.timeoutMs;
             let resolved;
             let activityTarget;
             // The address as written, used for activity when resolution never reached
@@ -244,10 +243,11 @@ export class InvocationService {
             };
             const enrich = (error, target, settled) => {
                 if (!target)
-                    return error;
+                    return ["unavailable", "catalog_lookup_failed", "unsupported_capability"].includes(error.code)
+                        ? { ...error, nextAction: error.nextAction ?? utilityRecovery(error.code, error.message).nextAction }
+                        : error;
                 const recovery = recoveryState.facts;
-                const enteredWrite = dispatchedToConnector &&
-                    ((resolved !== undefined && resolved.definition.classification !== "read") || sentSourceWrite());
+                const enteredWrite = dispatchedToConnector && ((resolved !== undefined && isWriteLike(resolved.definition)) || sentSourceWrite());
                 // A known answer alone is not dispatch evidence. Require an owned,
                 // complete ledger with a positively recorded auxiliary resource read;
                 // an empty ledger, custom entry or interruption proves nothing.
@@ -266,7 +266,7 @@ export class InvocationService {
                     return {
                         ...error,
                         code: "write_outcome_unknown",
-                        message: `${error.message} Its outcome is unknown. Check the target before repeating this call.`,
+                        message: `${error.message} It was sent once; its outcome is unknown. Check the target before repeating this call.`,
                         retryable: false,
                         ...(sentSourceWrite() ? { writeOutcome: "unknown" } : {}),
                         connector: target.connector.id,
@@ -303,7 +303,18 @@ export class InvocationService {
                 // retryable, and no advice below may tell the agent to retry it.
                 const unknownWrite = mayHaveWritten && classifyWriteOutcome({ ok: false, dispatched: true, answered, error }) === "unknown";
                 if (unknownWrite)
-                    error = { ...error, retryable: false, writeOutcome: "unknown" };
+                    error = {
+                        ...error,
+                        retryable: false,
+                        writeOutcome: "unknown",
+                        ...(!recovery && error.retry === undefined
+                            ? {
+                                retry: error.toolAnswered
+                                    ? "Its outcome is unknown: its handler ran before it answered, so check its target before acting. Give the user any approval link or request id in the message. Connecta will not resend it; a call the tool's words ask for is a new call."
+                                    : "No safe replay action exists. Re-read the target to reconcile whether the write took effect.",
+                            }
+                            : {}),
+                    };
                 // The failure's advice to send it again was kept apart until now, and
                 // joins its message only where the outcome allows it: never on a write
                 // whose outcome is unknown, whatever redaction did to the message.
@@ -334,9 +345,22 @@ export class InvocationService {
                     error = { ...error, code: "downstream_oauth_required" };
                 }
                 switch (error.code) {
+                    case "unsupported_capability":
+                        return unknownWrite
+                            ? error
+                            : {
+                                ...error,
+                                nextAction: utilityRecovery(error.code, "The requested capability is unsupported.").nextAction,
+                            };
                     case "input_required_unsupported":
                         if (context.processInputRequired)
-                            return error;
+                            return unknownWrite
+                                ? error
+                                : {
+                                    ...error,
+                                    nextAction: error.nextAction ??
+                                        utilityRecovery(error.code, "The requested input capability is unsupported.").nextAction,
+                                };
                         // Resending could apply the write twice: reconcile first.
                         if (unknownWrite)
                             return {
@@ -407,8 +431,13 @@ export class InvocationService {
                             retry: "Ask the provider's resource owner or administrator to grant the required permission or scope, then retry. Repeating the call or reconnecting alone will not grant access.",
                         };
                     case "invalid_args":
-                        if (!error.validation || error.writeOutcome === "unknown")
+                        if (error.writeOutcome === "unknown")
                             return error;
+                        if (!error.validation)
+                            return {
+                                ...error,
+                                nextAction: this.catalog.searchRecovery({ query: target.toolName, connector: target.connector.id }, "Inspect the current input schema and correct the arguments before a fresh call."),
+                            };
                         return {
                             ...error,
                             // An example comes only from the published schema, never a connector's copy of the
@@ -421,12 +450,38 @@ export class InvocationService {
                             },
                             connector: target.connector.id,
                             operation: `${target.connector.id}.${target.toolName}`,
-                            nextAction: this.catalog.searchRecovery({
-                                query: target.toolName,
-                                connector: target.connector.id,
-                            }, "Inspect the current input shape if the validation findings are not sufficient."),
+                            // Findings naming the fix lead on their own; a search would only cost a turn.
+                            ...(error.validation.issues?.length && error.validation.acceptedKeys && !error.validation.truncated
+                                ? {}
+                                : {
+                                    nextAction: this.catalog.searchRecovery({
+                                        query: target.toolName,
+                                        connector: target.connector.id,
+                                    }, "Only if the validation above is not enough: inspect the schema."),
+                                }),
                             retry: `Correct the listed arguments and retry ` + `${target.connector.id}.${target.toolName}.`,
                         };
+                    case "not_found":
+                        if (unknownWrite)
+                            return error;
+                        return {
+                            ...error,
+                            retry: "No automatic retry action exists. Verify the resource id, account and visibility with a read before a fresh call.",
+                        };
+                    case "unavailable":
+                    case "catalog_lookup_failed":
+                        if (unknownWrite)
+                            return error;
+                        // The continuation nonce is spent. Let the input boundary supply
+                        // its fresh-call action instead of generic availability advice.
+                        if (!isProgram(context.source) &&
+                            downstreamContinuation(this.catalog.requestScope, target.connector.id, `${target.connector.id}.${target.toolName}`))
+                            return error;
+                        return {
+                            ...error,
+                            nextAction: error.nextAction ?? utilityRecovery(error.code, error.message).nextAction,
+                            retry: "No immediate repair action exists on this endpoint. Ask the operator to check connector availability; a read can be tried again after recovery.",
+                        };
                     default:
                         return error;
                 }
@@ -437,7 +492,7 @@ export class InvocationService {
                 // a write. No connector failure arrives, so the logical call's
                 // recorded requests alone decide whether a 401 left it unknown.
                 if (dispatchedToConnector &&
-                    (resolved?.definition.classification !== "read" || sentSourceWrite()) &&
+                    (resolved === undefined || isWriteLike(resolved.definition) || sentSourceWrite()) &&
                     (error.code === "cancelled" || isTimeoutFailure(error))) {
                     const departed = settleWrite(logicalCall?.sent ?? [], undefined, true);
                     if (departed !== undefined) {
@@ -446,6 +501,13 @@ export class InvocationService {
                     }
                 }
                 const diagnostics = timing();
+                const trace = traceFor(this.catalog.requestScope);
+                if (trace) {
+                    trace.record("catalog", diagnostics.catalogMs);
+                    trace.record("admission", diagnostics.admissionMs);
+                    trace.record("connector", diagnostics.connectorMs);
+                    trace.record("result", diagnostics.resultProcessingMs, resultBytes ?? 0);
+                }
                 const target = resolved ?? activityTarget;
                 if (target && (error.code === "auth_required" || error.code === "downstream_oauth_required")) {
                     recordAuthFailure(this.catalog.requestScope, target.connector.id, (resolved !== undefined && !isWriteLike(resolved.definition) && resolved.classificationFresh === true) ||
@@ -455,13 +517,13 @@ export class InvocationService {
                 // Read before any step below rebuilds the details: Q8's verdict is final.
                 const settled = isSettledWrite(error);
                 // Attach host deadline facts before write recovery changes the code.
-                if (isTimeoutFailure(error)) {
+                if (isTimeoutFailure(error) && !gateRefused) {
                     const elapsedMs = Date.now() - started;
                     const operation = boundedEchoText(address, 512);
                     error = {
                         ...error,
-                        message: `Operation "${operation}" timed out during ${stage} after ${elapsedMs}ms (effective deadline ${context.timeoutMs}ms).`,
-                        details: { ...error.details, operation, stage, elapsedMs, ...defined({ deadlineMs: context.timeoutMs }) },
+                        message: `Operation "${operation}" timed out during ${stage} after ${elapsedMs}ms (effective deadline ${timeoutMs}ms).`,
+                        details: { ...error.details, operation, stage, elapsedMs, ...defined({ deadlineMs: timeoutMs }) },
                     };
                 }
                 // Downstream diagnostics were redacted under payload rules where they entered.
@@ -474,6 +536,7 @@ export class InvocationService {
                     ...defined({ resolved }),
                     dispatched: dispatchedToConnector,
                     ...(dispatchedToConnector ? { answered } : {}),
+                    ...defined({ failureText }),
                     error: details,
                 });
                 // A write refused only because its program had already returned
@@ -515,6 +578,11 @@ export class InvocationService {
             // expected, and a throw anywhere in it — a defect, to Effect — is
             // classified like a failure, as the async body this replaced did.
             const dispatch = (callSignal) => Effect.gen({ self: this }, function* () {
+                if (context.refusal) {
+                    gateRefused = true;
+                    return context.refusal;
+                }
+                let pastDeadline;
                 const admissionSignal = context.dispatchSignal
                     ? AbortSignal.any([context.dispatchSignal, ...(callSignal ? [callSignal] : [])])
                     : callSignal;
@@ -541,17 +609,20 @@ export class InvocationService {
                 activityTarget = target;
                 argumentEcho = echoedCallArgs(args ?? {}, target.definition.inputSchema);
                 sentSecrets.arguments(args ?? {}, target.definition.inputSchema);
-                const write = target.definition.classification !== "read";
-                const writeLike = isWriteLike(target.definition);
+                // Admission and presentation follow the served class. Dispatch and failure
+                // handling follow this: a source write served as a read still sends once.
+                const write = isWriteLike(target.definition);
+                if (write && context.writeTimeoutMs !== undefined)
+                    timeoutMs = context.writeTimeoutMs;
                 const canonicalAddress = `${target.connector.id}.${target.toolName}`;
-                const input = context.source !== "execute_code"
+                const input = !isProgram(context.source)
                     ? downstreamContinuation(this.catalog.requestScope, target.connector.id, canonicalAddress)
                     : undefined;
                 if (input)
                     recordDownstreamArgumentEcho(this.catalog.requestScope, argumentEcho);
                 const expectedDigest = replayClassificationDigest(this.catalog.requestScope, canonicalAddress);
                 if (expectedDigest !== undefined &&
-                    (writeLike ||
+                    (write ||
                         target.classificationFresh !== true ||
                         (yield* Effect.promise(() => classificationDigest(target.definition))) !== expectedDigest)) {
                     return {
@@ -562,9 +633,15 @@ export class InvocationService {
                 const connectorReadOnly = target.connector.readOnly === true;
                 const refusal = writeRefusal(target.definition.classification, context.source, context.readOnly || connectorReadOnly);
                 if (refusal === "read_only_endpoint") {
-                    return framingError("read_only_endpoint", `Tool "${canonicalAddress}" is a write, and ${connectorReadOnly ? `connector "${target.connector.id}"` : "this endpoint"} is read-only. Nothing here can send it.`);
+                    return framingError("read_only_endpoint", `Tool "${canonicalAddress}" is a write, and ${connectorReadOnly ? `connector "${target.connector.id}"` : "this endpoint"} is read-only. No write route exists ${connectorReadOnly ? "for this connection" : "on this endpoint"}; tell the user. Only the operator can provide a writable connection.`);
                 }
-                if (refusal === "destructive_tool_requires_approval") {
+                // Below the sandbox: no guest code can reach past this, and catching it sends nothing.
+                if (context.source === READ_PROGRAM_SOURCE) {
+                    if (readProgramRefuses(target.definition)) {
+                        return framingError("destructive_tool_requires_approval", `Tool "${canonicalAddress}" can write, so ${READ_PROGRAM_SOURCE} refused it and nothing was sent. Use call_destructive_tool for this one call, or execute_code for a program that writes; the MCP host can request approval for either.`);
+                    }
+                }
+                else if (refusal === "destructive_tool_requires_approval") {
                     return framingError("destructive_tool_requires_approval", `Tool "${canonicalAddress}" is a write. ${routePhrases(context).writeNeedsApproval}`);
                 }
                 // Remote MCP tools advertise their input schema in the catalog. Validate
@@ -582,10 +659,11 @@ export class InvocationService {
                         return classifyCallError(invalid);
                 }
                 // Source writes keep program write accounting; only effective writes spend W10 budget.
-                if (writeLike && context.beforeWrite) {
+                if (write && context.beforeWrite) {
                     const decision = yield* context.beforeWrite(target, args ?? {});
                     if (decision.kind === "refuse") {
                         unrecorded = decision.unrecorded === true;
+                        gateRefused = true;
                         return decision.error;
                     }
                 }
@@ -595,7 +673,7 @@ export class InvocationService {
                 const call = (permit) => Effect.gen({ self: this }, function* () {
                     const operationContext = this.registry.contextFor(target.connector.id, this.catalog.baseUrl, this.catalog.requestScope, defined({
                         signal: callSignal,
-                        timeoutMs: context.timeoutMs,
+                        timeoutMs,
                         defer: this.catalog.defer,
                         routes: context.routes,
                     }));
@@ -634,19 +712,27 @@ export class InvocationService {
                         const code = classifyCallError(causeError(cause, connectorContext.signal)).code;
                         preInvocationAuthFailure = code === "auth_required" || code === "downstream_oauth_required";
                     })));
-                    // Cancellation can arrive during admission or context construction.
+                    // Reflect.apply, never the function's own `call` or `apply`
+                    // property, which anyone holding the function could replace.
+                    const options = { definition: cloneTool(target.definition), ...defined({ input }) };
+                    const entry = callEntry(connector, callTool);
+                    // The final gate. Cancellation can arrive during admission or context
+                    // construction, and resolution, admission or auth can spend the deadline.
+                    // Nothing is awaited from here to the connector call below, so a call
+                    // refused here is proven unsent and one let through left in time (INV-9).
                     if (admissionSignal?.aborted)
                         throw admissionSignal.reason;
+                    if (context.dispatchDeadline && Date.now() >= context.dispatchDeadline.at) {
+                        gateRefused = true;
+                        pastDeadline = context.dispatchDeadline.refusal(canonicalAddress);
+                        return undefined;
+                    }
                     dispatchedToConnector = true;
                     recordCallEntry(this.catalog.requestScope, {
                         address: canonicalAddress,
-                        classification: writeLike ? "write" : "read",
+                        classification: write ? "write" : "read",
                         fresh: target.classificationFresh === true,
                     }, target.definition);
-                    // Reflect.apply, never the function's own `call` or `apply`
-                    // property, which anyone holding the function could replace.
-                    const options = { definition: cloneTool(target.definition), ...defined({ input }) };
-                    const entry = callEntry(connector, callTool);
                     if (entry)
                         return yield* entry(target.toolName, args ?? {}, options).pipe(Effect.provideContext(viewServices(connectorContext)));
                     return yield* Effect.tryPromise({
@@ -675,6 +761,8 @@ export class InvocationService {
                     const reply = yield* timed((elapsed) => {
                         connectorMs += elapsed;
                     }, call(permit));
+                    if (pastDeadline)
+                        return { pastDeadline };
                     if (target.connector.kind === "mcp" && isDownstreamInputResult(reply)) {
                         // The downstream suspended for input. A handler asks for
                         // input from inside its run, so a write may already have
@@ -715,8 +803,15 @@ export class InvocationService {
                     // An inner call's verdict that does not hold for this one is withdrawn.
                     if (failureWrite && !answered)
                         forgetProviderFailure(details);
+                    // The tool's own words, which a program's write accounting keeps.
+                    if (failureWrite && attemptError === thrown && thrown instanceof DownstreamToolError) {
+                        details.toolAnswered = true;
+                        failureText = thrown.fullText();
+                    }
                     return details;
                 }
+                if ("pastDeadline" in attempt.value)
+                    return attempt.value.pastDeadline;
                 if ("inputRequired" in attempt.value) {
                     inputRequiredValue = { value: attempt.value.value };
                     return undefined;
@@ -745,6 +840,7 @@ export class InvocationService {
                 ? withDeadlineEffect(dispatch, {
                     ...defined({
                         timeoutMs: context.timeoutMs,
+                        extendMs: () => (timeoutMs ?? 0) - (context.timeoutMs ?? 0),
                         signal: context.requestSignal,
                     }),
                     timeoutError: new ConnectorCallError("timeout", `Tool call timed out after ${context.timeoutMs}ms`),
@@ -769,7 +865,7 @@ export class InvocationService {
             // Q8 settles a result too: a write an undeclared 401 left unknown is no
             // success, whatever its handler made of the 401, and its result is not
             // processed.
-            if (dispatchedToConnector && (completed.definition.classification !== "read" || sentSourceWrite())) {
+            if (dispatchedToConnector && (isWriteLike(completed.definition) || sentSourceWrite())) {
                 const unknown = settleWriteResult(logicalCall?.sent ?? []);
                 if (unknown) {
                     failureAdvice = failureKeyAdvice = undefined;
@@ -786,7 +882,7 @@ export class InvocationService {
                 resultProcessingMs += elapsed;
             }, Effect.tap(withDeadlineEffect(() => processing, {
                 ...defined({
-                    timeoutMs: context.timeoutMs === undefined ? undefined : Math.max(1, context.timeoutMs - (Date.now() - started)),
+                    timeoutMs: timeoutMs === undefined ? undefined : Math.max(1, timeoutMs - (Date.now() - started)),
                     signal: context.requestSignal,
                 }),
                 timeoutError: new ConnectorCallError("timeout", "Result processing exceeded the tool call deadline."),
@@ -807,6 +903,13 @@ export class InvocationService {
             try {
                 const value = sentSecrets.redact(processed.value, "envelope");
                 const diagnostics = timing();
+                const trace = traceFor(this.catalog.requestScope);
+                if (trace) {
+                    trace.record("catalog", diagnostics.catalogMs);
+                    trace.record("admission", diagnostics.admissionMs);
+                    trace.record("connector", diagnostics.connectorMs);
+                    trace.record("result", diagnostics.resultProcessingMs, resultBytes ?? 0);
+                }
                 const friction = context.activityFriction?.(value);
                 record("success", friction ? { friction } : {});
                 return {

package/dist/membership.d.ts

@@ -26,7 +26,7 @@ export interface ResolvedPool {
     members: readonly Member[];
     /** Trimmed `owner`: the Workspace address agents in this pool act as. */
     owner?: string;
-    /** Trimmed `description`, appended to this pool's MCP instructions. */
+    /** Trimmed `description`, placed before this pool's MCP routing instructions. */
     description?: string;
     /** Present for a native pool; absent is the six meta-tools. */
     native?: {

package/dist/meta-output.js

@@ -1,7 +1,7 @@
 import { Validator } from "@cfworker/json-schema";
 import { CATALOG_SEARCH_RESULT_SCHEMA } from "./catalog-service.js";
 import * as z from "zod";
-import { advertisedSchema } from "./advertised-schema.js";
+import { advertisedSchema, openOutputSchema } from "./advertised-schema.js";
 const error = z
     .object({
     code: z.string(),
@@ -9,14 +9,13 @@ const error = z
     retryable: z.boolean(),
 })
     .passthrough();
-const format = z.enum(["json", "text"]);
 const counts = z.object({
     attempted: z.number().int().nonnegative(),
     admitted: z.number().int().nonnegative(),
     succeeded: z.number().int().nonnegative(),
     failed: z.number().int().nonnegative(),
 });
-export const EXECUTE_OUTPUT = advertisedSchema(z
+export const EXECUTE_OUTPUT = openOutputSchema(advertisedSchema(z
     .object({
     result: z.unknown().optional(),
     error: error.optional(),
@@ -26,19 +25,14 @@ export const EXECUTE_OUTPUT = advertisedSchema(z
     emittedDiscarded: z.number().int().nonnegative().optional(),
     diagnostics: z.record(z.string(), z.unknown()).optional(),
 })
-    .passthrough());
-export const SKILLS_OUTPUT = advertisedSchema(z
-    .object({
-    name: z.string().optional(),
-    text: z.string().optional(),
-    format: format.optional(),
-    skills: z.array(z.object({ name: z.string(), uri: z.string(), description: z.string() })).optional(),
-    error: error.optional(),
-})
-    .passthrough());
-// Catalog publication, SDK advertisement and validation share one schema.
+    .passthrough()), {
+    type: "object",
+    required: ["hostCalls"],
+    properties: { result: {}, error: { type: "object" }, hostCalls: { type: "object" }, logs: { type: "string" } },
+});
+// The server validates every page against the full catalog contract; clients get the open summary.
 const searchValidator = new Validator(CATALOG_SEARCH_RESULT_SCHEMA, "2020-12", false);
-export const SEARCH_OUTPUT = {
+export const SEARCH_OUTPUT = openOutputSchema({
     "~standard": {
         version: 1,
         vendor: "connecta",
@@ -50,12 +44,24 @@ export const SEARCH_OUTPUT = {
             output: () => CATALOG_SEARCH_RESULT_SCHEMA,
         },
     },
-};
-export const AUTHORIZE_OUTPUT = advertisedSchema(z
+}, {
+    type: "object",
+    required: ["catalogErrors", "tools", "total", "offset", "limit", "hasMore"],
+    properties: {
+        catalogErrors: { type: "array" },
+        tools: { type: "array", items: { type: "object", required: ["name", "address"] } },
+        total: { type: "integer" },
+        offset: { type: "integer" },
+        limit: { type: "integer" },
+        hasMore: { type: "boolean" },
+        nextOffset: { type: "integer" },
+    },
+});
+export const AUTHORIZE_OUTPUT = openOutputSchema(advertisedSchema(z
     .object({
     connector: z.string().optional(),
     recovery: z.string().optional(),
     message: z.string().optional(),
     error: error.optional(),
 })
-    .passthrough());
+    .passthrough()), { type: "object", properties: { connector: { type: "string" }, message: { type: "string" } } });

package/dist/meta-tool-names.d.ts

@@ -1,2 +1,2 @@
-/** The complete upward meta-tool set, shared with the CLI. */
+/** The upward meta-tool set every meta endpoint lists, shared with the CLI. */
 export declare const META_TOOL_NAMES: readonly string[];

package/dist/meta-tool-names.js

@@ -1,3 +1,3 @@
 import { META_TOOL_NAMES as names } from "../bin/meta-tool-names.mjs";
-/** The complete upward meta-tool set, shared with the CLI. */
+/** The upward meta-tool set every meta endpoint lists, shared with the CLI. */
 export const META_TOOL_NAMES = names;