@tulip-systems/ai 0.11.0

package/dist/chat/components/chat-thread.client.mjs

@@ -0,0 +1,164 @@
+"use client";
+
+import { AgentActivity } from "./agent-activity.client.mjs";
+import { ChatMessage, ChatMessageContent, ChatMessageParts } from "./chat-message.client.mjs";
+import { cn } from "@tulip-systems/core/lib";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Message, MessageContent } from "@tulip-systems/core/components";
+import { createContext, useContext, useMemo } from "react";
+import { MessageScroller, MessageScrollerButton, MessageScrollerContent, MessageScrollerItem, MessageScrollerProvider, MessageScrollerViewport } from "@tulip-systems/core/components/client";
+
+//#region src/chat/components/chat-thread.client.tsx
+const ChatThreadContext = createContext({});
+/**
+* Provides shared thread state for all chat thread slots.
+* Use it to configure chat status and scroll behavior once.
+*
+* @example
+* ```tsx
+* <ChatThread status={status}>
+*   {messages.length === 0 && <EmptyState />}
+*
+*   {messages.length > 0 && (
+*     <ChatThreadContent>
+*       {messages.map((message) => (
+*         <ChatThreadMessage key={message.id} message={message} />
+*       ))}
+*       <ChatThreadActivity />
+*     </ChatThreadContent>
+*   )}
+* </ChatThread>
+* ```
+*/
+function ChatThread({ status = "ready", autoScroll = true, defaultScrollPosition = "end", scrollPreviousItemPeek = 64, className, children, ...props }) {
+	const isAssistantResponding = status === "submitted" || status === "streaming";
+	const contextValue = useMemo(() => ({
+		status,
+		isAssistantResponding,
+		autoScroll,
+		defaultScrollPosition,
+		scrollPreviousItemPeek
+	}), [
+		status,
+		isAssistantResponding,
+		autoScroll,
+		defaultScrollPosition,
+		scrollPreviousItemPeek
+	]);
+	return /* @__PURE__ */ jsx(ChatThreadContext.Provider, {
+		value: contextValue,
+		children: /* @__PURE__ */ jsx("div", {
+			"data-slot": "chat-thread",
+			"data-status": status,
+			"data-responding": isAssistantResponding ? true : void 0,
+			className: cn("min-h-0 flex-1", className),
+			...props,
+			children
+		})
+	});
+}
+/**
+* Renders the scrollable message area for a chat thread.
+* Place `ChatThreadMessage`, `ChatThreadActivity`, and optional sentinels inside it.
+*
+* @example
+* ```tsx
+* <ChatThreadContent className="px-3">
+*   {messages.map((message) => (
+*     <ChatThreadMessage key={message.id} message={message} />
+*   ))}
+*   <ChatThreadActivity />
+* </ChatThreadContent>
+* ```
+*/
+function ChatThreadContent({ className, children, ...props }) {
+	const { isAssistantResponding, autoScroll, defaultScrollPosition, scrollPreviousItemPeek } = useContext(ChatThreadContext);
+	return /* @__PURE__ */ jsx(MessageScrollerProvider, {
+		autoScroll,
+		defaultScrollPosition,
+		scrollPreviousItemPeek,
+		children: /* @__PURE__ */ jsxs(MessageScroller, {
+			className: "min-h-0 flex-1",
+			children: [/* @__PURE__ */ jsx(MessageScrollerViewport, { children: /* @__PURE__ */ jsx(MessageScrollerContent, {
+				"aria-busy": isAssistantResponding,
+				className: cn("mx-auto w-full max-w-3xl gap-7 px-1 py-4 md:py-6", className),
+				...props,
+				children
+			}) }), /* @__PURE__ */ jsx(ChatThreadScrollButton, {})]
+		})
+	});
+}
+/**
+* Renders one AI SDK message using the current `ChatThread` configuration.
+* Use this inside `ChatThreadContent` when mapping over messages.
+*
+* @example
+* ```tsx
+* {messages.map((message) => (
+*   <ChatThreadMessage key={message.id} message={message} toolRenderers={toolRenderers} />
+* ))}
+* ```
+*/
+function ChatThreadMessage({ message, messageId = message.id, scrollAnchor = message.role === "user", toolRenderers, ...props }) {
+	return /* @__PURE__ */ jsx(MessageScrollerItem, {
+		messageId,
+		scrollAnchor,
+		...props,
+		children: /* @__PURE__ */ jsx(ChatMessage, {
+			message,
+			children: /* @__PURE__ */ jsx(ChatMessageContent, { children: /* @__PURE__ */ jsx(ChatMessageParts, { toolRenderers }) })
+		})
+	});
+}
+/**
+* Renders the assistant activity indicator while the thread status is `submitted` or `streaming`.
+* It returns nothing when the assistant is not responding.
+*
+* @example
+* ```tsx
+* <ChatThreadActivity />
+* ```
+*/
+function ChatThreadActivity({ messageId = "agent-activity", activityClassName, ...props }) {
+	const { isAssistantResponding } = useContext(ChatThreadContext);
+	if (!isAssistantResponding) return null;
+	return /* @__PURE__ */ jsx(MessageScrollerItem, {
+		messageId,
+		...props,
+		children: /* @__PURE__ */ jsx(Message, {
+			align: "start",
+			children: /* @__PURE__ */ jsx(MessageContent, { children: /* @__PURE__ */ jsx(AgentActivity, { className: activityClassName }) })
+		})
+	});
+}
+/**
+* Renders a bottom sentinel item inside the thread scroller.
+* Use it when callers need a stable ref at the end of the message list.
+*
+* @example
+* ```tsx
+* <ChatThreadBottom ref={bottomRef} />
+* ```
+*/
+function ChatThreadBottom({ messageId = "bottom-sentinel", scrollAnchor = false, ...props }) {
+	return /* @__PURE__ */ jsx(MessageScrollerItem, {
+		messageId,
+		scrollAnchor,
+		children: /* @__PURE__ */ jsx("div", { ...props })
+	});
+}
+/**
+* Renders the scroll-to-bottom button for `ChatThreadContent`.
+* `ChatThreadContent` includes this button by default.
+*
+* @example
+* ```tsx
+* <ChatThreadScrollButton />
+* ```
+*/
+function ChatThreadScrollButton(props) {
+	return /* @__PURE__ */ jsx(MessageScrollerButton, { ...props });
+}
+
+//#endregion
+export { ChatThread, ChatThreadActivity, ChatThreadBottom, ChatThreadContent, ChatThreadMessage, ChatThreadScrollButton };

