experimental-agent 0.5.0 → 0.6.1

package/dist/react.js

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  useAgent: () => useAgent,
+  useInterruptSession: () => useInterruptSession,
+  useSessionHistory: () => useSessionHistory
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/use-agent.ts
+var import_react = require("@ai-sdk/react");
+var import_ai = require("ai");
+var import_react2 = require("react");
+
+// src/rpc/base-path.ts
+function basePathForAgent(agent) {
+  return `/api/agents/${agent}`;
+}
+
+// src/react/use-agent.ts
+function useAgent(name, {
+  headers,
+  id,
+  ...options
+} = {}) {
+  const basePath = options.basePath ?? basePathForAgent(name);
+  const [agentStatus, setAgentStatus] = (0, import_react2.useState)(null);
+  const onData = (0, import_react2.useRef)(options.onData);
+  (0, import_react2.useEffect)(() => {
+    onData.current = options.onData;
+  }, [options.onData]);
+  const chat = (0, import_react.useChat)({
+    chat: (0, import_react2.useMemo)(
+      () => new import_react.Chat({
+        id,
+        transport: new import_ai.DefaultChatTransport({
+          api: basePath,
+          prepareSendMessagesRequest: async ({ messages }) => {
+            const h = await (typeof headers === "function" ? headers() : headers);
+            const lastAssistant = messages.findLast(
+              (m) => m.role === "assistant"
+            );
+            const lastPartContent = lastAssistant?.parts.at(-1);
+            const lastPart = lastAssistant && lastPartContent != null ? {
+              index: lastAssistant.parts.length - 1,
+              part: lastPartContent
+            } : void 0;
+            const body = {
+              message: messages.at(-1),
+              interruptIfStreaming: lastPart ? { lastPart } : true
+            };
+            return {
+              body,
+              headers: new Headers(h),
+              api: `${basePath}/${id}`
+            };
+          },
+          prepareReconnectToStreamRequest: async (request) => {
+            const h = await (typeof headers === "function" ? headers() : headers);
+            return {
+              ...request,
+              api: `${basePath}/${id}/reconnect`,
+              headers: h
+            };
+          }
+        }),
+        onData: (_part) => {
+          const part = _part;
+          if (part.type === "data-status") {
+            setAgentStatus(part.data);
+          }
+          onData.current?.(part);
+        }
+      }),
+      [id, basePath, headers]
+    )
+  });
+  return {
+    chat,
+    agentStatus
+  };
+}
+
+// src/react/use-history-query.ts
+var import_react_query2 = require("@tanstack/react-query");
+
+// src/react/use-query.ts
+var import_react_query = require("@tanstack/react-query");
+var client = new import_react_query.QueryClient();
+function useQuery(options) {
+  return (0, import_react_query.useQuery)(options, client);
+}
+
+// src/react/use-history-query.ts
+function useSessionHistory(options) {
+  return useQuery({
+    ...options.options,
+    queryKey: ["history", options.sessionId],
+    queryFn: options.sessionId ? async () => {
+      const path = `${options.basePath}/${options.sessionId}`;
+      return await fetch(path).then((res) => res.json());
+    } : import_react_query2.skipToken
+  });
+}
+
+// src/react/use-interrupt.ts
+var import_react_query3 = require("@tanstack/react-query");
+function useInterruptSession(options) {
+  return (0, import_react_query3.useMutation)({
+    mutationFn: async (input) => {
+      const path = `${options.basePath}/${options.sessionId}/interrupt`;
+      return await fetch(path, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }).then((res) => res.json());
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useAgent,
+  useInterruptSession,
+  useSessionHistory
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/react/index.ts", "../src/react/use-agent.ts", "../src/rpc/base-path.ts", "../src/react/use-history-query.ts", "../src/react/use-query.ts", "../src/react/use-interrupt.ts"],
  "sourcesContent": ["export { useAgent } from \"./use-agent\";\nexport { useSessionHistory } from \"./use-history-query\";\nexport { useInterruptSession } from \"./use-interrupt\";\n", "import { Chat, useChat } from \"@ai-sdk/react\";\nimport { DefaultChatTransport } from \"ai\";\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nimport type { AgentStatus, AnyAgent } from \"../agent/client\";\nimport { basePathForAgent } from \"../rpc/base-path\";\n\ntype DataEvent = {\n  type: \"data-status\";\n  data: AgentStatus;\n};\n\nexport function useAgent<Agent extends AnyAgent>(\n  name: Agent[\"name\"],\n  {\n    headers,\n    id,\n    ...options\n  }: {\n    basePath?: string;\n    headers?: HeadersInit | (() => Promise<HeadersInit>);\n    id?: string;\n    onData?: (data: DataEvent) => void;\n  } = {}\n) {\n  const basePath = options.basePath ?? basePathForAgent(name);\n  const [agentStatus, setAgentStatus] = useState<AgentStatus | null>(null);\n  const onData = useRef(options.onData);\n  useEffect(() => {\n    onData.current = options.onData;\n  }, [options.onData]);\n  const chat = useChat<Agent[\"$UIMessage\"]>({\n    chat: useMemo(\n      () =>\n        new Chat({\n          id,\n          transport: new DefaultChatTransport({\n            api: basePath,\n            prepareSendMessagesRequest: async ({ messages }) => {\n              const h = await (typeof headers === \"function\"\n                ? headers()\n                : headers);\n              const lastAssistant = messages.findLast(\n                (m) => m.role === \"assistant\"\n              );\n              const lastPartContent = lastAssistant?.parts.at(-1);\n              const lastPart =\n                lastAssistant && lastPartContent != null\n                  ? {\n                      index: lastAssistant.parts.length - 1,\n                      part: lastPartContent,\n                    }\n                  : undefined;\n              const body: Record<string, unknown> = {\n                message: messages.at(-1),\n                interruptIfStreaming: lastPart ? { lastPart } : true,\n              };\n              return {\n                body,\n                headers: new Headers(h),\n                api: `${basePath}/${id}`,\n              };\n            },\n            prepareReconnectToStreamRequest: async (request) => {\n              const h = await (typeof headers === \"function\"\n                ? headers()\n                : headers);\n              return {\n                ...request,\n                api: `${basePath}/${id}/reconnect`,\n                headers: h,\n              };\n            },\n          }),\n          onData: (_part) => {\n            const part = _part as unknown as DataEvent;\n            if (part.type === \"data-status\") {\n              setAgentStatus(part.data);\n            }\n            onData.current?.(part);\n          },\n        }),\n      [id, basePath, headers]\n    ),\n  });\n\n  return {\n    chat,\n    agentStatus,\n  };\n}\n", "export type BasePath = `/api/agents/[agent]`;\nexport type SessionPath = `${BasePath | (string & {})}/[sessionId]`;\nexport type ReconnectPath = `${SessionPath | (string & {})}/reconnect`;\nexport type InterruptPath = `${SessionPath | (string & {})}/interrupt`;\n\nexport type Path = SessionPath | ReconnectPath | InterruptPath;\n\nexport function basePathForAgent(agent: string) {\n  return `/api/agents/${agent}` as const;\n}\n", "import { type QueryOptions, skipToken } from \"@tanstack/react-query\";\nimport type { AnyAgent } from \"../agent/client\";\nimport { useQuery } from \"./use-query\";\n\ntype Response<Agent extends AnyAgent> = Awaited<\n  ReturnType<ReturnType<Agent[\"session\"]>[\"history\"]>\n>;\n\nexport function useSessionHistory<Agent extends AnyAgent>(options: {\n  basePath?: string;\n  sessionId: string | undefined;\n  options?: Omit<QueryOptions<Response<Agent>>, \"queryKey\" | \"queryFn\">;\n}) {\n  return useQuery<Response<Agent>>({\n    ...options.options,\n    queryKey: [\"history\", options.sessionId],\n    queryFn: options.sessionId\n      ? async () => {\n          const path = `${options.basePath}/${options.sessionId}`;\n          return await fetch(path).then((res) => res.json());\n        }\n      : skipToken,\n  });\n}\n", "import {\n  QueryClient,\n  type UseMutationOptions,\n  type UseQueryOptions,\n  useMutation as useUpstreamMutation,\n  useQuery as useUpstreamQuery,\n} from \"@tanstack/react-query\";\n\nconst client = new QueryClient();\n\nexport function useQuery<T>(options: UseQueryOptions<T>) {\n  return useUpstreamQuery<T>(options, client);\n}\n\nexport function useMutation<T, Variables, Error, Data>(\n  options: UseMutationOptions<T, Variables, Error, Data>\n) {\n  return useUpstreamMutation<T, Variables, Error, Data>(options, client);\n}\n", "import { useMutation } from \"@tanstack/react-query\";\nimport type { AnyAgent } from \"../agent/client\";\n\ntype Fn<Agent extends AnyAgent> = ReturnType<Agent[\"session\"]>[\"interrupt\"];\ntype Response<Agent extends AnyAgent> = Awaited<ReturnType<Fn<Agent>>>;\ntype Variables<Agent extends AnyAgent> = Parameters<Fn<Agent>>[0];\n\nexport function useInterruptSession<Agent extends AnyAgent>(options: {\n  basePath?: string;\n  sessionId: string;\n}) {\n  return useMutation<Response<Agent>, Error, Variables<Agent>, void>({\n    mutationFn: async (input) => {\n      const path = `${options.basePath}/${options.sessionId}/interrupt`;\n      return await fetch(path, {\n        method: \"POST\",\n        body: JSON.stringify(input),\n      }).then((res) => res.json());\n    },\n  });\n}\n"],
  "mappings": "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",
  "names": ["import_react", "import_react_query", "useUpstreamQuery", "import_react_query"]
}


package/dist/react.mjs

@@ -0,0 +1,117 @@
+import {
+  basePathForAgent
+} from "./chunk-PH2FXKOU.mjs";
+import "./chunk-LZOMFHX3.mjs";
+
+// src/react/use-agent.ts
+import { Chat, useChat } from "@ai-sdk/react";
+import { DefaultChatTransport } from "ai";
+import { useEffect, useMemo, useRef, useState } from "react";
+function useAgent(name, {
+  headers,
+  id,
+  ...options
+} = {}) {
+  const basePath = options.basePath ?? basePathForAgent(name);
+  const [agentStatus, setAgentStatus] = useState(null);
+  const onData = useRef(options.onData);
+  useEffect(() => {
+    onData.current = options.onData;
+  }, [options.onData]);
+  const chat = useChat({
+    chat: useMemo(
+      () => new Chat({
+        id,
+        transport: new DefaultChatTransport({
+          api: basePath,
+          prepareSendMessagesRequest: async ({ messages }) => {
+            const h = await (typeof headers === "function" ? headers() : headers);
+            const lastAssistant = messages.findLast(
+              (m) => m.role === "assistant"
+            );
+            const lastPartContent = lastAssistant?.parts.at(-1);
+            const lastPart = lastAssistant && lastPartContent != null ? {
+              index: lastAssistant.parts.length - 1,
+              part: lastPartContent
+            } : void 0;
+            const body = {
+              message: messages.at(-1),
+              interruptIfStreaming: lastPart ? { lastPart } : true
+            };
+            return {
+              body,
+              headers: new Headers(h),
+              api: `${basePath}/${id}`
+            };
+          },
+          prepareReconnectToStreamRequest: async (request) => {
+            const h = await (typeof headers === "function" ? headers() : headers);
+            return {
+              ...request,
+              api: `${basePath}/${id}/reconnect`,
+              headers: h
+            };
+          }
+        }),
+        onData: (_part) => {
+          const part = _part;
+          if (part.type === "data-status") {
+            setAgentStatus(part.data);
+          }
+          onData.current?.(part);
+        }
+      }),
+      [id, basePath, headers]
+    )
+  });
+  return {
+    chat,
+    agentStatus
+  };
+}
+
+// src/react/use-history-query.ts
+import { skipToken } from "@tanstack/react-query";
+
+// src/react/use-query.ts
+import {
+  QueryClient,
+  useMutation as useUpstreamMutation,
+  useQuery as useUpstreamQuery
+} from "@tanstack/react-query";
+var client = new QueryClient();
+function useQuery(options) {
+  return useUpstreamQuery(options, client);
+}
+
+// src/react/use-history-query.ts
+function useSessionHistory(options) {
+  return useQuery({
+    ...options.options,
+    queryKey: ["history", options.sessionId],
+    queryFn: options.sessionId ? async () => {
+      const path = `${options.basePath}/${options.sessionId}`;
+      return await fetch(path).then((res) => res.json());
+    } : skipToken
+  });
+}
+
+// src/react/use-interrupt.ts
+import { useMutation } from "@tanstack/react-query";
+function useInterruptSession(options) {
+  return useMutation({
+    mutationFn: async (input) => {
+      const path = `${options.basePath}/${options.sessionId}/interrupt`;
+      return await fetch(path, {
+        method: "POST",
+        body: JSON.stringify(input)
+      }).then((res) => res.json());
+    }
+  });
+}
+export {
+  useAgent,
+  useInterruptSession,
+  useSessionHistory
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/react/use-agent.ts", "../src/react/use-history-query.ts", "../src/react/use-query.ts", "../src/react/use-interrupt.ts"],
  "sourcesContent": ["import { Chat, useChat } from \"@ai-sdk/react\";\nimport { DefaultChatTransport } from \"ai\";\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nimport type { AgentStatus, AnyAgent } from \"../agent/client\";\nimport { basePathForAgent } from \"../rpc/base-path\";\n\ntype DataEvent = {\n  type: \"data-status\";\n  data: AgentStatus;\n};\n\nexport function useAgent<Agent extends AnyAgent>(\n  name: Agent[\"name\"],\n  {\n    headers,\n    id,\n    ...options\n  }: {\n    basePath?: string;\n    headers?: HeadersInit | (() => Promise<HeadersInit>);\n    id?: string;\n    onData?: (data: DataEvent) => void;\n  } = {}\n) {\n  const basePath = options.basePath ?? basePathForAgent(name);\n  const [agentStatus, setAgentStatus] = useState<AgentStatus | null>(null);\n  const onData = useRef(options.onData);\n  useEffect(() => {\n    onData.current = options.onData;\n  }, [options.onData]);\n  const chat = useChat<Agent[\"$UIMessage\"]>({\n    chat: useMemo(\n      () =>\n        new Chat({\n          id,\n          transport: new DefaultChatTransport({\n            api: basePath,\n            prepareSendMessagesRequest: async ({ messages }) => {\n              const h = await (typeof headers === \"function\"\n                ? headers()\n                : headers);\n              const lastAssistant = messages.findLast(\n                (m) => m.role === \"assistant\"\n              );\n              const lastPartContent = lastAssistant?.parts.at(-1);\n              const lastPart =\n                lastAssistant && lastPartContent != null\n                  ? {\n                      index: lastAssistant.parts.length - 1,\n                      part: lastPartContent,\n                    }\n                  : undefined;\n              const body: Record<string, unknown> = {\n                message: messages.at(-1),\n                interruptIfStreaming: lastPart ? { lastPart } : true,\n              };\n              return {\n                body,\n                headers: new Headers(h),\n                api: `${basePath}/${id}`,\n              };\n            },\n            prepareReconnectToStreamRequest: async (request) => {\n              const h = await (typeof headers === \"function\"\n                ? headers()\n                : headers);\n              return {\n                ...request,\n                api: `${basePath}/${id}/reconnect`,\n                headers: h,\n              };\n            },\n          }),\n          onData: (_part) => {\n            const part = _part as unknown as DataEvent;\n            if (part.type === \"data-status\") {\n              setAgentStatus(part.data);\n            }\n            onData.current?.(part);\n          },\n        }),\n      [id, basePath, headers]\n    ),\n  });\n\n  return {\n    chat,\n    agentStatus,\n  };\n}\n", "import { type QueryOptions, skipToken } from \"@tanstack/react-query\";\nimport type { AnyAgent } from \"../agent/client\";\nimport { useQuery } from \"./use-query\";\n\ntype Response<Agent extends AnyAgent> = Awaited<\n  ReturnType<ReturnType<Agent[\"session\"]>[\"history\"]>\n>;\n\nexport function useSessionHistory<Agent extends AnyAgent>(options: {\n  basePath?: string;\n  sessionId: string | undefined;\n  options?: Omit<QueryOptions<Response<Agent>>, \"queryKey\" | \"queryFn\">;\n}) {\n  return useQuery<Response<Agent>>({\n    ...options.options,\n    queryKey: [\"history\", options.sessionId],\n    queryFn: options.sessionId\n      ? async () => {\n          const path = `${options.basePath}/${options.sessionId}`;\n          return await fetch(path).then((res) => res.json());\n        }\n      : skipToken,\n  });\n}\n", "import {\n  QueryClient,\n  type UseMutationOptions,\n  type UseQueryOptions,\n  useMutation as useUpstreamMutation,\n  useQuery as useUpstreamQuery,\n} from \"@tanstack/react-query\";\n\nconst client = new QueryClient();\n\nexport function useQuery<T>(options: UseQueryOptions<T>) {\n  return useUpstreamQuery<T>(options, client);\n}\n\nexport function useMutation<T, Variables, Error, Data>(\n  options: UseMutationOptions<T, Variables, Error, Data>\n) {\n  return useUpstreamMutation<T, Variables, Error, Data>(options, client);\n}\n", "import { useMutation } from \"@tanstack/react-query\";\nimport type { AnyAgent } from \"../agent/client\";\n\ntype Fn<Agent extends AnyAgent> = ReturnType<Agent[\"session\"]>[\"interrupt\"];\ntype Response<Agent extends AnyAgent> = Awaited<ReturnType<Fn<Agent>>>;\ntype Variables<Agent extends AnyAgent> = Parameters<Fn<Agent>>[0];\n\nexport function useInterruptSession<Agent extends AnyAgent>(options: {\n  basePath?: string;\n  sessionId: string;\n}) {\n  return useMutation<Response<Agent>, Error, Variables<Agent>, void>({\n    mutationFn: async (input) => {\n      const path = `${options.basePath}/${options.sessionId}/interrupt`;\n      return await fetch(path, {\n        method: \"POST\",\n        body: JSON.stringify(input),\n      }).then((res) => res.json());\n    },\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/sandbox.d.mts

@@ -1,6 +1,6 @@
-export { E as ExecResult, d as SandboxAgentRef, S as SandboxBinding, b as SandboxInstance, a as SandboxSetupFields, U as UploadableFile } from './steps-eTytqxQb.mjs';
-export { d as dockerSandbox, l as localSandbox, v as vercelSandbox } from './entry-Bs17QEiq.mjs';
+export { E as ExecResult, S as SandboxAgentRef, a as SandboxBinding, b as SandboxInstance, c as SandboxSetupFields, U as UploadableFile } from './steps-Mi3sjYbD.mjs';
+export { d as dockerSandbox, l as localSandbox, v as vercelSandbox } from './entry-BUiucCNp.mjs';
 import '@vercel/sandbox';
-import './adapter-Cl735Kp4.mjs';
+import './adapter-txsF6hou.mjs';
 import '@workflow/serde';
 import 'ai';

package/dist/sandbox.d.ts

@@ -1,6 +1,6 @@
-export { E as ExecResult, d as SandboxAgentRef, S as SandboxBinding, b as SandboxInstance, a as SandboxSetupFields, U as UploadableFile } from './steps-XA4wG8W3.js';
-export { d as dockerSandbox, l as localSandbox, v as vercelSandbox } from './entry-QNyd4S1s.js';
+export { E as ExecResult, S as SandboxAgentRef, a as SandboxBinding, b as SandboxInstance, c as SandboxSetupFields, U as UploadableFile } from './steps-BOKeU8X3.js';
+export { d as dockerSandbox, l as localSandbox, v as vercelSandbox } from './entry-ok9EBUS3.js';
 import '@vercel/sandbox';
-import './adapter-Cl735Kp4.js';
+import './adapter-txsF6hou.js';
 import '@workflow/serde';
 import 'ai';