@langchain/react 0.3.5 → 1.0.0

package/dist/context.cjs

@@ -1,15 +1,16 @@
 "use client";
-const require_stream = require("./stream.cjs");
+const require_use_stream = require("./use-stream.cjs");
 let react = require("react");
 let react_jsx_runtime = require("react/jsx-runtime");
 //#region src/context.tsx
 const StreamContext = (0, react.createContext)(null);
 /**
-* Provides a shared `useStream` instance to all descendants via React Context.
+* Provides a shared {@link useStream} instance to all descendants via
+* React Context.
 *
-* Use `StreamProvider` when multiple components in a subtree need access to the
-* same stream state (messages, loading status, errors, interrupts, etc.) without
-* prop drilling.
+* Use `StreamProvider` when multiple components in a subtree need
+* access to the same stream state (messages, loading status, errors,
+* interrupts, …) without prop drilling.
 *
 * @example
 * ```tsx
@@ -34,20 +35,6 @@ const StreamContext = (0, react.createContext)(null);
 *     </header>
 *   );
 * }
-*
-* function MessageList() {
-*   const { messages } = useStreamContext();
-*   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);
-* }
-*
-* function MessageInput() {
-*   const { submit } = useStreamContext();
-*   return (
-*     <button onClick={() => submit({ messages: [{ type: "human", content: "Hi" }] })}>
-*       Send
-*     </button>
-*   );
-* }
 * ```
 *
 * Multiple providers can be nested for multi-agent scenarios:
@@ -64,35 +51,30 @@ const StreamContext = (0, react.createContext)(null);
 */
 function StreamProvider(props) {
 	const { children, ...options } = props;
-	const stream = require_stream.useStream(options);
+	const stream = require_use_stream.useStream(options);
 	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(StreamContext.Provider, {
 		value: stream,
 		children
 	});
 }
 /**
-* Accesses the shared stream instance from the nearest `StreamProvider`.
-*
-* Throws if called outside of a `StreamProvider`.
+* Accesses the shared stream instance from the nearest
+* {@link StreamProvider}. Throws if called outside of one.
 *
 * @example
 * ```tsx
 * function MessageList() {
-*   const { messages, getMessagesMetadata } = useStreamContext();
-*   return messages.map((msg, i) => {
-*     const metadata = getMessagesMetadata(msg, i);
-*     return <div key={msg.id ?? i}>{msg.content}</div>;
-*   });
+*   const { messages } = useStreamContext();
+*   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);
 * }
 * ```
 *
-* @example With type parameters for full type safety:
+* @example With a type parameter for full type safety:
 * ```tsx
 * import type { agent } from "./agent";
 *
 * function Chat() {
 *   const { toolCalls } = useStreamContext<typeof agent>();
-*   // toolCalls are fully typed from the agent's tools
 * }
 * ```
 */

