experimental-agent 0.2.1 → 0.3.0

package/dist/lifecycle-workflow.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,887 +27,142 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/sandbox/bindings/vercel-sdk.ts
-var vercel_sdk_exports = {};
-__export(vercel_sdk_exports, {
-  Sandbox: () => import_sandbox.Sandbox
-});
-var import_sandbox;
-var init_vercel_sdk = __esm({
-  "src/sandbox/bindings/vercel-sdk.ts"() {
-    "use strict";
-    import_sandbox = require("@vercel/sandbox");
-  }
-});
-
-// src/errors.ts
-var errore, SessionNotFoundError, SessionError, SandboxNotFoundError, StorageError, StorageConflictError, SandboxError, MessageNotFoundError;
-var init_errors = __esm({
-  "src/errors.ts"() {
-    "use strict";
-    errore = __toESM(require("errore"));
-    SessionNotFoundError = class extends errore.createTaggedError({
-      name: "SessionNotFoundError",
-      message: "Session $id not found"
-    }) {
-    };
-    SessionError = class extends errore.createTaggedError({
-      name: "SessionError",
-      message: "Session $id failed: $reason"
-    }) {
-    };
-    SandboxNotFoundError = class extends errore.createTaggedError({
-      name: "SandboxNotFoundError",
-      message: "Sandbox $id not found"
-    }) {
-    };
-    StorageError = class extends errore.createTaggedError({
-      name: "StorageError",
-      message: "$reason"
-    }) {
-    };
-    StorageConflictError = class extends errore.createTaggedError({
-      name: "StorageConflictError",
-      message: "$reason"
-    }) {
-    };
-    SandboxError = class extends errore.createTaggedError({
-      name: "SandboxError",
-      message: "$reason"
-    }) {
-    };
-    MessageNotFoundError = class extends errore.createTaggedError({
-      name: "MessageNotFoundError",
-      message: "Message $id not found"
-    }) {
-    };
-  }
+// src/sandbox/bindings/vercel-lifecycle/workflow.ts
+var workflow_exports = {};
+__export(workflow_exports, {
+  sandboxLifecycleWorkflow: () => sandboxLifecycleWorkflow
 });
+module.exports = __toCommonJS(workflow_exports);
+var import_workflow = require("workflow");
 
-// src/storage/client.ts
-function getStorageClient(rpcFn, name) {
-  async function rpc(method, params) {
-    const result = await rpcFn({ name, method, params });
-    if ("error" in result) {
-      if (result.error.code === "CONFLICT") {
-        throw new StorageConflictError({ reason: result.error.message });
-      }
-      throw new StorageError({
-        reason: `[${result.error.code}] ${result.error.message}`
-      });
-    }
-    return result.result;
-  }
-  return {
-    session: {
-      get: async (id) => {
-        try {
-          const result = await rpc("session.get", { id });
-          if (result === null) {
-            return new SessionNotFoundError({ id });
-          }
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (session) => {
-        try {
-          return await rpc("session.set", session);
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      update: async (opts) => {
-        try {
-          return await rpc("session.update", opts);
-        } catch (e) {
-          if (e instanceof StorageConflictError) {
-            return e;
-          }
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      delete: async (id) => {
-        try {
-          await rpc("session.delete", { id });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      list: async (opts) => {
-        try {
-          return await rpc("session.list", {
-            tags: opts?.tags,
-            order: opts?.order,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      listBySandbox: async (opts) => {
-        try {
-          return await rpc("session.listBySandbox", {
-            sandboxId: opts.sandboxId,
-            tags: opts.tags,
-            order: opts.order,
-            cursor: opts.cursor,
-            limit: opts.limit
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      tag: {
-        set: async ({ sessionId, tags }) => {
-          try {
-            return await rpc("session.tag.set", { sessionId, tags });
-          } catch (e) {
-            if (e instanceof StorageError) {
-              return e;
-            }
-            return new StorageError({ reason: String(e), cause: e });
-          }
-        }
-      }
-    },
-    message: {
-      list: async (sessionId, opts) => {
-        try {
-          return await rpc("message.list", {
-            sessionId,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      get: async (id) => {
-        try {
-          const result = await rpc("message.get", { id });
-          if (result === null) {
-            return new MessageNotFoundError({ id });
-          }
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (message) => {
-        try {
-          return await rpc("message.set", message);
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      }
-    },
-    part: {
-      listByMessage: async (messageId, opts) => {
-        try {
-          const result = await rpc("part.listByMessage", {
-            messageId,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      listBySession: async (sessionId, opts) => {
-        try {
-          const result = await rpc("part.listBySession", {
-            sessionId,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (part) => {
-        try {
-          return await rpc("part.set", part);
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      delete: async (id) => {
-        try {
-          await rpc("part.delete", { id });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      }
-    },
-    sandbox: {
-      get: async (key) => {
-        try {
-          const result = await rpc("sandbox.get", { key });
-          if (result === null) {
-            return new SandboxNotFoundError({ id: key });
-          }
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      getBySession: async (sessionId) => {
-        try {
-          const result = await rpc("sandbox.getBySession", { sessionId });
-          if (result === null) {
-            return new SandboxNotFoundError({ id: sessionId });
-          }
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (record) => {
-        try {
-          await rpc("sandbox.set", record);
-          return record;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      update: async (opts) => {
-        try {
-          return await rpc("sandbox.update", opts);
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      list: async (opts) => {
-        try {
-          return await rpc("sandbox.list", {
-            tags: opts?.tags,
-            order: opts?.order,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      tag: {
-        set: async ({ sandboxId, tags }) => {
-          try {
-            return await rpc("sandbox.tag.set", { sandboxId, tags });
-          } catch (e) {
-            if (e instanceof StorageError) {
-              return e;
-            }
-            return new StorageError({ reason: String(e), cause: e });
-          }
-        }
-      },
-      acquireLock: async (record, lockTimeoutMs) => {
-        try {
-          return await rpc("sandbox.acquireLock", {
-            record,
-            lockTimeoutMs
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      }
-    },
-    setup: {
-      get: async (key) => {
-        try {
-          return await rpc("setup.get", { key });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (snapshot) => {
-        try {
-          await rpc("setup.set", snapshot);
-          return snapshot;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      delete: async (key) => {
-        try {
-          await rpc("setup.delete", { key });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      acquireLock: async (key, lockId, lockTimeoutMs) => {
-        try {
-          return await rpc("setup.acquireLock", {
-            key,
-            lockId,
-            lockTimeoutMs
-          });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      }
-    },
-    command: {
-      get: async (id) => {
-        try {
-          return await rpc("command.get", { id });
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      set: async (command) => {
-        try {
-          return await rpc("command.set", command);
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      },
-      list: async (sessionId, opts) => {
-        try {
-          const result = await rpc("command.list", {
-            sessionId,
-            includeFinished: opts?.includeFinished,
-            cursor: opts?.cursor,
-            limit: opts?.limit
-          });
-          return result;
-        } catch (e) {
-          if (e instanceof StorageError) {
-            return e;
-          }
-          return new StorageError({ reason: String(e), cause: e });
-        }
-      }
-    }
-  };
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  info: 0,
+  warn: 1,
+  error: 2,
+  silent: 3
+};
+function getLevel(config) {
+  return config.level ?? "warn";
+}
+function getPrefix(config) {
+  return config.prefix ?? "agent";
 }
-function getStorage(opts) {
-  const name = opts.config.name ?? DEFAULT_NAMESPACE;
-  return getStorageClient(opts.rpc, name);
+function shouldLog(config, level) {
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[getLevel(config)];
 }
-var DEFAULT_NAMESPACE, LOCAL_STORAGE_VERSION;
-var init_client = __esm({
-  "src/storage/client.ts"() {
-    "use strict";
-    init_errors();
-    DEFAULT_NAMESPACE = "default";
-    LOCAL_STORAGE_VERSION = "v1";
+function formatTag(config, subsystem) {
+  return `[${getPrefix(config)}:${config.name}:${subsystem}]`;
+}
+function formatData(context, extra) {
+  const merged = { ...context, ...extra };
+  const entries = Object.entries(merged).filter(
+    ([, v]) => v !== void 0 && v !== null
+  );
+  if (entries.length === 0) {
+    return void 0;
   }
-});
-
-// src/storage/rpc.ts
-function ListResultSchema(itemSchema) {
-  return import_zod.z.object({
-    items: import_zod.z.array(itemSchema),
-    nextCursor: import_zod.z.string().nullable()
-  });
+  return Object.fromEntries(entries);
 }
-var import_zod, VercelLifecycleConfigSchema, NetworkPolicySchema, SandboxConfigBase, SandboxConfigSchema, GenerationSchema, SessionSchema, StepUsageSchema, UsageSummarySchema, MessageUsageSchema, InterruptedLastPartSchema, MessageSchema, PartSchema, CommandResultSchema, SandboxRecordSchema, SessionUpdateSchema, SandboxUpdateSchema, CommandBaseSchema, CommandSchema, SetupSnapshotSchema, methods, STORAGE_RPC_METHODS;
-var init_rpc = __esm({
-  "src/storage/rpc.ts"() {
-    "use strict";
-    import_zod = require("zod");
-    VercelLifecycleConfigSchema = import_zod.z.object({
-      pollIntervalMs: import_zod.z.number().optional(),
-      stopAfterInactiveMs: import_zod.z.number().optional(),
-      snapshotBeforeTimeoutMs: import_zod.z.number().optional(),
-      snapshotId: import_zod.z.string().optional(),
-      autoStart: import_zod.z.boolean().optional()
-    });
-    NetworkPolicySchema = import_zod.z.custom().optional();
-    SandboxConfigBase = import_zod.z.object({
-      cwd: import_zod.z.string().optional()
-    });
-    SandboxConfigSchema = import_zod.z.discriminatedUnion("type", [
-      SandboxConfigBase.extend({
-        type: import_zod.z.literal("vercel"),
-        resources: import_zod.z.object({ vcpus: import_zod.z.number() }).optional(),
-        ports: import_zod.z.array(import_zod.z.number()).optional(),
-        lifecycle: VercelLifecycleConfigSchema.optional(),
-        networkPolicy: NetworkPolicySchema
-      }),
-      SandboxConfigBase.extend({
-        type: import_zod.z.literal("local")
-      }),
-      SandboxConfigBase.extend({
-        type: import_zod.z.literal("docker")
-      }),
-      SandboxConfigBase.extend({
-        type: import_zod.z.literal("custom"),
-        url: import_zod.z.string(),
-        headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
-      })
-    ]);
-    GenerationSchema = import_zod.z.object({
-      maxSteps: import_zod.z.number().optional(),
-      temperature: import_zod.z.number().optional(),
-      topK: import_zod.z.number().optional(),
-      topP: import_zod.z.number().optional(),
-      frequencyPenalty: import_zod.z.number().optional(),
-      presencePenalty: import_zod.z.number().optional(),
-      maxOutputTokens: import_zod.z.number().optional(),
-      headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
-    });
-    SessionSchema = import_zod.z.object({
-      id: import_zod.z.string(),
-      createdAt: import_zod.z.number(),
-      updatedAt: import_zod.z.number(),
-      runId: import_zod.z.string().nullable(),
-      lastMessageId: import_zod.z.string().nullable(),
-      tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullable(),
-      system: import_zod.z.string().nullable(),
-      model: import_zod.z.string().nullable(),
-      sandboxId: import_zod.z.string().nullable(),
-      skillsDir: import_zod.z.array(import_zod.z.string()).nullable(),
-      hookToken: import_zod.z.string().nullable(),
-      activeTools: import_zod.z.array(import_zod.z.string()).nullable(),
-      generation: GenerationSchema.nullable().default(null)
-    });
-    StepUsageSchema = import_zod.z.object({
-      stepIndex: import_zod.z.number(),
-      model: import_zod.z.string(),
-      inputTokens: import_zod.z.number(),
-      outputTokens: import_zod.z.number(),
-      totalTokens: import_zod.z.number(),
-      cacheReadTokens: import_zod.z.number(),
-      cacheWriteTokens: import_zod.z.number(),
-      reasoningTokens: import_zod.z.number()
-    });
-    UsageSummarySchema = import_zod.z.object({
-      model: import_zod.z.string(),
-      inputTokens: import_zod.z.number(),
-      outputTokens: import_zod.z.number(),
-      totalTokens: import_zod.z.number(),
-      cacheReadTokens: import_zod.z.number(),
-      cacheWriteTokens: import_zod.z.number(),
-      reasoningTokens: import_zod.z.number(),
-      stepCount: import_zod.z.number()
-    });
-    MessageUsageSchema = import_zod.z.object({
-      steps: import_zod.z.array(StepUsageSchema),
-      summary: UsageSummarySchema
-    });
-    InterruptedLastPartSchema = import_zod.z.object({
-      index: import_zod.z.number(),
-      part: import_zod.z.unknown()
-    });
-    MessageSchema = import_zod.z.object({
-      id: import_zod.z.string(),
-      sessionId: import_zod.z.string(),
-      role: import_zod.z.enum(["user", "assistant", "system"]),
-      createdAt: import_zod.z.number(),
-      startedAt: import_zod.z.number().nullable(),
-      completedAt: import_zod.z.number().nullable(),
-      interruptedAt: import_zod.z.number().nullable(),
-      interruptedLastPart: InterruptedLastPartSchema.nullable().default(null),
-      usage: MessageUsageSchema.nullable()
-    });
-    PartSchema = import_zod.z.object({
-      id: import_zod.z.string(),
-      messageId: import_zod.z.string(),
-      sessionId: import_zod.z.string(),
-      index: import_zod.z.number(),
-      part: import_zod.z.unknown()
-    });
-    CommandResultSchema = import_zod.z.object({
-      stdout: import_zod.z.string(),
-      stderr: import_zod.z.string(),
-      exitCode: import_zod.z.number(),
-      completedAt: import_zod.z.number()
-    });
-    SandboxRecordSchema = import_zod.z.object({
-      id: import_zod.z.string(),
-      config: SandboxConfigSchema,
-      tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullable(),
-      createdAt: import_zod.z.number().nullable(),
-      lastActivityAt: import_zod.z.number().nullable(),
-      acquiringLockId: import_zod.z.string().nullable(),
-      acquiringLockAt: import_zod.z.number().nullable(),
-      setupKey: import_zod.z.string().nullable().optional(),
-      setupCompletedAt: import_zod.z.number().nullable().optional(),
-      providerMetadata: import_zod.z.discriminatedUnion("provider", [
-        import_zod.z.object({
-          provider: import_zod.z.literal("vercel"),
-          sandboxId: import_zod.z.string().nullable(),
-          snapshotId: import_zod.z.string().nullable()
-        })
-      ]).optional()
-    });
-    SessionUpdateSchema = SessionSchema.omit({
-      id: true,
-      generation: true
-    }).partial().extend({
-      id: SessionSchema.shape.id,
-      generation: GenerationSchema.nullable().optional()
-    }).strict();
-    SandboxUpdateSchema = SandboxRecordSchema.omit({ id: true }).partial().extend({
-      id: SandboxRecordSchema.shape.id
-    }).strict();
-    CommandBaseSchema = import_zod.z.object({
-      id: import_zod.z.string(),
-      sessionId: import_zod.z.string(),
-      command: import_zod.z.string(),
-      args: import_zod.z.array(import_zod.z.string()).optional(),
-      startedAt: import_zod.z.number()
+var Logger = class _Logger {
+  subsystem;
+  config;
+  context;
+  constructor({
+    subsystem,
+    config,
+    context
+  }) {
+    this.subsystem = subsystem;
+    this.config = config;
+    this.context = context ?? {};
+  }
+  child({
+    subsystem,
+    context
+  }) {
+    return new _Logger({
+      config: this.config,
+      subsystem: subsystem ? `${this.subsystem}:${subsystem}` : this.subsystem,
+      context: { ...this.context, ...context }
     });
-    CommandSchema = import_zod.z.discriminatedUnion("status", [
-      CommandBaseSchema.extend({ status: import_zod.z.literal("running") }),
-      CommandBaseSchema.extend({
-        status: import_zod.z.literal("completed"),
-        result: CommandResultSchema
-      }),
-      CommandBaseSchema.extend({
-        status: import_zod.z.literal("killed"),
-        result: CommandResultSchema.optional()
-      }),
-      CommandBaseSchema.extend({
-        status: import_zod.z.literal("failed"),
-        result: CommandResultSchema
-      })
-    ]);
-    SetupSnapshotSchema = import_zod.z.object({
-      key: import_zod.z.string(),
-      snapshotId: import_zod.z.string().nullable(),
-      createdAt: import_zod.z.number(),
-      lastUsedAt: import_zod.z.number().nullable(),
-      acquiringLockId: import_zod.z.string().nullable(),
-      acquiringLockAt: import_zod.z.number().nullable()
+  }
+  withContext(context) {
+    return new _Logger({
+      config: this.config,
+      subsystem: this.subsystem,
+      context: { ...this.context, ...context }
     });
-    methods = {
-      "session.get": {
-        params: import_zod.z.object({ id: import_zod.z.string() }),
-        result: SessionSchema.nullable()
-      },
-      "session.set": {
-        params: SessionSchema,
-        result: SessionSchema
-      },
-      "session.update": {
-        params: SessionUpdateSchema,
-        result: SessionSchema
-      },
-      "session.list": {
-        params: import_zod.z.object({
-          tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-          order: import_zod.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "updatedAt_asc",
-            "updatedAt_desc"
-          ]).optional(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(SessionSchema)
-      },
-      "session.listBySandbox": {
-        params: import_zod.z.object({
-          sandboxId: import_zod.z.string(),
-          tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-          order: import_zod.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "updatedAt_asc",
-            "updatedAt_desc"
-          ]).optional(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(SessionSchema)
-      },
-      "session.delete": {
-        params: import_zod.z.object({ id: import_zod.z.string() }),
-        result: import_zod.z.void()
-      },
-      "session.tag.set": {
-        params: import_zod.z.object({
-          sessionId: import_zod.z.string(),
-          tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
-        }),
-        result: SessionSchema
-      },
-      "message.get": {
-        params: import_zod.z.object({ id: import_zod.z.string() }),
-        result: MessageSchema.nullable()
-      },
-      "message.set": {
-        params: MessageSchema,
-        result: MessageSchema
-      },
-      "message.list": {
-        params: import_zod.z.object({
-          sessionId: import_zod.z.string(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(MessageSchema)
-      },
-      "part.listByMessage": {
-        params: import_zod.z.object({
-          messageId: import_zod.z.string(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(PartSchema)
-      },
-      "part.listBySession": {
-        params: import_zod.z.object({
-          sessionId: import_zod.z.string(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(PartSchema)
-      },
-      "part.set": {
-        params: PartSchema,
-        result: PartSchema
-      },
-      "part.delete": {
-        params: import_zod.z.object({ id: import_zod.z.string() }),
-        result: import_zod.z.void()
-      },
-      "sandbox.get": {
-        params: import_zod.z.object({ key: import_zod.z.string() }),
-        result: SandboxRecordSchema.nullable()
-      },
-      "sandbox.getBySession": {
-        params: import_zod.z.object({ sessionId: import_zod.z.string() }),
-        result: SandboxRecordSchema.nullable()
-      },
-      "sandbox.set": {
-        params: SandboxRecordSchema,
-        result: import_zod.z.void()
-      },
-      "sandbox.update": {
-        params: SandboxUpdateSchema,
-        result: SandboxRecordSchema
-      },
-      "sandbox.list": {
-        params: import_zod.z.object({
-          tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-          order: import_zod.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "lastActivityAt_asc",
-            "lastActivityAt_desc"
-          ]).optional(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(SandboxRecordSchema)
-      },
-      "sandbox.tag.set": {
-        params: import_zod.z.object({
-          sandboxId: import_zod.z.string(),
-          tags: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
-        }),
-        result: SandboxRecordSchema
-      },
-      "command.get": {
-        params: import_zod.z.object({ id: import_zod.z.string() }),
-        result: CommandSchema.nullable()
-      },
-      "command.set": {
-        params: CommandSchema,
-        result: CommandSchema
-      },
-      "command.list": {
-        params: import_zod.z.object({
-          sessionId: import_zod.z.string(),
-          includeFinished: import_zod.z.boolean().optional(),
-          cursor: import_zod.z.string().optional(),
-          limit: import_zod.z.number().optional()
-        }),
-        result: ListResultSchema(CommandSchema)
-      },
-      "setup.get": {
-        params: import_zod.z.object({ key: import_zod.z.string() }),
-        result: SetupSnapshotSchema.nullable()
-      },
-      "setup.set": {
-        params: SetupSnapshotSchema,
-        result: import_zod.z.void()
-      },
-      "setup.delete": {
-        params: import_zod.z.object({ key: import_zod.z.string() }),
-        result: import_zod.z.void()
-      },
-      "setup.acquireLock": {
-        params: import_zod.z.object({
-          key: import_zod.z.string(),
-          lockId: import_zod.z.string(),
-          lockTimeoutMs: import_zod.z.number()
-        }),
-        result: SetupSnapshotSchema.nullable()
-      },
-      "sandbox.acquireLock": {
-        params: import_zod.z.object({
-          record: SandboxRecordSchema,
-          lockTimeoutMs: import_zod.z.number()
-        }),
-        result: SandboxRecordSchema.nullable()
-      }
-    };
-    STORAGE_RPC_METHODS = Object.keys(methods);
   }
-});
-
-// src/storage/handler.ts
-async function handleStorageRpc(body, handlers) {
-  const { method, params } = body;
-  if (!(method in methods)) {
-    return {
-      error: { code: "METHOD_NOT_FOUND", message: `Unknown method: ${method}` }
-    };
+  info(message, data) {
+    if (!shouldLog(this.config, "info")) {
+      return;
+    }
+    const d = formatData(this.context, data);
+    if (d) {
+      console.info(formatTag(this.config, this.subsystem), message, d);
+    } else {
+      console.info(formatTag(this.config, this.subsystem), message);
+    }
   }
-  const methodName = method;
-  const schema = methods[methodName].params;
-  const parsed = schema.safeParse(params);
-  if (!parsed.success) {
-    return {
-      error: {
-        code: "INVALID_PARAMS",
-        message: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")
-      }
-    };
+  warn(message, data) {
+    if (!shouldLog(this.config, "warn")) {
+      return;
+    }
+    const d = formatData(this.context, data);
+    if (d) {
+      console.warn(formatTag(this.config, this.subsystem), message, d);
+    } else {
+      console.warn(formatTag(this.config, this.subsystem), message);
+    }
   }
-  try {
-    const handler = handlers[methodName];
-    const result = await handler(parsed.data);
-    return { result };
-  } catch (e) {
-    const isConflict = e instanceof StorageConflictError || e instanceof Error && e.name === "StorageConflictError";
-    if (isConflict) {
-      return {
-        error: {
-          code: "CONFLICT",
-          message: e instanceof Error ? e.message : String(e)
-        }
-      };
+  error(message, data) {
+    if (!shouldLog(this.config, "error")) {
+      return;
     }
-    return {
-      error: {
-        code: "INTERNAL_ERROR",
-        message: e instanceof Error ? e.message : String(e)
-      }
+    const d = formatData(this.context, data);
+    if (d) {
+      console.error(formatTag(this.config, this.subsystem), message, d);
+    } else {
+      console.error(formatTag(this.config, this.subsystem), message);
+    }
+  }
+  /**
+   * Returns a function that, when called, logs the elapsed time at info level.
+   * Pass `logOnStart: true` to also log when the timer begins.
+   *
+   * @example
+   * const done = log.time("sandbox setup", { sandboxId }, { logOnStart: true });
+   * await setup();
+   * done(); // start: [agent:default:sandbox] sandbox setup { sandboxId: '...' }
+   *         // end:   [agent:default:sandbox] sandbox setup { sandboxId: '...', durationMs: 123 }
+   */
+  time(message, data, opts) {
+    if (opts?.logOnStart) {
+      this.info(`[start] ${message}`, data);
+    }
+    const t0 = Date.now();
+    return (endData) => {
+      this.info(opts?.logOnStart ? `[end] ${message}` : message, {
+        ...data,
+        ...endData,
+        durationMs: Date.now() - t0
+      });
     };
   }
+};
+function createLogger({
+  config,
+  subsystem,
+  context
+}) {
+  return new Logger({ config, subsystem, context });
 }
-var init_handler = __esm({
-  "src/storage/handler.ts"() {
-    "use strict";
-    init_errors();
-    init_rpc();
-  }
-});
-
-// src/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  DEFAULT_NAMESPACE: () => DEFAULT_NAMESPACE,
-  LOCAL_STORAGE_VERSION: () => LOCAL_STORAGE_VERSION,
-  STORAGE_RPC_METHODS: () => STORAGE_RPC_METHODS,
-  getStorage: () => getStorage,
-  handleStorageRpc: () => handleStorageRpc
-});
-var init_storage = __esm({
-  "src/storage/index.ts"() {
-    "use strict";
-    init_client();
-    init_handler();
-    init_rpc();
-  }
-});
 
-// src/sandbox/bindings/lifecycle-workflow.ts
-var lifecycle_workflow_exports = {};
-__export(lifecycle_workflow_exports, {
-  sandboxLifecycleWorkflow: () => sandboxLifecycleWorkflow
-});
-module.exports = __toCommonJS(lifecycle_workflow_exports);
-var import_workflow = require("workflow");
-
-// src/sandbox/bindings/lifecycle-workflow-steps.ts
+// src/sandbox/bindings/vercel-lifecycle/steps.ts
+async function loadSandboxSDK() {
+  return (await import("@vercel/sandbox")).Sandbox;
+}
 var DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1e3;
 var DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
 var SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -921,40 +173,44 @@ var getTestCredentials = () => process.env.NODE_ENV === "test" ? {
 } : {};
 async function checkAndSnapshotStep(input) {
   "use step";
-  const { Sandbox: VercelSandboxSDK } = await Promise.resolve().then(() => (init_vercel_sdk(), vercel_sdk_exports));
-  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
-  if (!input.rpc) {
-    throw new Error("RPC not found");
-  }
-  const storage = getStorage2({
-    config: input.storageConfig,
-    rpc: input.rpc
+  const storage = input.agent.storage;
+  const log = createLogger({
+    config: { ...input.agent.options.logging, name: input.agent.name },
+    subsystem: "sandbox:lifecycle",
+    context: { sandboxId: input.sandboxId }
+  });
+  log.info("lifecycle check started", {
+    vercelSandboxId: input.vercelSandboxId
   });
-  const record = await storage.sandbox.get(input.id);
-  if (record instanceof Error) {
+  const record = await storage.sandbox.get(input.sandboxId);
+  if (!record) {
+    log.warn("sandbox record not found, exiting lifecycle");
     return { action: "exit", reason: "not_found" };
   }
-  const currentSandboxId = record.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+  const metadata = record.setup?.metadata;
+  const currentSandboxId = metadata?.sandboxId ?? null;
   if (currentSandboxId !== input.vercelSandboxId) {
+    log.info("sandbox ID changed, exiting lifecycle", {
+      expected: input.vercelSandboxId,
+      actual: currentSandboxId
+    });
     return { action: "exit", reason: "sandboxId_changed" };
   }
   if (!currentSandboxId) {
+    log.warn("no current sandbox ID in metadata, exiting lifecycle");
     return { action: "exit", reason: "not_found" };
   }
-  const config = record.config;
-  if (config.type !== "vercel") {
-    return { action: "exit", reason: "not_found" };
-  }
-  const pollIntervalMs = config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const idleTimeoutMs = config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-  const snapshotBeforeTimeoutMs = config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;
+  const pollIntervalMs = input.config?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const idleTimeoutMs = input.config?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const snapshotBeforeTimeoutMs = input.config?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;
   const now = Date.now();
-  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;
+  const lastActivity = record.lastActiveAt ?? record.createdAt ?? now;
   const idleDuration = now - lastActivity;
   const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
   let shouldSnapshotDueToTimeout = false;
   try {
-    const sandbox = await VercelSandboxSDK.get({
+    const SandboxSDK = await loadSandboxSDK();
+    const sandbox = await SandboxSDK.get({
       sandboxId: currentSandboxId,
       ...getTestCredentials()
     });
@@ -962,47 +218,78 @@ async function checkAndSnapshotStep(input) {
       shouldSnapshotDueToTimeout = true;
     }
   } catch {
+    log.warn("failed to get sandbox from SDK, exiting lifecycle", {
+      vercelSandboxId: currentSandboxId
+    });
     return { action: "exit", reason: "not_found" };
   }
   if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {
+    const reason = shouldSnapshotDueToIdle ? "idle" : "timeout";
+    log.info("snapshotting sandbox before exit", {
+      reason,
+      idleDurationMs: idleDuration,
+      vercelSandboxId: currentSandboxId
+    });
     try {
-      const sandbox = await VercelSandboxSDK.get({
+      const SandboxSDK = await loadSandboxSDK();
+      const sandbox = await SandboxSDK.get({
         sandboxId: currentSandboxId,
         ...getTestCredentials()
       });
       const snapshot = await sandbox.snapshot();
-      await storage.sandbox.update({
-        id: record.id,
-        acquiringLockId: null,
-        acquiringLockAt: null,
-        providerMetadata: {
-          provider: "vercel",
-          sandboxId: null,
-          snapshotId: snapshot.snapshotId
+      log.info("snapshot created", { snapshotId: snapshot.snapshotId });
+      await storage.sandbox.update(input.sandboxId, {
+        setup: {
+          ...record.setup,
+          metadata: { sandboxId: null, snapshotId: snapshot.snapshotId }
         }
       });
+      log.info("sandbox record updated with snapshot");
     } catch (e) {
+      log.error("failed to snapshot sandbox", { cause: e });
       return e instanceof Error ? e : new Error(String(e));
     }
-    return {
-      action: "exit",
-      reason: shouldSnapshotDueToIdle ? "idle" : "timeout"
-    };
+    return { action: "exit", reason };
   }
+  log.info("sandbox still active, continuing lifecycle", {
+    idleDurationMs: idleDuration,
+    nextPollMs: pollIntervalMs
+  });
   return { action: "continue", nextPollMs: pollIntervalMs };
 }
 
-// src/sandbox/bindings/lifecycle-workflow.ts
+// src/sandbox/bindings/vercel-lifecycle/workflow.ts
 var DEFAULT_POLL_MS = 2 * 60 * 1e3;
 async function sandboxLifecycleWorkflow({
   input
 }) {
   "use workflow";
-  let nextPollMs = DEFAULT_POLL_MS;
+  let nextPollMs = input.config?.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const log = createLogger({
+    config: { ...input.agent.options.logging, name: input.agent.name },
+    subsystem: "sandbox:lifecycle",
+    context: { sandboxId: input.sandboxId }
+  });
+  log.info("lifecycle workflow started", {
+    sandboxId: input.sandboxId,
+    vercelSandboxId: input.vercelSandboxId,
+    pollMs: nextPollMs
+  });
   while (true) {
     await (0, import_workflow.sleep)(nextPollMs);
     const result = await checkAndSnapshotStep(input);
-    if (result instanceof Error || result.action === "exit") {
+    if (result instanceof Error) {
+      log.error("lifecycle step failed", {
+        sandboxId: input.sandboxId,
+        error: result.message
+      });
+      break;
+    }
+    if (result.action === "exit") {
+      log.info("lifecycle workflow exiting", {
+        sandboxId: input.sandboxId,
+        reason: result.reason
+      });
       break;
     }
     nextPollMs = result.nextPollMs;
@@ -1012,4 +299,4 @@ async function sandboxLifecycleWorkflow({
 0 && (module.exports = {
   sandboxLifecycleWorkflow
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/vercel-sdk.ts", "../src/errors.ts", "../src/storage/client.ts", "../src/storage/rpc.ts", "../src/storage/handler.ts", "../src/storage/index.ts", "../src/sandbox/bindings/lifecycle-workflow.ts", "../src/sandbox/bindings/lifecycle-workflow-steps.ts"],
  "sourcesContent": ["export { Sandbox } from \"@vercel/sandbox\";\n", "import * as errore from \"errore\";\n\nexport class SessionNotFoundError extends errore.createTaggedError({\n  name: \"SessionNotFoundError\",\n  message: \"Session $id not found\",\n}) {}\n\nexport class SessionError extends errore.createTaggedError({\n  name: \"SessionError\",\n  message: \"Session $id failed: $reason\",\n}) {}\n\nexport class SandboxNotFoundError extends errore.createTaggedError({\n  name: \"SandboxNotFoundError\",\n  message: \"Sandbox $id not found\",\n}) {}\n\nexport class StorageError extends errore.createTaggedError({\n  name: \"StorageError\",\n  message: \"$reason\",\n}) {}\n\nexport class StorageConflictError extends errore.createTaggedError({\n  name: \"StorageConflictError\",\n  message: \"$reason\",\n}) {}\n\nexport class SandboxError extends errore.createTaggedError({\n  name: \"SandboxError\",\n  message: \"$reason\",\n}) {}\n\nexport class MessageNotFoundError extends errore.createTaggedError({\n  name: \"MessageNotFoundError\",\n  message: \"Message $id not found\",\n}) {}\n", "import type { z } from \"zod\";\nimport {\n  MessageNotFoundError,\n  SandboxNotFoundError,\n  SessionNotFoundError,\n  StorageConflictError,\n  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  SetupSnapshot,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport type RpcFn = (params: {\n  name?: string;\n  method: string;\n  params: unknown;\n  _quiet?: boolean;\n}) => Promise<RpcResponse<unknown>>;\n\nexport function getStorageClient(rpcFn: RpcFn, name?: string): Storage {\n  async function rpc<M extends keyof StorageMethods>(\n    method: M,\n    params: z.infer<StorageMethods[M][\"params\"]>\n  ): Promise<z.infer<StorageMethods[M][\"result\"]>> {\n    const result = await rpcFn({ name, method, params });\n\n    if (\"error\" in result) {\n      if (result.error.code === \"CONFLICT\") {\n        throw new StorageConflictError({ reason: result.error.message });\n      }\n      throw new StorageError({\n        reason: `[${result.error.code}] ${result.error.message}`,\n      });\n    }\n\n    return result.result as z.infer<StorageMethods[M][\"result\"]>;\n  }\n\n  return {\n    session: {\n      get: async (id) => {\n        try {\n          const result = await rpc(\"session.get\", { id });\n          if (result === null) {\n            return new SessionNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (session) => {\n        try {\n          return await rpc(\"session.set\", session);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      update: async (opts) => {\n        try {\n          return await rpc(\"session.update\", opts);\n        } catch (e) {\n          if (e instanceof StorageConflictError) {\n            return e;\n          }\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"session.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"session.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySandbox: async (opts) => {\n        try {\n          return await rpc(\"session.listBySandbox\", {\n            sandboxId: opts.sandboxId,\n            tags: opts.tags,\n            order: opts.order,\n            cursor: opts.cursor,\n            limit: opts.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sessionId, tags }) => {\n          try {\n            return await rpc(\"session.tag.set\", { sessionId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    message: {\n      list: async (sessionId, opts) => {\n        try {\n          return await rpc(\"message.list\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      get: async (id) => {\n        try {\n          const result = await rpc(\"message.get\", { id });\n          if (result === null) {\n            return new MessageNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (message) => {\n        try {\n          return await rpc(\"message.set\", message);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    part: {\n      listByMessage: async (messageId, opts) => {\n        try {\n          const result = await rpc(\"part.listByMessage\", {\n            messageId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySession: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"part.listBySession\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (part) => {\n        try {\n          return (await rpc(\"part.set\", part)) as Part;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"part.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    sandbox: {\n      get: async (key) => {\n        try {\n          const result = await rpc(\"sandbox.get\", { key });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: key });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      getBySession: async (sessionId) => {\n        try {\n          const result = await rpc(\"sandbox.getBySession\", { sessionId });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: sessionId });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (record) => {\n        try {\n          await rpc(\"sandbox.set\", record);\n          return record;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      update: async (opts) => {\n        try {\n          return await rpc(\"sandbox.update\", opts);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"sandbox.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sandboxId, tags }) => {\n          try {\n            return await rpc(\"sandbox.tag.set\", { sandboxId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n      acquireLock: async (record, lockTimeoutMs) => {\n        try {\n          return (await rpc(\"sandbox.acquireLock\", {\n            record,\n            lockTimeoutMs,\n          })) as import(\"./types\").SandboxRecord | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    setup: {\n      get: async (key) => {\n        try {\n          return (await rpc(\"setup.get\", { key })) as SetupSnapshot | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (snapshot) => {\n        try {\n          await rpc(\"setup.set\", snapshot);\n          return snapshot;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (key) => {\n        try {\n          await rpc(\"setup.delete\", { key });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      acquireLock: async (key, lockId, lockTimeoutMs) => {\n        try {\n          return (await rpc(\"setup.acquireLock\", {\n            key,\n            lockId,\n            lockTimeoutMs,\n          })) as SetupSnapshot | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    command: {\n      get: async (id) => {\n        try {\n          return (await rpc(\"command.get\", { id })) as Command | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (command) => {\n        try {\n          return (await rpc(\"command.set\", command)) as Command;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"command.list\", {\n            sessionId,\n            includeFinished: opts?.includeFinished,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Command>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n  };\n}\n\nexport const DEFAULT_NAMESPACE = \"default\";\nexport const LOCAL_STORAGE_VERSION = \"v1\";\n\nexport function getStorage(opts: {\n  config: StorageConfig;\n  rpc: RpcFn;\n}): Storage {\n  const name = opts.config.name ?? DEFAULT_NAMESPACE;\n  return getStorageClient(opts.rpc, name);\n}\n", "import { z } from \"zod\";\n\nconst VercelLifecycleConfigSchema = z.object({\n  pollIntervalMs: z.number().optional(),\n  stopAfterInactiveMs: z.number().optional(),\n  snapshotBeforeTimeoutMs: z.number().optional(),\n  snapshotId: z.string().optional(),\n  autoStart: z.boolean().optional(),\n});\n\nimport type { NetworkPolicy } from \"@vercel/sandbox\";\n\n/**\n * Passthrough schema \u2014 the SDK validates the actual shape.\n * Typed via z.custom so the inferred TS type matches the SDK's NetworkPolicy.\n */\nconst NetworkPolicySchema = z.custom<NetworkPolicy>().optional();\n\nexport type { NetworkPolicy };\n\nconst SandboxConfigBase = z.object({\n  cwd: z.string().optional(),\n});\n\nexport const SandboxConfigSchema = z.discriminatedUnion(\"type\", [\n  SandboxConfigBase.extend({\n    type: z.literal(\"vercel\"),\n    resources: z.object({ vcpus: z.number() }).optional(),\n    ports: z.array(z.number()).optional(),\n    lifecycle: VercelLifecycleConfigSchema.optional(),\n    networkPolicy: NetworkPolicySchema,\n  }),\n  SandboxConfigBase.extend({\n    type: z.literal(\"local\"),\n  }),\n  SandboxConfigBase.extend({\n    type: z.literal(\"docker\"),\n  }),\n  SandboxConfigBase.extend({\n    type: z.literal(\"custom\"),\n    url: z.string(),\n    headers: z.record(z.string(), z.string()).optional(),\n  }),\n]);\n\nexport type SandboxConfig = z.infer<typeof SandboxConfigSchema>;\n\nconst GenerationSchema = z.object({\n  maxSteps: z.number().optional(),\n  temperature: z.number().optional(),\n  topK: z.number().optional(),\n  topP: z.number().optional(),\n  frequencyPenalty: z.number().optional(),\n  presencePenalty: z.number().optional(),\n  maxOutputTokens: z.number().optional(),\n  headers: z.record(z.string(), z.string()).optional(),\n});\n\nexport const SessionSchema = z.object({\n  id: z.string(),\n  createdAt: z.number(),\n  updatedAt: z.number(),\n  runId: z.string().nullable(),\n  lastMessageId: z.string().nullable(),\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  system: z.string().nullable(),\n  model: z.string().nullable(),\n  sandboxId: z.string().nullable(),\n  skillsDir: z.array(z.string()).nullable(),\n  hookToken: z.string().nullable(),\n  activeTools: z.array(z.string()).nullable(),\n  generation: GenerationSchema.nullable().default(null),\n});\n\nexport const StepUsageSchema = z.object({\n  stepIndex: z.number(),\n  model: z.string(),\n  inputTokens: z.number(),\n  outputTokens: z.number(),\n  totalTokens: z.number(),\n  cacheReadTokens: z.number(),\n  cacheWriteTokens: z.number(),\n  reasoningTokens: z.number(),\n});\n\nexport const UsageSummarySchema = z.object({\n  model: z.string(),\n  inputTokens: z.number(),\n  outputTokens: z.number(),\n  totalTokens: z.number(),\n  cacheReadTokens: z.number(),\n  cacheWriteTokens: z.number(),\n  reasoningTokens: z.number(),\n  stepCount: z.number(),\n});\n\nexport const MessageUsageSchema = z.object({\n  steps: z.array(StepUsageSchema),\n  summary: UsageSummarySchema,\n});\n\nexport type MessageUsage = z.infer<typeof MessageUsageSchema>;\nexport type UsageSummary = z.infer<typeof UsageSummarySchema>;\nexport type StepUsage = z.infer<typeof StepUsageSchema>;\n\nexport const InterruptedLastPartSchema = z.object({\n  index: z.number(),\n  part: z.unknown(),\n});\n\nexport const MessageSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  role: z.enum([\"user\", \"assistant\", \"system\"]),\n  createdAt: z.number(),\n  startedAt: z.number().nullable(),\n  completedAt: z.number().nullable(),\n  interruptedAt: z.number().nullable(),\n  interruptedLastPart: InterruptedLastPartSchema.nullable().default(null),\n  usage: MessageUsageSchema.nullable(),\n});\n\n/**\n * The `part` field corresponds to `UIMessage[\"parts\"][number]` from the `ai` package.\n * We use `z.unknown()` because the exact shape varies by part type (text, tool-call,\n * tool-result, etc.) and may evolve with the AI SDK. The RPC layer just passes it through.\n */\nexport const PartSchema = z.object({\n  id: z.string(),\n  messageId: z.string(),\n  sessionId: z.string(),\n  index: z.number(),\n  part: z.unknown(),\n});\n\nexport const CommandResultSchema = z.object({\n  stdout: z.string(),\n  stderr: z.string(),\n  exitCode: z.number(),\n  completedAt: z.number(),\n});\n\nexport const SandboxRecordSchema = z.object({\n  id: z.string(),\n  config: SandboxConfigSchema,\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  createdAt: z.number().nullable(),\n  lastActivityAt: z.number().nullable(),\n  acquiringLockId: z.string().nullable(),\n  acquiringLockAt: z.number().nullable(),\n  setupKey: z.string().nullable().optional(),\n  setupCompletedAt: z.number().nullable().optional(),\n  providerMetadata: z\n    .discriminatedUnion(\"provider\", [\n      z.object({\n        provider: z.literal(\"vercel\"),\n        sandboxId: z.string().nullable(),\n        snapshotId: z.string().nullable(),\n      }),\n    ])\n    .optional(),\n});\n\nconst SessionUpdateSchema = SessionSchema.omit({\n  id: true,\n  generation: true,\n})\n  .partial()\n  .extend({\n    id: SessionSchema.shape.id,\n    generation: GenerationSchema.nullable().optional(),\n  })\n  .strict();\n\nconst SandboxUpdateSchema = SandboxRecordSchema.omit({ id: true })\n  .partial()\n  .extend({\n    id: SandboxRecordSchema.shape.id,\n  })\n  .strict();\n\nconst CommandBaseSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  command: z.string(),\n  args: z.array(z.string()).optional(),\n  startedAt: z.number(),\n});\n\nexport const CommandSchema = z.discriminatedUnion(\"status\", [\n  CommandBaseSchema.extend({ status: z.literal(\"running\") }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"completed\"),\n    result: CommandResultSchema,\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"killed\"),\n    result: CommandResultSchema.optional(),\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"failed\"),\n    result: CommandResultSchema,\n  }),\n]);\n\nfunction ListResultSchema<T extends z.ZodTypeAny>(itemSchema: T) {\n  return z.object({\n    items: z.array(itemSchema),\n    nextCursor: z.string().nullable(),\n  });\n}\n\nexport const SetupSnapshotSchema = z.object({\n  key: z.string(),\n  snapshotId: z.string().nullable(),\n  createdAt: z.number(),\n  lastUsedAt: z.number().nullable(),\n  acquiringLockId: z.string().nullable(),\n  acquiringLockAt: z.number().nullable(),\n});\n\nconst methods = {\n  \"session.get\": {\n    params: z.object({ id: z.string() }),\n    result: SessionSchema.nullable(),\n  },\n  \"session.set\": {\n    params: SessionSchema,\n    result: SessionSchema,\n  },\n  \"session.update\": {\n    params: SessionUpdateSchema,\n    result: SessionSchema,\n  },\n  \"session.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.listBySandbox\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.delete\": {\n    params: z.object({ id: z.string() }),\n    result: z.void(),\n  },\n  \"session.tag.set\": {\n    params: z.object({\n      sessionId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SessionSchema,\n  },\n  \"message.get\": {\n    params: z.object({ id: z.string() }),\n    result: MessageSchema.nullable(),\n  },\n  \"message.set\": {\n    params: MessageSchema,\n    result: MessageSchema,\n  },\n  \"message.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(MessageSchema),\n  },\n  \"part.listByMessage\": {\n    params: z.object({\n      messageId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.listBySession\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.set\": {\n    params: PartSchema,\n    result: PartSchema,\n  },\n  \"part.delete\": {\n    params: z.object({ id: z.string() }),\n    result: z.void(),\n  },\n  \"sandbox.get\": {\n    params: z.object({ key: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.getBySession\": {\n    params: z.object({ sessionId: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.set\": {\n    params: SandboxRecordSchema,\n    result: z.void(),\n  },\n  \"sandbox.update\": {\n    params: SandboxUpdateSchema,\n    result: SandboxRecordSchema,\n  },\n  \"sandbox.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"lastActivityAt_asc\",\n          \"lastActivityAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SandboxRecordSchema),\n  },\n  \"sandbox.tag.set\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SandboxRecordSchema,\n  },\n  \"command.get\": {\n    params: z.object({ id: z.string() }),\n    result: CommandSchema.nullable(),\n  },\n  \"command.set\": {\n    params: CommandSchema,\n    result: CommandSchema,\n  },\n  \"command.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      includeFinished: z.boolean().optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(CommandSchema),\n  },\n  \"setup.get\": {\n    params: z.object({ key: z.string() }),\n    result: SetupSnapshotSchema.nullable(),\n  },\n  \"setup.set\": {\n    params: SetupSnapshotSchema,\n    result: z.void(),\n  },\n  \"setup.delete\": {\n    params: z.object({ key: z.string() }),\n    result: z.void(),\n  },\n  \"setup.acquireLock\": {\n    params: z.object({\n      key: z.string(),\n      lockId: z.string(),\n      lockTimeoutMs: z.number(),\n    }),\n    result: SetupSnapshotSchema.nullable(),\n  },\n  \"sandbox.acquireLock\": {\n    params: z.object({\n      record: SandboxRecordSchema,\n      lockTimeoutMs: z.number(),\n    }),\n    result: SandboxRecordSchema.nullable(),\n  },\n} as const;\n\nexport { methods };\nexport type StorageMethods = typeof methods;\nexport type MethodName = keyof StorageMethods;\nexport const STORAGE_RPC_METHODS = Object.keys(methods) as MethodName[];\n", "import type { z } from \"zod\";\nimport { StorageConflictError } from \"../errors\";\nimport { type MethodName, methods, type StorageMethods } from \"./rpc\";\n\nexport type Handlers = {\n  [K in MethodName]: (\n    params: z.infer<StorageMethods[K][\"params\"]>\n  ) => Promise<z.infer<StorageMethods[K][\"result\"]>>;\n};\n\nexport type RpcRequest = {\n  method: string;\n  params: unknown;\n};\n\nexport type RpcSuccessResponse<T = unknown> = {\n  result: T;\n};\n\nexport type RpcErrorResponse = {\n  error: { code: string; message: string };\n};\n\nexport type RpcResponse<T = unknown> = RpcSuccessResponse<T> | RpcErrorResponse;\n\nexport async function handleStorageRpc(\n  body: RpcRequest,\n  handlers: Handlers\n): Promise<RpcResponse> {\n  const { method, params } = body;\n\n  if (!(method in methods)) {\n    return {\n      error: { code: \"METHOD_NOT_FOUND\", message: `Unknown method: ${method}` },\n    };\n  }\n\n  const methodName = method as MethodName;\n  const schema = methods[methodName].params;\n  const parsed = schema.safeParse(params);\n\n  if (!parsed.success) {\n    return {\n      error: {\n        code: \"INVALID_PARAMS\",\n        message: parsed.error.issues\n          .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n          .join(\", \"),\n      },\n    };\n  }\n\n  try {\n    const handler = handlers[methodName] as (\n      params: unknown\n    ) => Promise<unknown>;\n    const result = await handler(parsed.data);\n    return { result };\n  } catch (e) {\n    const isConflict =\n      e instanceof StorageConflictError ||\n      (e instanceof Error && e.name === \"StorageConflictError\");\n\n    if (isConflict) {\n      return {\n        error: {\n          code: \"CONFLICT\",\n          message: e instanceof Error ? e.message : String(e),\n        },\n      };\n    }\n    return {\n      error: {\n        code: \"INTERNAL_ERROR\",\n        message: e instanceof Error ? e.message : String(e),\n      },\n    };\n  }\n}\n", "export {\n  DEFAULT_NAMESPACE,\n  getStorage,\n  LOCAL_STORAGE_VERSION,\n  type RpcFn,\n} from \"./client\";\nexport {\n  type Handlers,\n  handleStorageRpc,\n  type RpcErrorResponse,\n  type RpcRequest,\n  type RpcResponse,\n  type RpcSuccessResponse,\n} from \"./handler\";\nexport {\n  type MessageUsage,\n  type MethodName,\n  type SandboxConfig,\n  STORAGE_RPC_METHODS,\n  type StepUsage,\n  type StorageMethods,\n  type UsageSummary,\n} from \"./rpc\";\nexport type {\n  Command,\n  ListResult,\n  Message,\n  Part,\n  ResolvedStorage,\n  SandboxRecord,\n  Session,\n  SetupSnapshot,\n  Storage,\n  StorageConfig,\n  TypedSession,\n  TypedStorage,\n} from \"./types\";\n", "import { sleep } from \"workflow\";\nimport type { SandboxLifecycleInput } from \"../types\";\nimport { checkAndSnapshotStep } from \"./lifecycle-workflow-steps\";\n\nexport type { SandboxLifecycleInput };\n\nconst DEFAULT_POLL_MS = 2 * 60 * 1000;\n\nexport async function sandboxLifecycleWorkflow({\n  input,\n}: {\n  input: SandboxLifecycleInput;\n}) {\n  \"use workflow\";\n\n  let nextPollMs = DEFAULT_POLL_MS;\n\n  while (true) {\n    await sleep(nextPollMs);\n\n    const result = await checkAndSnapshotStep(input);\n\n    if (result instanceof Error || result.action === \"exit\") {\n      break;\n    }\n\n    nextPollMs = result.nextPollMs;\n  }\n}\n", "import type { SandboxLifecycleInput } from \"../types\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;\nconst SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1000;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\nexport type LifecycleStepResult =\n  | { action: \"continue\"; nextPollMs: number }\n  | {\n      action: \"exit\";\n      reason: \"sandboxId_changed\" | \"idle\" | \"timeout\" | \"not_found\";\n    };\n\nexport async function checkAndSnapshotStep(\n  input: SandboxLifecycleInput\n): Promise<Error | LifecycleStepResult> {\n  \"use step\";\n\n  const { Sandbox: VercelSandboxSDK } = await import(\"./vercel-sdk\");\n  const { getStorage } = await import(\"../../storage\");\n  if (!input.rpc) {\n    throw new Error(\"RPC not found\");\n  }\n  const storage = getStorage({\n    config: input.storageConfig,\n    rpc: input.rpc,\n  });\n  const record = await storage.sandbox.get(input.id);\n  if (record instanceof Error) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const currentSandboxId =\n    record.providerMetadata?.provider === \"vercel\"\n      ? record.providerMetadata.sandboxId\n      : null;\n\n  if (currentSandboxId !== input.vercelSandboxId) {\n    return { action: \"exit\", reason: \"sandboxId_changed\" };\n  }\n\n  if (!currentSandboxId) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const config = record.config;\n  if (config.type !== \"vercel\") {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const pollIntervalMs =\n    config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const idleTimeoutMs =\n    config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n  const snapshotBeforeTimeoutMs =\n    config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;\n\n  const now = Date.now();\n  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;\n  const idleDuration = now - lastActivity;\n  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;\n\n  let shouldSnapshotDueToTimeout = false;\n  try {\n    const sandbox = await VercelSandboxSDK.get({\n      sandboxId: currentSandboxId,\n      ...getTestCredentials(),\n    });\n    if (sandbox.timeout < snapshotBeforeTimeoutMs) {\n      shouldSnapshotDueToTimeout = true;\n    }\n  } catch {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {\n    try {\n      const sandbox = await VercelSandboxSDK.get({\n        sandboxId: currentSandboxId,\n        ...getTestCredentials(),\n      });\n      const snapshot = await sandbox.snapshot();\n      await storage.sandbox.update({\n        id: record.id,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: snapshot.snapshotId,\n        },\n      });\n    } catch (e) {\n      return e instanceof Error ? e : new Error(String(e));\n    }\n    return {\n      action: \"exit\",\n      reason: shouldSnapshotDueToIdle ? \"idle\" : \"timeout\",\n    };\n  }\n\n  return { action: \"continue\", nextPollMs: pollIntervalMs };\n}\n"],
  "mappings": "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",
  "names": ["getStorage"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/vercel-lifecycle/workflow.ts", "../src/utils/logger.ts", "../src/sandbox/bindings/vercel-lifecycle/steps.ts"],
  "sourcesContent": ["import { sleep } from \"workflow\";\nimport { createLogger } from \"../../../utils/logger\";\nimport { checkAndSnapshotStep, type LifecycleInput } from \"./steps\";\n\nexport type { LifecycleInput };\n\nconst DEFAULT_POLL_MS = 2 * 60 * 1000;\n\nexport async function sandboxLifecycleWorkflow({\n  input,\n}: {\n  input: LifecycleInput;\n}) {\n  \"use workflow\";\n\n  let nextPollMs = input.config?.pollIntervalMs ?? DEFAULT_POLL_MS;\n  const log = createLogger({\n    config: { ...input.agent.options.logging, name: input.agent.name },\n    subsystem: \"sandbox:lifecycle\",\n    context: { sandboxId: input.sandboxId },\n  });\n\n  log.info(\"lifecycle workflow started\", {\n    sandboxId: input.sandboxId,\n    vercelSandboxId: input.vercelSandboxId,\n    pollMs: nextPollMs,\n  });\n\n  while (true) {\n    await sleep(nextPollMs);\n\n    const result = await checkAndSnapshotStep(input);\n\n    if (result instanceof Error) {\n      log.error(\"lifecycle step failed\", {\n        sandboxId: input.sandboxId,\n        error: result.message,\n      });\n      break;\n    }\n\n    if (result.action === \"exit\") {\n      log.info(\"lifecycle workflow exiting\", {\n        sandboxId: input.sandboxId,\n        reason: result.reason,\n      });\n      break;\n    }\n\n    nextPollMs = result.nextPollMs;\n  }\n}\n", "export type LogLevel = \"info\" | \"warn\" | \"error\" | \"silent\";\n\nconst LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  info: 0,\n  warn: 1,\n  error: 2,\n  silent: 3,\n};\n\nexport type LogContext = {\n  sessionId?: string;\n  messageId?: string;\n  sandboxId?: string;\n  [key: string]: unknown;\n};\n\nexport type LoggingConfig = {\n  level?: LogLevel;\n  /**\n   * Top-level label for all log lines.\n   * @default \"agent\"\n   * @example \"my-app\" \u2192 [my-app:default:workflow]\n   */\n  prefix?: string;\n  name?: string;\n};\n\nfunction getLevel(config: LoggingConfig): LogLevel {\n  return config.level ?? \"warn\";\n}\n\nfunction getPrefix(config: LoggingConfig): string {\n  return config.prefix ?? \"agent\";\n}\n\nfunction shouldLog(config: LoggingConfig, level: LogLevel): boolean {\n  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[getLevel(config)];\n}\n\nfunction formatTag(config: LoggingConfig, subsystem: string): string {\n  return `[${getPrefix(config)}:${config.name}:${subsystem}]`;\n}\n\nfunction formatData(\n  context: LogContext,\n  extra?: Record<string, unknown>\n): Record<string, unknown> | undefined {\n  const merged = { ...context, ...extra };\n  const entries = Object.entries(merged).filter(\n    ([, v]) => v !== undefined && v !== null\n  );\n  if (entries.length === 0) {\n    return undefined;\n  }\n  return Object.fromEntries(entries);\n}\n\nexport class Logger {\n  readonly subsystem: string;\n  private readonly config: LoggingConfig;\n  private readonly context: LogContext;\n\n  constructor({\n    subsystem,\n    config,\n    context,\n  }: {\n    subsystem: string;\n    config: LoggingConfig;\n    context?: LogContext;\n  }) {\n    this.subsystem = subsystem;\n    this.config = config;\n    this.context = context ?? {};\n  }\n\n  child({\n    subsystem,\n    context,\n  }: {\n    subsystem?: string;\n    context?: LogContext;\n  }): Logger {\n    return new Logger({\n      config: this.config,\n      subsystem: subsystem ? `${this.subsystem}:${subsystem}` : this.subsystem,\n      context: { ...this.context, ...context },\n    });\n  }\n\n  withContext(context: LogContext): Logger {\n    return new Logger({\n      config: this.config,\n      subsystem: this.subsystem,\n      context: { ...this.context, ...context },\n    });\n  }\n\n  info(message: string, data?: Record<string, unknown>): void {\n    if (!shouldLog(this.config, \"info\")) {\n      return;\n    }\n    const d = formatData(this.context, data);\n    if (d) {\n      console.info(formatTag(this.config, this.subsystem), message, d);\n    } else {\n      console.info(formatTag(this.config, this.subsystem), message);\n    }\n  }\n\n  warn(message: string, data?: Record<string, unknown>): void {\n    if (!shouldLog(this.config, \"warn\")) {\n      return;\n    }\n    const d = formatData(this.context, data);\n    if (d) {\n      console.warn(formatTag(this.config, this.subsystem), message, d);\n    } else {\n      console.warn(formatTag(this.config, this.subsystem), message);\n    }\n  }\n\n  error(message: string, data?: Record<string, unknown>): void {\n    if (!shouldLog(this.config, \"error\")) {\n      return;\n    }\n    const d = formatData(this.context, data);\n    if (d) {\n      console.error(formatTag(this.config, this.subsystem), message, d);\n    } else {\n      console.error(formatTag(this.config, this.subsystem), message);\n    }\n  }\n\n  /**\n   * Returns a function that, when called, logs the elapsed time at info level.\n   * Pass `logOnStart: true` to also log when the timer begins.\n   *\n   * @example\n   * const done = log.time(\"sandbox setup\", { sandboxId }, { logOnStart: true });\n   * await setup();\n   * done(); // start: [agent:default:sandbox] sandbox setup { sandboxId: '...' }\n   *         // end:   [agent:default:sandbox] sandbox setup { sandboxId: '...', durationMs: 123 }\n   */\n  time(\n    message: string,\n    data?: Record<string, unknown>,\n    opts?: { logOnStart?: boolean }\n  ): (endData?: Record<string, unknown>) => void {\n    if (opts?.logOnStart) {\n      this.info(`[start] ${message}`, data);\n    }\n    const t0 = Date.now();\n    return (endData?: Record<string, unknown>) => {\n      this.info(opts?.logOnStart ? `[end] ${message}` : message, {\n        ...data,\n        ...endData,\n        durationMs: Date.now() - t0,\n      });\n    };\n  }\n}\n\nexport function createLogger({\n  config,\n  subsystem,\n  context,\n}: {\n  config: LoggingConfig;\n  subsystem: string;\n  context?: LogContext;\n}): Logger {\n  return new Logger({ config, subsystem, context });\n}\n", "import type { Sandbox as VercelSandboxSDK } from \"@vercel/sandbox\";\nimport { createLogger } from \"../../../utils/logger\";\nimport type { SandboxAgentRef } from \"../../adapter\";\nimport type { VercelBindingMetadata } from \"../vercel\";\n\nasync function loadSandboxSDK(): Promise<typeof VercelSandboxSDK> {\n  return (await import(\"@vercel/sandbox\")).Sandbox;\n}\n\nconst DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;\nconst SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1000;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\nexport type LifecycleStepResult =\n  | { action: \"continue\"; nextPollMs: number }\n  | {\n      action: \"exit\";\n      reason: \"sandboxId_changed\" | \"idle\" | \"timeout\" | \"not_found\";\n    };\n\nexport type LifecycleConfig = {\n  pollIntervalMs?: number;\n  stopAfterInactiveMs?: number;\n  snapshotBeforeTimeoutMs?: number;\n};\n\nexport type LifecycleInput = {\n  agent: SandboxAgentRef;\n  sandboxId: string;\n  vercelSandboxId: string;\n  config?: LifecycleConfig;\n};\n\nexport async function checkAndSnapshotStep(\n  input: LifecycleInput\n): Promise<Error | LifecycleStepResult> {\n  \"use step\";\n\n  const storage = input.agent.storage;\n  const log = createLogger({\n    config: { ...input.agent.options.logging, name: input.agent.name },\n    subsystem: \"sandbox:lifecycle\",\n    context: { sandboxId: input.sandboxId },\n  });\n\n  log.info(\"lifecycle check started\", {\n    vercelSandboxId: input.vercelSandboxId,\n  });\n\n  const record = await storage.sandbox.get(input.sandboxId);\n  if (!record) {\n    log.warn(\"sandbox record not found, exiting lifecycle\");\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const metadata = record.setup?.metadata as VercelBindingMetadata | null;\n  const currentSandboxId = metadata?.sandboxId ?? null;\n\n  if (currentSandboxId !== input.vercelSandboxId) {\n    log.info(\"sandbox ID changed, exiting lifecycle\", {\n      expected: input.vercelSandboxId,\n      actual: currentSandboxId,\n    });\n    return { action: \"exit\", reason: \"sandboxId_changed\" };\n  }\n\n  if (!currentSandboxId) {\n    log.warn(\"no current sandbox ID in metadata, exiting lifecycle\");\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const pollIntervalMs =\n    input.config?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const idleTimeoutMs =\n    input.config?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n  const snapshotBeforeTimeoutMs =\n    input.config?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;\n\n  const now = Date.now();\n  const lastActivity = record.lastActiveAt ?? record.createdAt ?? now;\n  const idleDuration = now - lastActivity;\n  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;\n\n  let shouldSnapshotDueToTimeout = false;\n  try {\n    const SandboxSDK = await loadSandboxSDK();\n    const sandbox = await SandboxSDK.get({\n      sandboxId: currentSandboxId,\n      ...getTestCredentials(),\n    });\n    if (sandbox.timeout < snapshotBeforeTimeoutMs) {\n      shouldSnapshotDueToTimeout = true;\n    }\n  } catch {\n    log.warn(\"failed to get sandbox from SDK, exiting lifecycle\", {\n      vercelSandboxId: currentSandboxId,\n    });\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {\n    const reason = shouldSnapshotDueToIdle ? \"idle\" : \"timeout\";\n    log.info(\"snapshotting sandbox before exit\", {\n      reason,\n      idleDurationMs: idleDuration,\n      vercelSandboxId: currentSandboxId,\n    });\n\n    try {\n      const SandboxSDK = await loadSandboxSDK();\n      const sandbox = await SandboxSDK.get({\n        sandboxId: currentSandboxId,\n        ...getTestCredentials(),\n      });\n      const snapshot = await sandbox.snapshot();\n      log.info(\"snapshot created\", { snapshotId: snapshot.snapshotId });\n\n      await storage.sandbox.update(input.sandboxId, {\n        setup: {\n          ...record.setup,\n          metadata: { sandboxId: null, snapshotId: snapshot.snapshotId },\n        },\n      });\n      log.info(\"sandbox record updated with snapshot\");\n    } catch (e) {\n      log.error(\"failed to snapshot sandbox\", { cause: e });\n      return e instanceof Error ? e : new Error(String(e));\n    }\n    return { action: \"exit\", reason };\n  }\n\n  log.info(\"sandbox still active, continuing lifecycle\", {\n    idleDurationMs: idleDuration,\n    nextPollMs: pollIntervalMs,\n  });\n  return { action: \"continue\", nextPollMs: pollIntervalMs };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAsB;;;ACEtB,IAAM,qBAA+C;AAAA,EACnD,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AAAA,EACP,QAAQ;AACV;AAoBA,SAAS,SAAS,QAAiC;AACjD,SAAO,OAAO,SAAS;AACzB;AAEA,SAAS,UAAU,QAA+B;AAChD,SAAO,OAAO,UAAU;AAC1B;AAEA,SAAS,UAAU,QAAuB,OAA0B;AAClE,SAAO,mBAAmB,KAAK,KAAK,mBAAmB,SAAS,MAAM,CAAC;AACzE;AAEA,SAAS,UAAU,QAAuB,WAA2B;AACnE,SAAO,IAAI,UAAU,MAAM,CAAC,IAAI,OAAO,IAAI,IAAI,SAAS;AAC1D;AAEA,SAAS,WACP,SACA,OACqC;AACrC,QAAM,SAAS,EAAE,GAAG,SAAS,GAAG,MAAM;AACtC,QAAM,UAAU,OAAO,QAAQ,MAAM,EAAE;AAAA,IACrC,CAAC,CAAC,EAAE,CAAC,MAAM,MAAM,UAAa,MAAM;AAAA,EACtC;AACA,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AACA,SAAO,OAAO,YAAY,OAAO;AACnC;AAEO,IAAM,SAAN,MAAM,QAAO;AAAA,EACT;AAAA,EACQ;AAAA,EACA;AAAA,EAEjB,YAAY;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,EACF,GAIG;AACD,SAAK,YAAY;AACjB,SAAK,SAAS;AACd,SAAK,UAAU,WAAW,CAAC;AAAA,EAC7B;AAAA,EAEA,MAAM;AAAA,IACJ;AAAA,IACA;AAAA,EACF,GAGW;AACT,WAAO,IAAI,QAAO;AAAA,MAChB,QAAQ,KAAK;AAAA,MACb,WAAW,YAAY,GAAG,KAAK,SAAS,IAAI,SAAS,KAAK,KAAK;AAAA,MAC/D,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG,QAAQ;AAAA,IACzC,CAAC;AAAA,EACH;AAAA,EAEA,YAAY,SAA6B;AACvC,WAAO,IAAI,QAAO;AAAA,MAChB,QAAQ,KAAK;AAAA,MACb,WAAW,KAAK;AAAA,MAChB,SAAS,EAAE,GAAG,KAAK,SAAS,GAAG,QAAQ;AAAA,IACzC,CAAC;AAAA,EACH;AAAA,EAEA,KAAK,SAAiB,MAAsC;AAC1D,QAAI,CAAC,UAAU,KAAK,QAAQ,MAAM,GAAG;AACnC;AAAA,IACF;AACA,UAAM,IAAI,WAAW,KAAK,SAAS,IAAI;AACvC,QAAI,GAAG;AACL,cAAQ,KAAK,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,SAAS,CAAC;AAAA,IACjE,OAAO;AACL,cAAQ,KAAK,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,OAAO;AAAA,IAC9D;AAAA,EACF;AAAA,EAEA,KAAK,SAAiB,MAAsC;AAC1D,QAAI,CAAC,UAAU,KAAK,QAAQ,MAAM,GAAG;AACnC;AAAA,IACF;AACA,UAAM,IAAI,WAAW,KAAK,SAAS,IAAI;AACvC,QAAI,GAAG;AACL,cAAQ,KAAK,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,SAAS,CAAC;AAAA,IACjE,OAAO;AACL,cAAQ,KAAK,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,OAAO;AAAA,IAC9D;AAAA,EACF;AAAA,EAEA,MAAM,SAAiB,MAAsC;AAC3D,QAAI,CAAC,UAAU,KAAK,QAAQ,OAAO,GAAG;AACpC;AAAA,IACF;AACA,UAAM,IAAI,WAAW,KAAK,SAAS,IAAI;AACvC,QAAI,GAAG;AACL,cAAQ,MAAM,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,SAAS,CAAC;AAAA,IAClE,OAAO;AACL,cAAQ,MAAM,UAAU,KAAK,QAAQ,KAAK,SAAS,GAAG,OAAO;AAAA,IAC/D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,KACE,SACA,MACA,MAC6C;AAC7C,QAAI,MAAM,YAAY;AACpB,WAAK,KAAK,WAAW,OAAO,IAAI,IAAI;AAAA,IACtC;AACA,UAAM,KAAK,KAAK,IAAI;AACpB,WAAO,CAAC,YAAsC;AAC5C,WAAK,KAAK,MAAM,aAAa,SAAS,OAAO,KAAK,SAAS;AAAA,QACzD,GAAG;AAAA,QACH,GAAG;AAAA,QACH,YAAY,KAAK,IAAI,IAAI;AAAA,MAC3B,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEO,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA;AAAA,EACA;AACF,GAIW;AACT,SAAO,IAAI,OAAO,EAAE,QAAQ,WAAW,QAAQ,CAAC;AAClD;;;ACxKA,eAAe,iBAAmD;AAChE,UAAQ,MAAM,OAAO,iBAAiB,GAAG;AAC3C;AAEA,IAAM,2BAA2B,IAAI,KAAK;AAC1C,IAAM,0BAA0B,IAAI,KAAK;AACzC,IAAM,6BAA6B,KAAK,KAAK;AAE7C,IAAM,qBAAqB,MACzB,QAAQ,IAAI,aAAa,SACrB;AAAA,EACE,OAAO,QAAQ,IAAI;AAAA,EACnB,QAAQ,QAAQ,IAAI;AAAA,EACpB,WAAW,QAAQ,IAAI;AACzB,IACA,CAAC;AAsBP,eAAsB,qBACpB,OACsC;AACtC;AAEA,QAAM,UAAU,MAAM,MAAM;AAC5B,QAAM,MAAM,aAAa;AAAA,IACvB,QAAQ,EAAE,GAAG,MAAM,MAAM,QAAQ,SAAS,MAAM,MAAM,MAAM,KAAK;AAAA,IACjE,WAAW;AAAA,IACX,SAAS,EAAE,WAAW,MAAM,UAAU;AAAA,EACxC,CAAC;AAED,MAAI,KAAK,2BAA2B;AAAA,IAClC,iBAAiB,MAAM;AAAA,EACzB,CAAC;AAED,QAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI,MAAM,SAAS;AACxD,MAAI,CAAC,QAAQ;AACX,QAAI,KAAK,6CAA6C;AACtD,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,QAAM,WAAW,OAAO,OAAO;AAC/B,QAAM,mBAAmB,UAAU,aAAa;AAEhD,MAAI,qBAAqB,MAAM,iBAAiB;AAC9C,QAAI,KAAK,yCAAyC;AAAA,MAChD,UAAU,MAAM;AAAA,MAChB,QAAQ;AAAA,IACV,CAAC;AACD,WAAO,EAAE,QAAQ,QAAQ,QAAQ,oBAAoB;AAAA,EACvD;AAEA,MAAI,CAAC,kBAAkB;AACrB,QAAI,KAAK,sDAAsD;AAC/D,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,QAAM,iBACJ,MAAM,QAAQ,kBAAkB;AAClC,QAAM,gBACJ,MAAM,QAAQ,uBAAuB;AACvC,QAAM,0BACJ,MAAM,QAAQ,2BAA2B;AAE3C,QAAM,MAAM,KAAK,IAAI;AACrB,QAAM,eAAe,OAAO,gBAAgB,OAAO,aAAa;AAChE,QAAM,eAAe,MAAM;AAC3B,QAAM,0BAA0B,eAAe;AAE/C,MAAI,6BAA6B;AACjC,MAAI;AACF,UAAM,aAAa,MAAM,eAAe;AACxC,UAAM,UAAU,MAAM,WAAW,IAAI;AAAA,MACnC,WAAW;AAAA,MACX,GAAG,mBAAmB;AAAA,IACxB,CAAC;AACD,QAAI,QAAQ,UAAU,yBAAyB;AAC7C,mCAA6B;AAAA,IAC/B;AAAA,EACF,QAAQ;AACN,QAAI,KAAK,qDAAqD;AAAA,MAC5D,iBAAiB;AAAA,IACnB,CAAC;AACD,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,MAAI,2BAA2B,4BAA4B;AACzD,UAAM,SAAS,0BAA0B,SAAS;AAClD,QAAI,KAAK,oCAAoC;AAAA,MAC3C;AAAA,MACA,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,IACnB,CAAC;AAED,QAAI;AACF,YAAM,aAAa,MAAM,eAAe;AACxC,YAAM,UAAU,MAAM,WAAW,IAAI;AAAA,QACnC,WAAW;AAAA,QACX,GAAG,mBAAmB;AAAA,MACxB,CAAC;AACD,YAAM,WAAW,MAAM,QAAQ,SAAS;AACxC,UAAI,KAAK,oBAAoB,EAAE,YAAY,SAAS,WAAW,CAAC;AAEhE,YAAM,QAAQ,QAAQ,OAAO,MAAM,WAAW;AAAA,QAC5C,OAAO;AAAA,UACL,GAAG,OAAO;AAAA,UACV,UAAU,EAAE,WAAW,MAAM,YAAY,SAAS,WAAW;AAAA,QAC/D;AAAA,MACF,CAAC;AACD,UAAI,KAAK,sCAAsC;AAAA,IACjD,SAAS,GAAG;AACV,UAAI,MAAM,8BAA8B,EAAE,OAAO,EAAE,CAAC;AACpD,aAAO,aAAa,QAAQ,IAAI,IAAI,MAAM,OAAO,CAAC,CAAC;AAAA,IACrD;AACA,WAAO,EAAE,QAAQ,QAAQ,OAAO;AAAA,EAClC;AAEA,MAAI,KAAK,8CAA8C;AAAA,IACrD,gBAAgB;AAAA,IAChB,YAAY;AAAA,EACd,CAAC;AACD,SAAO,EAAE,QAAQ,YAAY,YAAY,eAAe;AAC1D;;;AF3IA,IAAM,kBAAkB,IAAI,KAAK;AAEjC,eAAsB,yBAAyB;AAAA,EAC7C;AACF,GAEG;AACD;AAEA,MAAI,aAAa,MAAM,QAAQ,kBAAkB;AACjD,QAAM,MAAM,aAAa;AAAA,IACvB,QAAQ,EAAE,GAAG,MAAM,MAAM,QAAQ,SAAS,MAAM,MAAM,MAAM,KAAK;AAAA,IACjE,WAAW;AAAA,IACX,SAAS,EAAE,WAAW,MAAM,UAAU;AAAA,EACxC,CAAC;AAED,MAAI,KAAK,8BAA8B;AAAA,IACrC,WAAW,MAAM;AAAA,IACjB,iBAAiB,MAAM;AAAA,IACvB,QAAQ;AAAA,EACV,CAAC;AAED,SAAO,MAAM;AACX,cAAM,uBAAM,UAAU;AAEtB,UAAM,SAAS,MAAM,qBAAqB,KAAK;AAE/C,QAAI,kBAAkB,OAAO;AAC3B,UAAI,MAAM,yBAAyB;AAAA,QACjC,WAAW,MAAM;AAAA,QACjB,OAAO,OAAO;AAAA,MAChB,CAAC;AACD;AAAA,IACF;AAEA,QAAI,OAAO,WAAW,QAAQ;AAC5B,UAAI,KAAK,8BAA8B;AAAA,QACrC,WAAW,MAAM;AAAA,QACjB,QAAQ,OAAO;AAAA,MACjB,CAAC;AACD;AAAA,IACF;AAEA,iBAAa,OAAO;AAAA,EACtB;AACF;",
  "names": []
}