package/dist/chat/components/message-part.client.d.mts

@@ -0,0 +1,23 @@
+import { ChatPart } from "../lib/types.mjs";
+import { ToolClientDefinition } from "../../tools/lib/types.client.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import * as react from "react";
+
+//#region src/chat/components/message-part.client.d.ts
+type ChatMessagePartProps = {
+  part: ChatPart;
+  isUser?: boolean;
+  toolRenderers?: ToolClientDefinition[];
+  className?: string;
+};
+/**
+ * Renders a visible AI SDK message part with a user bubble and plain assistant text.
+ */
+declare function ChatMessagePart({
+  part,
+  isUser,
+  toolRenderers,
+  className
+}: ChatMessagePartProps): string | number | bigint | boolean | react_jsx_runtime0.JSX.Element | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | null | undefined;
+//#endregion
+export { ChatMessagePart, ChatMessagePartProps };

package/dist/chat/components/message-part.client.mjs

@@ -0,0 +1,38 @@
+"use client";
+
+import { isToolPart } from "../lib/parts.mjs";
+import { ToolCallCard } from "./tool-call-card.client.mjs";
+import { cn } from "@tulip-systems/core/lib";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/chat/components/message-part.client.tsx
+/**
+* Renders a visible AI SDK message part with a user bubble and plain assistant text.
+*/
+function ChatMessagePart({ part, isUser = false, toolRenderers, className }) {
+	if (part.type === "text") return /* @__PURE__ */ jsx("div", {
+		className: cn("max-w-[min(44rem,100%)]", isUser ? "rounded-3xl bg-muted px-4 py-2.5 text-foreground" : "px-1 text-foreground", className),
+		children: /* @__PURE__ */ jsx("p", {
+			className: "whitespace-pre-wrap text-[15px] leading-7",
+			children: part.text
+		})
+	});
+	if (isToolPart(part)) {
+		const toolRenderer = getToolRenderer(part, toolRenderers);
+		return toolRenderer ? toolRenderer.render(part) : /* @__PURE__ */ jsx(ToolCallCard, { part });
+	}
+	return null;
+}
+/**
+* Helpers
+*/
+function getToolName(part) {
+	return part.type.startsWith("tool-") ? part.type.slice(5) : part.type;
+}
+function getToolRenderer(part, toolRenderers) {
+	const toolName = getToolName(part);
+	return toolRenderers?.find((renderer) => renderer.toolName === toolName);
+}
+
+//#endregion
+export { ChatMessagePart };

