@zapier/zapier-sdk 0.61.0 → 0.63.0

package/dist/index.mjs

@@ -2588,6 +2588,21 @@ var workflowIdResolver = {
   })
 };
 
+// src/resolvers/durableRunId.ts
+var durableRunIdResolver = {
+  type: "dynamic",
+  fetch: async (sdk) => toIterable(sdk.listDurableRuns()),
+  prompt: (runs) => ({
+    type: "list",
+    name: "run",
+    message: "Select a run:",
+    choices: runs.map((run) => ({
+      name: `${run.id} \u2014 ${run.status}`,
+      value: run.id
+    }))
+  })
+};
+
 // src/resolvers/triggerMessages.ts
 var triggerMessagesResolver = {
   type: "dynamic",
@@ -6337,7 +6352,7 @@ async function invalidateCredentialsToken(options) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.61.0" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.63.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -9199,4 +9214,4 @@ var registryPlugin = definePlugin((_sdk) => {
   return {};
 });
 
-export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierSdk, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver };
+export { ActionKeyPropertySchema, ActionPropertySchema, ActionTimeoutMsPropertySchema, ActionTypePropertySchema, AppKeyPropertySchema, AppPropertySchema, AppsPropertySchema, AuthenticationIdPropertySchema, BaseSdkOptionsSchema, CONTEXT_CACHE_MAX_SIZE, CONTEXT_CACHE_TTL_MS, ClientCredentialsObjectSchema, ConnectionEntrySchema, ConnectionIdPropertySchema, ConnectionPropertySchema, ConnectionsMapSchema, ConnectionsPropertySchema, CredentialsFunctionSchema, CredentialsObjectSchema, CredentialsSchema, DEFAULT_ACTION_TIMEOUT_MS, DEFAULT_APPROVAL_TIMEOUT_MS, DEFAULT_CONFIG_PATH, DEFAULT_MAX_APPROVAL_RETRIES, DEFAULT_PAGE_SIZE, DebugPropertySchema, FieldsPropertySchema, InputFieldPropertySchema, InputsPropertySchema, LeaseLimitPropertySchema, LeasePropertySchema, LeaseSecondsPropertySchema, LimitPropertySchema, MAX_CONCURRENCY_LIMIT, MAX_PAGE_LIMIT, OffsetPropertySchema, OutputPropertySchema, ParamsPropertySchema, PkceCredentialsObjectSchema, RecordPropertySchema, RecordsPropertySchema, RelayFetchSchema, RelayRequestSchema, ResolvedCredentialsSchema, TablePropertySchema, TablesPropertySchema, TriggerInboxNamePropertySchema, TriggerInboxPropertySchema, ZAPIER_BASE_URL, ZAPIER_MAX_CONCURRENT_REQUESTS, ZAPIER_MAX_NETWORK_RETRIES, ZAPIER_MAX_NETWORK_RETRY_DELAY_MS, ZapierAbortDrainSignal, ZapierActionError, ZapierApiError, ZapierAppNotFoundError, ZapierApprovalError, ZapierAuthenticationError, ZapierBundleError, ZapierConfigurationError, ZapierConflictError, ZapierError, ZapierNotFoundError, ZapierRateLimitError, ZapierRelayError, ZapierReleaseTriggerMessageSignal, ZapierResourceNotFoundError, ZapierSignal, ZapierTimeoutError, ZapierUnknownError, ZapierValidationError, actionKeyResolver, actionTypeResolver, apiPlugin, appKeyResolver, appsPlugin, connectionIdGenericResolver as authenticationIdGenericResolver, connectionIdResolver as authenticationIdResolver, batch, buildApplicationLifecycleEvent, buildCapabilityMessage, buildErrorEvent, buildErrorEventWithContext, buildMethodCalledEvent, cleanupEventListeners, clearTokenCache, clientCredentialsNameResolver, clientIdResolver, composePlugins, connectionIdGenericResolver, connectionIdResolver, connectionsPlugin, createBaseEvent, createClientCredentialsPlugin, createFunction, createMemoryCache, createOptionsPlugin, createPaginatedPluginMethod, createPluginMethod, createSdk, createTableFieldsPlugin, createTablePlugin, createTableRecordsPlugin, createZapierApi, createZapierSdk, createZapierSdkWithoutRegistry, definePlugin, deleteClientCredentialsPlugin, deleteTableFieldsPlugin, deleteTablePlugin, deleteTableRecordsPlugin, durableRunIdResolver, eventEmissionPlugin, fetchPlugin, findFirstConnectionPlugin, findManifestEntry, findUniqueConnectionPlugin, formatErrorMessage, generateEventId, getActionInputFieldsSchemaPlugin, getActionPlugin, getAppPlugin, getBaseUrlFromCredentials, getCiPlatform, getClientIdFromCredentials, getConnectionPlugin, getCpuTime, getCurrentTimestamp, getMemoryUsage, getOrCreateApiClient, getOsInfo, getPlatformVersions, getPreferredManifestEntryKey, getProfilePlugin, getReleaseId, getTablePlugin, getTableRecordPlugin, getTokenFromCliLogin, getZapierApprovalMode, getZapierDefaultApprovalMode, getZapierSdkService, injectCliLogin, inputFieldKeyResolver, inputsAllOptionalResolver, inputsResolver, invalidateCachedToken, invalidateCredentialsToken, isCi, isCliLoginAvailable, isClientCredentials, isCredentialsFunction, isCredentialsObject, isPkceCredentials, isPositional, listActionInputFieldChoicesPlugin, listActionInputFieldsPlugin, listActionsPlugin, listAppsPlugin, listClientCredentialsPlugin, listConnectionsPlugin, listTableFieldsPlugin, listTableRecordsPlugin, listTablesPlugin, logDeprecation, manifestPlugin, parseConcurrencyEnvVar, readManifestFromFile, registryPlugin, requestPlugin, resetDeprecationWarnings, resolveAuthToken, resolveCredentials, resolveCredentialsFromEnv, runActionPlugin, runWithTelemetryContext, tableFieldIdsResolver, tableFieldsResolver, tableFiltersResolver, tableIdResolver, tableNameResolver, tableRecordIdResolver, tableRecordIdsResolver, tableRecordsResolver, tableSortResolver, tableUpdateRecordsResolver, toSnakeCase, toTitleCase, triggerInboxResolver, triggerMessagesResolver, updateTableRecordsPlugin, workflowIdResolver };