package/dist/context.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"context.cjs","names":["useStream"],"sources":["../src/context.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { createContext, useContext, type ReactNode } from \"react\";\nimport type { BagTemplate } from \"@langchain/langgraph-sdk\";\nimport type {\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n  UseStreamCustomOptions,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { useStream } from \"./stream.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst StreamContext = createContext<any | null>(null);\n\n/**\n * Props for the StreamProvider component.\n * Accepts all `useStream` options plus `children`.\n */\nexport type StreamProviderProps<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = ResolveStreamOptions<T, InferBag<T, Bag>> & { children: ReactNode };\n\n/**\n * Props for the StreamProvider component when using a custom transport.\n * Accepts all `useStream` custom options plus `children`.\n */\nexport type StreamProviderCustomProps<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>> & {\n  children: ReactNode;\n};\n\n/**\n * Provides a shared `useStream` instance to all descendants via React Context.\n *\n * Use `StreamProvider` when multiple components in a subtree need access to the\n * same stream state (messages, loading status, errors, interrupts, etc.) without\n * prop drilling.\n *\n * @example\n * ```tsx\n * import { StreamProvider, useStreamContext } from \"@langchain/react\";\n *\n * function App() {\n *   return (\n *     <StreamProvider assistantId=\"agent\" apiUrl=\"http://localhost:2024\">\n *       <ChatHeader />\n *       <MessageList />\n *       <MessageInput />\n *     </StreamProvider>\n *   );\n * }\n *\n * function ChatHeader() {\n *   const { isLoading, error } = useStreamContext();\n *   return (\n *     <header>\n *       {isLoading && <span>Thinking...</span>}\n *       {error && <span>Error</span>}\n *     </header>\n *   );\n * }\n *\n * function MessageList() {\n *   const { messages } = useStreamContext();\n *   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);\n * }\n *\n * function MessageInput() {\n *   const { submit } = useStreamContext();\n *   return (\n *     <button onClick={() => submit({ messages: [{ type: \"human\", content: \"Hi\" }] })}>\n *       Send\n *     </button>\n *   );\n * }\n * ```\n *\n * Multiple providers can be nested for multi-agent scenarios:\n *\n * @example\n * ```tsx\n * <StreamProvider assistantId=\"researcher\" apiUrl=\"http://localhost:2024\">\n *   <ResearchPanel />\n * </StreamProvider>\n * <StreamProvider assistantId=\"writer\" apiUrl=\"http://localhost:2024\">\n *   <WriterPanel />\n * </StreamProvider>\n * ```\n */\nexport function StreamProvider<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  props: StreamProviderProps<T, Bag> | StreamProviderCustomProps<T, Bag>\n): ReactNode {\n  const { children, ...options } = props;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const stream = useStream<T, Bag>(options as any);\n\n  return (\n    <StreamContext.Provider value={stream}>{children}</StreamContext.Provider>\n  );\n}\n\n/**\n * Accesses the shared stream instance from the nearest `StreamProvider`.\n *\n * Throws if called outside of a `StreamProvider`.\n *\n * @example\n * ```tsx\n * function MessageList() {\n *   const { messages, getMessagesMetadata } = useStreamContext();\n *   return messages.map((msg, i) => {\n *     const metadata = getMessagesMetadata(msg, i);\n *     return <div key={msg.id ?? i}>{msg.content}</div>;\n *   });\n * }\n * ```\n *\n * @example With type parameters for full type safety:\n * ```tsx\n * import type { agent } from \"./agent\";\n *\n * function Chat() {\n *   const { toolCalls } = useStreamContext<typeof agent>();\n *   // toolCalls are fully typed from the agent's tools\n * }\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): ReturnType<typeof useStream<T, Bag>> {\n  const context = useContext(StreamContext);\n  if (context === null) {\n    throw new Error(\n      \"useStreamContext must be used within a <StreamProvider>. \" +\n        \"Wrap your component tree with <StreamProvider> or use useStream() directly.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;;;AAeA,MAAM,iBAAA,GAAA,MAAA,eAA0C,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFrD,SAAgB,eAId,OACW;CACX,MAAM,EAAE,UAAU,GAAG,YAAY;CAEjC,MAAM,SAASA,eAAAA,UAAkB,QAAe;AAEhD,QACE,iBAAA,GAAA,kBAAA,KAAC,cAAc,UAAf;EAAwB,OAAO;EAAS;EAAkC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B9E,SAAgB,mBAG0B;CACxC,MAAM,WAAA,GAAA,MAAA,YAAqB,cAAc;AACzC,KAAI,YAAY,KACd,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}
+{"version":3,"file":"context.cjs","names":["useStream"],"sources":["../src/context.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { createContext, useContext, type ReactNode } from \"react\";\nimport {\n  useStream,\n  type UseStreamOptions,\n  type UseStreamReturn,\n  type AgentServerOptions,\n  type CustomAdapterOptions,\n} from \"./use-stream.js\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst StreamContext = createContext<any | null>(null);\n\n/**\n * Props for {@link StreamProvider} when talking to the default\n * LangGraph Platform agent server. Mirrors {@link AgentServerOptions}\n * plus `children`.\n */\nexport type StreamProviderProps<T = Record<string, unknown>> =\n  AgentServerOptions<InferStateType<T>> & {\n    children: ReactNode;\n  };\n\n/**\n * Props for {@link StreamProvider} when wiring a custom\n * {@link AgentServerAdapter}. Mirrors {@link CustomAdapterOptions}\n * plus `children`.\n */\nexport type StreamProviderCustomProps<T = Record<string, unknown>> =\n  CustomAdapterOptions<InferStateType<T>> & {\n    children: ReactNode;\n  };\n\n/**\n * Provides a shared {@link useStream} instance to all descendants via\n * React Context.\n *\n * Use `StreamProvider` when multiple components in a subtree need\n * access to the same stream state (messages, loading status, errors,\n * interrupts, …) without prop drilling.\n *\n * @example\n * ```tsx\n * import { StreamProvider, useStreamContext } from \"@langchain/react\";\n *\n * function App() {\n *   return (\n *     <StreamProvider assistantId=\"agent\" apiUrl=\"http://localhost:2024\">\n *       <ChatHeader />\n *       <MessageList />\n *       <MessageInput />\n *     </StreamProvider>\n *   );\n * }\n *\n * function ChatHeader() {\n *   const { isLoading, error } = useStreamContext();\n *   return (\n *     <header>\n *       {isLoading && <span>Thinking...</span>}\n *       {error && <span>Error</span>}\n *     </header>\n *   );\n * }\n * ```\n *\n * Multiple providers can be nested for multi-agent scenarios:\n *\n * @example\n * ```tsx\n * <StreamProvider assistantId=\"researcher\" apiUrl=\"http://localhost:2024\">\n *   <ResearchPanel />\n * </StreamProvider>\n * <StreamProvider assistantId=\"writer\" apiUrl=\"http://localhost:2024\">\n *   <WriterPanel />\n * </StreamProvider>\n * ```\n */\nexport function StreamProvider<T = Record<string, unknown>>(\n  props: StreamProviderProps<T> | StreamProviderCustomProps<T>\n): ReactNode {\n  const { children, ...options } = props;\n  const stream = useStream<T>(options as UseStreamOptions<InferStateType<T>>);\n\n  return (\n    <StreamContext.Provider value={stream}>{children}</StreamContext.Provider>\n  );\n}\n\n/**\n * Accesses the shared stream instance from the nearest\n * {@link StreamProvider}. Throws if called outside of one.\n *\n * @example\n * ```tsx\n * function MessageList() {\n *   const { messages } = useStreamContext();\n *   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);\n * }\n * ```\n *\n * @example With a type parameter for full type safety:\n * ```tsx\n * import type { agent } from \"./agent\";\n *\n * function Chat() {\n *   const { toolCalls } = useStreamContext<typeof agent>();\n * }\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n>(): UseStreamReturn<T> {\n  const context = useContext(StreamContext);\n  if (context === null) {\n    throw new Error(\n      \"useStreamContext must be used within a <StreamProvider>. \" +\n        \"Wrap your component tree with <StreamProvider> or use useStream() directly.\"\n    );\n  }\n  return context as UseStreamReturn<T>;\n}\n"],"mappings":";;;;;AAeA,MAAM,iBAAA,GAAA,MAAA,eAA0C,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmErD,SAAgB,eACd,OACW;CACX,MAAM,EAAE,UAAU,GAAG,YAAY;CACjC,MAAM,SAASA,mBAAAA,UAAa,QAA+C;AAE3E,QACE,iBAAA,GAAA,kBAAA,KAAC,cAAc,UAAf;EAAwB,OAAO;EAAS;EAAkC,CAAA;;;;;;;;;;;;;;;;;;;;;;;AAyB9E,SAAgB,mBAEQ;CACtB,MAAM,WAAA,GAAA,MAAA,YAAqB,cAAc;AACzC,KAAI,YAAY,KACd,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}

package/dist/context.d.cts

@@ -1,29 +1,31 @@
-import { useStream } from "./stream.cjs";
-import { BagTemplate } from "@langchain/langgraph-sdk";
-import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
+import { AgentServerOptions as AgentServerOptions$1, CustomAdapterOptions as CustomAdapterOptions$1, UseStreamReturn } from "./use-stream.cjs";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
 import { ReactNode } from "react";
 
 //#region src/context.d.ts
 /**
- * Props for the StreamProvider component.
- * Accepts all `useStream` options plus `children`.
+ * Props for {@link StreamProvider} when talking to the default
+ * LangGraph Platform agent server. Mirrors {@link AgentServerOptions}
+ * plus `children`.
  */
-type StreamProviderProps<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = ResolveStreamOptions<T, InferBag<T, Bag>> & {
+type StreamProviderProps<T = Record<string, unknown>> = AgentServerOptions$1<InferStateType<T>> & {
   children: ReactNode;
 };
 /**
- * Props for the StreamProvider component when using a custom transport.
- * Accepts all `useStream` custom options plus `children`.
+ * Props for {@link StreamProvider} when wiring a custom
+ * {@link AgentServerAdapter}. Mirrors {@link CustomAdapterOptions}
+ * plus `children`.
  */
-type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>> & {
+type StreamProviderCustomProps<T = Record<string, unknown>> = CustomAdapterOptions$1<InferStateType<T>> & {
   children: ReactNode;
 };
 /**
- * Provides a shared `useStream` instance to all descendants via React Context.
+ * Provides a shared {@link useStream} instance to all descendants via
+ * React Context.
  *
- * Use `StreamProvider` when multiple components in a subtree need access to the
- * same stream state (messages, loading status, errors, interrupts, etc.) without
- * prop drilling.
+ * Use `StreamProvider` when multiple components in a subtree need
+ * access to the same stream state (messages, loading status, errors,
+ * interrupts, …) without prop drilling.
  *
  * @example
  * ```tsx
@@ -48,20 +50,6 @@ type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTempl
  *     </header>
  *   );
  * }
- *
- * function MessageList() {
- *   const { messages } = useStreamContext();
- *   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);
- * }
- *
- * function MessageInput() {
- *   const { submit } = useStreamContext();
- *   return (
- *     <button onClick={() => submit({ messages: [{ type: "human", content: "Hi" }] })}>
- *       Send
- *     </button>
- *   );
- * }
  * ```
  *
  * Multiple providers can be nested for multi-agent scenarios:
@@ -76,34 +64,29 @@ type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTempl
  * </StreamProvider>
  * ```
  */
-declare function StreamProvider<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(props: StreamProviderProps<T, Bag> | StreamProviderCustomProps<T, Bag>): ReactNode;
+declare function StreamProvider<T = Record<string, unknown>>(props: StreamProviderProps<T> | StreamProviderCustomProps<T>): ReactNode;
 /**
- * Accesses the shared stream instance from the nearest `StreamProvider`.
- *
- * Throws if called outside of a `StreamProvider`.
+ * Accesses the shared stream instance from the nearest
+ * {@link StreamProvider}. Throws if called outside of one.
  *
  * @example
  * ```tsx
  * function MessageList() {
- *   const { messages, getMessagesMetadata } = useStreamContext();
- *   return messages.map((msg, i) => {
- *     const metadata = getMessagesMetadata(msg, i);
- *     return <div key={msg.id ?? i}>{msg.content}</div>;
- *   });
+ *   const { messages } = useStreamContext();
+ *   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);
  * }
  * ```
  *
- * @example With type parameters for full type safety:
+ * @example With a type parameter for full type safety:
  * ```tsx
  * import type { agent } from "./agent";
  *
  * function Chat() {
  *   const { toolCalls } = useStreamContext<typeof agent>();
- *   // toolCalls are fully typed from the agent's tools
  * }
  * ```
  */
-declare function useStreamContext<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
+declare function useStreamContext<T = Record<string, unknown>>(): UseStreamReturn<T>;
 //#endregion
 export { StreamProvider, StreamProviderCustomProps, StreamProviderProps, useStreamContext };
 //# sourceMappingURL=context.d.cts.map

package/dist/context.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.tsx"],"mappings":";;;;;;;;AAqBA;;KAAY,mBAAA,KACN,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;EAAU,QAAA,EAAU,SAAA;AAAA;;;;;KAMhD,yBAAA,KACN,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA;EACxD,QAAA,EAAU,SAAA;AAAA;;;;;;;;;;;;;;;;;AAJZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA;;;;;;;;;;;;iBAAgB,cAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,KAAA,EAAO,mBAAA,CAAoB,CAAA,EAAG,GAAA,IAAO,yBAAA,CAA0B,CAAA,EAAG,GAAA,IACjE,SAAA;;;;;;;;;;;;;;;;;;AAoCH;;;;;;;;;iBAAgB,gBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}
+{"version":3,"file":"context.d.cts","names":[],"sources":["../src/context.tsx"],"mappings":";;;;;;;AAsBA;;;KAAY,mBAAA,KAAwB,MAAA,qBAClC,oBAAA,CAAmB,cAAA,CAAe,CAAA;EAChC,QAAA,EAAU,SAAA;AAAA;;;;;;KAQF,yBAAA,KAA8B,MAAA,qBACxC,sBAAA,CAAqB,cAAA,CAAe,CAAA;EAClC,QAAA,EAAU,SAAA;AAAA;;;;;;AAFd;;;;;;;;;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,KAAmB,MAAA,kBAAA,CACjC,KAAA,EAAO,mBAAA,CAAoB,CAAA,IAAK,yBAAA,CAA0B,CAAA,IACzD,SAAA;;;;;;;;;;;;;;;;;;;;;;iBA8Ba,gBAAA,KACV,MAAA,kBAAA,CAAA,GACD,eAAA,CAAgB,CAAA"}

package/dist/context.d.ts

@@ -1,29 +1,31 @@
-import { useStream } from "./stream.js";
+import { AgentServerOptions as AgentServerOptions$1, CustomAdapterOptions as CustomAdapterOptions$1, UseStreamReturn } from "./use-stream.js";
 import { ReactNode } from "react";
-import { InferBag, InferStateType, ResolveStreamOptions, UseStreamCustomOptions } from "@langchain/langgraph-sdk/ui";
-import { BagTemplate } from "@langchain/langgraph-sdk";
+import { InferStateType } from "@langchain/langgraph-sdk/stream";
 
 //#region src/context.d.ts
 /**
- * Props for the StreamProvider component.
- * Accepts all `useStream` options plus `children`.
+ * Props for {@link StreamProvider} when talking to the default
+ * LangGraph Platform agent server. Mirrors {@link AgentServerOptions}
+ * plus `children`.
  */
-type StreamProviderProps<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = ResolveStreamOptions<T, InferBag<T, Bag>> & {
+type StreamProviderProps<T = Record<string, unknown>> = AgentServerOptions$1<InferStateType<T>> & {
   children: ReactNode;
 };
 /**
- * Props for the StreamProvider component when using a custom transport.
- * Accepts all `useStream` custom options plus `children`.
+ * Props for {@link StreamProvider} when wiring a custom
+ * {@link AgentServerAdapter}. Mirrors {@link CustomAdapterOptions}
+ * plus `children`.
  */
-type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate> = UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>> & {
+type StreamProviderCustomProps<T = Record<string, unknown>> = CustomAdapterOptions$1<InferStateType<T>> & {
   children: ReactNode;
 };
 /**
- * Provides a shared `useStream` instance to all descendants via React Context.
+ * Provides a shared {@link useStream} instance to all descendants via
+ * React Context.
  *
- * Use `StreamProvider` when multiple components in a subtree need access to the
- * same stream state (messages, loading status, errors, interrupts, etc.) without
- * prop drilling.
+ * Use `StreamProvider` when multiple components in a subtree need
+ * access to the same stream state (messages, loading status, errors,
+ * interrupts, …) without prop drilling.
  *
  * @example
  * ```tsx
@@ -48,20 +50,6 @@ type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTempl
  *     </header>
  *   );
  * }
- *
- * function MessageList() {
- *   const { messages } = useStreamContext();
- *   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);
- * }
- *
- * function MessageInput() {
- *   const { submit } = useStreamContext();
- *   return (
- *     <button onClick={() => submit({ messages: [{ type: "human", content: "Hi" }] })}>
- *       Send
- *     </button>
- *   );
- * }
  * ```
  *
  * Multiple providers can be nested for multi-agent scenarios:
@@ -76,34 +64,29 @@ type StreamProviderCustomProps<T = Record<string, unknown>, Bag extends BagTempl
  * </StreamProvider>
  * ```
  */
-declare function StreamProvider<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(props: StreamProviderProps<T, Bag> | StreamProviderCustomProps<T, Bag>): ReactNode;
+declare function StreamProvider<T = Record<string, unknown>>(props: StreamProviderProps<T> | StreamProviderCustomProps<T>): ReactNode;
 /**
- * Accesses the shared stream instance from the nearest `StreamProvider`.
- *
- * Throws if called outside of a `StreamProvider`.
+ * Accesses the shared stream instance from the nearest
+ * {@link StreamProvider}. Throws if called outside of one.
  *
  * @example
  * ```tsx
  * function MessageList() {
- *   const { messages, getMessagesMetadata } = useStreamContext();
- *   return messages.map((msg, i) => {
- *     const metadata = getMessagesMetadata(msg, i);
- *     return <div key={msg.id ?? i}>{msg.content}</div>;
- *   });
+ *   const { messages } = useStreamContext();
+ *   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);
  * }
  * ```
  *
- * @example With type parameters for full type safety:
+ * @example With a type parameter for full type safety:
  * ```tsx
  * import type { agent } from "./agent";
  *
  * function Chat() {
  *   const { toolCalls } = useStreamContext<typeof agent>();
- *   // toolCalls are fully typed from the agent's tools
  * }
  * ```
  */
-declare function useStreamContext<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(): ReturnType<typeof useStream<T, Bag>>;
+declare function useStreamContext<T = Record<string, unknown>>(): UseStreamReturn<T>;
 //#endregion
 export { StreamProvider, StreamProviderCustomProps, StreamProviderProps, useStreamContext };
 //# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.tsx"],"mappings":";;;;;;;;AAqBA;;KAAY,mBAAA,KACN,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;EAAU,QAAA,EAAU,SAAA;AAAA;;;;;KAMhD,yBAAA,KACN,MAAA,+BACQ,WAAA,GAAc,WAAA,IACxB,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA;EACxD,QAAA,EAAU,SAAA;AAAA;;;;;;;;;;;;;;;;;AAJZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEA;;;;;;;;;;;;iBAAgB,cAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,KAAA,EAAO,mBAAA,CAAoB,CAAA,EAAG,GAAA,IAAO,yBAAA,CAA0B,CAAA,EAAG,GAAA,IACjE,SAAA;;;;;;;;;;;;;;;;;;AAoCH;;;;;;;;;iBAAgB,gBAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAAA,GACvB,UAAA,QAAkB,SAAA,CAAU,CAAA,EAAG,GAAA"}
+{"version":3,"file":"context.d.ts","names":[],"sources":["../src/context.tsx"],"mappings":";;;;;;;AAsBA;;;KAAY,mBAAA,KAAwB,MAAA,qBAClC,oBAAA,CAAmB,cAAA,CAAe,CAAA;EAChC,QAAA,EAAU,SAAA;AAAA;;;;;;KAQF,yBAAA,KAA8B,MAAA,qBACxC,sBAAA,CAAqB,cAAA,CAAe,CAAA;EAClC,QAAA,EAAU,SAAA;AAAA;;;;;;AAFd;;;;;;;;;;;;;;;;;;;AAkDA;;;;;;;;;;;;;;;;;;;;;iBAAgB,cAAA,KAAmB,MAAA,kBAAA,CACjC,KAAA,EAAO,mBAAA,CAAoB,CAAA,IAAK,yBAAA,CAA0B,CAAA,IACzD,SAAA;;;;;;;;;;;;;;;;;;;;;;iBA8Ba,gBAAA,KACV,MAAA,kBAAA,CAAA,GACD,eAAA,CAAgB,CAAA"}

package/dist/context.js

@@ -1,15 +1,16 @@
 "use client";
-import { useStream } from "./stream.js";
+import { useStream } from "./use-stream.js";
 import { createContext, useContext } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/context.tsx
 const StreamContext = createContext(null);
 /**
-* Provides a shared `useStream` instance to all descendants via React Context.
+* Provides a shared {@link useStream} instance to all descendants via
+* React Context.
 *
-* Use `StreamProvider` when multiple components in a subtree need access to the
-* same stream state (messages, loading status, errors, interrupts, etc.) without
-* prop drilling.
+* Use `StreamProvider` when multiple components in a subtree need
+* access to the same stream state (messages, loading status, errors,
+* interrupts, …) without prop drilling.
 *
 * @example
 * ```tsx
@@ -34,20 +35,6 @@ const StreamContext = createContext(null);
 *     </header>
 *   );
 * }
-*
-* function MessageList() {
-*   const { messages } = useStreamContext();
-*   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);
-* }
-*
-* function MessageInput() {
-*   const { submit } = useStreamContext();
-*   return (
-*     <button onClick={() => submit({ messages: [{ type: "human", content: "Hi" }] })}>
-*       Send
-*     </button>
-*   );
-* }
 * ```
 *
 * Multiple providers can be nested for multi-agent scenarios:
@@ -71,28 +58,23 @@ function StreamProvider(props) {
 	});
 }
 /**
-* Accesses the shared stream instance from the nearest `StreamProvider`.
-*
-* Throws if called outside of a `StreamProvider`.
+* Accesses the shared stream instance from the nearest
+* {@link StreamProvider}. Throws if called outside of one.
 *
 * @example
 * ```tsx
 * function MessageList() {
-*   const { messages, getMessagesMetadata } = useStreamContext();
-*   return messages.map((msg, i) => {
-*     const metadata = getMessagesMetadata(msg, i);
-*     return <div key={msg.id ?? i}>{msg.content}</div>;
-*   });
+*   const { messages } = useStreamContext();
+*   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);
 * }
 * ```
 *
-* @example With type parameters for full type safety:
+* @example With a type parameter for full type safety:
 * ```tsx
 * import type { agent } from "./agent";
 *
 * function Chat() {
 *   const { toolCalls } = useStreamContext<typeof agent>();
-*   // toolCalls are fully typed from the agent's tools
 * }
 * ```
 */

package/dist/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","names":[],"sources":["../src/context.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { createContext, useContext, type ReactNode } from \"react\";\nimport type { BagTemplate } from \"@langchain/langgraph-sdk\";\nimport type {\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n  UseStreamCustomOptions,\n} from \"@langchain/langgraph-sdk/ui\";\nimport { useStream } from \"./stream.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst StreamContext = createContext<any | null>(null);\n\n/**\n * Props for the StreamProvider component.\n * Accepts all `useStream` options plus `children`.\n */\nexport type StreamProviderProps<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = ResolveStreamOptions<T, InferBag<T, Bag>> & { children: ReactNode };\n\n/**\n * Props for the StreamProvider component when using a custom transport.\n * Accepts all `useStream` custom options plus `children`.\n */\nexport type StreamProviderCustomProps<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n> = UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>> & {\n  children: ReactNode;\n};\n\n/**\n * Provides a shared `useStream` instance to all descendants via React Context.\n *\n * Use `StreamProvider` when multiple components in a subtree need access to the\n * same stream state (messages, loading status, errors, interrupts, etc.) without\n * prop drilling.\n *\n * @example\n * ```tsx\n * import { StreamProvider, useStreamContext } from \"@langchain/react\";\n *\n * function App() {\n *   return (\n *     <StreamProvider assistantId=\"agent\" apiUrl=\"http://localhost:2024\">\n *       <ChatHeader />\n *       <MessageList />\n *       <MessageInput />\n *     </StreamProvider>\n *   );\n * }\n *\n * function ChatHeader() {\n *   const { isLoading, error } = useStreamContext();\n *   return (\n *     <header>\n *       {isLoading && <span>Thinking...</span>}\n *       {error && <span>Error</span>}\n *     </header>\n *   );\n * }\n *\n * function MessageList() {\n *   const { messages } = useStreamContext();\n *   return messages.map((msg, i) => <div key={msg.id ?? i}>{msg.content}</div>);\n * }\n *\n * function MessageInput() {\n *   const { submit } = useStreamContext();\n *   return (\n *     <button onClick={() => submit({ messages: [{ type: \"human\", content: \"Hi\" }] })}>\n *       Send\n *     </button>\n *   );\n * }\n * ```\n *\n * Multiple providers can be nested for multi-agent scenarios:\n *\n * @example\n * ```tsx\n * <StreamProvider assistantId=\"researcher\" apiUrl=\"http://localhost:2024\">\n *   <ResearchPanel />\n * </StreamProvider>\n * <StreamProvider assistantId=\"writer\" apiUrl=\"http://localhost:2024\">\n *   <WriterPanel />\n * </StreamProvider>\n * ```\n */\nexport function StreamProvider<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(\n  props: StreamProviderProps<T, Bag> | StreamProviderCustomProps<T, Bag>\n): ReactNode {\n  const { children, ...options } = props;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const stream = useStream<T, Bag>(options as any);\n\n  return (\n    <StreamContext.Provider value={stream}>{children}</StreamContext.Provider>\n  );\n}\n\n/**\n * Accesses the shared stream instance from the nearest `StreamProvider`.\n *\n * Throws if called outside of a `StreamProvider`.\n *\n * @example\n * ```tsx\n * function MessageList() {\n *   const { messages, getMessagesMetadata } = useStreamContext();\n *   return messages.map((msg, i) => {\n *     const metadata = getMessagesMetadata(msg, i);\n *     return <div key={msg.id ?? i}>{msg.content}</div>;\n *   });\n * }\n * ```\n *\n * @example With type parameters for full type safety:\n * ```tsx\n * import type { agent } from \"./agent\";\n *\n * function Chat() {\n *   const { toolCalls } = useStreamContext<typeof agent>();\n *   // toolCalls are fully typed from the agent's tools\n * }\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate,\n>(): ReturnType<typeof useStream<T, Bag>> {\n  const context = useContext(StreamContext);\n  if (context === null) {\n    throw new Error(\n      \"useStreamContext must be used within a <StreamProvider>. \" +\n        \"Wrap your component tree with <StreamProvider> or use useStream() directly.\"\n    );\n  }\n  return context;\n}\n"],"mappings":";;;;;AAeA,MAAM,gBAAgB,cAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFrD,SAAgB,eAId,OACW;CACX,MAAM,EAAE,UAAU,GAAG,YAAY;CAEjC,MAAM,SAAS,UAAkB,QAAe;AAEhD,QACE,oBAAC,cAAc,UAAf;EAAwB,OAAO;EAAS;EAAkC,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B9E,SAAgB,mBAG0B;CACxC,MAAM,UAAU,WAAW,cAAc;AACzC,KAAI,YAAY,KACd,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}
+{"version":3,"file":"context.js","names":[],"sources":["../src/context.tsx"],"sourcesContent":["/* __LC_ALLOW_ENTRYPOINT_SIDE_EFFECTS__ */\n\n\"use client\";\n\nimport { createContext, useContext, type ReactNode } from \"react\";\nimport {\n  useStream,\n  type UseStreamOptions,\n  type UseStreamReturn,\n  type AgentServerOptions,\n  type CustomAdapterOptions,\n} from \"./use-stream.js\";\nimport type { InferStateType } from \"@langchain/langgraph-sdk/stream\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst StreamContext = createContext<any | null>(null);\n\n/**\n * Props for {@link StreamProvider} when talking to the default\n * LangGraph Platform agent server. Mirrors {@link AgentServerOptions}\n * plus `children`.\n */\nexport type StreamProviderProps<T = Record<string, unknown>> =\n  AgentServerOptions<InferStateType<T>> & {\n    children: ReactNode;\n  };\n\n/**\n * Props for {@link StreamProvider} when wiring a custom\n * {@link AgentServerAdapter}. Mirrors {@link CustomAdapterOptions}\n * plus `children`.\n */\nexport type StreamProviderCustomProps<T = Record<string, unknown>> =\n  CustomAdapterOptions<InferStateType<T>> & {\n    children: ReactNode;\n  };\n\n/**\n * Provides a shared {@link useStream} instance to all descendants via\n * React Context.\n *\n * Use `StreamProvider` when multiple components in a subtree need\n * access to the same stream state (messages, loading status, errors,\n * interrupts, …) without prop drilling.\n *\n * @example\n * ```tsx\n * import { StreamProvider, useStreamContext } from \"@langchain/react\";\n *\n * function App() {\n *   return (\n *     <StreamProvider assistantId=\"agent\" apiUrl=\"http://localhost:2024\">\n *       <ChatHeader />\n *       <MessageList />\n *       <MessageInput />\n *     </StreamProvider>\n *   );\n * }\n *\n * function ChatHeader() {\n *   const { isLoading, error } = useStreamContext();\n *   return (\n *     <header>\n *       {isLoading && <span>Thinking...</span>}\n *       {error && <span>Error</span>}\n *     </header>\n *   );\n * }\n * ```\n *\n * Multiple providers can be nested for multi-agent scenarios:\n *\n * @example\n * ```tsx\n * <StreamProvider assistantId=\"researcher\" apiUrl=\"http://localhost:2024\">\n *   <ResearchPanel />\n * </StreamProvider>\n * <StreamProvider assistantId=\"writer\" apiUrl=\"http://localhost:2024\">\n *   <WriterPanel />\n * </StreamProvider>\n * ```\n */\nexport function StreamProvider<T = Record<string, unknown>>(\n  props: StreamProviderProps<T> | StreamProviderCustomProps<T>\n): ReactNode {\n  const { children, ...options } = props;\n  const stream = useStream<T>(options as UseStreamOptions<InferStateType<T>>);\n\n  return (\n    <StreamContext.Provider value={stream}>{children}</StreamContext.Provider>\n  );\n}\n\n/**\n * Accesses the shared stream instance from the nearest\n * {@link StreamProvider}. Throws if called outside of one.\n *\n * @example\n * ```tsx\n * function MessageList() {\n *   const { messages } = useStreamContext();\n *   return messages.map((m, i) => <div key={m.id ?? i}>{String(m.content)}</div>);\n * }\n * ```\n *\n * @example With a type parameter for full type safety:\n * ```tsx\n * import type { agent } from \"./agent\";\n *\n * function Chat() {\n *   const { toolCalls } = useStreamContext<typeof agent>();\n * }\n * ```\n */\nexport function useStreamContext<\n  T = Record<string, unknown>,\n>(): UseStreamReturn<T> {\n  const context = useContext(StreamContext);\n  if (context === null) {\n    throw new Error(\n      \"useStreamContext must be used within a <StreamProvider>. \" +\n        \"Wrap your component tree with <StreamProvider> or use useStream() directly.\"\n    );\n  }\n  return context as UseStreamReturn<T>;\n}\n"],"mappings":";;;;;AAeA,MAAM,gBAAgB,cAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmErD,SAAgB,eACd,OACW;CACX,MAAM,EAAE,UAAU,GAAG,YAAY;CACjC,MAAM,SAAS,UAAa,QAA+C;AAE3E,QACE,oBAAC,cAAc,UAAf;EAAwB,OAAO;EAAS;EAAkC,CAAA;;;;;;;;;;;;;;;;;;;;;;;AAyB9E,SAAgB,mBAEQ;CACtB,MAAM,UAAU,WAAW,cAAc;AACzC,KAAI,YAAY,KACd,OAAM,IAAI,MACR,uIAED;AAEH,QAAO"}

package/dist/index.cjs

@@ -1,43 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("./stream.custom.cjs");
-const require_stream = require("./stream.cjs");
+const require_use_stream = require("./use-stream.cjs");
+const require_use_projection = require("./use-projection.cjs");
+const require_selectors = require("./selectors.cjs");
+const require_use_media_url = require("./use-media-url.cjs");
+const require_use_audio_player = require("./use-audio-player.cjs");
+const require_use_video_player = require("./use-video-player.cjs");
 const require_suspense_stream = require("./suspense-stream.cjs");
 const require_context = require("./context.cjs");
-let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
 let _langchain_langgraph_sdk = require("@langchain/langgraph-sdk");
-exports.FetchStreamTransport = _langchain_langgraph_sdk_ui.FetchStreamTransport;
-exports.StreamProvider = require_context.StreamProvider;
-Object.defineProperty(exports, "SubagentManager", {
+let _langchain_langgraph_sdk_stream = require("@langchain/langgraph-sdk/stream");
+Object.defineProperty(exports, "HttpAgentServerAdapter", {
 	enumerable: true,
 	get: function() {
-		return _langchain_langgraph_sdk_ui.SubagentManager;
+		return _langchain_langgraph_sdk.HttpAgentServerAdapter;
 	}
 });
-Object.defineProperty(exports, "calculateDepthFromNamespace", {
+Object.defineProperty(exports, "MediaAssemblyError", {
 	enumerable: true,
 	get: function() {
-		return _langchain_langgraph_sdk_ui.calculateDepthFromNamespace;
+		return _langchain_langgraph_sdk_stream.MediaAssemblyError;
 	}
 });
-exports.createSuspenseCache = require_suspense_stream.createSuspenseCache;
+exports.STREAM_CONTROLLER = require_use_stream.STREAM_CONTROLLER;
+exports.StreamProvider = require_context.StreamProvider;
 Object.defineProperty(exports, "executeHeadlessTool", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk.executeHeadlessTool;
 	}
 });
-Object.defineProperty(exports, "extractParentIdFromNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.extractParentIdFromNamespace;
-	}
-});
-Object.defineProperty(exports, "extractToolCallIdFromNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
-	}
-});
 Object.defineProperty(exports, "filterOutHeadlessToolInterrupts", {
 	enumerable: true,
 	get: function() {
@@ -68,25 +59,33 @@ Object.defineProperty(exports, "headlessToolResumeCommand", {
 		return _langchain_langgraph_sdk.headlessToolResumeCommand;
 	}
 });
-exports.invalidateSuspenseCache = require_suspense_stream.invalidateSuspenseCache;
 Object.defineProperty(exports, "isHeadlessToolInterrupt", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk.isHeadlessToolInterrupt;
 	}
 });
-Object.defineProperty(exports, "isSubagentNamespace", {
-	enumerable: true,
-	get: function() {
-		return _langchain_langgraph_sdk_ui.isSubagentNamespace;
-	}
-});
 Object.defineProperty(exports, "parseHeadlessToolInterruptPayload", {
 	enumerable: true,
 	get: function() {
 		return _langchain_langgraph_sdk.parseHeadlessToolInterruptPayload;
 	}
 });
-exports.useStream = require_stream.useStream;
+exports.useAudio = require_selectors.useAudio;
+exports.useAudioPlayer = require_use_audio_player.useAudioPlayer;
+exports.useChannel = require_selectors.useChannel;
+exports.useExtension = require_selectors.useExtension;
+exports.useFiles = require_selectors.useFiles;
+exports.useImages = require_selectors.useImages;
+exports.useMediaURL = require_use_media_url.useMediaURL;
+exports.useMessageMetadata = require_selectors.useMessageMetadata;
+exports.useMessages = require_selectors.useMessages;
+exports.useProjection = require_use_projection.useProjection;
+exports.useStream = require_use_stream.useStream;
 exports.useStreamContext = require_context.useStreamContext;
+exports.useSubmissionQueue = require_selectors.useSubmissionQueue;
 exports.useSuspenseStream = require_suspense_stream.useSuspenseStream;
+exports.useToolCalls = require_selectors.useToolCalls;
+exports.useValues = require_selectors.useValues;
+exports.useVideo = require_selectors.useVideo;
+exports.useVideoPlayer = require_use_video_player.useVideoPlayer;

package/dist/index.d.cts

@@ -1,14 +1,17 @@
-import { SubagentStream, SubagentStreamInterface, UseStream, UseStreamCustom, UseSuspenseStream } from "./types.cjs";
-import { ClassSubagentStreamInterface, useStream } from "./stream.cjs";
-import { SuspenseCache, createSuspenseCache, invalidateSuspenseCache, useSuspenseStream } from "./suspense-stream.cjs";
-import { FetchStreamTransport } from "./stream.custom.cjs";
+import { AgentServerOptions, AnyStream, CustomAdapterOptions, STREAM_CONTROLLER, UseStreamOptions, UseStreamResult, UseStreamReturn, useStream } from "./use-stream.cjs";
+import { useProjection } from "./use-projection.cjs";
+import { SelectorTarget, SubmissionQueueEntry, SubmissionQueueSnapshot, UseSubmissionQueueReturn, useAudio, useChannel, useExtension, useFiles, useImages, useMessageMetadata, useMessages, useSubmissionQueue, useToolCalls, useValues, useVideo } from "./selectors.cjs";
+import { useMediaURL } from "./use-media-url.cjs";
+import { AudioPlayerHandle, PlayerStatus, UseAudioPlayerOptions, useAudioPlayer } from "./use-audio-player.cjs";
+import { UseVideoPlayerOptions, VideoPlayerHandle, useVideoPlayer } from "./use-video-player.cjs";
+import { UseSuspenseStreamReturn, useSuspenseStream } from "./suspense-stream.cjs";
 import { StreamProvider, StreamProviderCustomProps, StreamProviderProps, useStreamContext } from "./context.cjs";
 import { AIMessage, ToolMessage } from "@langchain/core/messages";
-import { AnyHeadlessToolImplementation, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
-import { AgentTypeConfigLike, BaseStream, BaseSubagentState, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, GetToolCallsType, InferAgentToolCalls, InferBag, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, QueueEntry, QueueInterface, ResolveStreamInterface, ResolveStreamOptions, SubAgentLike, SubagentManager, SubagentStateMap, SubagentStatus, SubagentToolCall, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
+import { AnyHeadlessToolImplementation, DefaultToolCall, DefaultToolCall as DefaultToolCall$1, FlushPendingHeadlessToolInterruptsOptions, HeadlessToolImplementation, HeadlessToolInterrupt, HttpAgentServerAdapter, HttpAgentServerAdapterOptions, OnToolCallback, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools, ToolEvent, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload } from "@langchain/langgraph-sdk";
+import { AgentServerAdapter, AnyMediaHandle, AssembledToolCall, AudioMedia, Channel, Event, FileMedia, ImageMedia, InferStateType, InferSubagentStates, InferToolCalls, MediaAssemblyError, MediaAssemblyErrorKind, MediaBase, MediaBlockType, MessageMetadata, MessageMetadataMap, StreamSubmitOptions, SubagentDiscoverySnapshot, SubgraphDiscoverySnapshot, ToolCallStatus, VideoMedia, WidenUpdateMessages } from "@langchain/langgraph-sdk/stream";
 
 //#region src/index.d.ts
 type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
 //#endregion
-export { type AgentTypeConfigLike, type AnyHeadlessToolImplementation, type BaseStream, type BaseSubagentState, type ClassSubagentStreamInterface, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type FlushPendingHeadlessToolInterruptsOptions, type GetToolCallsType, type HeadlessToolImplementation, type HeadlessToolInterrupt, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type OnToolCallback, type QueueEntry, type QueueInterface, type ResolveStreamInterface, type ResolveStreamOptions, StreamProvider, type StreamProviderCustomProps, type StreamProviderProps, type SubAgentLike, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type SuspenseCache, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStream, type UseStreamCustom, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, type UseSuspenseStream, calculateDepthFromNamespace, createSuspenseCache, executeHeadlessTool, extractParentIdFromNamespace, extractToolCallIdFromNamespace, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, invalidateSuspenseCache, isHeadlessToolInterrupt, isSubagentNamespace, parseHeadlessToolInterruptPayload, useStream, useStreamContext, useSuspenseStream };
+export { type AgentServerAdapter, type AgentServerOptions, type AnyHeadlessToolImplementation, type AnyMediaHandle, type AnyStream, type AssembledToolCall, type AudioMedia, type AudioPlayerHandle, type Channel, type CustomAdapterOptions, type DefaultToolCall, type Event, type FileMedia, type FlushPendingHeadlessToolInterruptsOptions, type HeadlessToolImplementation, type HeadlessToolInterrupt, HttpAgentServerAdapter, type HttpAgentServerAdapterOptions, type ImageMedia, type InferStateType, type InferSubagentStates, type InferToolCalls, MediaAssemblyError, type MediaAssemblyErrorKind, type MediaBase, type MediaBlockType, type MessageMetadata, type MessageMetadataMap, type OnToolCallback, type PlayerStatus, STREAM_CONTROLLER, type SelectorTarget, StreamProvider, type StreamProviderCustomProps, type StreamProviderProps, type StreamSubmitOptions, type SubagentDiscoverySnapshot, type SubgraphDiscoverySnapshot, type SubmissionQueueEntry, type SubmissionQueueSnapshot, type ToolCallFromTool, type ToolCallState, type ToolCallStatus, ToolCallWithResult, type ToolCallsFromTools, type ToolEvent, type UseAudioPlayerOptions, type UseStreamOptions, type UseStreamResult, type UseStreamReturn, type UseSubmissionQueueReturn, type UseSuspenseStreamReturn, type UseVideoPlayerOptions, type VideoMedia, type VideoPlayerHandle, type WidenUpdateMessages, executeHeadlessTool, filterOutHeadlessToolInterrupts, findHeadlessTool, flushPendingHeadlessToolInterrupts, handleHeadlessToolInterrupt, headlessToolResumeCommand, isHeadlessToolInterrupt, parseHeadlessToolInterruptPayload, useAudio, useAudioPlayer, useChannel, useExtension, useFiles, useImages, useMediaURL, useMessageMetadata, useMessages, useProjection, useStream, useStreamContext, useSubmissionQueue, useSuspenseStream, useToolCalls, useValues, useVideo, useVideoPlayer };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;KAkFY,kBAAA,YAA8B,iBAAA,IACxC,oBAAA,CAAoB,QAAA,EAAU,WAAA,EAAiB,SAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;KAkGY,kBAAA,YAA8B,iBAAA,IACxC,oBAAA,CAAoB,QAAA,EAAU,WAAA,EAAiB,SAAA"}