package/dist/chat/components/starter-prompts.client.d.mts

@@ -0,0 +1,25 @@
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/chat/components/starter-prompts.client.d.ts
+type StarterPromptsProps = {
+  prompts: string[];
+  onSelect: (prompt: string) => void;
+  disabled?: boolean;
+  label?: ReactNode;
+  icon?: ReactNode;
+  className?: string;
+};
+/**
+ * Renders starter prompt buttons for a new chat state.
+ */
+declare function StarterPrompts({
+  prompts,
+  onSelect,
+  disabled,
+  label,
+  icon,
+  className
+}: StarterPromptsProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { StarterPrompts, StarterPromptsProps };

package/dist/chat/components/starter-prompts.client.mjs

@@ -0,0 +1,31 @@
+"use client";
+
+import { cn } from "@tulip-systems/core/lib";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/chat/components/starter-prompts.client.tsx
+/**
+* Renders starter prompt buttons for a new chat state.
+*/
+function StarterPrompts({ prompts, onSelect, disabled = false, label, icon, className }) {
+	const hasMeta = Boolean(label || icon);
+	return /* @__PURE__ */ jsx("div", {
+		className: cn("grid w-full gap-2 sm:grid-cols-2", className),
+		children: prompts.map((prompt) => /* @__PURE__ */ jsxs("button", {
+			type: "button",
+			className: "group rounded-2xl border border-border/60 bg-background/80 p-3 text-left shadow-sm backdrop-blur transition-colors hover:bg-muted/40 disabled:cursor-not-allowed disabled:opacity-60",
+			disabled,
+			onClick: () => onSelect(prompt),
+			children: [hasMeta && /* @__PURE__ */ jsxs("div", {
+				className: "mb-2 flex items-center gap-2 font-medium text-muted-foreground text-xs uppercase tracking-[0.14em]",
+				children: [icon, label]
+			}), /* @__PURE__ */ jsx("p", {
+				className: "text-foreground/90 text-sm leading-6",
+				children: prompt
+			})]
+		}, prompt))
+	});
+}
+
+//#endregion
+export { StarterPrompts };

package/dist/chat/components/tool-call-card.client.d.mts

@@ -0,0 +1,29 @@
+import { ToolChatPart } from "../lib/types.mjs";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
+
+//#region src/chat/components/tool-call-card.client.d.ts
+type ToolCallCardLabels = {
+  input?: string;
+  output?: string;
+  preliminaryOutput?: string;
+};
+type ToolCallCardProps = {
+  part: ToolChatPart;
+  title?: ReactNode | ((toolName: string, part: ToolChatPart) => ReactNode);
+  icon?: ReactNode | ((toolName: string, part: ToolChatPart) => ReactNode);
+  labels?: ToolCallCardLabels;
+  className?: string;
+};
+/**
+ * Renders a streamed AI SDK tool part with input, output, state, and error details.
+ */
+declare function ToolCallCard({
+  part,
+  title,
+  icon,
+  labels,
+  className
+}: ToolCallCardProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+export { ToolCallCard, ToolCallCardLabels, ToolCallCardProps };

package/dist/chat/components/tool-call-card.client.mjs

@@ -0,0 +1,60 @@
+"use client";
+
+import { getDefaultToolTitle, getToolName, stringifyChatValue } from "../lib/parts.mjs";
+import { cn } from "@tulip-systems/core/lib";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/chat/components/tool-call-card.client.tsx
+/**
+* Renders a streamed AI SDK tool part with input, output, state, and error details.
+*/
+function ToolCallCard({ part, title, icon, labels, className }) {
+	const toolName = getToolName(part);
+	const resolvedTitle = typeof title === "function" ? title(toolName, part) : title;
+	const resolvedIcon = typeof icon === "function" ? icon(toolName, part) : icon;
+	const inputLabel = labels?.input ?? "Input";
+	const outputLabel = part.preliminary ? labels?.preliminaryOutput ?? "Intermediate result" : labels?.output ?? "Result";
+	return /* @__PURE__ */ jsxs("div", {
+		className: cn("max-w-full rounded-3xl border border-border/60 bg-muted/35 p-3.5 text-sm shadow-sm backdrop-blur-sm", className),
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center gap-2 font-medium text-[11px] text-muted-foreground uppercase tracking-[0.18em]",
+				children: [
+					resolvedIcon,
+					/* @__PURE__ */ jsx("span", { children: resolvedTitle ?? getDefaultToolTitle(toolName) }),
+					part.state && /* @__PURE__ */ jsx("span", {
+						className: "text-[10px] normal-case tracking-normal",
+						children: part.state
+					})
+				]
+			}),
+			part.input !== void 0 && /* @__PURE__ */ jsxs("div", {
+				className: "mt-3 space-y-1.5",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "font-medium text-[11px] text-muted-foreground uppercase tracking-[0.14em]",
+					children: inputLabel
+				}), /* @__PURE__ */ jsx("pre", {
+					className: "overflow-x-auto whitespace-pre-wrap rounded-2xl bg-background/80 p-3 text-foreground/90 text-xs leading-5",
+					children: stringifyChatValue(part.input)
+				})]
+			}),
+			part.output !== void 0 && /* @__PURE__ */ jsxs("div", {
+				className: "mt-3 space-y-1.5",
+				children: [/* @__PURE__ */ jsx("div", {
+					className: "font-medium text-[11px] text-muted-foreground uppercase tracking-[0.14em]",
+					children: outputLabel
+				}), /* @__PURE__ */ jsx("pre", {
+					className: "overflow-x-auto whitespace-pre-wrap rounded-2xl bg-background/80 p-3 text-foreground/90 text-xs leading-5",
+					children: stringifyChatValue(part.output)
+				})]
+			}),
+			part.errorText && /* @__PURE__ */ jsx("div", {
+				className: "mt-3 rounded-xl border border-red-200 bg-red-50 p-3 text-red-700 text-xs",
+				children: part.errorText
+			})
+		]
+	});
+}
+
+//#endregion
+export { ToolCallCard };

