@zapier/zapier-sdk 0.60.0 → 0.62.0

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"}

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

@@ -0,0 +1,27 @@
+import { definePlugin, createPaginatedPluginMethod, } from "../../../utils/plugin-utils";
+import { DEFAULT_PAGE_SIZE } from "../../../constants";
+import { codeSubstrateDefaults } from "../shared";
+import { ListDurableRunsOptionsSchema, RunItemSchema, } from "./schemas";
+export const listDurableRunsPlugin = definePlugin((sdk) => createPaginatedPluginMethod(sdk, {
+    ...codeSubstrateDefaults,
+    name: "listDurableRuns",
+    type: "list",
+    itemType: "DurableRun",
+    inputSchema: ListDurableRunsOptionsSchema,
+    outputSchema: RunItemSchema,
+    defaultPageSize: DEFAULT_PAGE_SIZE,
+    handler: async ({ sdk, options }) => {
+        const searchParams = {};
+        if (options.pageSize !== undefined) {
+            searchParams.limit = options.pageSize.toString();
+        }
+        if (options.cursor) {
+            searchParams.cursor = options.cursor;
+        }
+        const response = await sdk.context.api.get("/sdkdurableapi/api/v0/runs", { searchParams, authRequired: true });
+        return {
+            data: response.results,
+            nextCursor: response.meta.next_cursor ?? undefined,
+        };
+    },
+}));

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

@@ -0,0 +1,73 @@
+import { z } from "zod";
+export declare const RunStatusSchema: z.ZodEnum<{
+    initialized: "initialized";
+    started: "started";
+    finished: "finished";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+export type RunStatus = z.infer<typeof RunStatusSchema>;
+export declare const RunErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$loose>;
+export type RunError = z.infer<typeof RunErrorSchema>;
+export declare const RunItemSchema: 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_id: z.ZodNullable<z.ZodString>;
+    is_private: z.ZodBoolean;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type RunItem = z.infer<typeof RunItemSchema>;
+export declare const ListDurableRunsOptionsSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListDurableRunsOptions = z.infer<typeof ListDurableRunsOptionsSchema>;
+export declare const ListDurableRunsApiResponseSchema: z.ZodObject<{
+    results: z.ZodArray<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_id: z.ZodNullable<z.ZodString>;
+        is_private: z.ZodBoolean;
+        created_at: z.ZodString;
+        updated_at: z.ZodString;
+    }, z.core.$strip>>;
+    meta: z.ZodObject<{
+        limit: z.ZodNumber;
+        cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        next_cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    links: z.ZodOptional<z.ZodObject<{
+        next: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListDurableRunsApiResponse = z.infer<typeof ListDurableRunsApiResponseSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../../src/plugins/codeSubstrate/listDurableRuns/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;;;EAIzB,CAAC;AAEJ,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,cAAc;;;iBAQxB,CAAC;AAEJ,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;iBAwBxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,4BAA4B;;;;iBAiBtC,CAAC;AAEJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAC1C,OAAO,4BAA4B,CACpC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAY3C,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,gCAAgC,CACxC,CAAC"}

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

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export const RunStatusSchema = z
+    .enum(["initialized", "started", "finished", "failed", "cancelled"])
+    .describe("Run lifecycle status. `finished` / `failed` / `cancelled` are terminal.");
+export const RunErrorSchema = z
+    .object({
+    code: z.string().describe("Machine-readable error category"),
+    message: z.string().describe("Human-readable error summary"),
+})
+    .passthrough()
+    .describe("Structured run error. Always carries `code` and `message`; additional keys may appear depending on the error type.");
+export const RunItemSchema = 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_id: z
+        .string()
+        .nullable()
+        .describe("Linked execution ID. Null until the run leaves the `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)"),
+});
+export const ListDurableRunsOptionsSchema = z
+    .object({
+    pageSize: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("Number of runs per page (max 100)"),
+    cursor: z.string().optional().describe("Pagination cursor"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("List run-once durable runs for the authenticated account, newest first");
+export const ListDurableRunsApiResponseSchema = z.object({
+    results: z.array(RunItemSchema),
+    meta: z.object({
+        limit: z.number(),
+        cursor: z.string().nullable().optional(),
+        next_cursor: z.string().nullable().optional(),
+    }),
+    links: z
+        .object({
+        next: z.string().nullable().optional(),
+    })
+        .optional(),
+});