experimental-agent 0.1.3 → 0.2.0

package/dist/chunk-TGNVXSMX.mjs

@@ -0,0 +1,399 @@
+import {
+  MessageNotFoundError,
+  SandboxNotFoundError,
+  SessionNotFoundError,
+  StorageConflictError,
+  StorageError
+} from "./chunk-YRYXN7W4.mjs";
+
+// 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 });
+        }
+      }
+    }
+  };
+}
+var DEFAULT_NAMESPACE = "default";
+var LOCAL_STORAGE_VERSION = "v1";
+function getStorage(opts) {
+  const name = opts.config.name ?? DEFAULT_NAMESPACE;
+  return getStorageClient(opts.rpc, name);
+}
+
+export {
+  getStorageClient,
+  DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION,
+  getStorage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/client.ts"],
  "sourcesContent": ["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"],
  "mappings": "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",
  "names": []
}