package/dist/chat/lib/classes.mjs

@@ -0,0 +1,7 @@
+//#region src/chat/lib/classes.ts
+function cx(...classes) {
+	return classes.filter(Boolean).join(" ");
+}
+
+//#endregion
+export { cx };

package/dist/chat/lib/parts.d.mts

@@ -0,0 +1,10 @@
+import { ChatPart, ToolChatPart } from "./types.mjs";
+
+//#region src/chat/lib/parts.d.ts
+declare function isToolPart(part: ChatPart): part is ToolChatPart;
+declare function getToolName(part: ToolChatPart): string;
+declare function getDefaultToolTitle(toolName: string): string;
+declare function stringifyChatValue(value: unknown): string;
+declare function getChatPartKey(messageId: string, part: ChatPart): string;
+//#endregion
+export { getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue };

package/dist/chat/lib/parts.mjs

@@ -0,0 +1,25 @@
+//#region src/chat/lib/parts.ts
+function isToolPart(part) {
+	return part.type.startsWith("tool-");
+}
+function getToolName(part) {
+	return part.type.slice(5);
+}
+function getDefaultToolTitle(toolName) {
+	return toolName.replaceAll("_", " ");
+}
+function stringifyChatValue(value) {
+	try {
+		return JSON.stringify(value, null, 2);
+	} catch {
+		return String(value);
+	}
+}
+function getChatPartKey(messageId, part) {
+	if (part.type === "text") return `${messageId}-text-${part.text.slice(0, 40)}`;
+	if (isToolPart(part)) return `${messageId}-${part.type}-${stringifyChatValue(part.input ?? part.output ?? part.type).slice(0, 60)}`;
+	return `${messageId}-${part.type}`;
+}
+
+//#endregion
+export { getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue };

