experimental-agent 0.2.1 → 0.3.0

package/dist/lifecycle-workflow-steps.d.mts

@@ -0,0 +1,5 @@
+export { e as LifecycleConfig, L as LifecycleInput, f as LifecycleStepResult, g as checkAndSnapshotStep } from './steps-u-mGDbP_.mjs';
+import '@vercel/sandbox';
+import './adapter-BigchkkI.mjs';
+import '@workflow/serde';
+import 'ai';

package/dist/lifecycle-workflow-steps.d.ts

@@ -0,0 +1,5 @@
+export { e as LifecycleConfig, L as LifecycleInput, f as LifecycleStepResult, g as checkAndSnapshotStep } from './steps-BnkRQKlc.js';
+import '@vercel/sandbox';
+import './adapter-BigchkkI.js';
+import '@workflow/serde';
+import 'ai';

package/dist/lifecycle-workflow-steps.js

@@ -0,0 +1,263 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sandbox/bindings/vercel-lifecycle/steps.ts
+var steps_exports = {};
+__export(steps_exports, {
+  checkAndSnapshotStep: () => checkAndSnapshotStep
+});
+module.exports = __toCommonJS(steps_exports);
+
+// 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 shouldLog(config, level) {
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[getLevel(config)];
+}
+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;
+  }
+  return Object.fromEntries(entries);
+}
+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 }
+    });
+  }
+  withContext(context) {
+    return new _Logger({
+      config: this.config,
+      subsystem: this.subsystem,
+      context: { ...this.context, ...context }
+    });
+  }
+  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);
+    }
+  }
+  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);
+    }
+  }
+  error(message, data) {
+    if (!shouldLog(this.config, "error")) {
+      return;
+    }
+    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 });
+}
+
+// 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;
+var getTestCredentials = () => process.env.NODE_ENV === "test" ? {
+  token: process.env.TEST_VERCEL_TOKEN,
+  teamId: process.env.TEST_VERCEL_TEAM_ID,
+  projectId: process.env.TEST_VERCEL_PROJECT_ID
+} : {};
+async function checkAndSnapshotStep(input) {
+  "use step";
+  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.sandboxId);
+  if (!record) {
+    log.warn("sandbox record not found, exiting lifecycle");
+    return { action: "exit", reason: "not_found" };
+  }
+  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 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.lastActiveAt ?? record.createdAt ?? now;
+  const idleDuration = now - lastActivity;
+  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
+  let shouldSnapshotDueToTimeout = false;
+  try {
+    const SandboxSDK = await loadSandboxSDK();
+    const sandbox = await SandboxSDK.get({
+      sandboxId: currentSandboxId,
+      ...getTestCredentials()
+    });
+    if (sandbox.timeout < snapshotBeforeTimeoutMs) {
+      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 SandboxSDK = await loadSandboxSDK();
+      const sandbox = await SandboxSDK.get({
+        sandboxId: currentSandboxId,
+        ...getTestCredentials()
+      });
+      const snapshot = await sandbox.snapshot();
+      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 };
+  }
+  log.info("sandbox still active, continuing lifecycle", {
+    idleDurationMs: idleDuration,
+    nextPollMs: pollIntervalMs
+  });
+  return { action: "continue", nextPollMs: pollIntervalMs };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkAndSnapshotStep
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/vercel-lifecycle/steps.ts", "../src/utils/logger.ts"],
  "sourcesContent": ["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", "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"],
  "mappings": "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",
  "names": []
}


package/dist/lifecycle-workflow-steps.mjs

@@ -0,0 +1,9 @@
+import {
+  checkAndSnapshotStep
+} from "./chunk-JO3JDCH5.mjs";
+import "./chunk-MSWINCCM.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  checkAndSnapshotStep
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lifecycle-workflow.d.mts

@@ -1,11 +1,11 @@
-import { J as SandboxLifecycleInput } from './client-CEeSFGva.mjs';
-import 'errore';
-import 'ai';
-import 'zod';
+import { L as LifecycleInput } from './steps-u-mGDbP_.mjs';
 import '@vercel/sandbox';
+import './adapter-BigchkkI.mjs';
+import '@workflow/serde';
+import 'ai';
 
 declare function sandboxLifecycleWorkflow({ input, }: {
-    input: SandboxLifecycleInput;
+    input: LifecycleInput;
 }): Promise<void>;
 
-export { SandboxLifecycleInput, sandboxLifecycleWorkflow };
+export { LifecycleInput, sandboxLifecycleWorkflow };

package/dist/lifecycle-workflow.d.ts

@@ -1,11 +1,11 @@
-import { J as SandboxLifecycleInput } from './client-CEeSFGva.js';
-import 'errore';
-import 'ai';
-import 'zod';
+import { L as LifecycleInput } from './steps-BnkRQKlc.js';
 import '@vercel/sandbox';
+import './adapter-BigchkkI.js';
+import '@workflow/serde';
+import 'ai';
 
 declare function sandboxLifecycleWorkflow({ input, }: {
-    input: SandboxLifecycleInput;
+    input: LifecycleInput;
 }): Promise<void>;
 
-export { SandboxLifecycleInput, sandboxLifecycleWorkflow };
+export { LifecycleInput, sandboxLifecycleWorkflow };