@apifuse/provider-sdk 2.2.0-beta.4 → 2.2.0-beta.41

package/dist/runtime/executor.js

@@ -1,9 +1,18 @@
-import { isSessionExpiredError, ProviderError, SessionExpiredError } from "../errors.js";
+import { safeProviderErrorObservability } from "../error-observability.js";
+import { isSessionExpiredError, isValidationError, ProviderError, SessionExpiredError, ValidationError, } from "../errors.js";
+import { z } from "zod";
 import { parseSchema } from "../schema.js";
+import { assertRequiredSecretsPresent } from "./secrets.js";
 export function isStreamingOperation(provider, operationId) {
     const kind = provider.operations[operationId]?.transport?.kind ?? "json";
     return kind !== "json";
 }
+function preservedSessionExpiredOptions(error) {
+    const observability = safeProviderErrorObservability(error);
+    return observability
+        ? { observability, retryable: true }
+        : { retryable: true };
+}
 /**
  * Execute a provider operation by calling its handler.
  *
@@ -23,6 +32,14 @@ export async function executeOperation(provider, operationId, ctx, input, _optio
             fix: `Valid operations: ${Object.keys(provider.operations).join(", ")}`,
         });
     }
+    // SDK-owned secret presence gate (single source of truth): declared
+    // `required: true` secrets are validated here, before input parsing and the
+    // handler, so every invocation path (serve /v1, self-test probes, perf,
+    // record) fails with the same structured MISSING_SECRET error instead of a
+    // handler-specific crash. Providers must not re-check presence locally.
+    if (provider.secrets?.some((secret) => secret.required === true)) {
+        assertRequiredSecretsPresent(provider, "env" in ctx ? ctx.env : { get: () => undefined });
+    }
     const validatedInput = await parseSchema(operation.input, input, `operations.${operationId}.input`);
     const execute = () => ctx.trace.span(`handler:${operationId}`, () => Promise.resolve(operation.handler(ctx, validatedInput)));
     let result;
@@ -45,12 +62,29 @@ export async function executeOperation(provider, operationId, ctx, input, _optio
         // executor's, which `instanceof` would miss — dropping the retryable
         // upgrade and stranding an operation that opted into auth refresh.
         if (isSessionExpiredError(error) && operation.retryOnAuthRefresh) {
-            throw new SessionExpiredError(error.message, { retryable: true });
+            // Preserve provider-authored safe metadata while forcing the retry signal.
+            // `cause` intentionally remains dropped, matching the pre-existing
+            // reconstruction semantics.
+            throw new SessionExpiredError(error.message, preservedSessionExpiredOptions(error));
         }
         throw error;
     }
     if (isStreamingOperation(provider, operationId)) {
         return result;
     }
-    return parseSchema(operation.output, result, `operations.${operationId}.output`);
+    try {
+        return await parseSchema(operation.output, result, `operations.${operationId}.output`);
+    }
+    catch (cause) {
+        if (!(cause instanceof z.ZodError) && !isValidationError(cause)) {
+            throw cause;
+        }
+        throw new ValidationError(`Operation handler output failed schema validation.`, {
+            code: "OUTPUT_VALIDATION_FAILED",
+            category: "output_validation",
+            retryable: false,
+            zodError: isValidationError(cause) ? cause.zodError : cause,
+            ...(cause instanceof Error ? { cause } : {}),
+        });
+    }
 }

package/dist/runtime/http.d.ts

@@ -4,5 +4,6 @@ export type HttpClientOptions = ProxyResolutionOptions & {
     warn?: (message: string) => void;
     userAgent?: string;
     onRetrySummary?: (summary: HttpRetrySummary) => void;
+    signal?: AbortSignal;
 };
 export declare function createHttpClient(baseUrl?: string, clientOptions?: HttpClientOptions): HttpClient;