package/dist/chat/lib/stream.server.d.mts

@@ -0,0 +1,24 @@
+import { StreamAgentChatOptions } from "./types.mjs";
+import "server-cli-only";
+import * as ai from "ai";
+import * as _orpc_server0 from "@orpc/server";
+
+//#region src/chat/lib/stream.server.d.ts
+/**
+ * Streams a Tulip agent response as an AI SDK UI message stream.
+ * Use this when the caller wants a framework-neutral `ReadableStream`.
+ */
+declare function streamAgentChat({
+  agent,
+  messages,
+  abortSignal,
+  convertToModelMessagesOptions,
+  uiMessageStreamOptions
+}: StreamAgentChatOptions): Promise<ReadableStream<ai.InferUIMessageChunk<ai.UIMessage<unknown, ai.UIDataTypes, ai.UITools>>>>;
+/**
+ * Streams a Tulip agent response as an oRPC event iterator.
+ * Use this from oRPC procedures that return an AI SDK UI message stream to clients.
+ */
+declare function streamAgentChatEventIterator(options: StreamAgentChatOptions): Promise<_orpc_server0.AsyncIteratorClass<ai.InferUIMessageChunk<ai.UIMessage<unknown, ai.UIDataTypes, ai.UITools>>, unknown, unknown>>;
+//#endregion
+export { streamAgentChat, streamAgentChatEventIterator };

package/dist/chat/lib/stream.server.mjs

@@ -0,0 +1,34 @@
+import "server-cli-only";
+import { convertToModelMessages, toUIMessageStream } from "ai";
+import { streamToEventIterator } from "@orpc/server";
+
+//#region src/chat/lib/stream.server.ts
+/**
+* Streams a Tulip agent response as an AI SDK UI message stream.
+* Use this when the caller wants a framework-neutral `ReadableStream`.
+*/
+async function streamAgentChat({ agent, messages, abortSignal, convertToModelMessagesOptions, uiMessageStreamOptions }) {
+	const modelMessages = await convertToModelMessages(messages, {
+		ignoreIncompleteToolCalls: true,
+		...convertToModelMessagesOptions
+	});
+	const result = await agent.stream({
+		messages: modelMessages,
+		abortSignal
+	});
+	return toUIMessageStream({
+		...uiMessageStreamOptions,
+		stream: result.stream,
+		tools: agent.tools
+	});
+}
+/**
+* Streams a Tulip agent response as an oRPC event iterator.
+* Use this from oRPC procedures that return an AI SDK UI message stream to clients.
+*/
+async function streamAgentChatEventIterator(options) {
+	return streamToEventIterator(await streamAgentChat(options));
+}
+
+//#endregion
+export { streamAgentChat, streamAgentChatEventIterator };

package/dist/chat/lib/types.d.mts

@@ -0,0 +1,21 @@
+import { CreatedAgent } from "../../agents/lib/types.mjs";
+import { UIMessage, convertToModelMessages, toUIMessageStream } from "ai";
+
+//#region src/chat/lib/types.d.ts
+type ChatPart = UIMessage["parts"][number];
+type ToolChatPart = ChatPart & {
+  input?: unknown;
+  output?: unknown;
+  state?: string;
+  preliminary?: boolean;
+  errorText?: string;
+};
+type StreamAgentChatOptions = {
+  agent: CreatedAgent;
+  messages: UIMessage[];
+  abortSignal?: AbortSignal;
+  convertToModelMessagesOptions?: Parameters<typeof convertToModelMessages>[1];
+  uiMessageStreamOptions?: Omit<Parameters<typeof toUIMessageStream>[0], "stream" | "tools">;
+};
+//#endregion
+export { ChatPart, StreamAgentChatOptions, ToolChatPart };

package/dist/chat/server.d.mts

@@ -0,0 +1,3 @@
+import { ChatPart, StreamAgentChatOptions, ToolChatPart } from "./lib/types.mjs";
+import { streamAgentChat, streamAgentChatEventIterator } from "./lib/stream.server.mjs";
+export { ChatPart, StreamAgentChatOptions, ToolChatPart, streamAgentChat, streamAgentChatEventIterator };

