@anchrd/colab-sdk 0.1.10 → 0.1.12

package/dist/error/error.d.ts

@@ -1,11 +1,11 @@
 import { z } from "zod";
 export declare const errorCodes: readonly ["not_found", "invalid", "conflict", "unauthenticated", "unavailable"];
 export declare const ErrorCode: z.ZodEnum<{
-    unavailable: "unavailable";
     not_found: "not_found";
     invalid: "invalid";
     conflict: "conflict";
     unauthenticated: "unauthenticated";
+    unavailable: "unavailable";
 }>;
 export type ErrorCode = z.infer<typeof ErrorCode>;
 export declare const ErrorIssue: z.ZodObject<{
@@ -15,7 +15,10 @@ export declare const ErrorIssue: z.ZodObject<{
 export type ErrorIssue = z.infer<typeof ErrorIssue>;
 export declare const ErrorResponse: z.ZodObject<{
     error: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        code: z.ZodLiteral<"invalid">;
+        code: z.ZodEnum<{
+            invalid: "invalid";
+            conflict: "conflict";
+        }>;
         message: z.ZodString;
         issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
             path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
@@ -23,10 +26,9 @@ export declare const ErrorResponse: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>, z.ZodObject<{
         code: z.ZodEnum<{
-            unavailable: "unavailable";
             not_found: "not_found";
-            conflict: "conflict";
             unauthenticated: "unauthenticated";
+            unavailable: "unavailable";
         }>;
         message: z.ZodString;
     }, z.core.$strict>], "code">;

package/dist/error/error.js

@@ -14,16 +14,17 @@ export const ErrorIssue = z.strictObject({
     path: z.array(z.union([z.string(), z.number()])),
     message: z.string(),
 });
-// `issues` exists only next to `invalid`; on every other code a strict object rejects it.
+// `issues` exists only next to `invalid` and `conflict` (a change of many entries names each stale
+// one, #630, #625); on every other code a strict object rejects it.
 export const ErrorResponse = z.strictObject({
     error: z.discriminatedUnion("code", [
         z.strictObject({
-            code: z.literal("invalid"),
+            code: z.enum(["invalid", "conflict"]),
             message: z.string(),
             issues: z.array(ErrorIssue).optional(),
         }),
         z.strictObject({
-            code: ErrorCode.exclude(["invalid"]),
+            code: ErrorCode.exclude(["invalid", "conflict"]),
             message: z.string(),
         }),
     ]),

package/dist/gadgets/gadgets.d.ts

@@ -0,0 +1,532 @@
+import { z } from "zod";
+export declare const GadgetFilePath: z.ZodString;
+export type GadgetFilePath = z.infer<typeof GadgetFilePath>;
+export declare const gadgetLimits: {
+    readonly files: 200;
+    readonly bytes: number;
+};
+export declare const GadgetFunctionName: z.ZodString;
+export declare const GadgetFunction: z.ZodObject<{
+    description: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type GadgetFunction = z.infer<typeof GadgetFunction>;
+export declare const GadgetManifest: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    functions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GadgetManifest = z.infer<typeof GadgetManifest>;
+export declare const GadgetVersionRef: z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+    live: "live";
+    draft: "draft";
+}>, z.ZodNumber]>, unknown>;
+export type GadgetVersionRef = z.infer<typeof GadgetVersionRef>;
+export declare const GadgetLevel: z.ZodEnum<{
+    publish: "publish";
+    draft: "draft";
+    report: "report";
+}>;
+export type GadgetLevel = z.infer<typeof GadgetLevel>;
+export declare const gadgetLogDays: readonly [7, 14, 30];
+export declare const GadgetCreateInput: z.ZodObject<{
+    parentId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type GadgetCreateInput = z.infer<typeof GadgetCreateInput>;
+export declare const GadgetGetInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    version: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+        live: "live";
+        draft: "draft";
+    }>, z.ZodNumber]>, unknown>>;
+    include: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodEnum<{
+        files: "files";
+    }>>, unknown>>;
+}, z.core.$strict>;
+export type GadgetGetInput = z.infer<typeof GadgetGetInput>;
+export declare const GadgetUpdateInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    files: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        responsibleId: z.ZodOptional<z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>>;
+        level: z.ZodOptional<z.ZodEnum<{
+            publish: "publish";
+            draft: "draft";
+            report: "report";
+        }>>;
+        logDays: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<7>, z.ZodLiteral<14>, z.ZodLiteral<30>]>>;
+    }, z.core.$strict>>;
+    fromVersion: z.ZodOptional<z.ZodNumber>;
+    discard: z.ZodOptional<z.ZodLiteral<true>>;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type GadgetUpdateInput = z.infer<typeof GadgetUpdateInput>;
+export declare const GadgetPublishInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    force: z.ZodOptional<z.ZodLiteral<true>>;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type GadgetPublishInput = z.infer<typeof GadgetPublishInput>;
+export declare const GadgetTestInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    version: z.ZodOptional<z.ZodEnum<{
+        live: "live";
+        draft: "draft";
+    }>>;
+}, z.core.$strict>;
+export type GadgetTestInput = z.infer<typeof GadgetTestInput>;
+export declare const GadgetCallStatus: z.ZodEnum<{
+    failed: "failed";
+    succeeded: "succeeded";
+}>;
+export type GadgetCallStatus = z.infer<typeof GadgetCallStatus>;
+export declare const GadgetCallListInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    status: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>>;
+    version: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+        live: "live";
+        draft: "draft";
+    }>, z.ZodNumber]>, unknown>>;
+    function: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodISODateTime>;
+    query: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type GadgetCallListInput = z.infer<typeof GadgetCallListInput>;
+export declare const GadgetCallGetInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    callId: z.ZodTemplateLiteral<`call_${string}`>;
+}, z.core.$strict>;
+export type GadgetCallGetInput = z.infer<typeof GadgetCallGetInput>;
+export declare const GadgetClientLog: z.ZodObject<{
+    callId: z.ZodOptional<z.ZodTemplateLiteral<`call_${string}`>>;
+    version: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+        live: "live";
+        draft: "draft";
+    }>, z.ZodNumber]>, unknown>>;
+    console: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            log: "log";
+            info: "info";
+            warn: "warn";
+            debug: "debug";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strict>>>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type GadgetClientLog = z.infer<typeof GadgetClientLog>;
+export declare const GadgetCallCreateInput: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    function: z.ZodString;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    version: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
+        live: "live";
+        draft: "draft";
+    }>, z.ZodNumber]>, unknown>>;
+}, z.core.$strict>;
+export type GadgetCallCreateInput = z.infer<typeof GadgetCallCreateInput>;
+export declare const GadgetFile: z.ZodObject<{
+    path: z.ZodString;
+    size: z.ZodNumber;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GadgetFile = z.infer<typeof GadgetFile>;
+export declare const GadgetChange: z.ZodObject<{
+    path: z.ZodString;
+    change: z.ZodEnum<{
+        added: "added";
+        changed: "changed";
+        removed: "removed";
+    }>;
+}, z.core.$strip>;
+export type GadgetChange = z.infer<typeof GadgetChange>;
+export declare const GadgetSettings: z.ZodObject<{
+    responsible: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>>;
+    level: z.ZodEnum<{
+        publish: "publish";
+        draft: "draft";
+        report: "report";
+    }>;
+    logDays: z.ZodNumber;
+}, z.core.$strip>;
+export type GadgetSettings = z.infer<typeof GadgetSettings>;
+export declare const GadgetTestResult: z.ZodObject<{
+    file: z.ZodString;
+    path: z.ZodArray<z.ZodString>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    durationMs: z.ZodNumber;
+    message: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GadgetTestResult = z.infer<typeof GadgetTestResult>;
+export declare const GadgetTestRun: z.ZodObject<{
+    version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+    current: z.ZodBoolean;
+    status: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    at: z.ZodISODateTime;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    durationMs: z.ZodNumber;
+    error: z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tests: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        path: z.ZodArray<z.ZodString>;
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+        durationMs: z.ZodNumber;
+        message: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GadgetTestRun = z.infer<typeof GadgetTestRun>;
+export declare const GadgetDetail: z.ZodObject<{
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    name: z.ZodString;
+    hidden: z.ZodBoolean;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    path: z.ZodObject<{
+        section: z.ZodEnum<{
+            users: "users";
+            own: "own";
+            shared: "shared";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    version: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>>;
+    manifest: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        functions: z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        size: z.ZodNumber;
+        content: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    live: z.ZodNullable<z.ZodObject<{
+        version: z.ZodNumber;
+        publishedAt: z.ZodISODateTime;
+        publishedBy: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    draft: z.ZodNullable<z.ZodObject<{
+        updatedAt: z.ZodISODateTime;
+        updatedBy: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            change: z.ZodEnum<{
+                added: "added";
+                changed: "changed";
+                removed: "removed";
+            }>;
+        }, z.core.$strip>>;
+        newTools: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    test: z.ZodNullable<z.ZodObject<{
+        version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+        current: z.ZodBoolean;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        at: z.ZodISODateTime;
+        by: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+        durationMs: z.ZodNumber;
+        error: z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            stack: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        tests: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            path: z.ZodArray<z.ZodString>;
+            name: z.ZodString;
+            status: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+            }>;
+            durationMs: z.ZodNumber;
+            message: z.ZodNullable<z.ZodString>;
+            location: z.ZodNullable<z.ZodObject<{
+                file: z.ZodString;
+                line: z.ZodNumber;
+                column: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    usage: z.ZodNullable<z.ZodObject<{
+        calls: z.ZodNumber;
+        errors: z.ZodNumber;
+        lastCallAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+    settings: z.ZodNullable<z.ZodObject<{
+        responsible: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>>;
+        level: z.ZodEnum<{
+            publish: "publish";
+            draft: "draft";
+            report: "report";
+        }>;
+        logDays: z.ZodNumber;
+    }, z.core.$strip>>;
+    rights: z.ZodObject<{
+        write: z.ZodBoolean;
+    }, z.core.$strip>;
+    rev: z.ZodNumber;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type GadgetDetail = z.infer<typeof GadgetDetail>;
+export declare const GadgetToolUse: z.ZodObject<{
+    name: z.ZodString;
+    durationMs: z.ZodNumber;
+    code: z.ZodNullable<z.ZodEnum<{
+        not_found: "not_found";
+        invalid: "invalid";
+        conflict: "conflict";
+        unauthenticated: "unauthenticated";
+        unavailable: "unavailable";
+    }>>;
+}, z.core.$strip>;
+export type GadgetToolUse = z.infer<typeof GadgetToolUse>;
+export declare const GadgetConsoleLine: z.ZodObject<{
+    level: z.ZodEnum<{
+        error: "error";
+        log: "log";
+        info: "info";
+        warn: "warn";
+        debug: "debug";
+    }>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export type GadgetConsoleLine = z.infer<typeof GadgetConsoleLine>;
+export declare const GadgetCall: z.ZodObject<{
+    callId: z.ZodNullable<z.ZodTemplateLiteral<`call_${string}`>>;
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    function: z.ZodString;
+    version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    output: z.ZodUnknown;
+    error: z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    durationMs: z.ZodNumber;
+    console: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            log: "log";
+            info: "info";
+            warn: "warn";
+            debug: "debug";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        durationMs: z.ZodNumber;
+        code: z.ZodNullable<z.ZodEnum<{
+            not_found: "not_found";
+            invalid: "invalid";
+            conflict: "conflict";
+            unauthenticated: "unauthenticated";
+            unavailable: "unavailable";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GadgetCall = z.infer<typeof GadgetCall>;
+export declare const GadgetCallItem: z.ZodObject<{
+    callId: z.ZodTemplateLiteral<`call_${string}`>;
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    at: z.ZodISODateTime;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    origin: z.ZodEnum<{
+        server: "server";
+        client: "client";
+    }>;
+    function: z.ZodNullable<z.ZodString>;
+    version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    unavailable: z.ZodBoolean;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    message: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type GadgetCallItem = z.infer<typeof GadgetCallItem>;
+export declare const GadgetCallList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        callId: z.ZodTemplateLiteral<`call_${string}`>;
+        gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+        at: z.ZodISODateTime;
+        by: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strip>;
+        origin: z.ZodEnum<{
+            server: "server";
+            client: "client";
+        }>;
+        function: z.ZodNullable<z.ZodString>;
+        version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        unavailable: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        message: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type GadgetCallList = z.infer<typeof GadgetCallList>;
+export declare const GadgetCallEntry: z.ZodObject<{
+    callId: z.ZodTemplateLiteral<`call_${string}`>;
+    gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
+    at: z.ZodISODateTime;
+    by: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strip>;
+    origin: z.ZodEnum<{
+        server: "server";
+        client: "client";
+    }>;
+    function: z.ZodNullable<z.ZodString>;
+    version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        succeeded: "succeeded";
+    }>;
+    unavailable: z.ZodBoolean;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    message: z.ZodNullable<z.ZodString>;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        stack: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    console: z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            log: "log";
+            info: "info";
+            warn: "warn";
+            debug: "debug";
+        }>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        durationMs: z.ZodNumber;
+        code: z.ZodNullable<z.ZodEnum<{
+            not_found: "not_found";
+            invalid: "invalid";
+            conflict: "conflict";
+            unauthenticated: "unauthenticated";
+            unavailable: "unavailable";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GadgetCallEntry = z.infer<typeof GadgetCallEntry>;