experimental-agent 0.0.0

package/dist/chunk-DPPQO7DA.mjs

@@ -0,0 +1,343 @@
+// src/errors.ts
+import * as errore from "errore";
+var SessionNotFoundError = class extends errore.createTaggedError({
+  name: "SessionNotFoundError",
+  message: "Session $id not found"
+}) {
+};
+var SessionError = class extends errore.createTaggedError({
+  name: "SessionError",
+  message: "Session $id failed: $reason"
+}) {
+};
+var SandboxNotFoundError = class extends errore.createTaggedError({
+  name: "SandboxNotFoundError",
+  message: "Sandbox $id not found"
+}) {
+};
+var StorageError = class extends errore.createTaggedError({
+  name: "StorageError",
+  message: "$reason"
+}) {
+};
+var SandboxError = class extends errore.createTaggedError({
+  name: "SandboxError",
+  message: "$reason"
+}) {
+};
+var MessageNotFoundError = class extends errore.createTaggedError({
+  name: "MessageNotFoundError",
+  message: "Message $id not found"
+}) {
+};
+
+// src/storage/client.ts
+function getStorageClient({ url, headers }) {
+  async function rpc(method, params) {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify({ method, params })
+    });
+    if (!res.ok) {
+      throw new StorageError({
+        reason: `HTTP ${res.status}: ${res.statusText}`
+      });
+    }
+    const json = await res.json();
+    if ("error" in json) {
+      throw new StorageError({ reason: json.error.message });
+    }
+    return json.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 });
+        }
+      },
+      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 });
+        }
+      },
+      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 });
+        }
+      }
+    },
+    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 });
+        }
+      }
+    },
+    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 });
+        }
+      }
+    }
+  };
+}
+async function resolveStorageUrl(config) {
+  switch (config.type) {
+    case "local": {
+      const { startLocalStorage } = await import("./local-J6QFWSWB.mjs");
+      return { url: await startLocalStorage({ path: config.path }) };
+    }
+    case "vercel": {
+      const { getVercelStorageConfig } = await import("./vercel-2CFDMEHB.mjs");
+      return getVercelStorageConfig();
+    }
+    case "custom": {
+      return { url: config.url, headers: config.headers };
+    }
+    default: {
+      config;
+      throw new Error(
+        `Unknown storage type: ${config.type}`
+      );
+    }
+  }
+}
+function getStorage(storageConfig) {
+  let clientPromise = null;
+  const getClient = () => {
+    if (!clientPromise) {
+      clientPromise = resolveStorageUrl(storageConfig).then(
+        (resolved) => getStorageClient(resolved)
+      );
+    }
+    return clientPromise;
+  };
+  return {
+    session: {
+      get: async (id) => (await getClient()).session.get(id),
+      set: async (session) => (await getClient()).session.set(session),
+      list: async (opts) => (await getClient()).session.list(opts),
+      tag: {
+        set: async (opts) => (await getClient()).session.tag.set(opts)
+      }
+    },
+    message: {
+      list: async (sessionId, opts) => (await getClient()).message.list(sessionId, opts),
+      get: async (id) => (await getClient()).message.get(id),
+      set: async (message) => (await getClient()).message.set(message)
+    },
+    part: {
+      listByMessage: async (messageId, opts) => (await getClient()).part.listByMessage(messageId, opts),
+      listBySession: async (sessionId, opts) => (await getClient()).part.listBySession(sessionId, opts),
+      set: async (part) => (await getClient()).part.set(part)
+    },
+    sandbox: {
+      get: async (key) => (await getClient()).sandbox.get(key),
+      set: async (opts) => (await getClient()).sandbox.set(opts),
+      getBySession: async (sessionId) => (await getClient()).sandbox.getBySession(sessionId)
+    },
+    command: {
+      get: async (id) => (await getClient()).command.get(id),
+      set: async (command) => (await getClient()).command.set(command),
+      list: async (sessionId, opts) => (await getClient()).command.list(sessionId, opts)
+    }
+  };
+}
+
+export {
+  SessionNotFoundError,
+  SessionError,
+  SandboxNotFoundError,
+  StorageError,
+  SandboxError,
+  MessageNotFoundError,
+  getStorageClient,
+  getStorage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/errors.ts", "../src/storage/client.ts"],
  "sourcesContent": ["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 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  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  ResolvedStorage,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport function getStorageClient({ url, headers }: ResolvedStorage): 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 res = await fetch(url, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\", ...headers },\n      body: JSON.stringify({ method, params }),\n    });\n\n    if (!res.ok) {\n      throw new StorageError({\n        reason: `HTTP ${res.status}: ${res.statusText}`,\n      });\n    }\n\n    const json = (await res.json()) as RpcResponse<\n      z.infer<StorageMethods[M][\"result\"]>\n    >;\n\n    if (\"error\" in json) {\n      throw new StorageError({ reason: json.error.message });\n    }\n\n    return json.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      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      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    },\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    },\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\nasync function resolveStorageUrl(\n  config: StorageConfig\n): Promise<ResolvedStorage> {\n  switch (config.type) {\n    case \"local\": {\n      const { startLocalStorage } = await import(\"./bindings/local\");\n      return { url: await startLocalStorage({ path: config.path }) };\n    }\n    case \"vercel\": {\n      const { getVercelStorageConfig } = await import(\"./bindings/vercel\");\n      return getVercelStorageConfig();\n    }\n    case \"custom\": {\n      return { url: config.url, headers: config.headers };\n    }\n    default: {\n      config satisfies never;\n      throw new Error(\n        `Unknown storage type: ${(config as { type: string }).type}`\n      );\n    }\n  }\n}\n\nexport function getStorage(storageConfig: StorageConfig): Storage {\n  let clientPromise: Promise<Storage> | null = null;\n  const getClient = () => {\n    if (!clientPromise) {\n      clientPromise = resolveStorageUrl(storageConfig).then((resolved) =>\n        getStorageClient(resolved)\n      );\n    }\n    return clientPromise;\n  };\n\n  return {\n    session: {\n      get: async (id) => (await getClient()).session.get(id),\n      set: async (session) => (await getClient()).session.set(session),\n      list: async (opts) => (await getClient()).session.list(opts),\n      tag: {\n        set: async (opts) => (await getClient()).session.tag.set(opts),\n      },\n    },\n    message: {\n      list: async (sessionId, opts) =>\n        (await getClient()).message.list(sessionId, opts),\n      get: async (id) => (await getClient()).message.get(id),\n      set: async (message) => (await getClient()).message.set(message),\n    },\n    part: {\n      listByMessage: async (messageId, opts) =>\n        (await getClient()).part.listByMessage(messageId, opts),\n      listBySession: async (sessionId, opts) =>\n        (await getClient()).part.listBySession(sessionId, opts),\n      set: async (part) => (await getClient()).part.set(part),\n    },\n    sandbox: {\n      get: async (key) => (await getClient()).sandbox.get(key),\n      set: async (opts) => (await getClient()).sandbox.set(opts),\n      getBySession: async (sessionId) =>\n        (await getClient()).sandbox.getBySession(sessionId),\n    },\n    command: {\n      get: async (id) => (await getClient()).command.get(id),\n      set: async (command) => (await getClient()).command.set(command),\n      list: async (sessionId, opts) =>\n        (await getClient()).command.list(sessionId, opts),\n    },\n  };\n}\n"],
  "mappings": "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",
  "names": []
}
