experimental-agent 0.0.2 → 0.0.3

package/dist/chunk-TQRCSTCF.mjs

@@ -0,0 +1,103 @@
+// src/sandbox/bindings/lifecycle-workflow.ts
+import { sleep } from "workflow";
+
+// src/sandbox/bindings/lifecycle-workflow-steps.ts
+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 { Sandbox: VercelSandboxSDK } = await import("./vercel-sdk-VHKEX2GQ.mjs");
+  const { getStorage } = await import("./storage-Q376OZH3.mjs");
+  const storage = getStorage({
+    config: input.storageConfig,
+    rpc: input.rpc
+  });
+  const record = await storage.sandbox.get(input.id);
+  if (record instanceof Error) {
+    return { action: "exit", reason: "not_found" };
+  }
+  const currentSandboxId = record.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+  if (currentSandboxId !== input.vercelSandboxId) {
+    return { action: "exit", reason: "sandboxId_changed" };
+  }
+  if (!currentSandboxId) {
+    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 now = Date.now();
+  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;
+  const idleDuration = now - lastActivity;
+  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
+  let shouldSnapshotDueToTimeout = false;
+  try {
+    const sandbox = await VercelSandboxSDK.get({
+      sandboxId: currentSandboxId,
+      ...getTestCredentials()
+    });
+    if (sandbox.timeout < snapshotBeforeTimeoutMs) {
+      shouldSnapshotDueToTimeout = true;
+    }
+  } catch {
+    return { action: "exit", reason: "not_found" };
+  }
+  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {
+    try {
+      const sandbox = await VercelSandboxSDK.get({
+        sandboxId: currentSandboxId,
+        ...getTestCredentials()
+      });
+      const snapshot = await sandbox.snapshot();
+      await storage.sandbox.set({
+        ...record,
+        acquiringLockId: null,
+        acquiringLockAt: null,
+        providerMetadata: {
+          provider: "vercel",
+          sandboxId: null,
+          snapshotId: snapshot.snapshotId
+        }
+      });
+    } catch (e) {
+      return e instanceof Error ? e : new Error(String(e));
+    }
+    return {
+      action: "exit",
+      reason: shouldSnapshotDueToIdle ? "idle" : "timeout"
+    };
+  }
+  return { action: "continue", nextPollMs: pollIntervalMs };
+}
+
+// src/sandbox/bindings/lifecycle-workflow.ts
+var DEFAULT_POLL_MS = 2 * 60 * 1e3;
+async function sandboxLifecycleWorkflow({
+  input
+}) {
+  "use workflow";
+  let nextPollMs = DEFAULT_POLL_MS;
+  while (true) {
+    await sleep(nextPollMs);
+    const result = await checkAndSnapshotStep(input);
+    if (result instanceof Error || result.action === "exit") {
+      break;
+    }
+    nextPollMs = result.nextPollMs;
+  }
+}
+
+export {
+  sandboxLifecycleWorkflow
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/lifecycle-workflow.ts", "../src/sandbox/bindings/lifecycle-workflow-steps.ts"],
  "sourcesContent": ["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  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.set({\n        ...record,\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": ";AAAA,SAAS,aAAa;;;ACEtB,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;AASP,eAAsB,qBACpB,OACsC;AACtC;AAEA,QAAM,EAAE,SAAS,iBAAiB,IAAI,MAAM,OAAO,2BAAc;AACjE,QAAM,EAAE,WAAW,IAAI,MAAM,OAAO,wBAAe;AACnD,QAAM,UAAU,WAAW;AAAA,IACzB,QAAQ,MAAM;AAAA,IACd,KAAK,MAAM;AAAA,EACb,CAAC;AACD,QAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI,MAAM,EAAE;AACjD,MAAI,kBAAkB,OAAO;AAC3B,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,QAAM,mBACJ,OAAO,kBAAkB,aAAa,WAClC,OAAO,iBAAiB,YACxB;AAEN,MAAI,qBAAqB,MAAM,iBAAiB;AAC9C,WAAO,EAAE,QAAQ,QAAQ,QAAQ,oBAAoB;AAAA,EACvD;AAEA,MAAI,CAAC,kBAAkB;AACrB,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,QAAM,SAAS,OAAO;AACtB,MAAI,OAAO,SAAS,UAAU;AAC5B,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,QAAM,iBACJ,OAAO,WAAW,kBAAkB;AACtC,QAAM,gBACJ,OAAO,WAAW,uBAAuB;AAC3C,QAAM,0BACJ,OAAO,WAAW,2BAA2B;AAE/C,QAAM,MAAM,KAAK,IAAI;AACrB,QAAM,eAAe,OAAO,kBAAkB,OAAO,aAAa;AAClE,QAAM,eAAe,MAAM;AAC3B,QAAM,0BAA0B,eAAe;AAE/C,MAAI,6BAA6B;AACjC,MAAI;AACF,UAAM,UAAU,MAAM,iBAAiB,IAAI;AAAA,MACzC,WAAW;AAAA,MACX,GAAG,mBAAmB;AAAA,IACxB,CAAC;AACD,QAAI,QAAQ,UAAU,yBAAyB;AAC7C,mCAA6B;AAAA,IAC/B;AAAA,EACF,QAAQ;AACN,WAAO,EAAE,QAAQ,QAAQ,QAAQ,YAAY;AAAA,EAC/C;AAEA,MAAI,2BAA2B,4BAA4B;AACzD,QAAI;AACF,YAAM,UAAU,MAAM,iBAAiB,IAAI;AAAA,QACzC,WAAW;AAAA,QACX,GAAG,mBAAmB;AAAA,MACxB,CAAC;AACD,YAAM,WAAW,MAAM,QAAQ,SAAS;AACxC,YAAM,QAAQ,QAAQ,IAAI;AAAA,QACxB,GAAG;AAAA,QACH,iBAAiB;AAAA,QACjB,iBAAiB;AAAA,QACjB,kBAAkB;AAAA,UAChB,UAAU;AAAA,UACV,WAAW;AAAA,UACX,YAAY,SAAS;AAAA,QACvB;AAAA,MACF,CAAC;AAAA,IACH,SAAS,GAAG;AACV,aAAO,aAAa,QAAQ,IAAI,IAAI,MAAM,OAAO,CAAC,CAAC;AAAA,IACrD;AACA,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ,0BAA0B,SAAS;AAAA,IAC7C;AAAA,EACF;AAEA,SAAO,EAAE,QAAQ,YAAY,YAAY,eAAe;AAC1D;;;ADtGA,IAAM,kBAAkB,IAAI,KAAK;AAEjC,eAAsB,yBAAyB;AAAA,EAC7C;AACF,GAEG;AACD;AAEA,MAAI,aAAa;AAEjB,SAAO,MAAM;AACX,UAAM,MAAM,UAAU;AAEtB,UAAM,SAAS,MAAM,qBAAqB,KAAK;AAE/C,QAAI,kBAAkB,SAAS,OAAO,WAAW,QAAQ;AACvD;AAAA,IACF;AAEA,iBAAa,OAAO;AAAA,EACtB;AACF;",
  "names": []
}


package/dist/chunk-UFVWOC5L.mjs

@@ -0,0 +1,79 @@
+// package.json
+var package_default = {
+  name: "experimental-agent",
+  version: "0.0.3",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  sideEffects: true,
+  license: "MIT",
+  files: [
+    "dist/**"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./next": {
+      types: "./dist/next.d.ts",
+      import: "./dist/next.mjs",
+      require: "./dist/next.js"
+    },
+    "./next/loader": {
+      types: "./dist/next/loader.d.ts",
+      import: "./dist/next/loader.mjs",
+      require: "./dist/next/loader.js"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.mjs",
+      require: "./dist/client.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    release: "pnpm build && npm publish",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@hono/node-server": "^1.19.9",
+    "@swc/core": "^1.10.0",
+    "@vercel/oidc": "^3.1.0",
+    "better-all": "^0.0.5",
+    errore: "^0.8.2",
+    "fast-deep-equal": "^3.1.3",
+    glob: "^11.0.0",
+    hono: "^4.11.6",
+    sandbox: "^1.0.18",
+    ulid: "^3.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@agent/tsconfig": "workspace:*",
+    "@types/node": "^20.11.24",
+    dotenv: "^17.2.3",
+    next: "^16.0.0",
+    tsup: "^8.0.2",
+    "type-fest": "^5.4.2",
+    typescript: "5.5.4",
+    vitest: "^3.0.0"
+  },
+  peerDependencies: {
+    ai: "^6.0.0",
+    workflow: "https://workflow-docs-7evupb64d.vercel.sh/workflow.tgz"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+export {
+  package_default
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-VBLZWXVE.mjs

@@ -0,0 +1,318 @@
+// src/storage/rpc.ts
+import { z } from "zod";
+var VercelLifecycleConfigSchema = z.object({
+  pollIntervalMs: z.number().optional(),
+  stopAfterInactiveMs: z.number().optional(),
+  snapshotBeforeTimeoutMs: z.number().optional(),
+  snapshotId: z.string().optional(),
+  autoStart: z.boolean().optional()
+});
+var SandboxConfigSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("vercel"),
+    resources: z.object({ vcpus: z.number() }).optional(),
+    ports: z.array(z.number()).optional(),
+    lifecycle: VercelLifecycleConfigSchema.optional()
+  }),
+  z.object({
+    type: z.literal("local"),
+    path: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("custom"),
+    url: z.string(),
+    headers: z.record(z.string(), z.string()).optional()
+  })
+]);
+var GenerationSchema = z.object({
+  maxSteps: z.number().optional(),
+  temperature: z.number().optional(),
+  topK: z.number().optional(),
+  topP: z.number().optional(),
+  frequencyPenalty: z.number().optional(),
+  presencePenalty: z.number().optional(),
+  maxOutputTokens: z.number().optional(),
+  headers: z.record(z.string(), z.string()).optional()
+});
+var SessionSchema = z.object({
+  id: z.string(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  runId: z.string().nullable(),
+  lastMessageId: z.string().nullable(),
+  tags: z.record(z.string(), z.unknown()).nullable(),
+  system: z.string().nullable(),
+  model: z.string().nullable(),
+  sandboxId: z.string().nullable(),
+  skillsDir: z.array(z.string()).nullable(),
+  hookToken: z.string().nullable(),
+  activeTools: z.array(z.string()).nullable(),
+  generation: GenerationSchema.nullable().default(null)
+});
+var StepUsageSchema = z.object({
+  stepIndex: z.number(),
+  model: z.string(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  totalTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number(),
+  reasoningTokens: z.number()
+});
+var UsageSummarySchema = z.object({
+  model: z.string(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  totalTokens: z.number(),
+  cacheReadTokens: z.number(),
+  cacheWriteTokens: z.number(),
+  reasoningTokens: z.number(),
+  stepCount: z.number()
+});
+var MessageUsageSchema = z.object({
+  steps: z.array(StepUsageSchema),
+  summary: UsageSummarySchema
+});
+var MessageSchema = z.object({
+  id: z.string(),
+  sessionId: z.string(),
+  role: z.enum(["user", "assistant", "system"]),
+  createdAt: z.number(),
+  startedAt: z.number().nullable(),
+  completedAt: z.number().nullable(),
+  interruptedAt: z.number().nullable(),
+  usage: MessageUsageSchema.nullable()
+});
+var PartSchema = z.object({
+  id: z.string(),
+  messageId: z.string(),
+  sessionId: z.string(),
+  index: z.number(),
+  part: z.unknown()
+});
+var CommandResultSchema = z.object({
+  stdout: z.string(),
+  stderr: z.string(),
+  exitCode: z.number(),
+  completedAt: z.number()
+});
+var SandboxRecordSchema = z.object({
+  id: z.string(),
+  config: SandboxConfigSchema,
+  tags: z.record(z.string(), z.unknown()).nullable(),
+  createdAt: z.number().nullable(),
+  lastActivityAt: z.number().nullable(),
+  acquiringLockId: z.string().nullable(),
+  acquiringLockAt: z.number().nullable(),
+  providerMetadata: z.discriminatedUnion("provider", [
+    z.object({
+      provider: z.literal("vercel"),
+      sandboxId: z.string().nullable(),
+      snapshotId: z.string().nullable()
+    })
+  ]).optional()
+});
+var CommandBaseSchema = z.object({
+  id: z.string(),
+  sessionId: z.string(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  startedAt: z.number()
+});
+var CommandSchema = z.discriminatedUnion("status", [
+  CommandBaseSchema.extend({ status: z.literal("running") }),
+  CommandBaseSchema.extend({
+    status: z.literal("completed"),
+    result: CommandResultSchema
+  }),
+  CommandBaseSchema.extend({
+    status: z.literal("killed"),
+    result: CommandResultSchema.optional()
+  }),
+  CommandBaseSchema.extend({
+    status: z.literal("failed"),
+    result: CommandResultSchema
+  })
+]);
+function ListResultSchema(itemSchema) {
+  return z.object({
+    items: z.array(itemSchema),
+    nextCursor: z.string().nullable()
+  });
+}
+var methods = {
+  "session.get": {
+    params: z.object({ id: z.string() }),
+    result: SessionSchema.nullable()
+  },
+  "session.set": {
+    params: SessionSchema,
+    result: SessionSchema
+  },
+  "session.list": {
+    params: z.object({
+      tags: z.record(z.string(), z.unknown()).optional(),
+      order: z.enum([
+        "createdAt_asc",
+        "createdAt_desc",
+        "updatedAt_asc",
+        "updatedAt_desc"
+      ]).optional(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(SessionSchema)
+  },
+  "session.listBySandbox": {
+    params: z.object({
+      sandboxId: z.string(),
+      tags: z.record(z.string(), z.unknown()).optional(),
+      order: z.enum([
+        "createdAt_asc",
+        "createdAt_desc",
+        "updatedAt_asc",
+        "updatedAt_desc"
+      ]).optional(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(SessionSchema)
+  },
+  "session.tag.set": {
+    params: z.object({
+      sessionId: z.string(),
+      tags: z.record(z.string(), z.unknown())
+    }),
+    result: SessionSchema
+  },
+  "message.get": {
+    params: z.object({ id: z.string() }),
+    result: MessageSchema.nullable()
+  },
+  "message.set": {
+    params: MessageSchema,
+    result: MessageSchema
+  },
+  "message.list": {
+    params: z.object({
+      sessionId: z.string(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(MessageSchema)
+  },
+  "part.listByMessage": {
+    params: z.object({
+      messageId: z.string(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(PartSchema)
+  },
+  "part.listBySession": {
+    params: z.object({
+      sessionId: z.string(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(PartSchema)
+  },
+  "part.set": {
+    params: PartSchema,
+    result: PartSchema
+  },
+  "part.delete": {
+    params: z.object({ id: z.string() }),
+    result: z.void()
+  },
+  "sandbox.get": {
+    params: z.object({ key: z.string() }),
+    result: SandboxRecordSchema.nullable()
+  },
+  "sandbox.getBySession": {
+    params: z.object({ sessionId: z.string() }),
+    result: SandboxRecordSchema.nullable()
+  },
+  "sandbox.set": {
+    params: SandboxRecordSchema,
+    result: z.void()
+  },
+  "sandbox.list": {
+    params: z.object({
+      tags: z.record(z.string(), z.unknown()).optional(),
+      order: z.enum([
+        "createdAt_asc",
+        "createdAt_desc",
+        "lastActivityAt_asc",
+        "lastActivityAt_desc"
+      ]).optional(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(SandboxRecordSchema)
+  },
+  "sandbox.tag.set": {
+    params: z.object({
+      sandboxId: z.string(),
+      tags: z.record(z.string(), z.unknown())
+    }),
+    result: SandboxRecordSchema
+  },
+  "command.get": {
+    params: z.object({ id: z.string() }),
+    result: CommandSchema.nullable()
+  },
+  "command.set": {
+    params: CommandSchema,
+    result: CommandSchema
+  },
+  "command.list": {
+    params: z.object({
+      sessionId: z.string(),
+      includeFinished: z.boolean().optional(),
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }),
+    result: ListResultSchema(CommandSchema)
+  }
+};
+var 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}` }
+    };
+  }
+  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(", ")
+      }
+    };
+  }
+  try {
+    const handler = handlers[methodName];
+    const result = await handler(parsed.data);
+    return { result };
+  } catch (e) {
+    return {
+      error: {
+        code: "INTERNAL_ERROR",
+        message: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
+}
+
+export {
+  STORAGE_RPC_METHODS,
+  handleStorageRpc
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/rpc.ts", "../src/storage/handler.ts"],
  "sourcesContent": ["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\nexport const SandboxConfigSchema = z.discriminatedUnion(\"type\", [\n  z.object({\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  }),\n  z.object({\n    type: z.literal(\"local\"),\n    path: z.string().optional(),\n  }),\n  z.object({\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 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  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  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 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\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.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.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.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} 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 { 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    return {\n      error: {\n        code: \"INTERNAL_ERROR\",\n        message: e instanceof Error ? e.message : String(e),\n      },\n    };\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
