@langchain/langgraph-sdk 1.6.5 → 1.7.1

package/dist/react/stream.d.cts

@@ -1,174 +0,0 @@
-import { BagTemplate } from "../types.template.cjs";
-import { UseStreamCustomOptions } from "../ui/types.cjs";
-import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.cjs";
-
-//#region src/react/stream.d.ts
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, subagent streams, and errors.
- *
- * ## Usage with ReactAgent (recommended for createAgent users)
- *
- * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the
- * type parameter to automatically infer tool call types:
- *
- * @example
- * ```typescript
- * // In your agent file (e.g., agent.ts)
- * import { createAgent, tool } from "langchain";
- * import { z } from "zod";
- *
- * const getWeather = tool(
- *   async ({ location }) => `Weather in ${location}`,
- *   { name: "get_weather", schema: z.object({ location: z.string() }) }
- * );
- *
- * export const agent = createAgent({
- *   model: "openai:gpt-4o",
- *   tools: [getWeather],
- * });
- *
- * // In your React component
- * import { agent } from "./agent";
- *
- * function Chat() {
- *   // Tool calls are automatically typed from the agent's tools!
- *   const stream = useStream<typeof agent>({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.toolCalls[0].call.name is typed as "get_weather"
- *   // stream.toolCalls[0].call.args is typed as { location: string }
- * }
- * ```
- *
- * ## Usage with StateGraph (for custom LangGraph applications)
- *
- * When building custom graphs with `StateGraph`, embed your tool call types directly
- * in your state's messages property using `Message<MyToolCalls>`:
- *
- * @example
- * ```typescript
- * import { Message } from "@langchain/langgraph-sdk";
- *
- * // Define your tool call types as a discriminated union
- * type MyToolCalls =
- *   | { name: "search"; args: { query: string }; id?: string }
- *   | { name: "calculate"; args: { expression: string }; id?: string };
- *
- * // Embed tool call types in your state's messages
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- *   context?: string;
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.values is typed as MyGraphState
- *   // stream.toolCalls[0].call.name is typed as "search" | "calculate"
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With additional type configuration (interrupts, configurable)
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState, {
- *     InterruptType: { question: string };
- *     ConfigurableType: { userId: string };
- *   }>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.interrupt is typed as { question: string } | undefined
- * }
- * ```
- *
- * ## Usage with Deep Agents (subagent streaming, experimental)
- *
- * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`
- * to keep the main message stream clean while tracking subagent activity separately:
- *
- * @example
- * ```typescript
- * import { useStream, SubagentStream } from "@langchain/langgraph-sdk/react";
- * import type { agent } from "./agent";
- *
- * function DeepAgentChat() {
- *   const stream = useStream<typeof agent>({
- *     assistantId: "deepagent",
- *     apiUrl: "http://localhost:2024",
- *     // Filter subagent messages from main stream
- *     filterSubagentMessages: true,
- *   });
- *
- *   const handleSubmit = (content: string) => {
- *     stream.submit(
- *       { messages: [{ content, type: "human" }] },
- *       { streamSubgraphs: true } // Enable subgraph streaming
- *     );
- *   };
- *
- *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)
- *   const subagentList = [...stream.subagents.values()];
- *
- *   return (
- *     <div>
- *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}
- *
- *       {subagentList.map((subagent) => (
- *         <SubagentCard
- *           key={subagent.id}
- *           status={subagent.status} // "pending" | "running" | "complete" | "error"
- *           messages={subagent.messages}
- *           toolCalls={subagent.toolCalls}
- *         />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, and errors.
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.d.cts.map

package/dist/react/stream.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.cts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;;;;AA4KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;iBAkBzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.d.ts

@@ -1,174 +0,0 @@
-import { BagTemplate } from "../types.template.js";
-import { UseStreamCustomOptions } from "../ui/types.js";
-import { InferBag, InferStateType, ResolveStreamInterface, ResolveStreamOptions } from "../ui/stream/index.js";
-
-//#region src/react/stream.d.ts
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, subagent streams, and errors.
- *
- * ## Usage with ReactAgent (recommended for createAgent users)
- *
- * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the
- * type parameter to automatically infer tool call types:
- *
- * @example
- * ```typescript
- * // In your agent file (e.g., agent.ts)
- * import { createAgent, tool } from "langchain";
- * import { z } from "zod";
- *
- * const getWeather = tool(
- *   async ({ location }) => `Weather in ${location}`,
- *   { name: "get_weather", schema: z.object({ location: z.string() }) }
- * );
- *
- * export const agent = createAgent({
- *   model: "openai:gpt-4o",
- *   tools: [getWeather],
- * });
- *
- * // In your React component
- * import { agent } from "./agent";
- *
- * function Chat() {
- *   // Tool calls are automatically typed from the agent's tools!
- *   const stream = useStream<typeof agent>({
- *     assistantId: "agent",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.toolCalls[0].call.name is typed as "get_weather"
- *   // stream.toolCalls[0].call.args is typed as { location: string }
- * }
- * ```
- *
- * ## Usage with StateGraph (for custom LangGraph applications)
- *
- * When building custom graphs with `StateGraph`, embed your tool call types directly
- * in your state's messages property using `Message<MyToolCalls>`:
- *
- * @example
- * ```typescript
- * import { Message } from "@langchain/langgraph-sdk";
- *
- * // Define your tool call types as a discriminated union
- * type MyToolCalls =
- *   | { name: "search"; args: { query: string }; id?: string }
- *   | { name: "calculate"; args: { expression: string }; id?: string };
- *
- * // Embed tool call types in your state's messages
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- *   context?: string;
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.values is typed as MyGraphState
- *   // stream.toolCalls[0].call.name is typed as "search" | "calculate"
- * }
- * ```
- *
- * @example
- * ```typescript
- * // With additional type configuration (interrupts, configurable)
- * interface MyGraphState {
- *   messages: Message<MyToolCalls>[];
- * }
- *
- * function Chat() {
- *   const stream = useStream<MyGraphState, {
- *     InterruptType: { question: string };
- *     ConfigurableType: { userId: string };
- *   }>({
- *     assistantId: "my-graph",
- *     apiUrl: "http://localhost:2024",
- *   });
- *
- *   // stream.interrupt is typed as { question: string } | undefined
- * }
- * ```
- *
- * ## Usage with Deep Agents (subagent streaming, experimental)
- *
- * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`
- * to keep the main message stream clean while tracking subagent activity separately:
- *
- * @example
- * ```typescript
- * import { useStream, SubagentStream } from "@langchain/langgraph-sdk/react";
- * import type { agent } from "./agent";
- *
- * function DeepAgentChat() {
- *   const stream = useStream<typeof agent>({
- *     assistantId: "deepagent",
- *     apiUrl: "http://localhost:2024",
- *     // Filter subagent messages from main stream
- *     filterSubagentMessages: true,
- *   });
- *
- *   const handleSubmit = (content: string) => {
- *     stream.submit(
- *       { messages: [{ content, type: "human" }] },
- *       { streamSubgraphs: true } // Enable subgraph streaming
- *     );
- *   };
- *
- *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)
- *   const subagentList = [...stream.subagents.values()];
- *
- *   return (
- *     <div>
- *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}
- *
- *       {subagentList.map((subagent) => (
- *         <SubagentCard
- *           key={subagent.id}
- *           status={subagent.status} // "pending" | "running" | "complete" | "error"
- *           messages={subagent.messages}
- *           toolCalls={subagent.toolCalls}
- *         />
- *       ))}
- *     </div>
- *   );
- * }
- * ```
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: ResolveStreamOptions<T, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-/**
- * A React hook that provides seamless integration with LangGraph streaming capabilities.
- *
- * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,
- * letting you focus on building great chat experiences. It provides automatic state management for
- * messages, interrupts, loading states, and errors.
- *
- * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)
- * @template Bag Type configuration bag containing:
- *   - `ConfigurableType`: Type for the `config.configurable` property
- *   - `InterruptType`: Type for interrupt values
- *   - `CustomEventType`: Type for custom events
- *   - `UpdateType`: Type for the submit function updates
- *
- * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}
- */
-declare function useStream<T = Record<string, unknown>, Bag extends BagTemplate = BagTemplate>(options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>): ResolveStreamInterface<T, InferBag<T, Bag>>;
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.d.ts.map

package/dist/react/stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.ts","names":[],"sources":["../../src/react/stream.tsx"],"mappings":";;;;;;;AA4KA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvBgB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,oBAAA,CAAqB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA,KAC5C,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA;;;;;;;;;;;;;;;;;iBAkBzB,SAAA,KACV,MAAA,+BACQ,WAAA,GAAc,WAAA,CAAA,CAE1B,OAAA,EAAS,sBAAA,CAAuB,cAAA,CAAe,CAAA,GAAI,QAAA,CAAS,CAAA,EAAG,GAAA,KAC9D,sBAAA,CAAuB,CAAA,EAAG,QAAA,CAAS,CAAA,EAAG,GAAA"}

package/dist/react/stream.js

@@ -1,17 +0,0 @@
-import { useStreamLGP } from "./stream.lgp.js";
-import { useStreamCustom } from "./stream.custom.js";
-import { useState } from "react";
-
-//#region src/react/stream.tsx
-function isCustomOptions(options) {
-	return "transport" in options;
-}
-function useStream(options) {
-	const [isCustom] = useState(isCustomOptions(options));
-	if (isCustom) return useStreamCustom(options);
-	return useStreamLGP(options);
-}
-
-//#endregion
-export { useStream };
-//# sourceMappingURL=stream.js.map

package/dist/react/stream.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.js","names":[],"sources":["../../src/react/stream.tsx"],"sourcesContent":["import { useState } from \"react\";\nimport { useStreamLGP } from \"./stream.lgp.js\";\nimport { useStreamCustom } from \"./stream.custom.js\";\nimport type { UseStreamOptions } from \"../ui/types.js\";\nimport type { BagTemplate } from \"../types.template.js\";\nimport type { UseStreamCustomOptions } from \"./types.js\";\nimport type {\n  ResolveStreamInterface,\n  ResolveStreamOptions,\n  InferBag,\n  InferStateType,\n} from \"../ui/stream/index.js\";\n\nfunction isCustomOptions<\n  StateType extends Record<string, unknown> = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options:\n    | UseStreamOptions<StateType, Bag>\n    | UseStreamCustomOptions<StateType, Bag>\n): options is UseStreamCustomOptions<StateType, Bag> {\n  return \"transport\" in options;\n}\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, subagent streams, and errors.\n *\n * ## Usage with ReactAgent (recommended for createAgent users)\n *\n * When using `createAgent` from `@langchain/langgraph`, you can pass `typeof agent` as the\n * type parameter to automatically infer tool call types:\n *\n * @example\n * ```typescript\n * // In your agent file (e.g., agent.ts)\n * import { createAgent, tool } from \"langchain\";\n * import { z } from \"zod\";\n *\n * const getWeather = tool(\n *   async ({ location }) => `Weather in ${location}`,\n *   { name: \"get_weather\", schema: z.object({ location: z.string() }) }\n * );\n *\n * export const agent = createAgent({\n *   model: \"openai:gpt-4o\",\n *   tools: [getWeather],\n * });\n *\n * // In your React component\n * import { agent } from \"./agent\";\n *\n * function Chat() {\n *   // Tool calls are automatically typed from the agent's tools!\n *   const stream = useStream<typeof agent>({\n *     assistantId: \"agent\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.toolCalls[0].call.name is typed as \"get_weather\"\n *   // stream.toolCalls[0].call.args is typed as { location: string }\n * }\n * ```\n *\n * ## Usage with StateGraph (for custom LangGraph applications)\n *\n * When building custom graphs with `StateGraph`, embed your tool call types directly\n * in your state's messages property using `Message<MyToolCalls>`:\n *\n * @example\n * ```typescript\n * import { Message } from \"@langchain/langgraph-sdk\";\n *\n * // Define your tool call types as a discriminated union\n * type MyToolCalls =\n *   | { name: \"search\"; args: { query: string }; id?: string }\n *   | { name: \"calculate\"; args: { expression: string }; id?: string };\n *\n * // Embed tool call types in your state's messages\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n *   context?: string;\n * }\n *\n * function Chat() {\n *   const stream = useStream<MyGraphState>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.values is typed as MyGraphState\n *   // stream.toolCalls[0].call.name is typed as \"search\" | \"calculate\"\n * }\n * ```\n *\n * @example\n * ```typescript\n * // With additional type configuration (interrupts, configurable)\n * interface MyGraphState {\n *   messages: Message<MyToolCalls>[];\n * }\n *\n * function Chat() {\n *   const stream = useStream<MyGraphState, {\n *     InterruptType: { question: string };\n *     ConfigurableType: { userId: string };\n *   }>({\n *     assistantId: \"my-graph\",\n *     apiUrl: \"http://localhost:2024\",\n *   });\n *\n *   // stream.interrupt is typed as { question: string } | undefined\n * }\n * ```\n *\n * ## Usage with Deep Agents (subagent streaming, experimental)\n *\n * For agents that spawn subagents (nested graphs), use `filterSubagentMessages`\n * to keep the main message stream clean while tracking subagent activity separately:\n *\n * @example\n * ```typescript\n * import { useStream, SubagentStream } from \"@langchain/langgraph-sdk/react\";\n * import type { agent } from \"./agent\";\n *\n * function DeepAgentChat() {\n *   const stream = useStream<typeof agent>({\n *     assistantId: \"deepagent\",\n *     apiUrl: \"http://localhost:2024\",\n *     // Filter subagent messages from main stream\n *     filterSubagentMessages: true,\n *   });\n *\n *   const handleSubmit = (content: string) => {\n *     stream.submit(\n *       { messages: [{ content, type: \"human\" }] },\n *       { streamSubgraphs: true } // Enable subgraph streaming\n *     );\n *   };\n *\n *   // Access subagent streams via stream.subagents (Map<string, SubagentStream>)\n *   const subagentList = [...stream.subagents.values()];\n *\n *   return (\n *     <div>\n *       {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}\n *\n *       {subagentList.map((subagent) => (\n *         <SubagentCard\n *           key={subagent.id}\n *           status={subagent.status} // \"pending\" | \"running\" | \"complete\" | \"error\"\n *           messages={subagent.messages}\n *           toolCalls={subagent.toolCalls}\n *         />\n *       ))}\n *     </div>\n *   );\n * }\n * ```\n *\n * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: ResolveStreamOptions<T, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\n/**\n * A React hook that provides seamless integration with LangGraph streaming capabilities.\n *\n * The `useStream` hook handles all the complexities of streaming, state management, and branching logic,\n * letting you focus on building great chat experiences. It provides automatic state management for\n * messages, interrupts, loading states, and errors.\n *\n * @template T Either a ReactAgent type (with `~agentTypes`) or a state type (`Record<string, unknown>`)\n * @template Bag Type configuration bag containing:\n *   - `ConfigurableType`: Type for the `config.configurable` property\n *   - `InterruptType`: Type for interrupt values\n *   - `CustomEventType`: Type for custom events\n *   - `UpdateType`: Type for the submit function updates\n *\n * @see {@link https://docs.langchain.com/langgraph-platform/use-stream-react | LangGraph React Integration Guide}\n */\nexport function useStream<\n  T = Record<string, unknown>,\n  Bag extends BagTemplate = BagTemplate\n>(\n  options: UseStreamCustomOptions<InferStateType<T>, InferBag<T, Bag>>\n): ResolveStreamInterface<T, InferBag<T, Bag>>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useStream(options: any): any {\n  // Store this in useState to make sure we're not changing the implementation in re-renders\n  const [isCustom] = useState(isCustomOptions(options));\n\n  if (isCustom) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStreamCustom(options);\n  }\n\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return useStreamLGP(options);\n}\n"],"mappings":";;;;;AAaA,SAAS,gBAIP,SAGmD;AACnD,QAAO,eAAe;;AAsLxB,SAAgB,UAAU,SAAmB;CAE3C,MAAM,CAAC,YAAY,SAAS,gBAAgB,QAAQ,CAAC;AAErD,KAAI,SAEF,QAAO,gBAAgB,QAAQ;AAIjC,QAAO,aAAa,QAAQ"}