package/dist/chat/server.mjs

@@ -0,0 +1,3 @@
+import { streamAgentChat, streamAgentChatEventIterator } from "./lib/stream.server.mjs";
+
+export { streamAgentChat, streamAgentChatEventIterator };

package/dist/chat.d.mts

@@ -0,0 +1,3 @@
+import { ChatPart, StreamAgentChatOptions, ToolChatPart } from "./chat/lib/types.mjs";
+import { getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue } from "./chat/lib/parts.mjs";
+export { ChatPart, StreamAgentChatOptions, ToolChatPart, getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue };

package/dist/chat.mjs

@@ -0,0 +1,3 @@
+import { getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue } from "./chat/lib/parts.mjs";
+
+export { getChatPartKey, getDefaultToolTitle, getToolName, isToolPart, stringifyChatValue };

package/dist/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/index.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/mcp/lib/content.d.mts

@@ -0,0 +1,66 @@
+import { McpResourceContent, McpToolResult } from "./types.mjs";
+
+//#region src/mcp/lib/content.d.ts
+/**
+ * Creates a plain text MCP tool result.
+ *
+ * @example
+ * ```ts
+ * resolveMCPTool(getStatus, {
+ *   content: ({ output }) => text(`Status: ${output.status}`),
+ * });
+ * ```
+ */
+declare function text(value: string, options?: {
+  isError?: boolean;
+}): McpToolResult;
+/**
+ * Creates a JSON MCP tool result with structured content preserved for clients that support it.
+ *
+ * @example
+ * ```ts
+ * resolveMCPTool(createProspect, {
+ *   content: ({ output }) => json(output, { label: "Created prospect:" }),
+ * });
+ * ```
+ */
+declare function json<TValue>(value: TValue, options?: {
+  label?: string;
+  isError?: boolean;
+}): McpToolResult<TValue>;
+/**
+ * Creates an MCP resource result for text, blob, or URI-backed resources.
+ *
+ * @example
+ * ```ts
+ * resolveMCPTool(getInvoice, {
+ *   content: ({ output }) =>
+ *     resource({ uri: output.uri, mimeType: "application/pdf" }),
+ * });
+ * ```
+ */
+declare function resource(value: McpResourceContent["resource"]): McpToolResult;
+/**
+ * Creates a markdown table MCP result and keeps the original rows as structured content.
+ *
+ * @example
+ * ```ts
+ * resolveMCPTool(listCustomers, {
+ *   content: ({ output }) =>
+ *     table(output.customers, {
+ *       title: "Customers",
+ *       columns: ["id", "name"],
+ *     }),
+ * });
+ * ```
+ */
+declare function table<TRow extends Record<string, unknown>>(rows: TRow[], options?: {
+  columns?: Array<keyof TRow & string>;
+  emptyText?: string;
+  title?: string;
+}): McpToolResult<{
+  columns: string[];
+  rows: TRow[];
+}>;
+//#endregion
+export { json, resource, table, text };

package/dist/mcp/lib/content.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.mts","names":[],"sources":["../../../src/mcp/lib/content.ts"],"mappings":";;;iBAEgB,WAAA,CAAY,IAAA,UAAc,OAAA;EAAY,OAAA;AAAA,IAAsB,aAAA;AAAA,iBAO5D,WAAA,QAAA,CACd,KAAA,EAAO,MAAA,EACP,OAAA;EAAY,KAAA;EAAgB,OAAA;AAAA,IAC3B,aAAA,CAAc,MAAA;AAAA,iBAeD,eAAA,CAAgB,QAAA,EAAU,kBAAA,eAAiC,aAAA;AAAA,iBAM3D,YAAA,cAA0B,MAAA,kBAAA,CACxC,IAAA,EAAM,IAAA,IACN,OAAA;EACE,OAAA,GAAU,KAAA,OAAY,IAAA;EACtB,SAAA;EACA,KAAA;AAAA,IAED,aAAA;EAAgB,OAAA;EAAmB,IAAA,EAAM,IAAA;AAAA"}