@zapier/zapier-sdk 0.69.3 → 0.70.1

package/dist/experimental.d.ts

@@ -2691,7 +2691,7 @@ export declare function createZapierSdkStack(options?: ZapierSdkOptions): import
         maxItems?: number;
     }) | undefined) => import("kitcore").PaginatedSdkResult<{
         id: string;
-        status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+        status: string;
         input: unknown;
         output: unknown;
         error: {
@@ -2716,7 +2716,7 @@ export declare function createZapierSdkStack(options?: ZapierSdkOptions): import
     } | undefined) => Promise<{
         data: {
             id: string;
-            status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+            status: string;
             input: unknown;
             output: unknown;
             error: {
@@ -2727,7 +2727,7 @@ export declare function createZapierSdkStack(options?: ZapierSdkOptions): import
             execution: {
                 id: string;
                 name: string;
-                status: "failed" | "waiting" | "completed" | "running";
+                status: string;
                 input: unknown;
                 created_at: string;
                 output?: unknown;
@@ -2747,8 +2747,8 @@ export declare function createZapierSdkStack(options?: ZapierSdkOptions): import
                     id: string;
                     execution_id: string;
                     name: string;
-                    type: "step" | "wait" | "callback";
-                    status: "pending" | "failed" | "exhausted" | "completed";
+                    type: string;
+                    status: string;
                     retry_count: number;
                     created_at: string;
                     result?: unknown;
@@ -5696,7 +5696,7 @@ export declare function createZapierSdk(options?: ZapierSdkOptions): import("kit
         maxItems?: number;
     }) | undefined) => import("kitcore").PaginatedSdkResult<{
         id: string;
-        status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+        status: string;
         input: unknown;
         output: unknown;
         error: {
@@ -5721,7 +5721,7 @@ export declare function createZapierSdk(options?: ZapierSdkOptions): import("kit
     } | undefined) => Promise<{
         data: {
             id: string;
-            status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+            status: string;
             input: unknown;
             output: unknown;
             error: {
@@ -5732,7 +5732,7 @@ export declare function createZapierSdk(options?: ZapierSdkOptions): import("kit
             execution: {
                 id: string;
                 name: string;
-                status: "failed" | "waiting" | "completed" | "running";
+                status: string;
                 input: unknown;
                 created_at: string;
                 output?: unknown;
@@ -5752,8 +5752,8 @@ export declare function createZapierSdk(options?: ZapierSdkOptions): import("kit
                     id: string;
                     execution_id: string;
                     name: string;
-                    type: "step" | "wait" | "callback";
-                    status: "pending" | "failed" | "exhausted" | "completed";
+                    type: string;
+                    status: string;
                     retry_count: number;
                     created_at: string;
                     result?: unknown;

package/dist/experimental.mjs

@@ -1014,6 +1014,9 @@ function isPositional(schema) {
   }
   return false;
 }
+function openEnum(values, description) {
+  return z.union([z.enum(values), z.string()]).describe(description);
+}
 
 // src/utils/logging.ts
 var { logDeprecation: logDeprecation2, resetDeprecationWarnings: resetDeprecationWarnings2 } = createDeprecationLogger("zapier-sdk");
@@ -2893,13 +2896,16 @@ async function exchangeClientCredentials(options) {
       },
       timestamp: Date.now()
     });
-    throw new Error(
-      `Client credentials exchange failed: ${response.status} ${response.statusText}`
+    throw new ZapierAuthenticationError(
+      `Client credentials exchange failed: ${response.status} ${response.statusText}`,
+      { statusCode: response.status }
     );
   }
   const data = await response.json();
   if (!data.access_token) {
-    throw new Error("Client credentials response missing access_token");
+    throw new ZapierAuthenticationError(
+      "Client credentials response missing access_token"
+    );
   }
   onEvent?.({
     type: "auth_success",
@@ -3122,6 +3128,17 @@ async function invalidateCredentialsToken(options) {
 }
 
 // src/api/sse-parser.ts
+async function* jsonFrames(source) {
+  for await (const { data } of source) {
+    let frame;
+    try {
+      frame = { parsed: true, data: JSON.parse(data), raw: data };
+    } catch {
+      frame = { parsed: false, data: null, raw: data };
+    }
+    yield frame;
+  }
+}
 function createSseParserStream() {
   let buffer = "";
   let data = "";
@@ -3169,7 +3186,7 @@ function createSseParserStream() {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.69.3" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.70.1" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -3544,6 +3561,15 @@ var ZapierApiClient = class {
      * never pins a slot — see `withSemaphore`.
      */
     this.fetchStream = (path, init) => this.streamSse(path, init);
+    /**
+     * Like `fetchStream`, but parses each frame's `data` as JSON. Diverges from
+     * `fetchJson` deliberately: that throws on invalid JSON, but a long-lived
+     * stream must survive a single malformed frame, so a parse failure is yielded
+     * as `{ parsed: false, data: null, raw }` rather than thrown. A non-ok
+     * response still throws the shared `ZapierError` (from `fetchStream`, before
+     * any frame), so transport / auth failures surface as usual.
+     */
+    this.fetchJsonStream = (path, init) => jsonFrames(this.fetchStream(path, init));
     this.get = async (path, options = {}) => {
       return this.fetchJson("GET", path, void 0, options);
     };
@@ -3750,16 +3776,16 @@ var ZapierApiClient = class {
       if (typeof errorInfo.data === "string") {
         return { message: `${fallbackMessage}: ${errorInfo.data}` };
       }
-      const errorMessage = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
+      const errorMessage2 = this.extractErrorMessage(errorInfo.data) || fallbackMessage;
       if (this.hasErrorArray(errorInfo.data)) {
         if (this.isApiErrorArray(errorInfo.data.errors)) {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors
           };
         } else {
           return {
-            message: errorMessage,
+            message: errorMessage2,
             errors: errorInfo.data.errors.map((e) => ({
               status: errorInfo.status,
               code: String(errorInfo.status),
@@ -3769,7 +3795,7 @@ var ZapierApiClient = class {
           };
         }
       }
-      return { message: errorMessage };
+      return { message: errorMessage2 };
     } catch {
       return { message: fallbackMessage };
     }
@@ -4109,7 +4135,11 @@ var createZapierApi = (options) => {
 
 // src/api/error-classification.ts
 function isPermanentHttpError(err) {
-  const statusCode = err instanceof ZapierError ? err.statusCode : void 0;
+  if (!(err instanceof ZapierError)) return false;
+  if (err instanceof ZapierAuthenticationError && err.statusCode === void 0) {
+    return true;
+  }
+  const { statusCode } = err;
   return statusCode !== void 0 && statusCode >= 400 && statusCode < 500 && statusCode !== 429;
 }
 
@@ -6097,11 +6127,11 @@ var runActionPlugin = definePlugin(
           timeoutMs
         });
         if (result.errors && result.errors.length > 0) {
-          const errorMessage = result.errors.map(
+          const errorMessage2 = result.errors.map(
             (error) => error.detail || error.title || "Unknown error"
           ).join("; ");
           throw new ZapierActionError(
-            `Action execution failed: ${errorMessage}`,
+            `Action execution failed: ${errorMessage2}`,
             { appKey, actionKey }
           );
         }
@@ -9275,10 +9305,10 @@ var eventEmissionPlugin = definePlugin(
         registeredListeners.uncaughtException = uncaughtExceptionHandler;
         globalThis.process.on("uncaughtException", uncaughtExceptionHandler);
         const unhandledRejectionHandler = async (reason, promise) => {
-          const errorMessage = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
+          const errorMessage2 = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unhandled promise rejection";
           const errorStack = reason instanceof Error ? reason.stack : null;
           let errorEvent = buildErrorEventWithContext({
-            error_message: errorMessage,
+            error_message: errorMessage2,
             error_type: "UnhandledRejection",
             error_stack_trace: errorStack,
             error_severity: "critical",
@@ -10465,6 +10495,16 @@ async function runBatchedDrainPipeline(options) {
 }
 
 // src/plugins/triggers/drainTriggerInbox/index.ts
+var nonRetryableDrainErrors = /* @__PURE__ */ new WeakSet();
+function markNonRetryableDrainError(err) {
+  if (typeof err === "object" && err !== null) {
+    nonRetryableDrainErrors.add(err);
+  }
+  return err;
+}
+function isNonRetryableDrainError(err) {
+  return typeof err === "object" && err !== null && nonRetryableDrainErrors.has(err);
+}
 function isLeaseExpiredError(err) {
   if (!(err instanceof ZapierValidationError)) return false;
   return err.errors?.some((e) => e.code === "lease_expired") ?? false;
@@ -10485,6 +10525,7 @@ async function runDrainPass(options) {
   } = options;
   let firstFetch = options.firstFetch;
   let abortedFromCallback = false;
+  let handlerErrorCaptured = false;
   let firstHandlerError = void 0;
   const outcomes = await runBatchedDrainPipeline({
     concurrency,
@@ -10506,8 +10547,10 @@ async function runDrainPass(options) {
       }
       if (lease.results.length === 0) {
         if (firstFetch && lease.inbox_attributes.status === "initialization_failure") {
-          throw new ZapierApiError(
-            `Trigger inbox ${inboxId} is in initialization_failure state \u2014 inspect via getTriggerInbox.`
+          throw markNonRetryableDrainError(
+            new ZapierApiError(
+              `Trigger inbox ${inboxId} is in initialization_failure state \u2014 inspect via getTriggerInbox.`
+            )
           );
         }
         firstFetch = false;
@@ -10547,7 +10590,10 @@ async function runDrainPass(options) {
           }
         }
         if (!continueOnError && !(err instanceof ZapierSignal)) {
-          if (firstHandlerError === void 0) firstHandlerError = err;
+          if (!handlerErrorCaptured) {
+            firstHandlerError = err;
+            handlerErrorCaptured = true;
+          }
           abort = true;
         }
         return { value: message, action, abort };
@@ -10576,7 +10622,9 @@ async function runDrainPass(options) {
       }
     }
   });
-  if (firstHandlerError !== void 0) throw firstHandlerError;
+  if (handlerErrorCaptured) {
+    throw markNonRetryableDrainError(firstHandlerError);
+  }
   return { abortedFromCallback, processed: outcomes.length };
 }
 function requireOnMessage(onMessage) {
@@ -10650,16 +10698,12 @@ async function* readInboxEvents({
   signal,
   onOpen
 }) {
-  for await (const message of api.fetchStream(
+  for await (const message of api.fetchJsonStream(
     `/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`,
     { method: "GET", signal, authRequired: true, onOpen }
   )) {
-    let parsed;
-    try {
-      parsed = JSON.parse(message.data);
-    } catch {
-      continue;
-    }
+    if (!message.parsed) continue;
+    const parsed = message.data;
     if (typeof parsed === "object" && parsed !== null && typeof parsed.inbox_id === "string" && // Only wake on a frame for this inbox. Case-insensitive: the endpoint
     // echoes the canonical lowercase UUID, but resolveTriggerInboxId passes
     // a UUID-shaped `inbox` through unchanged, so its casing may differ.
@@ -10673,6 +10717,7 @@ async function* readInboxEvents({
 var SSE_RECONNECT_BACKOFF_MS = [500, 1e3, 2e3, 5e3];
 var DEFAULT_SAFETY_DRAIN_INTERVAL_MS = 3e5;
 var SSE_HEALTHY_CONNECTION_MS = 5e3;
+var ERROR_BACKOFF_CAP = 4;
 function createDrainLatch() {
   let pending = false;
   const make = () => {
@@ -10703,9 +10748,14 @@ function createDrainLatch() {
 async function drainRunner({
   drainOptions,
   drainRequest,
-  signal
+  signal,
+  inboxId,
+  debug
 }) {
   let firstFetch = true;
+  let consecutiveErrors = 0;
+  let errorAttempts = 0;
+  let drainDegraded = false;
   while (!signal.aborted) {
     await drainRequest.waitForRequest();
     if (signal.aborted) return { kind: "aborted" };
@@ -10716,17 +10766,47 @@ async function drainRunner({
         firstFetch
       }));
     } catch (error) {
-      return { kind: "error", error };
+      if (signal.aborted) return { kind: "aborted" };
+      const isNonObjectThrow = typeof error !== "object" || error === null;
+      if (isNonObjectThrow || isNonRetryableDrainError(error) || isPermanentHttpError(error)) {
+        return { kind: "error", error };
+      }
+      consecutiveErrors = Math.min(consecutiveErrors + 1, ERROR_BACKOFF_CAP);
+      errorAttempts += 1;
+      const delay = calculateErrorBackoffMs(
+        BASE_ERROR_BACKOFF_MS,
+        consecutiveErrors
+      );
+      const statusCode = errorStatusCode(error);
+      const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
+      if (!drainDegraded && consecutiveErrors >= ERROR_BACKOFF_CAP) {
+        console.warn(
+          `[zapier-sdk] Draining inbox ${inboxId}${httpPart} is failing repeatedly: ${errorMessage(error)}. Continuing to retry with backoff.`
+        );
+        drainDegraded = true;
+      }
+      if (debug) {
+        console.error(
+          `[zapier-sdk] Retrying drain for inbox ${inboxId} (attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`
+        );
+      }
+      await sleep(delay, signal);
+      if (signal.aborted) return { kind: "aborted" };
+      drainRequest.request();
+      continue;
     }
     firstFetch = false;
+    consecutiveErrors = 0;
+    errorAttempts = 0;
+    drainDegraded = false;
     if (abortedFromCallback) return { kind: "abortedFromCallback" };
   }
   return { kind: "aborted" };
 }
-function sseErrorStatusCode(err) {
+function errorStatusCode(err) {
   return err instanceof ZapierError ? err.statusCode : void 0;
 }
-function sseErrorMessage(err) {
+function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 async function sseLoop({
@@ -10767,8 +10847,8 @@ async function sseLoop({
       if (signal.aborted || isAbortError(err)) return;
       if (isPermanentHttpError(err)) {
         if (!degraded) {
-          const statusCode = sseErrorStatusCode(err);
-          const errorMsg = sseErrorMessage(err);
+          const statusCode = errorStatusCode(err);
+          const errorMsg = errorMessage(err);
           const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
           console.warn(
             `[zapier-sdk] Real-time wake-ups for inbox ${inboxId}${httpPart} paused: ${errorMsg}. Falling back to the periodic safety drain.`
@@ -10787,8 +10867,8 @@ async function sseLoop({
     const delay = SSE_RECONNECT_BACKOFF_MS[Math.min(attempt, SSE_RECONNECT_BACKOFF_MS.length - 1)];
     attempt = Math.min(attempt + 1, SSE_RECONNECT_BACKOFF_MS.length - 1);
     if (transientError !== void 0 && debug) {
-      const statusCode = sseErrorStatusCode(transientError);
-      const errorMsg = sseErrorMessage(transientError);
+      const statusCode = errorStatusCode(transientError);
+      const errorMsg = errorMessage(transientError);
       const httpPart = statusCode !== void 0 ? ` (HTTP ${statusCode})` : "";
       console.error(
         `[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} (attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`
@@ -10848,7 +10928,13 @@ var watchTriggerInboxPlugin = definePlugin(
         signal
       };
       drainRequest.request();
-      const runnerDone = drainRunner({ drainOptions, drainRequest, signal });
+      const runnerDone = drainRunner({
+        drainOptions,
+        drainRequest,
+        signal,
+        inboxId,
+        debug
+      });
       const sseDone = sseLoop({
         api: sdk.context.api,
         inboxId,
@@ -10881,7 +10967,7 @@ var watchTriggerInboxPlugin = definePlugin(
           watchTriggerInbox: {
             ...triggersDefaults,
             type: "create",
-            description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler; rejects on fatal SDK errors or fail-fast handler errors. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices.",
+            description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler. Transient drain failures (5xx, 429, network blips) retry indefinitely with bounded backoff until they succeed or the watch is aborted; it rejects on a fail-fast handler error, an initialization_failure, or a permanent HTTP error. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices. Persistent drain failures likewise warn once on stderr while bounded-backoff retries continue.",
             itemType: "void",
             // See drainTriggerInbox: override the doc generator's default
             // suffix so the rendered return type is Promise<void>, not
@@ -11216,11 +11302,12 @@ var createWorkflowPlugin = definePlugin(
       if (options.is_private !== void 0) {
         body.is_private = options.is_private;
       }
-      const data = await sdk2.context.api.post(
+      const raw = await sdk2.context.api.post(
         "/durableworkflowzaps/api/v0/workflows",
         body,
         { authRequired: true }
       );
+      const data = CreateWorkflowResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11262,7 +11349,7 @@ var updateWorkflowPlugin = definePlugin(
       if (options.description !== void 0) {
         body.description = options.description;
       }
-      const data = await sdk2.context.api.patch(
+      const raw = await sdk2.context.api.patch(
         `/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}`,
         body,
         {
@@ -11270,6 +11357,7 @@ var updateWorkflowPlugin = definePlugin(
           resource: { type: "workflow", id: options.workflow }
         }
       );
+      const data = UpdateWorkflowResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11293,7 +11381,7 @@ var enableWorkflowPlugin = definePlugin(
     outputSchema: EnableWorkflowResponseSchema,
     resolvers: { workflow: workflowIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
-      const data = await sdk2.context.api.post(
+      const raw = await sdk2.context.api.post(
         `/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/enable`,
         void 0,
         {
@@ -11301,6 +11389,7 @@ var enableWorkflowPlugin = definePlugin(
           resource: { type: "workflow", id: options.workflow }
         }
       );
+      const data = EnableWorkflowResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11326,7 +11415,7 @@ var disableWorkflowPlugin = definePlugin(
     outputSchema: DisableWorkflowResponseSchema,
     resolvers: { workflow: workflowIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
-      const data = await sdk2.context.api.post(
+      const raw = await sdk2.context.api.post(
         `/durableworkflowzaps/api/v0/workflows/${encodeURIComponent(options.workflow)}/disable`,
         void 0,
         {
@@ -11334,6 +11423,7 @@ var disableWorkflowPlugin = definePlugin(
           resource: { type: "workflow", id: options.workflow }
         }
       );
+      const data = DisableWorkflowResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11343,6 +11433,9 @@ var DeleteWorkflowOptionsSchema = z.object({
 }).describe(
   "Delete a durable workflow. Throws `ZapierNotFoundError` if the workflow doesn't exist; callers wanting idempotency should catch that themselves."
 );
+var DeleteWorkflowResponseSchema = z.object({
+  id: z.string().describe("Workflow ID that was targeted for deletion")
+});
 
 // src/plugins/codeSubstrate/deleteWorkflow/index.ts
 var deleteWorkflowPlugin = definePlugin(
@@ -11353,6 +11446,7 @@ var deleteWorkflowPlugin = definePlugin(
     itemType: "Workflow",
     confirm: "delete",
     inputSchema: DeleteWorkflowOptionsSchema,
+    outputSchema: DeleteWorkflowResponseSchema,
     resolvers: { workflow: workflowIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       await sdk2.context.api.delete(
@@ -11367,7 +11461,8 @@ var deleteWorkflowPlugin = definePlugin(
     }
   })
 );
-var RunStatusSchema = z.enum(["initialized", "started", "finished", "failed", "cancelled"]).describe(
+var RunStatusSchema = openEnum(
+  ["initialized", "started", "finished", "failed", "cancelled"],
   "Run lifecycle status. `finished` / `failed` / `cancelled` are terminal."
 );
 var RunErrorSchema = z.object({
@@ -11400,7 +11495,7 @@ var ListDurableRunsOptionsSchema = z.object({
 }).describe(
   "List run-once durable runs for the authenticated account, newest first"
 );
-z.object({
+var ListDurableRunsApiResponseSchema = z.object({
   results: z.array(RunItemSchema),
   meta: z.object({
     limit: z.number(),
@@ -11430,10 +11525,11 @@ var listDurableRunsPlugin = definePlugin(
       if (options.cursor) {
         searchParams.cursor = options.cursor;
       }
-      const response = await sdk2.context.api.get(
-        "/sdkdurableapi/api/v0/runs",
-        { searchParams, authRequired: true }
-      );
+      const raw = await sdk2.context.api.get("/sdkdurableapi/api/v0/runs", {
+        searchParams,
+        authRequired: true
+      });
+      const response = ListDurableRunsApiResponseSchema.parse(raw);
       return {
         data: response.results,
         nextCursor: response.meta.next_cursor ?? void 0
@@ -11441,10 +11537,12 @@ var listDurableRunsPlugin = definePlugin(
     }
   })
 );
-var OperationTypeSchema = z.enum(["step", "wait", "callback"]).describe(
+var OperationTypeSchema = openEnum(
+  ["step", "wait", "callback"],
   "Operation kind: `step` is a journaled function call; `wait` is a time-based suspension; `callback` is a wait on an external callback."
 );
-var OperationStatusSchema = z.enum(["pending", "completed", "failed", "exhausted"]).describe(
+var OperationStatusSchema = openEnum(
+  ["pending", "completed", "failed", "exhausted"],
   "Operation lifecycle status. `exhausted` means retries were exceeded."
 );
 var OperationSchema = z.object({
@@ -11472,7 +11570,8 @@ var OperationSchema = z.object({
   completed_at: z.string().optional().describe("When the operation reached a terminal state (ISO-8601)"),
   created_at: z.string().describe("When the operation was created (ISO-8601)")
 });
-var ExecutionStatusSchema = z.enum(["running", "waiting", "completed", "failed"]).describe(
+var ExecutionStatusSchema = openEnum(
+  ["running", "waiting", "completed", "failed"],
   "Execution lifecycle status. `waiting` means blocked on a wait or callback operation."
 );
 var ExecutionSummarySchema = z.object({
@@ -11536,13 +11635,14 @@ var getDurableRunPlugin = definePlugin(
     outputSchema: GetDurableRunResponseSchema,
     resolvers: { run: durableRunIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
-      const data = await sdk2.context.api.get(
+      const raw = await sdk2.context.api.get(
         `/sdkdurableapi/api/v0/runs/${encodeURIComponent(options.run)}`,
         {
           authRequired: true,
           resource: { type: "run", id: options.run }
         }
       );
+      const data = GetDurableRunResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11621,11 +11721,12 @@ var runDurablePlugin = definePlugin(
       if (options.private !== void 0) {
         body.is_private = options.private;
       }
-      const data = await sdk2.context.api.post(
+      const raw = await sdk2.context.api.post(
         "/sdkdurableapi/api/v0/runs",
         body,
         { authRequired: true }
       );
+      const data = RunDurableResponseSchema.parse(raw);
       return { data };
     }
   })
@@ -11635,7 +11736,7 @@ var CancelDurableRunOptionsSchema = z.object({
 }).describe(
   "Cancel a run-once durable run in initialized or started status. Returns 409 if the run is already terminal."
 );
-z.object({
+var CancelDurableRunResponseSchema = z.object({
   id: z.string().describe("Run ID that was targeted"),
   status: z.literal("cancelled").describe(
     "Always `cancelled` on a successful call. Synthesized client-side \u2014 the backend returns 204; callers needing the run's full state should follow up with getDurableRun."
@@ -11650,6 +11751,7 @@ var cancelDurableRunPlugin = definePlugin(
     type: "update",
     itemType: "DurableRun",
     inputSchema: CancelDurableRunOptionsSchema,
+    outputSchema: CancelDurableRunResponseSchema,
     resolvers: { run: durableRunIdResolver },
     handler: async ({ sdk: sdk2, options }) => {
       await sdk2.context.api.post(