package/dist/plugins/codeSubstrate/cancelDurableRun/index.d.ts

@@ -0,0 +1,40 @@
+export declare const cancelDurableRunPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    cancelDurableRun: (options?: {
+        run: string;
+    } | undefined) => Promise<{
+        data: {
+            id: string;
+            status: "cancelled";
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            cancelDurableRun: import("../../..").PluginMeta;
+        };
+    };
+};
+export type CancelDurableRunPluginProvides = ReturnType<typeof cancelDurableRunPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/cancelDurableRun/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/cancelDurableRun/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlC,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG,UAAU,CACrD,OAAO,sBAAsB,CAC9B,CAAC"}

package/dist/plugins/codeSubstrate/cancelDurableRun/index.js

@@ -0,0 +1,27 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { durableRunIdResolver } from "../../../resolvers/durableRunId";
+import { codeSubstrateDefaults } from "../shared";
+import { CancelDurableRunOptionsSchema } from "./schemas";
+export const cancelDurableRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "cancelDurableRun",
+    type: "update",
+    itemType: "DurableRun",
+    inputSchema: CancelDurableRunOptionsSchema,
+    resolvers: { run: durableRunIdResolver },
+    handler: async ({ sdk, options }) => {
+        // Backend returns 204 on success. 404 (run missing) and 409 (run
+        // already terminal) propagate as their respective ZapierErrors so
+        // callers can distinguish — we don't soft-fold them into a status
+        // enum the way deleteWorkflow does, because cancelling an
+        // already-terminal run is a meaningfully different outcome that
+        // callers may want to surface to users.
+        await sdk.context.api.post(`/sdkdurableapi/api/v0/runs/${encodeURIComponent(options.run)}/cancel`, undefined, {
+            authRequired: true,
+            resource: { type: "run", id: options.run },
+        });
+        return {
+            data: { id: options.run, status: "cancelled" },
+        };
+    },
+}));

package/dist/plugins/codeSubstrate/cancelDurableRun/schemas.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const CancelDurableRunOptionsSchema: z.ZodObject<{
+    run: z.ZodString;
+}, z.core.$strip>;
+export type CancelDurableRunOptions = z.infer<typeof CancelDurableRunOptionsSchema>;
+export declare const CancelDurableRunResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>;
+export type CancelDurableRunResponse = z.infer<typeof CancelDurableRunResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/cancelDurableRun/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/cancelDurableRun/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;iBAMvC,CAAC;AAEJ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;iBAOzC,CAAC;AAEH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC"}

package/dist/plugins/codeSubstrate/cancelDurableRun/schemas.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export const CancelDurableRunOptionsSchema = z
+    .object({
+    run: z.string().uuid().describe("Durable run ID"),
+})
+    .describe("Cancel a run-once durable run in initialized or started status. Returns 409 if the run is already terminal.");
+export const 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 — the backend returns 204; callers needing the run's full state should follow up with getDurableRun."),
+});

package/dist/plugins/codeSubstrate/getDurableRun/index.d.ts

@@ -0,0 +1,89 @@
+export declare const getDurableRunPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    getDurableRun: (options?: {
+        run: string;
+    } | undefined) => Promise<{
+        data: {
+            id: string;
+            status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+            input: unknown;
+            output: unknown;
+            error: {
+                [x: string]: unknown;
+                code: string;
+                message: string;
+            } | null;
+            execution: {
+                id: string;
+                name: string;
+                status: "failed" | "waiting" | "completed" | "running";
+                input: unknown;
+                created_at: string;
+                output?: unknown;
+                error?: unknown;
+                metadata?: Record<string, unknown> | undefined;
+                summary?: {
+                    [x: string]: unknown;
+                    total_attempts: number;
+                    last_error?: {
+                        [x: string]: unknown;
+                        code: string;
+                        title: string;
+                        detail?: string | null | undefined;
+                    } | undefined;
+                } | null | undefined;
+                operations?: {
+                    id: string;
+                    execution_id: string;
+                    name: string;
+                    type: "step" | "wait" | "callback";
+                    status: "pending" | "failed" | "exhausted" | "completed";
+                    retry_count: number;
+                    created_at: string;
+                    result?: unknown;
+                    error?: unknown;
+                    max_attempts?: number | undefined;
+                    next_retry_at?: string | undefined;
+                    resume_at?: string | undefined;
+                    callback_token?: string | null | undefined;
+                    payload_schema?: unknown;
+                    payload?: unknown;
+                    expires_at?: string | undefined;
+                    completed_at?: string | undefined;
+                }[] | undefined;
+            } | null;
+            is_private: boolean;
+            created_at: string;
+            updated_at: string;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getDurableRun: import("../../..").PluginMeta;
+        };
+    };
+};
+export type GetDurableRunPluginProvides = ReturnType<typeof getDurableRunPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/getDurableRun/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getDurableRun/index.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqB/B,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,OAAO,mBAAmB,CAC3B,CAAC"}

package/dist/plugins/codeSubstrate/getDurableRun/index.js

@@ -0,0 +1,20 @@
+import { definePlugin, createPluginMethod } from "../../../utils/plugin-utils";
+import { durableRunIdResolver } from "../../../resolvers/durableRunId";
+import { codeSubstrateDefaults } from "../shared";
+import { GetDurableRunOptionsSchema, GetDurableRunResponseSchema, } from "./schemas";
+export const getDurableRunPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "getDurableRun",
+    type: "item",
+    itemType: "DurableRun",
+    inputSchema: GetDurableRunOptionsSchema,
+    outputSchema: GetDurableRunResponseSchema,
+    resolvers: { run: durableRunIdResolver },
+    handler: async ({ sdk, options }) => {
+        const data = await sdk.context.api.get(`/sdkdurableapi/api/v0/runs/${encodeURIComponent(options.run)}`, {
+            authRequired: true,
+            resource: { type: "run", id: options.run },
+        });
+        return { data };
+    },
+}));

package/dist/plugins/codeSubstrate/getDurableRun/schemas.d.ts

@@ -0,0 +1,178 @@
+import { z } from "zod";
+export declare const OperationTypeSchema: z.ZodEnum<{
+    step: "step";
+    wait: "wait";
+    callback: "callback";
+}>;
+export type OperationType = z.infer<typeof OperationTypeSchema>;
+export declare const OperationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    failed: "failed";
+    exhausted: "exhausted";
+    completed: "completed";
+}>;
+export type OperationStatus = z.infer<typeof OperationStatusSchema>;
+export declare const OperationSchema: z.ZodObject<{
+    id: z.ZodString;
+    execution_id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        step: "step";
+        wait: "wait";
+        callback: "callback";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        exhausted: "exhausted";
+        completed: "completed";
+    }>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodUnknown>;
+    retry_count: z.ZodNumber;
+    max_attempts: z.ZodOptional<z.ZodNumber>;
+    next_retry_at: z.ZodOptional<z.ZodString>;
+    resume_at: z.ZodOptional<z.ZodString>;
+    callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    payload_schema: z.ZodOptional<z.ZodUnknown>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    completed_at: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+export type Operation = z.infer<typeof OperationSchema>;
+export declare const ExecutionStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    waiting: "waiting";
+    completed: "completed";
+    running: "running";
+}>;
+export type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
+export declare const ExecutionSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        waiting: "waiting";
+        completed: "completed";
+        running: "running";
+    }>;
+    input: z.ZodUnknown;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodString;
+    summary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        total_attempts: z.ZodNumber;
+        last_error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodString;
+            title: z.ZodString;
+            detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>>;
+    operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        execution_id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            step: "step";
+            wait: "wait";
+            callback: "callback";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            exhausted: "exhausted";
+            completed: "completed";
+        }>;
+        result: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        retry_count: z.ZodNumber;
+        max_attempts: z.ZodOptional<z.ZodNumber>;
+        next_retry_at: z.ZodOptional<z.ZodString>;
+        resume_at: z.ZodOptional<z.ZodString>;
+        callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        payload_schema: z.ZodOptional<z.ZodUnknown>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+        expires_at: z.ZodOptional<z.ZodString>;
+        completed_at: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ExecutionSummary = z.infer<typeof ExecutionSummarySchema>;
+export declare const GetDurableRunOptionsSchema: z.ZodObject<{
+    run: z.ZodString;
+}, z.core.$strip>;
+export type GetDurableRunOptions = z.infer<typeof GetDurableRunOptionsSchema>;
+export declare const GetDurableRunResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        initialized: "initialized";
+        started: "started";
+        finished: "finished";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    input: z.ZodUnknown;
+    output: z.ZodNullable<z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$loose>>;
+    execution: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            waiting: "waiting";
+            completed: "completed";
+            running: "running";
+        }>;
+        input: z.ZodUnknown;
+        output: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodUnknown>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        created_at: z.ZodString;
+        summary: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            total_attempts: z.ZodNumber;
+            last_error: z.ZodOptional<z.ZodObject<{
+                code: z.ZodString;
+                title: z.ZodString;
+                detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        operations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            execution_id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                step: "step";
+                wait: "wait";
+                callback: "callback";
+            }>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                failed: "failed";
+                exhausted: "exhausted";
+                completed: "completed";
+            }>;
+            result: z.ZodOptional<z.ZodUnknown>;
+            error: z.ZodOptional<z.ZodUnknown>;
+            retry_count: z.ZodNumber;
+            max_attempts: z.ZodOptional<z.ZodNumber>;
+            next_retry_at: z.ZodOptional<z.ZodString>;
+            resume_at: z.ZodOptional<z.ZodString>;
+            callback_token: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            payload_schema: z.ZodOptional<z.ZodUnknown>;
+            payload: z.ZodOptional<z.ZodUnknown>;
+            expires_at: z.ZodOptional<z.ZodString>;
+            completed_at: z.ZodOptional<z.ZodString>;
+            created_at: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    is_private: z.ZodBoolean;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type GetDurableRunResponse = z.infer<typeof GetDurableRunResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/codeSubstrate/getDurableRun/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/getDurableRun/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,mBAAmB;;;;EAI7B,CAAC;AAEJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB;;;;;EAI/B,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyD1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,qBAAqB;;;;;EAI/B,CAAC;AAEJ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,0BAA0B;;iBAMpC,CAAC;AAEJ,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/plugins/codeSubstrate/getDurableRun/schemas.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+import { RunErrorSchema, RunStatusSchema } from "../listDurableRuns/schemas";
+export const OperationTypeSchema = z
+    .enum(["step", "wait", "callback"])
+    .describe("Operation kind: `step` is a journaled function call; `wait` is a time-based suspension; `callback` is a wait on an external callback.");
+export const OperationStatusSchema = z
+    .enum(["pending", "completed", "failed", "exhausted"])
+    .describe("Operation lifecycle status. `exhausted` means retries were exceeded.");
+export const OperationSchema = z.object({
+    id: z.string().describe("Operation ID (UUID)"),
+    execution_id: z.string().describe("Parent execution ID"),
+    name: z
+        .string()
+        .describe("Operation name as declared by the workflow author"),
+    type: OperationTypeSchema,
+    status: OperationStatusSchema,
+    result: z
+        .unknown()
+        .optional()
+        .describe("Result value when the operation completed"),
+    error: z
+        .unknown()
+        .optional()
+        .describe("Error payload when the operation failed"),
+    retry_count: z.number().describe("Number of retry attempts so far"),
+    max_attempts: z
+        .number()
+        .optional()
+        .describe("Cap on total attempts for this operation. Absent if no cap applies."),
+    next_retry_at: z
+        .string()
+        .optional()
+        .describe("When the next retry will be attempted (ISO-8601)"),
+    resume_at: z
+        .string()
+        .optional()
+        .describe("When a `wait` operation resumes (ISO-8601). Set only for type=wait."),
+    callback_token: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Token for delivering a callback. Set only for type=callback; null until the callback URL is materialized."),
+    payload_schema: z
+        .unknown()
+        .optional()
+        .describe("JSON Schema describing the expected callback payload"),
+    payload: z
+        .unknown()
+        .optional()
+        .describe("Payload delivered to a callback operation, when received"),
+    expires_at: z
+        .string()
+        .optional()
+        .describe("When a callback or wait operation expires (ISO-8601)"),
+    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)"),
+});
+export const ExecutionStatusSchema = z
+    .enum(["running", "waiting", "completed", "failed"])
+    .describe("Execution lifecycle status. `waiting` means blocked on a wait or callback operation.");
+export const ExecutionSummarySchema = z.object({
+    id: z.string().describe("Execution ID (UUID)"),
+    name: z.string().describe("Durable function name"),
+    status: ExecutionStatusSchema,
+    input: z.unknown().describe("Input passed when the execution was created"),
+    output: z
+        .unknown()
+        .optional()
+        .describe("Return value when status is `completed`"),
+    error: z
+        .unknown()
+        .optional()
+        .describe("Error details when status is `failed`"),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Caller-supplied tags (Zap ID, Step ID, Agent ID, etc.) carried alongside the execution"),
+    created_at: z.string().describe("When the execution was created (ISO-8601)"),
+    summary: z
+        .object({
+        total_attempts: z
+            .number()
+            .describe("Total ticks attempted against this execution across all retries"),
+        last_error: z
+            .object({
+            code: z.string().describe("Machine-readable error category"),
+            title: z.string().describe("Short error label"),
+            detail: z
+                .string()
+                .nullable()
+                .optional()
+                .describe("Longer-form error detail, when provided"),
+        })
+            .passthrough()
+            .optional()
+            .describe("The most recent error, if the execution has failed once"),
+    })
+        .passthrough()
+        .nullable()
+        .optional()
+        .describe("Aggregate health summary. Null when no attempts have been recorded yet."),
+    operations: z
+        .array(OperationSchema)
+        .optional()
+        .describe("Operations journal — append-only record of every step/wait/callback the execution made"),
+});
+export const GetDurableRunOptionsSchema = z
+    .object({
+    run: z.string().uuid().describe("Durable run ID"),
+})
+    .describe("Get the full state of a run-once durable run, including its operations journal");
+export const GetDurableRunResponseSchema = z.object({
+    id: z.string().describe("Run ID (UUID)"),
+    status: RunStatusSchema,
+    input: z.unknown().describe("Input data passed to the run"),
+    output: z
+        .unknown()
+        .nullable()
+        .describe("Return value, present when status is `finished`"),
+    error: RunErrorSchema.nullable().describe("Structured error details when the run failed (null otherwise)"),
+    execution: ExecutionSummarySchema.nullable().describe("Linked execution, including the operations journal. Null while the run is still in `initialized` state."),
+    is_private: z
+        .boolean()
+        .describe("When true, the run is visible only to the creating user; otherwise visible across the account."),
+    created_at: z.string().describe("When the run was created (ISO-8601)"),
+    updated_at: z.string().describe("When the run was last updated (ISO-8601)"),
+});

package/dist/plugins/codeSubstrate/listDurableRuns/index.d.ts

@@ -0,0 +1,55 @@
+export declare const listDurableRunsPlugin: (sdk: {
+    context: {
+        api: import("../../..").ApiClient;
+        resolveCredentials: () => Promise<string | {
+            clientId: string;
+            clientSecret: string;
+            type?: "client_credentials" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | {
+            clientId: string;
+            type?: "pkce" | undefined;
+            baseUrl?: string | undefined;
+            scope?: string | undefined;
+        } | undefined>;
+    };
+} & {
+    context: import("../../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../../..").PluginMeta>;
+    };
+}) => {
+    listDurableRuns: (options?: ({
+        pageSize?: number | undefined;
+        cursor?: string | undefined;
+        maxItems?: number | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../../..").PaginatedSdkResult<{
+        id: string;
+        status: "initialized" | "started" | "finished" | "failed" | "cancelled";
+        input: unknown;
+        output: unknown;
+        error: {
+            [x: string]: unknown;
+            code: string;
+            message: string;
+        } | null;
+        execution_id: string | null;
+        is_private: boolean;
+        created_at: string;
+        updated_at: string;
+    }>;
+} & {
+    context: {
+        meta: {
+            listDurableRuns: import("../../..").PluginMeta;
+        };
+    };
+};
+export type ListDurableRunsPluginProvides = ReturnType<typeof listDurableRunsPlugin>;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/codeSubstrate/listDurableRuns/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listDurableRuns/index.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BjC,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG,UAAU,CACpD,OAAO,qBAAqB,CAC7B,CAAC"}