ensure build works

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: himself65 <14026360+himself65@users.noreply.github.com>

.changeset/ten-toys-accept.md

@@ -0,0 +1,5 @@
+---
+"@llamaindex/openai": patch
+---
+
+Update o4-mini to accept reasoning parameters and exclude temperature

apps/next/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @llamaindex/doc
 
+## 0.2.12
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+  - llamaindex@0.10.1
+
 ## 0.2.11
 
 ### Patch Changes

apps/next/fallback.js

@@ -0,0 +1,2 @@
+// fallback for `fs` usage in `web-tree-sitter`
+module.exports = {};

apps/next/next.config.mjs

@@ -1,5 +1,4 @@
 import { createMDX } from "fumadocs-mdx/next";
-import MonacoWebpackPlugin from "monaco-editor-webpack-plugin";
 const withMDX = createMDX();
 
 /** @type {import('next').NextConfig} */
@@ -16,7 +15,12 @@ const config = {
     "twoslash",
     "typescript",
   ],
-  webpack: (config, { isServer }) => {
+  turbopack: {
+    resolveAlias: {
+      fs: { browser: "./fallback.js" },
+    },
+  },
+  webpack: (config) => {
     if (Array.isArray(config.target) && config.target.includes("web")) {
       config.target = ["web", "es2020"];
     }
@@ -28,14 +32,6 @@ const config = {
     };
     config.resolve.fallback ??= {};
     config.resolve.fallback.fs = false;
-    if (!isServer) {
-      config.plugins.push(
-        new MonacoWebpackPlugin({
-          languages: ["typescript"],
-          filename: "static/[name].worker.js",
-        }),
-      );
-    }
     config.resolve.alias["replicate"] = false;
     return config;
   },

apps/next/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@llamaindex/doc",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "private": true,
   "scripts": {
     "postinstall": "fumadocs-mdx",
     "prebuild": "pnpm run build:docs",
     "build": "next build",
-    "dev": "next dev",
+    "dev": "next dev --turbo",
     "start": "next start",
     "postbuild": "tsx scripts/post-build.mts && tsx scripts/validate-links.mts",
     "build:docs": "cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" typedoc && tsx scripts/generate-docs.mts",
     "validate-links": "tsx scripts/validate-links.mts"
   },
   "dependencies": {
+    "@huggingface/transformers": "^3.5.0",
     "@icons-pack/react-simple-icons": "^10.1.0",
     "@llama-flow/docs": "0.0.3",
     "@llamaindex/chat-ui": "0.2.0",
@@ -23,6 +24,7 @@
     "@llamaindex/readers": "workspace:*",
     "@llamaindex/workflow": "workspace:*",
     "@mdx-js/mdx": "^3.1.0",
+    "@monaco-editor/react": "^4.7.0",
     "@number-flow/react": "^0.3.4",
     "@radix-ui/react-dialog": "^1.1.2",
     "@radix-ui/react-icons": "^1.3.2",
@@ -40,9 +42,9 @@
     "fumadocs-core": "^15.2.7",
     "fumadocs-docgen": "^2.0.0",
     "fumadocs-mdx": "^11.6.0",
-    "fumadocs-openapi": "^6.3.0",
+    "fumadocs-openapi": "^8.0.1",
     "fumadocs-twoslash": "^3.1.1",
-    "fumadocs-typescript": "^3.1.0",
+    "fumadocs-typescript": "^4.0.2",
     "fumadocs-ui": "^15.2.7",
     "hast-util-to-jsx-runtime": "^2.3.2",
     "llamaindex": "workspace:*",
@@ -52,7 +54,6 @@
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-icons": "^5.3.0",
-    "react-monaco-editor": "^0.56.2",
     "react-use-measure": "^2.1.1",
     "rehype-katex": "^7.0.1",
     "remark-math": "^6.0.0",
@@ -64,6 +65,8 @@
     "tailwindcss-animate": "^1.0.7",
     "tree-sitter": "^0.22.1",
     "tree-sitter-typescript": "^0.23.2",
+    "ts-morph": "^25.0.1",
+    "twoslash": "^0.3.1",
     "use-stick-to-bottom": "^1.0.42",
     "web-tree-sitter": "^0.24.4",
     "zod": "^3.23.8"
@@ -79,7 +82,6 @@
     "cross-env": "^7.0.3",
     "fast-glob": "^3.3.2",
     "gray-matter": "^4.0.3",
-    "monaco-editor-webpack-plugin": "^7.1.0",
     "postcss": "^8.5.3",
     "raw-loader": "^4.0.2",
     "remark": "^15.0.1",
@@ -88,9 +90,9 @@
     "remark-stringify": "^11.0.0",
     "tailwindcss": "^4.0.9",
     "tsx": "^4.19.3",
-    "typedoc": "0.27.4",
-    "typedoc-plugin-markdown": "^4.3.1",
-    "typedoc-plugin-merge-modules": "^6.1.0",
+    "typedoc": "0.28.2",
+    "typedoc-plugin-markdown": "^4.6.2",
+    "typedoc-plugin-merge-modules": "^7.0.0",
     "typescript": "^5.7.3"
   }
 }

apps/next/scripts/generate-docs.mts

@@ -1,9 +1,13 @@
 import { generateFiles as openapiGenerateFiles } from "fumadocs-openapi";
-import { generateFiles as typescriptGenerateFiles } from "fumadocs-typescript";
+import {
+  createGenerator,
+  generateFiles as typescriptGenerateFiles,
+} from "fumadocs-typescript";
 import fs from "node:fs";
 import * as path from "node:path";
 import { rimrafSync } from "rimraf";
 
+const generator = createGenerator();
 const out = "./src/content/docs/cloud/api";
 const apiRefOut = "./src/content/docs/api";
 
@@ -20,7 +24,7 @@ void openapiGenerateFiles({
   groupBy: "tag",
 });
 
-void typescriptGenerateFiles({
+void typescriptGenerateFiles(generator, {
   input: ["./src/content/docs/api/**/*.mdx"],
   output: (file) => path.resolve(path.dirname(file), path.basename(file)),
   transformOutput,

apps/next/source.config.ts

@@ -8,6 +8,9 @@ import remarkMath from "remark-math";
 
 export const docs = defineDocs({
   dir: ["./src/content/docs", "./node_modules/@llama-flow/docs"],
+  docs: {
+    async: true,
+  },
 });
 
 export default defineConfig({

apps/next/src/app/(home)/page.tsx

@@ -10,16 +10,55 @@ import { MagicMove } from "@/components/magic-move";
 import { NpmInstall } from "@/components/npm-install";
 import { Supports } from "@/components/supports";
 import { Button } from "@/components/ui/button";
-import { Skeleton } from "@/components/ui/skeleton";
 import { DOCUMENT_URL } from "@/lib/const";
 import { SiStackblitz } from "@icons-pack/react-simple-icons";
-import {
-  CodeBlock as FumaCodeBlock,
-  Pre,
-} from "fumadocs-ui/components/codeblock";
 import { Blocks, Bot, Footprints, Terminal } from "lucide-react";
 import Link from "next/link";
-import { Suspense } from "react";
+
+const codes = [
+  `import { openai } from "@llamaindex/openai";
+
+const llm = openai();
+const response = await llm.complete({ prompt: "How are you?" });`,
+  `import { openai } from "@llamaindex/openai";
+
+const llm = openai();
+const response = await llm.chat({
+  messages: [{ content: "Tell me a joke.", role: "user" }],
+});`,
+  `import { agent } from "llamaindex";
+import { openai } from "@llamaindex/openai";
+
+const analyseAgent = agent({
+  llm: openai({ model: "gpt-4o" }),
+  tools: [analyseTools],
+  systemPrompt,
+});
+const response = await analyseAgent.run(\`Analyse the given data:
+\${data}\`);`,
+  `import { agent, multiAgent } from "llamaindex";
+import { openai } from "@llamaindex/openai";
+
+const analyseAgent = agent({
+  name: "AnalyseAgent",
+  llm: openai({ model: "gpt-4o" }),
+  tools: [analyseTools],
+});
+const reporterAgent = agent({
+  name: "ReporterAgent",
+  llm: openai({ model: "gpt-4o" }),
+  tools: [reporterTools],
+  canHandoffTo: [analyseAgent],
+});
+
+const agents = multiAgent({
+  agents: [analyseAgent, reporterAgent],
+  rootAgent: reporterAgent,
+});
+
+const response = await agents.run(\`Analyse the given data:
+\${data}\`);`,
+];
 
 export default function HomePage() {
   return (
@@ -62,65 +101,10 @@ export default function HomePage() {
           heading="From the simplest to the most complex"
           description="LlamaIndex.TS is designed to be simple to get started, but powerful enough to build complex, agentic AI applications using multi-agents."
         >
-          <Suspense
-            fallback={
-              <FumaCodeBlock allowCopy={false}>
-                <Pre>
-                  <div className="space-y-2">
-                    <Skeleton className="h-4 w-[250px]" />
-                    <Skeleton className="h-4 w-[200px]" />
-                  </div>
-                </Pre>
-              </FumaCodeBlock>
-            }
-          >
-            <MagicMove
-              code={[
-                `import { openai } from "@llamaindex/openai";
-
-const llm = openai();
-const response = await llm.complete({ prompt: "How are you?" });`,
-                `import { openai } from "@llamaindex/openai";
-
-const llm = openai();
-const response = await llm.chat({
-  messages: [{ content: "Tell me a joke.", role: "user" }],
-});`,
-                `import { agent } from "llamaindex";
-import { openai } from "@llamaindex/openai";
-
-const analyseAgent = agent({
-  llm: openai({ model: "gpt-4o" }),
-  tools: [analyseTools],
-  systemPrompt,
-});
-const response = await analyseAgent.run(\`Analyse the given data:
-\${data}\`);`,
-                `import { agent, multiAgent } from "llamaindex";
-import { openai } from "@llamaindex/openai";
-
-const analyseAgent = agent({
-  name: "AnalyseAgent",
-  llm: openai({ model: "gpt-4o" }),
-  tools: [analyseTools],
-});
-const reporterAgent = agent({
-  name: "ReporterAgent",
-  llm: openai({ model: "gpt-4o" }),
-  tools: [reporterTools],
-  canHandoffTo: [analyseAgent],
-});
-
-const agents = multiAgent({
-  agents: [analyseAgent, reporterAgent],
-  rootAgent: reporterAgent,
-});
-
-const response = await agents.run(\`Analyse the given data:
-\${data}\`);`,
-              ]}
-            />
-          </Suspense>
+          <MagicMove
+            placeholder={<CodeBlock lang="ts" code={codes[0]} />}
+            code={codes}
+          />
         </Feature>
         <Feature
           icon={Bot}

apps/next/src/app/api/search/route.ts

@@ -1,4 +1,12 @@
 import { source } from "@/lib/source";
+import { structure } from "fumadocs-core/mdx-plugins";
 import { createFromSource } from "fumadocs-core/search/server";
 
-export const { GET } = createFromSource(source);
+// TODO: migrate to another search service, I don't think Vercel can handle that many of documents.
+export const { GET } = createFromSource(source, (page) => ({
+  id: page.url,
+  title: page.data.title,
+  description: page.data.description,
+  url: page.url,
+  structuredData: structure(page.data.content),
+}));

apps/next/src/app/docs/[[...slug]]/page.tsx

@@ -1,7 +1,13 @@
+import { ChatDemoRSC } from "@/components/demo/chat/rsc/demo";
+import * as demos from "@/components/demo/lazy";
 import { createMetadata, metadataImage } from "@/lib/metadata";
 import { openapi, source } from "@/lib/source";
+import * as Icons from "@icons-pack/react-simple-icons";
+import { APIPage } from "fumadocs-openapi/ui";
 import { Popup, PopupContent, PopupTrigger } from "fumadocs-twoslash/ui";
-import { createTypeTable } from "fumadocs-typescript/ui";
+import { createGenerator } from "fumadocs-typescript";
+import { AutoTypeTable } from "fumadocs-typescript/ui";
+import { Accordion, Accordions } from "fumadocs-ui/components/accordion";
 import { Tab, Tabs } from "fumadocs-ui/components/tabs";
 import defaultMdxComponents from "fumadocs-ui/mdx";
 import {
@@ -12,6 +18,8 @@ import {
 } from "fumadocs-ui/page";
 import { notFound } from "next/navigation";
 
+const generator = createGenerator();
+
 export const revalidate = false;
 
 export default async function Page(props: {
@@ -21,14 +29,13 @@ export default async function Page(props: {
   const page = source.getPage(params.slug);
   if (!page) notFound();
 
-  const { AutoTypeTable } = createTypeTable();
-  const MDX = page.data.body;
+  const { body: MDX, toc, lastModified } = await page.data.load();
 
   return (
     <DocsPage
-      toc={page.data.toc}
+      toc={toc}
       full={page.data.full}
-      lastUpdate={page.data.lastModified}
+      lastUpdate={lastModified}
       editOnGithub={{
         owner: "run-llama",
         repo: "LlamaIndexTS",
@@ -41,14 +48,21 @@ export default async function Page(props: {
       <DocsBody>
         <MDX
           components={{
+            ...Icons,
             ...defaultMdxComponents,
-            APIPage: openapi.APIPage,
+            ...demos,
+            ChatDemoRSC,
+            Accordion,
+            Accordions,
+            APIPage: (props) => <APIPage {...openapi.getAPIPageProps(props)} />,
             Tab,
             Tabs,
             Popup,
             PopupContent,
             PopupTrigger,
-            AutoTypeTable,
+            AutoTypeTable: (props) => (
+              <AutoTypeTable generator={generator} {...props} />
+            ),
           }}
         />
       </DocsBody>

apps/next/src/components/demo/code-node-parser.tsx

@@ -1,24 +1,26 @@
 "use client";
-import { createContextState } from "foxact/context-state";
-import { useIsClient } from "foxact/use-is-client";
-import { CodeBlock, Pre } from "fumadocs-ui/components/codeblock";
-import { lazy, Suspense, use, useMemo } from "react";
-import { StickToBottom, useStickToBottomContext } from "use-stick-to-bottom";
-import Parser from "web-tree-sitter";
-
 import { Label } from "@/components/ui/label";
 import { Skeleton } from "@/components/ui/skeleton";
 import { Slider } from "@/components/ui/slider";
 import { CodeSplitter } from "@llamaindex/node-parser/code";
+import { Editor } from "@monaco-editor/react";
+import { createContextState } from "foxact/context-state";
+import { useIsClient } from "foxact/use-is-client";
 import { useShiki } from "fumadocs-core/highlight/client";
+import { CodeBlock, Pre } from "fumadocs-ui/components/codeblock";
+import { Suspense, use, useMemo } from "react";
+import { StickToBottom, useStickToBottomContext } from "use-stick-to-bottom";
 
 let promise: Promise<CodeSplitter>;
 if (typeof window !== "undefined") {
-  promise = Parser.init({
-    locateFile(scriptName: string) {
-      return "/" + scriptName;
-    },
-  }).then(async () => {
+  async function run() {
+    const { default: Parser } = await import("web-tree-sitter");
+    await Parser.init({
+      locateFile(scriptName: string) {
+        return "/" + scriptName;
+      },
+    });
+
     const parser = new Parser();
     const Lang = await Parser.Language.load("/tree-sitter-typescript.wasm");
     parser.setLanguage(Lang);
@@ -26,7 +28,9 @@ if (typeof window !== "undefined") {
       getParser: () => parser,
       maxChars: 100,
     });
-  });
+  }
+
+  promise = run();
 }
 
 const [SliderProvider, useSlider, useSetSlider] = createContextState(100);
@@ -48,8 +52,6 @@ const john: Person = {
 
 console.log(greet(john));`);
 
-const Editor = lazy(() => import("react-monaco-editor"));
-
 export const IDE = () => {
   const codeSplitter = use(promise);
   const code = useCode();
@@ -73,21 +75,6 @@ export const IDE = () => {
         />
       </div>
       <Editor
-        editorWillMount={() => {}}
-        editorDidMount={() => {
-          window.MonacoEnvironment!.getWorkerUrl = (
-            _moduleId: string,
-            label: string,
-          ) => {
-            if (label === "json") return "/_next/static/json.worker.js";
-            if (label === "css") return "/_next/static/css.worker.js";
-            if (label === "html") return "/_next/static/html.worker.js";
-            if (label === "typescript" || label === "javascript")
-              return "/_next/static/ts.worker.js";
-            return "/_next/static/editor.worker.js";
-          };
-        }}
-        editorWillUnmount={() => {}}
         options={{
           minimap: {
             enabled: false,
@@ -97,7 +84,9 @@ export const IDE = () => {
         height="100%"
         width="100%"
         language="typescript"
-        onChange={setCode}
+        onChange={(v) => {
+          if (v) setCode(v);
+        }}
         value={code}
       />
     </div>

apps/next/src/components/demo/lazy.ts

@@ -0,0 +1,18 @@
+"use client";
+import dynamic from "next/dynamic";
+
+// lazy load client components
+export const ChatDemo = dynamic(() =>
+  import("@/components/demo/chat/api/demo").then((mod) => mod.ChatDemo),
+);
+
+export const CodeNodeParserDemo = dynamic(() =>
+  import("@/components/demo/code-node-parser").then(
+    (mod) => mod.CodeNodeParserDemo,
+  ),
+);
+export const WorkflowStreamingDemo = dynamic(() =>
+  import("@/components/demo/workflow-streaming-ui").then(
+    (mod) => mod.WorkflowStreamingDemo,
+  ),
+);

apps/next/src/components/magic-move.tsx

@@ -1,25 +1,27 @@
 "use client";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
-import { CodeBlock, Pre } from "fumadocs-ui/components/codeblock";
+import { CodeBlock } from "fumadocs-ui/components/codeblock";
 import { RotateCcw } from "lucide-react";
 import { useTheme } from "next-themes";
-import { use, useCallback, useEffect, useState } from "react";
-import { getSingletonHighlighter } from "shiki";
+import { type ReactNode, use, useCallback, useEffect, useState } from "react";
+import { createJavaScriptRegexEngine, getSingletonHighlighter } from "shiki";
 import { ShikiMagicMove } from "shiki-magic-move/react";
-import { createOnigurumaEngine } from "shiki/engine/oniguruma";
 
+const engine = createJavaScriptRegexEngine();
 const highlighterPromise = getSingletonHighlighter({
-  engine: createOnigurumaEngine(() => import("shiki/wasm")),
+  engine,
   themes: ["vesper", "github-light"],
   langs: ["js", "ts", "tsx"],
 });
 
 export type MagicMoveProps = {
   code: string[];
+  placeholder: ReactNode;
 };
 
 export function MagicMove(props: MagicMoveProps) {
+  const [mounted, setMounted] = useState(false);
   const [move, setMove] = useState<number>(0);
   const currentCode = props.code[move];
   const highlighter = use(highlighterPromise);
@@ -38,24 +40,27 @@ export function MagicMove(props: MagicMoveProps) {
     }
   }, [animate, move, props.code]);
 
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+
+  if (!mounted) return props.placeholder;
+
   return (
     <CodeBlock allowCopy={false}>
-      {highlighter && (
-        <Pre>
-          <ShikiMagicMove
-            lang="ts"
-            theme={resolvedTheme === "dark" ? "vesper" : "github-light"}
-            highlighter={highlighter}
-            code={currentCode}
-            options={{
-              duration: 800,
-              stagger: 0.3,
-              lineNumbers: false,
-              containerStyle: false,
-            }}
-          />
-        </Pre>
-      )}
+      <ShikiMagicMove
+        className="shiki !block p-4 *:!inline"
+        lang="ts"
+        theme={resolvedTheme === "dark" ? "vesper" : "github-light"}
+        highlighter={highlighter}
+        code={currentCode}
+        options={{
+          duration: 800,
+          stagger: 0.3,
+          lineNumbers: false,
+          containerStyle: false,
+        }}
+      />
       <Button
         className={cn(
           "absolute bottom-2 right-2",

apps/next/src/content/docs/llamaindex/getting_started/create_llama.mdx

@@ -18,4 +18,4 @@ npm run dev
 
 to start the development server. You can then visit [http://localhost:3000](http://localhost:3000) to see your app, which should look something like this:
 
-![create-llama interface](./images/create_llama.png)
+![create-llama interface](/images/create_llama.png)

apps/next/src/content/docs/llamaindex/getting_started/installation/cloudflare.mdx

@@ -3,13 +3,6 @@ title: With Cloudflare Worker
 description: In this guide, you'll learn how to use LlamaIndex with CloudFlare Worker
 ---
 
-import {
-  SiNodedotjs,
-  SiDeno,
-  SiBun,
-  SiCloudflareworkers,
-} from "@icons-pack/react-simple-icons";
-
 Before you start, make sure you have try LlamaIndex.TS in Node.js to make sure you understand the basics.
 
 <Card

apps/next/src/content/docs/llamaindex/getting_started/installation/index.mdx

@@ -3,14 +3,6 @@ title: Installation
 description: How to install llamaindex packages.
 ---
 
-import {
-	SiNodedotjs,
-	SiTypescript,
-	SiNextdotjs,
-	SiCloudflareworkers,
-	SiVite
-} from "@icons-pack/react-simple-icons";
-
 To install llamaindex, run the following command:
 
 ```package-install

apps/next/src/content/docs/llamaindex/index.mdx

@@ -3,13 +3,6 @@ title: What is LlamaIndex.TS
 description: LlamaIndex is the leading data framework for building LLM applications
 ---
 
-import {
-  SiNodedotjs,
-  SiDeno,
-  SiBun,
-  SiCloudflareworkers,
-} from "@icons-pack/react-simple-icons";
-
 LlamaIndex is a framework for building context-augmented generative AI applications with LLMs including agents and workflows.
 
 The TypeScript implementation is designed for JavaScript server side applications using <SiNodedotjs className="inline" color="#5FA04E" /> Node.js, <SiDeno className="inline" color="#70FFAF" /> Deno, <SiBun className="inline" /> Bun, <SiCloudflareworkers className="inline" color="#F38020" /> Cloudflare Workers, and more.

apps/next/src/content/docs/llamaindex/modules/agents/workflows.mdx

@@ -2,9 +2,6 @@
 title: Workflows
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/workflow/joke.ts";
-
 A `Workflow` in LlamaIndexTS is an event-driven abstraction used to chain together several events. Workflows are made up of `steps`, with each step responsible for handling certain event types and emitting new events.
 
 Workflows in LlamaIndexTS work by defining step functions that handle specific event types and emit new events.
@@ -22,7 +19,7 @@ npm i @llamaindex/workflow
 
 As an illustrative example, let's consider a naive workflow where a joke is generated and then critiqued.
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/workflow/joke.ts</include>
 
 There's a few moving pieces here, so let's go through this piece by piece.
 

apps/next/src/content/docs/llamaindex/modules/data/data_index/managed.mdx

@@ -3,10 +3,6 @@ title: Managed Index
 description: Managed index using LlamaCloud
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/cloud/chat.ts";
-import CodeSource2 from "!raw-loader!@/examples/cloud/from-documents.ts";
-
 LlamaCloud is a new generation of managed parsing, ingestion, and retrieval services, designed to bring production-grade context-augmentation to your LLM and RAG applications.
 
 LlamaCloud supports
@@ -22,13 +18,13 @@ Visit [LlamaCloud](https://cloud.llamaindex.ai) to sign in and get an API key.
 
 Here's an example of how to create a managed index by ingesting a couple of documents:
 
-<DynamicCodeBlock lang="ts" code={CodeSource2} />
+<include cwd>../../examples/cloud/chat.ts</include>
 
 ## Use a Managed Index
 
 Here's an example of how to use a managed index together with a chat engine:
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/cloud/from-documents.ts</include>
 
 ## API Reference
 

apps/next/src/content/docs/llamaindex/modules/data/ingestion_pipeline/transformations/node-parser.mdx

@@ -2,7 +2,6 @@
 title: Node Parsers / Text Splitters
 description: Learn how to use Node Parsers and Text Splitters to extract data from documents.
 ---
-import { CodeNodeParserDemo } from '@/components/demo/code-node-parser.tsx';
 
 Node parsers are a simple abstraction that take a list of `Document` objects, and chunk them into `Node` objects, such that each node is a specific chunk of the parent document. When a document is broken into nodes, all of it's attributes are inherited to the children nodes (i.e. `metadata`, text and metadata templates, etc.). You can read more about `Node` and `Document` properties [here](/docs/llamaindex/modules/data).
 
@@ -150,8 +149,6 @@ Try it out ⬇️
 
 <CodeNodeParserDemo/>
 
-import { Accordion, Accordions } from 'fumadocs-ui/components/accordion';
-
 <Accordions>
 	<Accordion title="Use it in browser">
 		You might setup WASM files for `web-tree-sitter` and use it in the browser.

apps/next/src/content/docs/llamaindex/modules/data/readers/discord.mdx

@@ -2,9 +2,6 @@
 title: DiscordReader
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/readers/src/discord";
-
 DiscordReader is a simple data loader that reads all messages in a given Discord channel and returns them as Document objects.
 It uses the [@discordjs/rest](https://github.com/discordjs/discord.js/tree/main/packages/rest) library to fetch the messages.
 
@@ -15,7 +12,7 @@ In your Discord Application, go to the `OAuth2` tab and generate an invite URL b
 This will invite the bot with the necessary permissions to read messages.
 Copy the URL in your browser and select the server you want your bot to join.
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/readers/src/discord.ts</include>
 
 ### Params
 

apps/next/src/content/docs/llamaindex/modules/data/readers/index.mdx

@@ -3,11 +3,6 @@ title: Loading Data
 description: Loading data using Readers into Documents
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/readers/src/simple-directory-reader";
-import CodeSource2 from "!raw-loader!@/examples/readers/src/custom-simple-directory-reader";
-import { Accordion, Accordions } from 'fumadocs-ui/components/accordion';
-
 Before you can start indexing your documents, you need to load them into memory.
 A reader is a module that loads data from a file into a `Document` object.
 
@@ -55,7 +50,7 @@ LlamaIndex.TS supports easy loading of files from folders using the `SimpleDirec
 
 It is a simple reader that reads all files from a directory and its subdirectories and delegates the actual reading to the reader specified in the `fileExtToReader` map.
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/readers/src/simple-directory-reader.ts</include>
 
 Currently, the following readers are mapped to specific file types:
 
@@ -77,7 +72,7 @@ SimpleDirectoryReader supports up to 9 concurrent requests. Use the `numWorkers`
 
 ### Example
 
-<DynamicCodeBlock lang="ts" code={CodeSource2} />
+<include cwd>../../examples/readers/src/custom-simple-directory-reader.ts</include>
 
 ## Tips when using in non-Node.js environments
 

apps/next/src/content/docs/llamaindex/modules/data/readers/llama_parse/index.mdx

@@ -2,10 +2,6 @@
 title: LlamaParse
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/readers/src/llamaparse";
-import CodeSource2 from "!raw-loader!@/examples/readers/src/simple-directory-reader-with-llamaparse.ts";
-
 LlamaParse is an API created by LlamaIndex to efficiently parse files, e.g. it's great at converting PDF tables into markdown.
 
 To use it, first login and get an API key from https://cloud.llamaindex.ai. Make sure to store the key as `apiKey` parameter or in the environment variable `LLAMA_CLOUD_API_KEY`.
@@ -17,7 +13,7 @@ Official documentation for LlamaParse can be found [here](https://docs.cloud.lla
 You can then use the `LlamaParseReader` class to load local files and convert them into a parsed document that can be used by LlamaIndex.
 See [reader.ts](https://github.com/run-llama/LlamaIndexTS/blob/main/packages/cloud/src/reader.ts) for a list of supported file types:
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/readers/src/llamaparse.ts</include>
 
 ### Params
 
@@ -60,7 +56,7 @@ They can be divided into two groups.
 
 Below a full example of `LlamaParse` integrated in `SimpleDirectoryReader` with additional options.
 
-<DynamicCodeBlock lang="ts" code={CodeSource2} />
+<include cwd>../../examples/readers/src/simple-directory-reader-with-llamaparse.ts</include>
 
 ## API Reference
 

apps/next/src/content/docs/llamaindex/modules/models/llms/groq.mdx

@@ -2,9 +2,6 @@
 title: Groq
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/groq.ts";
-
 ## Installation
 
 ```package-install
@@ -58,7 +55,7 @@ const results = await queryEngine.query({
 
 ## Full Example
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/groq.ts</include>
 
 ## API Reference
 

apps/next/src/content/docs/llamaindex/modules/ui/chat.mdx

@@ -2,7 +2,6 @@
 title: Using API Route
 description: Chat interface for your LlamaIndexTS application using API Route
 ---
-import { ChatDemo } from '../../../../../components/demo/chat/api/demo';
 
 Using [chat-ui](https://github.com/run-llama/chat-ui), it's easy to add a chat interface to your LlamaIndexTS application.
 You just need to create an API route that provides an `api/chat` endpoint and a chat component to consume the API.

apps/next/src/content/docs/llamaindex/modules/ui/rsc.mdx

@@ -2,7 +2,6 @@
 title: Using Next.js RSC
 description: Chat interface for your LlamaIndexTS application using Next.js RSC
 ---
-import { ChatDemoRSC } from '../../../../../components/demo/chat/rsc/demo';
 
 Using [chat-ui](https://github.com/run-llama/chat-ui), it's easy to add a chat interface to your LlamaIndexTS application using [Next.js RSC](https://nextjs.org/docs/app/building-your-application/rendering/server-components) and [Vercel AI RSC](https://sdk.vercel.ai/docs/ai-sdk-rsc/overview).
 

apps/next/src/content/docs/llamaindex/more.mdx

@@ -3,13 +3,6 @@ title: More
 description: More
 ---
 
-import {
-  SiGithub,
-  SiNpm,
-  SiX,
-  SiDiscord,
-} from "@icons-pack/react-simple-icons";
-
 ## 🗺️ Ecosystem
 
 To download or contribute, find LlamaIndex on:

apps/next/src/content/docs/llamaindex/tutorials/agents/1_setup.mdx

@@ -8,7 +8,7 @@ In this guide we'll walk you through the process of building an Agent in JavaScr
 
 In LlamaIndex, an agent is a semi-autonomous piece of software powered by an LLM that is given a task and executes a series of steps towards solving that task. It is given a set of tools, which can be anything from arbitrary functions up to full LlamaIndex query engines, and it selects the best available tool to complete each step. When each step is completed, the agent judges whether the task is now complete, in which case it returns a result to the user, or whether it needs to take another step, in which case it loops back to the start.
 
-![agent flow](./images/agent_flow.png)
+![agent flow](/images/agent_flow.png)
 
 ## Install LlamaIndex.TS
 

apps/next/src/content/docs/llamaindex/tutorials/basic_agent.mdx

@@ -2,9 +2,6 @@
 title: Basic Agent 
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/agent/openai";
-
 We have a comprehensive, step-by-step [guide to building agents in LlamaIndex.TS](/docs/llamaindex/tutorials/agents/1_setup) that we recommend to learn what agents are and how to build them for production. But building a basic agent is simple:
 
 ## Set up
@@ -27,7 +24,7 @@ Create the file `example.ts`. This code will:
 - Give an example of the data structure we wish to generate
 - Prompt the LLM with instructions and the example, plus a sample transcript
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/agent/openai.ts</include>
 
 To run the code:
 

apps/next/src/content/docs/llamaindex/tutorials/rag/index.mdx

@@ -2,10 +2,6 @@
 title: Retrieval Augmented Generation (RAG) 
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/vectorIndex";
-import TSConfigSource from "!!raw-loader!@/examples/tsconfig.json";
-
 One of the most common use-cases for LlamaIndex is Retrieval-Augmented Generation or RAG, in which your data is indexed and selectively retrieved to be given to an LLM as source material for responding to a query. You can learn more about the [concepts behind RAG](/docs/llamaindex/tutorials/rag/concepts).
 
 ## Set up the project
@@ -30,11 +26,11 @@ Create the file `example.ts`. This code will
 - index it (which creates embeddings using OpenAI)
 - create a query engine to answer questions about the data
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/vectorIndex.ts</include>
 
 Create a `tsconfig.json` file in the same folder:
 
-<DynamicCodeBlock lang="json" code={TSConfigSource} />
+<include cwd>../../examples/tsconfig.json</include>
 
 Now you can run the code with
 

apps/next/src/content/docs/llamaindex/tutorials/structured_data_extraction.mdx

@@ -2,9 +2,6 @@
 title: Structured data extraction 
 ---
 
-import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
-import CodeSource from "!raw-loader!@/examples/jsonExtract";
-
 Make sure you have installed LlamaIndex.TS and have an OpenAI key. If you haven't, check out the [installation](/docs/llamaindex/getting_started/installation) guide.
 
 You can use [other LLMs](/docs/llamaindex/modules/models/llms) via their APIs; if you would prefer to use local models check out our [local LLM example](/docs/llamaindex/tutorials/local_llm).
@@ -26,7 +23,7 @@ Create the file `example.ts`. This code will:
 - Give an example of the data structure we wish to generate
 - Prompt the LLM with instructions and the example, plus a sample transcript
 
-<DynamicCodeBlock lang="ts" code={CodeSource} />
+<include cwd>../../examples/jsonExtract.ts</include>
 
 To run the code:
 

apps/next/src/content/docs/llamaindex/tutorials/workflow/advanced-events.mdx

@@ -0,0 +1,530 @@
+---
+title: Advanced Event Handling
+description: Master complex event patterns and middleware with Workflows
+---
+
+This guide explores advanced event handling techniques and patterns you can use with Workflows to build more sophisticated patterns.
+
+## Event Composition
+
+Workflows allow you to work with different event types and compose them in powerful ways:
+
+### Multiple Event Types
+
+You can define multiple event types for different kinds of data flowing through your workflow:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define different event types
+const textEvent = workflowEvent<string>();
+const numberEvent = workflowEvent<number>();
+const booleanEvent = workflowEvent<boolean>();
+const complexEvent = workflowEvent<{ id: string; value: number }>();
+
+// Create a workflow that can process different event types
+const workflow = createWorkflow();
+
+// Handle text events
+workflow.handle([textEvent], (event) => {
+  console.log(`Processing text: ${event.data}`);
+  return numberEvent.with(event.data.length);
+});
+
+// Handle number events
+workflow.handle([numberEvent], (event) => {
+  const isEven = event.data % 2 === 0;
+  console.log(`Number ${event.data} is ${isEven ? 'even' : 'odd'}`);
+  return booleanEvent.with(isEven);
+});
+
+// Handle boolean events
+workflow.handle([booleanEvent], (event) => {
+  return complexEvent.with({
+    id: crypto.randomUUID(),
+    value: event.data ? 100 : 0
+  });
+});
+```
+
+### Event Branching and Merging
+
+You can create complex event flows with branching and merging patterns:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Define events for a data processing pipeline
+const inputEvent = workflowEvent<string>();
+const validateEvent = workflowEvent<string>();
+const processEvent = workflowEvent<string>();
+const errorEvent = workflowEvent<Error>();
+const resultEvent = workflowEvent<string>();
+const completeEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Branch based on input validation
+workflow.handle([inputEvent], (event) => {
+  if (event.data && event.data.trim().length > 0) {
+    return validateEvent.with(event.data.trim());
+  } else {
+    return errorEvent.with(new Error("Empty input"));
+  }
+});
+
+// Process valid inputs
+workflow.handle([validateEvent], (event) => {
+  return processEvent.with(event.data.toUpperCase());
+});
+
+// Handle processing
+workflow.handle([processEvent], (event) => {
+  return resultEvent.with(`Processed: ${event.data}`);
+});
+
+// Handle errors
+workflow.handle([errorEvent], (event) => {
+  return resultEvent.with(`Error: ${event.data.message}`);
+});
+
+// Merge results: collect multiple results into a single completion event
+workflow.handle([inputEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Process all inputs
+  const inputs = start.data.split(',').map(s => s.trim());
+  inputs.forEach(input => sendEvent(inputEvent.with(input)));
+  
+  // Collect all results
+  const results = await collect(
+    until(stream, result => resultEvent.include(result))
+      .filter(ev => resultEvent.include(ev))
+      .take(inputs.length)
+  );
+  
+  return completeEvent.with(results.map(r => r.data));
+});
+```
+
+## Event Filtering and Transformation
+
+You can filter and transform events to build sophisticated data processing pipelines:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const dataEvent = workflowEvent<number>();
+const evenEvent = workflowEvent<number>();
+const oddEvent = workflowEvent<number>();
+const transformedEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Filter even numbers
+workflow.handle([dataEvent], (event) => {
+  if (event.data % 2 === 0) {
+    return evenEvent.with(event.data);
+  } else {
+    return oddEvent.with(event.data);
+  }
+});
+
+// Transform even numbers
+workflow.handle([evenEvent], (event) => {
+  return transformedEvent.with(`Even: ${event.data}`);
+});
+
+// Transform odd numbers
+workflow.handle([oddEvent], (event) => {
+  return transformedEvent.with(`Odd: ${event.data}`);
+});
+
+// Collect and organize results
+workflow.handle([dataEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Generate a sequence of numbers
+  for (let i = 1; i <= 10; i++) {
+    sendEvent(dataEvent.with(i));
+  }
+  
+  // Collect transformed events
+  const results = await collect(
+    until(stream)
+      .filter(ev => transformedEvent.include(ev))
+      .take(10)
+  );
+  
+  return resultEvent.with(results.map(r => r.data));
+});
+```
+
+## Working with `withTraceEvents` Middleware
+
+The `withTraceEvents` middleware adds powerful tracing capabilities to your workflows:
+
+```ts
+import { 
+  createWorkflow, 
+  workflowEvent,
+  withTraceEvents,
+  runOnce,
+  createHandlerDecorator
+} from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const processEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow with tracing
+const workflow = withTraceEvents(createWorkflow());
+
+// Create a custom handler decorator that logs execution time
+const measureTime = createHandlerDecorator({
+  debugLabel: "measureTime",
+  getInitialValue: () => performance.now(),
+  onBeforeHandler: (handler, context, startTime) => {
+    console.log(`Starting handler execution at ${new Date().toISOString()}`);
+    return handler;
+  },
+  onAfterHandler: (result, context, startTime) => {
+    const duration = performance.now() - startTime;
+    console.log(`Handler executed in ${duration.toFixed(2)}ms`);
+    return startTime; // Return the initial value for next execution
+  }
+});
+
+// Run a specific handler only once
+workflow.handle(
+  [startEvent],
+  runOnce((event) => {
+    console.log("This handler will only run once per workflow context");
+    return processEvent.with(event.data);
+  })
+);
+
+// Measure the execution time of this handler
+workflow.handle(
+  [processEvent],
+  measureTime((event) => {
+    // Simulate processing time
+    const start = Date.now();
+    while (Date.now() - start < 100) {
+      // Busy wait for 100ms
+    }
+    return resultEvent.with(`Processed: ${event.data}`);
+  })
+);
+```
+
+### Debugging with Substreams
+
+You can use the `substream` feature to debug specific event flows:
+
+```ts
+import { createWorkflow, workflowEvent, withTraceEvents } from "llamaindex";
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const fetchEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow with tracing
+const workflow = withTraceEvents(createWorkflow());
+
+// Query handler
+workflow.handle([queryEvent], (event) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Create a specific fetch event for this query
+  const fetchInstance = fetchEvent.with(event.data);
+  sendEvent(fetchInstance);
+  
+  // Create a substream to only track events related to this fetch
+  const substream = workflow.substream(fetchInstance, stream);
+  
+  // Listen for results in the substream
+  (async () => {
+    for await (const event of substream) {
+      console.log(`Event in substream: ${event.type}`);
+    }
+  })();
+  
+  return resultEvent.with(`Querying: ${event.data}`);
+});
+
+// Fetch handler
+workflow.handle([fetchEvent], (event) => {
+  console.log(`Fetching data for: ${event.data}`);
+  // Actual fetch logic would go here
+  return resultEvent.with(`Results for: ${event.data}`);
+});
+```
+
+## Advanced Validation and Type Safety
+
+The `withValidation` middleware ensures your workflow connections are both type-safe and runtime-safe:
+
+```ts
+import { createWorkflow, workflowEvent, withValidation } from "llamaindex";
+
+// Define events with explicit types
+const inputEvent = workflowEvent<string, "input">();
+const validateEvent = workflowEvent<string, "validate">();
+const processEvent = workflowEvent<string, "process">();
+const resultEvent = workflowEvent<string, "result">();
+const errorEvent = workflowEvent<Error, "error">({
+  debugLabel: "errorEvent" // Add debug labels for better error messages
+});
+
+// Define the allowed event flow paths
+const workflow = withValidation(
+  createWorkflow(),
+  [
+    [[inputEvent], [validateEvent, errorEvent]],    // inputEvent can lead to validateEvent or errorEvent
+    [[validateEvent], [processEvent, errorEvent]],  // validateEvent can lead to processEvent or errorEvent
+    [[processEvent], [resultEvent, errorEvent]],    // processEvent can lead to resultEvent or errorEvent
+    [[errorEvent], [resultEvent]]                   // errorEvent can lead to resultEvent
+  ]
+);
+
+// Now use strictHandle to get compile-time validation
+workflow.strictHandle([inputEvent], (sendEvent, event) => {
+  try {
+    if (!event.data || event.data.trim().length === 0) {
+      throw new Error("Empty input");
+    }
+    // This is allowed by our validation rules
+    sendEvent(validateEvent.with(event.data.trim()));
+    
+    // This would cause a compile-time error:
+    // sendEvent(resultEvent.with("Result")); // ❌ Not allowed by validation rules
+  } catch (err) {
+    // This is allowed by our validation rules
+    sendEvent(errorEvent.with(err instanceof Error ? err : new Error(String(err))));
+  }
+});
+
+// The rest of the workflow with strict validation
+workflow.strictHandle([validateEvent], (sendEvent, event) => {
+  // Validation logic here
+  sendEvent(processEvent.with(event.data));
+});
+
+workflow.strictHandle([processEvent], (sendEvent, event) => {
+  // Processing logic here
+  sendEvent(resultEvent.with(`Processed: ${event.data}`));
+});
+
+workflow.strictHandle([errorEvent], (sendEvent, event) => {
+  // Error handling logic here
+  sendEvent(resultEvent.with(`Error handled: ${event.data.message}`));
+});
+```
+
+## Creating Custom Middleware
+
+You can create your own middleware to extend the workflow capabilities:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Create a logging middleware
+function withLogging(workflow) {
+  const originalHandle = workflow.handle;
+  
+  workflow.handle = function(eventTypes, handler) {
+    return originalHandle.call(workflow, eventTypes, async function(...args) {
+      const eventType = eventTypes.map(e => e.name || 'AnonymousEvent').join(',');
+      console.log(`[${new Date().toISOString()}] Handling ${eventType}`);
+      
+      try {
+        const result = await handler(...args);
+        console.log(`[${new Date().toISOString()}] Completed ${eventType}`);
+        return result;
+      } catch (error) {
+        console.error(`[${new Date().toISOString()}] Error in ${eventType}:`, error);
+        throw error;
+      }
+    });
+  };
+  
+  return workflow;
+}
+
+// Create a retry middleware
+function withRetry(maxRetries = 3, workflow) {
+  const originalHandle = workflow.handle;
+  
+  workflow.handle = function(eventTypes, handler) {
+    return originalHandle.call(workflow, eventTypes, async function(...args) {
+      let lastError;
+      
+      for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+          return await handler(...args);
+        } catch (error) {
+          lastError = error;
+          console.warn(`Attempt ${attempt}/${maxRetries} failed:`, error);
+          
+          if (attempt < maxRetries) {
+            // Exponential backoff
+            await new Promise(resolve => 
+              setTimeout(resolve, Math.pow(2, attempt - 1) * 100)
+            );
+          }
+        }
+      }
+      
+      throw lastError;
+    });
+  };
+  
+  return workflow;
+}
+
+// Use the custom middleware
+const workflow = withRetry(3, withLogging(createWorkflow()));
+
+// Define events
+const startEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Add handlers
+workflow.handle([startEvent], (event) => {
+  // This handler might fail but will be retried
+  if (Math.random() < 0.7) {
+    throw new Error("Random failure");
+  }
+  return resultEvent.with(`Processed: ${event.data}`);
+});
+```
+
+## Integrating with External Systems
+
+You can extend your workflows to integrate with external systems:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const fetchEvent = workflowEvent<string>();
+const successEvent = workflowEvent<any>();
+const failureEvent = workflowEvent<Error>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Handle external API calls with proper error handling
+workflow.handle([fetchEvent], async (event) => {
+  const { signal } = getContext();
+  
+  try {
+    // Use AbortSignal for cancellation support
+    const response = await fetch(event.data, { signal });
+    
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status}`);
+    }
+    
+    const data = await response.json();
+    return successEvent.with(data);
+  } catch (error) {
+    if (error.name === 'AbortError') {
+      return failureEvent.with(new Error('Request was aborted'));
+    }
+    return failureEvent.with(error instanceof Error ? error : new Error(String(error)));
+  }
+});
+
+// Database integration example
+const dbQueryEvent = workflowEvent<{ collection: string; query: any }>();
+const dbResultEvent = workflowEvent<any[]>();
+
+workflow.handle([dbQueryEvent], async (event) => {
+  // Connect to database (pseudo-code)
+  const db = await connectToDatabase();
+  
+  try {
+    const results = await db.collection(event.data.collection)
+      .find(event.data.query)
+      .toArray();
+      
+    return dbResultEvent.with(results);
+  } catch (error) {
+    return failureEvent.with(error);
+  } finally {
+    await db.close();
+  }
+});
+```
+
+## Handling Complex Asynchronous Patterns
+
+LlamaIndex workflows excel at managing complex asynchronous patterns:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Events for an orchestration workflow
+const orchestrateEvent = workflowEvent<string[]>();
+const taskEvent = workflowEvent<string>();
+const progressEvent = workflowEvent<{ task: string; progress: number }>();
+const taskCompleteEvent = workflowEvent<string>();
+const aggregateEvent = workflowEvent<any>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Orchestrator: distribute tasks and collect results
+workflow.handle([orchestrateEvent], async (event) => {
+  const { sendEvent, stream } = getContext();
+  const tasks = event.data;
+  
+  // Start all tasks
+  tasks.forEach(task => sendEvent(taskEvent.with(task)));
+  
+  // Track progress
+  let completed = 0;
+  const results = {};
+  
+  // Process task completion and progress events
+  for await (const event of until(stream, () => completed === tasks.length)) {
+    if (progressEvent.include(event)) {
+      console.log(`Task ${event.data.task}: ${event.data.progress}%`);
+    } else if (taskCompleteEvent.include(event)) {
+      completed++;
+      results[event.data] = `Completed ${event.data}`;
+      console.log(`Completed ${completed}/${tasks.length} tasks`);
+    }
+  }
+  
+  return aggregateEvent.with(results);
+});
+
+// Task processor
+workflow.handle([taskEvent], async (event) => {
+  const { sendEvent } = getContext();
+  const task = event.data;
+  
+  // Simulate task processing with progress updates
+  for (let progress = 0; progress <= 100; progress += 20) {
+    sendEvent(progressEvent.with({ task, progress }));
+    await new Promise(resolve => setTimeout(resolve, 200));
+  }
+  
+  return taskCompleteEvent.with(task);
+});
+```
+
+## Next Steps
+
+Now that you've explored advanced event handling with workflows, you're ready to build sophisticated applications:
+
+- [Integrating Workflows with other LlamaIndex Features](./llamaindex-integration.mdx) 

apps/next/src/content/docs/llamaindex/tutorials/workflow/basic-workflow.mdx

@@ -0,0 +1,263 @@
+---
+title: Basic Workflow Patterns
+description: Learn common patterns and techniques for building effective workflows
+---
+
+This guide explores common patterns you can use to build more complex workflows with workflows.
+
+## Fan-out (Parallelism)
+
+One of the most powerful features of workflows is the ability to run tasks in parallel:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const processItemEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<string>();
+const completeEvent = workflowEvent<string[]>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Process start event: fan out to multiple processItemEvent events
+workflow.handle([startEvent], (start) => {
+  const { sendEvent, stream } = getContext();
+  
+  // Emit multiple events to be processed in parallel
+  for (let i = 0; i < 10; i++) {
+    sendEvent(processItemEvent.with(i));
+  }
+  
+  // Collect all resultEvents and emit a final completeEvent
+  let condition = false;
+  const results = collect(
+    until(stream, () => condition)
+      .filter((ev) => resultEvent.includes(ev))
+  );
+  
+  return completeEvent.with(results.map(event => event.data));
+});
+
+// Process each item
+workflow.handle([processItemEvent], (event) => {
+  // Process the item
+  const processedValue = `Processed: ${event.data}`;
+  
+  // If this is the last item, set the condition to stop collecting
+  if (event.data === 9) {
+    condition = true;
+  }
+  
+  return resultEvent.with(processedValue);
+});
+```
+
+This pattern allows you to:
+1. Emit multiple events to be processed in parallel
+2. Collect results as they come in
+3. Complete once all parallel tasks are finished
+
+## Conditional Branching
+
+You can implement conditional logic in your workflows:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const inputEvent = workflowEvent<number>();
+const evenNumberEvent = workflowEvent<string>();
+const oddNumberEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+// Branch based on whether the number is even or odd
+workflow.handle([inputEvent], (event) => {
+  if (event.data % 2 === 0) {
+    return evenNumberEvent.with(`${event.data} is even`);
+  } else {
+    return oddNumberEvent.with(`${event.data} is odd`);
+  }
+});
+
+// Handle even numbers
+workflow.handle([evenNumberEvent], (event) => {
+  return resultEvent.with(`Even result: ${event.data}`);
+});
+
+// Handle odd numbers
+workflow.handle([oddNumberEvent], (event) => {
+  return resultEvent.with(`Odd result: ${event.data}`);
+});
+```
+
+## Using Middleware
+
+LlamaIndex workflows provide middleware that can enhance your workflows:
+
+### `withStore` Middleware
+
+The `withStore` middleware adds a persistent store to your workflow context:
+
+```ts
+import { createWorkflow, workflowEvent, withStore } from "llamaindex";
+
+const startEvent = workflowEvent<void>();
+const incrementEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<number>();
+
+// Create a workflow with store middleware
+const workflow = withStore(
+  () => ({
+    count: 0,
+    history: [] as number[],
+  }), 
+  createWorkflow()
+);
+
+// Increment the counter
+workflow.handle([startEvent], () => {
+  const store = workflow.getStore();
+  store.count += 1;
+  store.history.push(store.count);
+  return incrementEvent.with(store.count);
+});
+
+// Return the current count
+workflow.handle([incrementEvent], (event) => {
+  const store = workflow.getStore();
+  return resultEvent.with(store.count);
+});
+```
+
+### `withValidation` Middleware
+
+The `withValidation` middleware adds compile-time and runtime validation to your workflows:
+
+```ts
+import { createWorkflow, workflowEvent, withValidation } from "llamaindex";
+
+const startEvent = workflowEvent<string, "start">();
+const processEvent = workflowEvent<number, "process">();
+const resultEvent = workflowEvent<string, "result">();
+const disallowedEvent = workflowEvent<void, "disallowed">();
+
+// Create a workflow with validation middleware
+// Define allowed event paths
+const workflow = withValidation(
+  createWorkflow(), 
+  [
+    [[startEvent], [processEvent]], // startEvent can only lead to processEvent
+    [[processEvent], [resultEvent]], // processEvent can only lead to resultEvent
+  ]
+);
+
+// This will pass validation
+workflow.strictHandle([startEvent], (sendEvent, start) => {
+  sendEvent(processEvent.with(123)); // ✅ This is allowed
+});
+
+// This would fail at compile time and runtime
+workflow.strictHandle([startEvent], (sendEvent, start) => {
+  // sendEvent(disallowedEvent.with()); // ❌ This would cause an error
+  // sendEvent(resultEvent.with("result")); // ❌ This would also cause an error
+});
+```
+
+## Error Handling
+
+LlamaIndex workflows provide built-in mechanisms for handling errors:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const startEvent = workflowEvent<string>();
+const processEvent = workflowEvent<number>();
+const errorEvent = workflowEvent<Error>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (start) => {
+  try {
+    const num = Number.parseInt(start.data, 10);
+    if (isNaN(num)) {
+      throw new Error("Invalid number");
+    }
+    return processEvent.with(num);
+  } catch (err) {
+    return errorEvent.with(err instanceof Error ? err : new Error(String(err)));
+  }
+});
+
+workflow.handle([processEvent], (event) => {
+  return resultEvent.with(`Result: ${event.data * 2}`);
+});
+
+workflow.handle([errorEvent], (event) => {
+  return resultEvent.with(`Error: ${event.data.message}`);
+});
+```
+
+You can also use the signal in `getContext()` to handle errors:
+
+```ts
+workflow.handle([processEvent], () => {
+  const { signal } = getContext();
+
+  signal.onabort = () => {
+    console.error("Process aborted:", signal.reason);
+    // Clean up resources
+  };
+  
+  // Your processing logic here
+});
+```
+
+## Connecting with Server Endpoints
+
+Workflow can be used as middleware in server frameworks like Express, Hono, or Fastify:
+
+```ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { createWorkflow, workflowEvent, createHonoHandler } from "llamaindex";
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const responseEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([queryEvent], (event) => {
+  const response = `Processed: ${event.data}`;
+  return responseEvent.with(response);
+});
+
+// Create Hono app
+const app = new Hono();
+
+// Set up workflow endpoint
+app.post(
+  "/workflow",
+  createHonoHandler(
+    workflow,
+    async (ctx) => queryEvent.with(await ctx.req.text()),
+    responseEvent
+  )
+);
+
+// Start server
+serve(app, ({ port }) => {
+  console.log(`Server started at http://localhost:${port}`);
+});
+```
+
+## Next Steps
+
+Now that you've learned about basic workflow patterns, explore more advanced topics:
+- [Streaming with Workflows](./streaming.mdx)
+- [Advanced Event Handling](./advanced-events.mdx) 

apps/next/src/content/docs/llamaindex/tutorials/workflow/different-inputs-outputs.mdx

@@ -1,8 +1,18 @@
 ---
-title: Inputs / Outputs
-description: Learn how to use different inputs and outputs in your workflows.
+title: Inputs / Outputs (Outdated)
+description: This page has been replaced with newer documentation
 ---
 
+# ⚠️ Outdated Documentation
+
+This documentation is for an older version of the workflow API. Please refer to the new llama-flow documentation:
+
+- [Getting Started with llama-flow](./index.mdx)
+- [Basic Workflow Patterns](./basic-workflow.mdx)
+- [Advanced Event Handling](./advanced-events.mdx)
+
+The new API provides a more lightweight and flexible approach to building workflows.
+
 Inputs and outputs are the way to communicate between steps in a workflow. In the previous example,
 we used `StartEvent` and `StopEvent` to communicate between steps. However, you can use any type of event to communicate between steps.
 
@@ -164,8 +174,6 @@ This step means that it requires either `AEvent` or `BEvent`. It will return a `
 
 You can still combine the logic with `context.requireEvent` to get the data from the event.
 
-import { Accordion, Accordions } from 'fumadocs-ui/components/accordion';
-
 <Accordions>
 	<Accordion title="Under the hood">
 		We use JavaScript Inheritance and the prototype chain to implement the `or` logic.

apps/next/src/content/docs/llamaindex/tutorials/workflow/index.mdx

@@ -1,196 +1,111 @@
 ---
-title: Basic Usage
-description: Learn how to use the LlamaIndex workflow.
+title: Getting Started with Workflows
+description: Learn how to use LlamaIndex's lightweight workflow engine for TypeScript
 ---
 
-A `Workflow` in LlamaIndex.TS is an event-driven abstraction used to chain together several events.
-Workflows are made up of steps, with each step responsible for handling certain event types and emitting new events.
+Workflows are a simple and lightweight engine for TypeScript. Built with ❤️ by LlamaIndex.
 
-Workflows are designed for any cases that benefit from event-driven programming, not only for LLM and AI tasks.
+- Minimal core API (\<\=2kb)
+- 100% Type safe
+- Event-driven, stream oriented programming
+- Support for multiple JS runtimes/frameworks
 
-```package-install
-npm i @llamaindex/workflow
+## Installation
+
+It's directly included with the `llamaindex` package:
+
+```shell
+npm i llamaindex
 ```
 
-## Start from scratch
-
-Let's start from a Hello World workflow.
-
-```ts twoslash
-import { Workflow } from '@llamaindex/workflow';
-
-type ContextData = {
-	counter: number;
-}
-// ---cut---
-const contextData: ContextData = { counter: 0 };
-
-const workflow = new Workflow<ContextData, string, string>();
-//     ^?
+But can also be installed separately:
 
+```shell
+npm i @llama-flow/core
 
+# or with yarn
+yarn add @llama-flow/core
 
+# or with pnpm
+pnpm add @llama-flow/core
 ```
 
-First, we define a workflow with 3 generic types: `ContextData`, `Input`, and `Output`.
+## Key Concepts
 
-In general, `ContextData` is used to store the shared data between steps, `Input` is the type of the input event, and `Output` is the type of the output event.
+- **Events**: Data carriers that flow through the workflow
+- **Handlers**: Functions that process events and emit new events
+- **Workflow**: Connects events and handlers together
+- **Context**: Runtime environment for a workflow execution
 
-In you code logic, you should **share state between steps via `ContextData`**.
+## Basic Usage
 
-```ts twoslash
-import { Workflow, StartEvent, StopEvent } from '@llamaindex/workflow';
+Let's build a simple workflow that processes a text input:
 
-type ContextData = {
-	counter: number;
-}
+### 1. Define events
 
-const contextData: ContextData = { counter: 0 };
+First, we need to define the events that will flow through our workflow:
 
-const workflow = new Workflow<ContextData, string, string>();
-// ---cut---
-workflow.addStep({
-	inputs: [StartEvent<string>],
-	outputs: [StopEvent<string>]
-}, async (context, startEvent) => {
-	const input = startEvent.data;
-	context.data.counter++;
-	return new StopEvent(`Hello, ${input}!`);
+```ts
+import { workflowEvent } from "llamaindex";
+
+// Define input and output events
+const startEvent = workflowEvent<string>(); // Takes a string input
+const convertEvent = workflowEvent<Number>();       // Intermediate event
+const stopEvent = workflowEvent<1 | -1>();  // Final output event, returns 1 or -1
+```
+
+### 2. Create a workflow and connect events
+
+Next, we'll create our workflow and define how events are processed:
+
+```ts
+import { createWorkflow } from "llamaindex";
+
+const workflow = createWorkflow();
+
+// Handle the start event: convert the string to a number
+workflow.handle([startEvent], (start) => {
+  return convertEvent.with(Number.parseInt(start.data, 10));
+});
+
+// Handle the convert event: determine if number is positive or negative
+workflow.handle([convertEvent], (convert) => {
+  return stopEvent.with(convert.data > 0 ? 1 : -1);
 });
 ```
 
-In the workflow, we add a step that listens to `StartEvent<string>` and emits `StopEvent<string>`.
+### 3. Run the workflow
 
-The step is an async function that takes two arguments: `context` and `event`.
+Finally, we can execute our workflow:
 
-### `context` type
+```ts
+// Create a workflow context and send the initial event
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with("42"));
 
-<AutoTypeTable path="./src/deps/type.ts" name="HandlerContext" />
+// Process the stream to get the result
+import { pipeline } from "node:stream/promises";
 
-There are two more properties in `HandlerContext`:
-
-- `sendEvent`: invoke another event in the workflow, other than `StartEvent`, `StopEvent`, or the current event. (Or there will have circular reference)
-- `requireEvent`: wait for a specific event to be emitted.
-
-You can use `sendEvent` and `requireEvent` to build complex workflows.
-
-```ts twoslash
-import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
-
-type ContextData = {
-	counter: number;
-}
-
-const contextData: ContextData = { counter: 0 };
-
-const workflow = new Workflow<ContextData, string, string>();
-
-// ---cut---
-class AnalysisStartEvent extends WorkflowEvent<string> {}
-class AnalysisStopEvent extends WorkflowEvent<boolean> {}
-workflow.addStep({
-	inputs: [AnalysisStartEvent],
-	outputs: [AnalysisStopEvent]
-}, async (...args) => {
-	// do some analysis
-	return new AnalysisStopEvent(true);
-})
-workflow.addStep({
-	inputs: [StartEvent<string>],
-	outputs: [StopEvent<string>]
-}, async (context, startEvent) => {
-	const input = startEvent.data;
-	context.sendEvent(new AnalysisStartEvent('start'));
-	context.data.counter++;
-	const { data } = await context.requireEvent(AnalysisStopEvent);
-	return new StopEvent(`Hello, ${input}! Analysis result: ${data ? 'success' : 'fail'}`);
-});
-```
-
-For example, you can compile `requireEvent` with `waitUntil` in [Vercel Functions](https://vercel.com/docs/functions/functions-api-reference#waituntil) or [Cloudflare Worker](https://developers.cloudflare.com/workers/runtime-apis/context/#waituntil)
-
-```ts twoslash
-import { waitUntil } from '@vercel/functions';
-import { Workflow, StartEvent, StopEvent, WorkflowEvent } from '@llamaindex/workflow';
-
-type ContextData = {
-	counter: number;
-}
-
-const contextData: ContextData = { counter: 0 };
-
-const workflow = new Workflow<ContextData, string, string>();
-
-class AnalysisStartEvent extends WorkflowEvent<string> {}
-class AnalysisStopEvent extends WorkflowEvent<boolean> {}
-
-// ---cut---
-workflow.addStep({
-	inputs: [StartEvent<string>],
-	outputs: [StopEvent<string>]
-}, async (context, startEvent) => {
-	const input = startEvent.data;
-	context.sendEvent(new AnalysisStartEvent('start'));
-	context.data.counter++;
-	waitUntil(context.requireEvent(AnalysisStopEvent));
-	// note that `waitUntil` is not a promise, it will extend the lifetime of the workflow
-	// you can wait for some background tasks to finish
-	return new StopEvent(`Hello, ${input}!`);
-});
-```
-
-## Multiple runs
-
-You can run the same workflow multiple times with different inputs.
-
-```ts twoslash
-import { Workflow, StartEvent, StopEvent } from '@llamaindex/workflow';
-
-type ContextData = {
-	counter: number;
-}
-
-const contextData: ContextData = { counter: 0 };
-
-const workflow = new Workflow<ContextData, string, string>();
-
-workflow.addStep({
-	inputs: [StartEvent<string>],
-	outputs: [StopEvent<string>]
-}, async (context, startEvent) => {
-	const input = startEvent.data;
-	context.data.counter++;
-	return new StopEvent(`Hello, ${input}!`);
+const result = await pipeline(stream, async function (source) {
+  for await (const event of source) {
+    if (stopEvent.include(event)) {
+      return `Result: ${event.data === 1 ? 'positive' : 'negative'}`;
+    }
+  }
 });
 
-// ---cut---
-{
-	const ret = await workflow.run('Alex', contextData);
-	console.log(ret.data); // Hello, Alex!
-}
-
-{
-	const ret = await workflow.run('World', contextData);
-	console.log(ret.data); // Hello, World!
-}
+console.log(result); // "Result: positive"
 ```
 
-Context is shared between runs, so the counter will be increased.
+Or using the stream utilities:
 
-Ideally, it should be serializable to make sure it can be recovered from HTTP requests or other storage.
+```ts
+import { collect, until } from "llamaindex";
 
-### Full example
+// Collect all events until we get a stopEvent
+const allEvents = await collect(until(stream, stopEvent));
+const finalEvent = allEvents[allEvents.length - 1];
+console.log(`Result: ${finalEvent.data === 1 ? 'positive' : 'negative'}`);
+```
 
-<iframe
-	className="w-full h-[440px]"
-	aria-label="Workflow example"
-	src="https://stackblitz.com/github/run-llama/LlamaIndexTS/tree/main/examples?file=node/workflow/basic.ts"
-/>
-
-## `Workflow` type
-
-<AutoTypeTable path="./src/deps/type.ts" name="Workflow" />
-
-## `WorkflowContext` type
-
-<AutoTypeTable path="./src/deps/type.ts" name="WorkflowContext" />
+Ready to learn more? Check out our [detailed examples](./basic-workflow.mdx) to see llama-flow in action!

apps/next/src/content/docs/llamaindex/tutorials/workflow/llamaindex-integration.mdx

@@ -0,0 +1,288 @@
+---
+title: Integrating with LlamaIndex
+description: Build AI applications by combining Workflows with other LlamaIndex features
+---
+
+This guide demonstrates how to combine the power of the workflow engine with LlamaIndex's retrieval and reasoning capabilities to build sophisticated AI applications.
+
+## Basic RAG Workflow
+
+Let's build a simple Retrieval-Augmented Generation (RAG) workflow:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+import { Document, serviceContextFromDefaults, VectorStoreIndex } from "llamaindex";
+import { OpenAI, OpenAIEmbedding } from "@llamaindex/openai";
+import { Settings } from "@llamaindex/core/global"
+
+// Define events
+const queryEvent = workflowEvent<string>();
+const retrieveEvent = workflowEvent<{ query: string; documents: Document[] }>();
+const generateEvent = workflowEvent<{ query: string; context: string }>();
+const responseEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+// Set default global llm
+Settings.llm = new OpenAI({ 
+  model: "gpt-4.1-mini", 
+  temperature: 0.2 
+});
+
+// Set the default global embedModel
+Settings.embedModel = new OpenAIEmbedding({
+  model: "text-embedding-3-small",
+});
+
+// Sample documents
+const documents = [
+  new Document({
+    text: "LlamaIndex is a data framework for LLM applications to ingest, structure, and access private or domain-specific data.",
+  }),
+  new Document({
+    text: "LlamaIndex workflows are a lightweight workflow engine for TypeScript, designed to create event-driven processes.",
+  }),
+];
+
+// Create vector store index
+const index = await VectorStoreIndex.fromDocuments(documents);
+
+// Handle query: Retrieve relevant documents
+workflow.handle([queryEvent], (event) => {
+  const query = event.data;
+  console.log(`Processing query: ${query}`);
+  
+  // Retrieve relevant documents
+  const retriever = index.asRetriever();
+  const nodes = retriever.retrieve(query);
+  
+  return retrieveEvent.with({
+    query,
+    documents: nodes.map(node => node.node),
+  });
+});
+
+// Handle retrieval results: Generate response
+workflow.handle([retrieveEvent], async (event) => {
+  const { query, documents } = event.data;
+  
+  // Combine document content as context
+  const context = documents.map(doc => doc.text).join('\n\n');
+  
+  return generateEvent.with({ query, context });
+});
+
+// Handle generation: Produce final response
+workflow.handle([generateEvent], async (event) => {
+  const { query, context } = event.data;
+  
+  // Create a prompt with the context and query
+  const prompt = `
+Context information:
+${context}
+
+Based on the context information and no other knowledge, answer the following query:
+${query}
+  `;
+  
+  // Generate response with LLM
+  const response = await Settings.llm.complete({ prompt });
+  
+  return responseEvent.with(response.text);
+});
+
+// Execute the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(queryEvent.with("What is LlamaIndex?"));
+
+// Process the stream
+for await (const event of stream) {
+  if (responseEvent.include(event)) {
+    console.log("Final response:", event.data);
+    break;
+  }
+}
+```
+
+## Building a Chat Application
+
+Let's create a more complex chat application that maintains conversation history:
+
+```ts
+import { createWorkflow, workflowEvent, withStore } from "llamaindex";
+import { OpenAI, OpenAIEmbedding } from "@llamaindex/openai";
+import { Document, serviceContextFromDefaults, VectorStoreIndex } from "llamaindex";
+import { Settings } from "@llamaindex/core/global"
+
+// Set default global llm
+Settings.llm = new OpenAI({ 
+  model: "gpt-4.1-mini", 
+  temperature: 0.2 
+});
+
+// Set the default global embedModel
+Settings.embedModel = new OpenAIEmbedding({
+  model: "text-embedding-3-small",
+});
+
+// Define store type
+type ChatStore = {
+  history: Array<{ role: string; content: string }>;
+  documents: Document[];
+  index: VectorStoreIndex | null;
+};
+
+// Define events
+const initEvent = workflowEvent<Document[]>();
+const indexCreatedEvent = workflowEvent<VectorStoreIndex>();
+const userMessageEvent = workflowEvent<string>();
+const retrievalEvent = workflowEvent<{ query: string; nodes: any[] }>();
+const responseEvent = workflowEvent<{ message: { content: string } }>();
+
+// Create workflow with store
+const workflow = withStore<ChatStore>(
+  () => ({
+    history: [],
+    documents: [],
+    index: null,
+  }),
+  createWorkflow()
+);
+
+// Initialize the chat context
+workflow.handle([initEvent], async (event) => {
+  const store = workflow.getStore();
+  store.documents = event.data;
+  
+  // Create index from documents
+  const index = await VectorStoreIndex.fromDocuments(store.documents);
+  
+  store.index = index;
+  return indexCreatedEvent.with(index);
+});
+
+// Process user message
+workflow.handle([userMessageEvent], (event) => {
+  const userMessage = event.data;
+  const store = workflow.getStore();
+  
+  // Add user message to history
+  store.history.push({
+    role: "user",
+    content: userMessage,
+  });
+  
+  if (!store.index) {
+    throw new Error("Index not initialized yet");
+  }
+  
+  // Retrieve relevant context
+  const retriever = store.index.asRetriever();
+  const nodes = retriever.retrieve(userMessage);
+  
+  return retrievalEvent.with({
+    query: userMessage,
+    nodes,
+  });
+});
+
+// Generate response from retrieval results
+workflow.handle([retrievalEvent], async (event) => {
+  const { query, nodes } = event.data;
+  const store = workflow.getStore();
+  
+  // Context from retrieved nodes
+  const context = nodes.map(node => node.node.text).join('\n\n');
+  
+  // Create the system message with context
+  const systemMessage = {
+    role: "system",
+    content: `You are a helpful assistant. Use the following information to answer the user's question:
+    
+${context}
+    
+Only use the information provided above to answer. If you don't know, say so.`,
+  };
+  
+  // Create full conversation history for the chat
+  const messages = [
+    systemMessage,
+    ...store.history,
+  ];
+  
+  // Generate response
+  const response = await Settings.llm.chat({
+    messages,
+  });
+  
+  // Add assistant response to history
+  store.history.push({
+    role: "assistant",
+    content: response.message.content,
+  });
+  
+  return responseEvent.with(response);
+});
+
+// Example usage
+async function runChat() {
+  // Sample documents
+  const documents = [
+    new Document({
+      text: "LlamaIndex is a data framework for LLM applications to ingest, structure, and access private or domain-specific data.",
+    }),
+    new Document({
+      text: "LlamaIndex Workflows are a lightweight workflow engine for TypeScript, designed to create event-driven processes.",
+    }),
+  ];
+  
+  // Initialize the chat
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(initEvent.with(documents));
+  
+  // Wait for index creation
+  for await (const event of stream) {
+    if (indexCreatedEvent.include(event)) {
+      console.log("Index created successfully");
+      break;
+    }
+  }
+  
+  // Start conversation
+  async function sendUserMessage(message: string) {
+    sendEvent(userMessageEvent.with(message));
+    
+    for await (const event of stream) {
+      if (responseEvent.include(event)) {
+        console.log("Assistant:", event.data.message.content);
+        return event.data.message.content;
+      }
+    }
+  }
+  
+  await sendUserMessage("What is LlamaIndex?");
+  await sendUserMessage("Can you tell me about LlamaIndex workflows?");
+  await sendUserMessage("How might these two technologies work together?");
+}
+
+runChat();
+```
+
+## Building an Tool Calling Agent
+
+[TODO]
+
+## Conclusion
+
+By combining the lightweight, event-driven workflow engine with LlamaIndex's powerful document indexing and querying capabilities, you can build sophisticated AI applications with clean, maintainable code.
+
+The event-driven architecture allows you to:
+
+1. Break complex processes into manageable steps
+2. Create reusable components for common AI workflows
+3. Easily debug and monitor each phase of execution
+4. Scale your applications by isolating resource-intensive steps
+5. Build more resilient systems with better error handling
+
+As you build your own applications, consider how the patterns shown here can be adapted to your specific use cases. 

apps/next/src/content/docs/llamaindex/tutorials/workflow/meta.json

@@ -1,6 +1,12 @@
 {
-  "title": "Workflow",
-  "description": "See how to use @llamaindex/workflow",
+  "title": "Workflows",
+  "description": "Event-driven workflow engine for TypeScript",
   "defaultOpen": false,
-  "pages": ["index", "different-inputs-outputs", "streaming"]
+  "pages": [
+    "index",
+    "basic-workflow",
+    "streaming",
+    "advanced-events",
+    "llamaindex-integration"
+  ]
 }

apps/next/src/content/docs/llamaindex/tutorials/workflow/streaming.mdx

@@ -1,199 +1,371 @@
 ---
-title: Streaming
-description: Learn how to use the LlamaIndex workflow with streaming.
+title: Streaming with Workflows
+description: Learn how to build streaming workflows
 ---
-import { WorkflowStreamingDemo } from '../../../../../components/demo/workflow-streaming-ui';
 
-`Workflow` API by default is designed for streaming data. In this guide, we will show you how to use the `Workflow` API with streaming data.
+LlamaIndex workflows are designed from the ground up to work with streaming data. The streaming capabilities make it perfect for:
 
-Each `workflow.run` call returns `WorkflowContext`, which implements `AsyncIterable` interface. You can use it to stream data.
+- Building real-time applications
+- Handling large datasets incrementally
+- Creating responsive UIs that update as data becomes available
+- Implementing long-running tasks with partial results
 
-```ts twoslash
-import { Workflow, WorkflowEvent, StartEvent, StopEvent } from '@llamaindex/workflow';
-class ComputeEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
+## Basic Streaming
+
+Every workflow context provides a stream of events:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+// Define events
+const startEvent = workflowEvent<string>();
+const intermediateEvent = workflowEvent<string>();
+const resultEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (event) => {
+  const { sendEvent } = getContext();
+  
+  // Emit multiple intermediate events
+  for (let i = 0; i < 5; i++) {
+    sendEvent(intermediateEvent.with(`Progress: ${i * 20}%`));
+  }
+  
+  return resultEvent.with("Completed");
+});
+
+// Run the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with("Start processing"));
+
+// Process events as they arrive
+for await (const event of stream) {
+  if (intermediateEvent.include(event)) {
+    console.log(event.data); // Show progress updates
+  } else if (resultEvent.include(event)) {
+    console.log("Final result:", event.data);
+    break; // Exit the loop when done
+  }
 }
-class ComputeResultEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
+```
+
+## Using the Stream Utilities
+
+Workflows provide utility functions to make working with streams easier:
+
+```ts
+import { createWorkflow, workflowEvent, until, collect } from "llamaindex";
+
+const startEvent = workflowEvent<void>();
+const progressEvent = workflowEvent<number>();
+const resultEvent = workflowEvent<string>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], () => {
+  const { sendEvent } = getContext();
+  
+  // Emit progress events
+  for (let i = 0; i < 100; i += 10) {
+    sendEvent(progressEvent.with(i));
+  }
+  
+  return resultEvent.with("Complete");
+});
+
+// Run the workflow and collect events until a condition is met
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with());
+
+// Collect all events until resultEvent is encountered
+const events = await collect(until(stream, (event) => resultEvent.include(event)));
+
+// Filter only progress events
+const progressEvents = events.filter(event => progressEvent.include(event));
+console.log(`Received ${progressEvents.length} progress updates`);
+```
+
+## Conditional Stream Processing
+
+You can conditionally process events and even stop the stream early:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+const startEvent = workflowEvent<number>();
+const dataEvent = workflowEvent<number>();
+const thresholdEvent = workflowEvent<void>();
+const resultEvent = workflowEvent<number[]>();
+
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], (event) => {
+  const { sendEvent } = getContext();
+  const max = event.data;
+  
+  for (let i = 0; i < max; i++) {
+    sendEvent(dataEvent.with(i));
+    if (i >= 10) {
+      // Signal that we've hit a threshold
+      sendEvent(thresholdEvent.with());
+    }
+  }
+  
+  return resultEvent.with(Array.from({ length: max }, (_, i) => i));
+});
+
+// Run the workflow
+const { stream, sendEvent } = workflow.createContext();
+sendEvent(startEvent.with(100)); // Generate 100 numbers
+
+const results = [];
+let hitThreshold = false;
+
+// Process the stream
+for await (const event of stream) {
+  if (dataEvent.include(event)) {
+    results.push(event.data);
+  } else if (thresholdEvent.include(event)) {
+    hitThreshold = true;
+    break; // Stop processing early
+  }
 }
 
-type ContextData = {
-	sum: number;
-}
+console.log(`Collected ${results.length} items before ${hitThreshold ? 'hitting threshold' : 'completion'}`);
+```
 
-const workflow = new Workflow<ContextData, number, number>();
-workflow.addStep({
-	inputs: [StartEvent<number>],
-	outputs: [StopEvent<number>]
-}, async (context, startEvent) => {
-	const total = startEvent.data;
-	for (let i = 0; i < total; i++) {
-		context.sendEvent(new ComputeEvent(i));
-	}
-	const computeResults = await Promise.all(Array.from({ length: total }).map(() => context.requireEvent(ComputeResultEvent)));
-	// Workflow API allows you to start events in parallel and wait for all of them to finish
-	context.data.sum = computeResults.reduce((acc, curr) => acc + curr.data, 0);
-	return new StopEvent(context.data.sum);
+## Integration with UI Frameworks
+
+Workflow streams can be easily integrated with UI frameworks like React to create responsive interfaces:
+
+```tsx
+// In a React component
+import { useEffect, useState } from 'react';
+import { createWorkflow, workflowEvent } from "llamaindex";
+
+function StreamingComponent() {
+  const [updates, setUpdates] = useState([]);
+  const [isComplete, setIsComplete] = useState(false);
+  
+  useEffect(() => {
+    // Set up workflow
+    const startEvent = workflowEvent<void>();
+    const updateEvent = workflowEvent<string>();
+    const completeEvent = workflowEvent<void>();
+    
+    const workflow = createWorkflow();
+    
+    workflow.handle([startEvent], () => {
+      const { sendEvent } = getContext();
+      
+      // Simulate async updates
+      const intervals = [
+        setTimeout(() => sendEvent(updateEvent.with("First update")), 500),
+        setTimeout(() => sendEvent(updateEvent.with("Second update")), 1000),
+        setTimeout(() => sendEvent(updateEvent.with("Final update")), 1500),
+        setTimeout(() => sendEvent(completeEvent.with()), 2000)
+      ];
+      
+      // Cleanup function
+      getContext().signal.onabort = () => {
+        intervals.forEach(clearTimeout);
+      };
+    });
+    
+    // Run the workflow
+    const { stream, sendEvent } = workflow.createContext();
+    sendEvent(startEvent.with());
+    
+    // Process events
+    const processEvents = async () => {
+      for await (const event of stream) {
+        if (updateEvent.include(event)) {
+          setUpdates(prev => [...prev, event.data]);
+        } else if (completeEvent.include(event)) {
+          setIsComplete(true);
+          break;
+        }
+      }
+    };
+    
+    processEvents();
+    
+    // Cleanup
+    return () => {
+      // The workflow will be aborted when the component unmounts
+    };
+  }, []);
+  
+  return (
+    <div>
+      <h2>Streaming Updates</h2>
+      <ul>
+        {updates.map((update, i) => (
+          <li key={i}>{update}</li>
+        ))}
+      </ul>
+      {isComplete && <div>Process complete!</div>}
+    </div>
+  );
+}
+```
+
+## Server-Sent Events (SSE)
+
+Workflows are also suitable for implementing Server-Sent Events:
+
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
+import express from 'express';
+
+// Define events
+const startEvent = workflowEvent<void>();
+const dataEvent = workflowEvent<string>();
+
+// Create workflow
+const workflow = createWorkflow();
+
+workflow.handle([startEvent], () => {
+  const { sendEvent } = getContext();
+  
+  // Send periodic updates
+  const intervals = [
+    setInterval(() => {
+      sendEvent(dataEvent.with(`Update: ${new Date().toISOString()}`));
+    }, 1000)
+  ];
+  
+  // Cleanup
+  getContext().signal.onabort = () => {
+    intervals.forEach(clearInterval);
+  };
+});
+
+// Set up Express server
+const app = express();
+
+app.get('/events', (req, res) => {
+  // Set headers for SSE
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  
+  // Run workflow
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(startEvent.with());
+  
+  // Handle client disconnect
+  req.on('close', () => {
+    // This will trigger the abort signal in the workflow
+  });
+  
+  // Process and send events
+  (async () => {
+    for await (const event of stream) {
+      if (dataEvent.include(event)) {
+        res.write(`data: ${JSON.stringify(event.data)}\n\n`);
+      }
+    }
+  })();
+});
+
+app.listen(3000, () => {
+  console.log('SSE server running on port 3000');
 });
 ```
 
-We define a parallel computation workflow that computes the sum of numbers from 0 to `total`.
+## Advanced Techniques
 
-The workflow sends `ComputeEvent` events for each number and waits for `ComputeResultEvent` events. After receiving all `ComputeResultEvent` events, the workflow returns the sum as a `StopEvent`.
+### Flow Control
 
-What if we want cutoff if the sum exceeds a certain value?
+You can implement flow control with backpressure in your streaming workflows:
 
-## Streaming
+```ts
+import { createWorkflow, workflowEvent } from "llamaindex";
 
-```ts twoslash
-import { Workflow, WorkflowEvent, StartEvent, StopEvent } from '@llamaindex/workflow';
-import { StopCircle } from 'lucide-react';
-class ComputeEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
-class ComputeResultEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
+// This example shows how to process items with controlled concurrency
+const processItems = async (items, maxConcurrency = 3) => {
+  const startEvent = workflowEvent<string[]>();
+  const processItemEvent = workflowEvent<string>();
+  const itemProcessedEvent = workflowEvent<string>();
+  const resultEvent = workflowEvent<string[]>();
+  
+  const workflow = createWorkflow();
+  
+  // Handler to process individual items
+  workflow.handle([processItemEvent], async (event) => {
+    // Simulate processing time
+    await new Promise(resolve => setTimeout(resolve, 100));
+    return itemProcessedEvent.with(`Processed: ${event.data}`);
+  });
+  
+  // Main workflow handler
+  workflow.handle([startEvent], async (event) => {
+    const { sendEvent, stream } = getContext();
+    const results = [];
+    
+    // Process with controlled concurrency
+    const items = event.data;
+    let inProgress = 0;
+    let itemIndex = 0;
+    
+    // Start initial batch of items
+    while (inProgress < maxConcurrency && itemIndex < items.length) {
+      sendEvent(processItemEvent.with(items[itemIndex++]));
+      inProgress++;
+    }
+    
+    // Process items and collect results
+    for await (const event of stream) {
+      if (itemProcessedEvent.include(event)) {
+        results.push(event.data);
+        inProgress--;
+        
+        // Add next item if available
+        if (itemIndex < items.length) {
+          sendEvent(processItemEvent.with(items[itemIndex++]));
+          inProgress++;
+        } else if (inProgress === 0) {
+          // All done
+          break;
+        }
+      }
+    }
+    
+    return resultEvent.with(results);
+  });
+  
+  // Run the workflow
+  const { stream, sendEvent } = workflow.createContext();
+  sendEvent(startEvent.with(items));
+  
+  // Wait for final result
+  for await (const event of stream) {
+    if (resultEvent.include(event)) {
+      return event.data;
+    }
+  }
+  
+  return [];
+};
 
-
-type ContextData = {
-	sum: number;
-}
-
-const workflow = new Workflow<ContextData, number, number>();
-// ---cut---
-const context = workflow.run(1000, {
-	sum: 0
-});
-
-for await (const event of context) {
-	if (event instanceof ComputeEvent) {
-		if (context.data.sum > 100) {
-			throw new Error('Sum exceeds 100');
-		}
-	}
-	if (event instanceof StopEvent) {
-		console.log('result', event.data);
-	}
-}
-```
-
-You can define more custom logic using `AsyncIterable` interface.
-
-For example. I just want to stop the workflow if I get a `ComputeResultEvent`
-
-
-```ts twoslash
-import { Workflow, WorkflowEvent, StartEvent, StopEvent } from '@llamaindex/workflow';
-import { StopCircle } from 'lucide-react';
-class ComputeEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
-class ComputeResultEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
-
-
-type ContextData = {
-	sum: number;
-}
-
-const workflow = new Workflow<ContextData, number, number>();
-// ---cut---
-async function compute() {
-	const context = workflow.run(1000, {
-		sum: 0
-	});
-	for await (const event of context) {
-		if (event instanceof ComputeResultEvent) {
-			return event.data;
-		}
-	}
-	throw new Error('UNREACHABLE');
-}
-
-const result = await compute();
-```
-
-### Streaming with UI
-
-You can use the `Workflow` API with UI libraries like React.
-
-```tsx twoslash
-// @filename: utils.ts
-export async function runWithoutBlocking(fn: () => Promise<void>) {
-	fn();
-}
-// @filename: action.ts
-// ---cut---
-'use server';
-// "use server" is required to enable server side feature in React
-import { createStreamableUI } from 'ai/rsc';
-import { runWithoutBlocking } from './utils';
-// ---cut-start---
-import { Workflow, WorkflowEvent, StartEvent, StopEvent } from '@llamaindex/workflow';
-class ComputeEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
-class ComputeResultEvent extends WorkflowEvent<number> {
-	constructor(data: number) {
-		super(data);
-	}
-}
-
-
-type ContextData = {
-	sum: number;
-}
-
-const workflow = new Workflow<ContextData, number, number>();
-const min = 100;
-const max = 1000;
-workflow.addStep(
-	{
-		inputs: [ComputeEvent],
-		outputs: [ComputeResultEvent]
-	},
-	async (context, event) => {
-		await new Promise((resolve) =>
-			setTimeout(resolve, Math.floor(Math.random() * (max - min + 1) + min))
-		);
-		return new ComputeResultEvent(event.data);
-	}
+// Usage
+const results = await processItems(
+  Array.from({ length: 20 }, (_, i) => `Item ${i}`)
 );
-// ---cut-end---
-export async function compute() {
-	'use server';
-	const ui = createStreamableUI();
-	const context = workflow.run(100, {
-		sum: 0
-	});
-	runWithoutBlocking(async () => {
-		for await (const event of context) {
-			if (event instanceof ComputeResultEvent) {
-				// Update UI
-			} else if (event instanceof StopEvent) {
-				// Update UI
-			}
-			// ...
-		}
-	});
-	return ui.value;
-}
+console.log(results);
 ```
 
-<WorkflowStreamingDemo />
+This pattern allows you to:
+1. Process large datasets without overwhelming system resources
+2. Control the level of concurrency
+3. Process data as it becomes available
+4. Create efficient data pipelines
+
+## Next Steps
+
+Now that you've learned about streaming with workflows, explore more advanced topics:
+- [Advanced Event Handling](./advanced-events.mdx)
+- [Integration Workflows with other LlamaIndex features](./llamaindex-integration.mdx)

e2e/examples/cloudflare-worker-agent/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/cloudflare-worker-agent-test
 
+## 0.0.155
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.0.154
 
 ### Patch Changes

e2e/examples/cloudflare-worker-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/cloudflare-worker-agent-test",
-  "version": "0.0.154",
+  "version": "0.0.155",
   "type": "module",
   "private": true,
   "scripts": {

e2e/examples/nextjs-agent/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/next-agent-test
 
+## 0.1.155
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.1.154
 
 ### Patch Changes

e2e/examples/nextjs-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/next-agent-test",
-  "version": "0.1.154",
+  "version": "0.1.155",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/nextjs-edge-runtime/CHANGELOG.md

@@ -1,5 +1,11 @@
 # test-edge-runtime
 
+## 0.1.154
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.1.153
 
 ### Patch Changes

e2e/examples/nextjs-edge-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/nextjs-edge-runtime-test",
-  "version": "0.1.153",
+  "version": "0.1.154",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/nextjs-node-runtime/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/next-node-runtime
 
+## 0.1.21
+
+### Patch Changes
+
+- llamaindex@0.10.1
+- @llamaindex/huggingface@0.1.5
+
 ## 0.1.20
 
 ### Patch Changes

e2e/examples/nextjs-node-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/next-node-runtime-test",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "private": true,
   "scripts": {
     "dev": "next dev",

e2e/examples/vite-import-llamaindex/CHANGELOG.md

@@ -1,5 +1,11 @@
 # vite-import-llamaindex
 
+## 0.0.21
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.0.20
 
 ### Patch Changes

e2e/examples/vite-import-llamaindex/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-import-llamaindex",
   "private": true,
-  "version": "0.0.20",
+  "version": "0.0.21",
   "type": "module",
   "scripts": {
     "build": "vite build",

e2e/examples/waku-query-engine/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/waku-query-engine-test
 
+## 0.0.155
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.0.154
 
 ### Patch Changes

e2e/examples/waku-query-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/waku-query-engine-test",
-  "version": "0.0.154",
+  "version": "0.0.155",
   "type": "module",
   "private": true,
   "scripts": {
@@ -14,13 +14,14 @@
     "react": "19.0.0",
     "react-dom": "19.0.0",
     "react-server-dom-webpack": "19.0.0",
-    "waku": "0.21.20"
+    "waku": "0.22.2"
   },
   "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.4",
     "@types/react": "19.0.10",
     "@types/react-dom": "19.0.4",
-    "autoprefixer": "^10.4.20",
-    "tailwindcss": "^4.0.9",
+    "rollup": "4.38.0",
+    "tailwindcss": "^4.1.4",
     "typescript": "5.7.3"
   }
 }

e2e/node/embedding/clip.e2e.ts

@@ -21,19 +21,21 @@ test.beforeEach(() => {
   callback.mock.resetCalls();
 });
 
-await test("clip embedding", async (t) => {
+await test.skip("clip embedding", async (t) => {
   const major = parseInt(process.versions.node.split(".")[0] ?? "0", 10);
   if (major < 20) {
     t.skip("Skip CLIP tests on Node.js < 20");
     return;
   }
+  const imageUrl = new URL(
+    "../../fixtures/img/llamaindex-white.png",
+    import.meta.url,
+  );
+
   await t.test("should trigger load transformer event", async () => {
     const nodes = [
       new ImageNode({
-        image: new URL(
-          "../../fixtures/img/llamaindex-white.png",
-          import.meta.url,
-        ),
+        image: imageUrl,
       }),
     ];
     assert.equal(callback.mock.callCount(), 0);
@@ -46,21 +48,14 @@ await test("clip embedding", async (t) => {
 
   await t.test("init & get image embedding", async () => {
     const clipEmbedding = new ClipEmbedding();
-    const imgUrl = new URL(
-      "../../fixtures/img/llamaindex-white.png",
-      import.meta.url,
-    );
-    const vec = await clipEmbedding.getImageEmbedding(imgUrl);
+    const vec = await clipEmbedding.getImageEmbedding(imageUrl);
     assert.ok(vec);
   });
 
   await t.test("load image document", async () => {
     const nodes = [
       new ImageNode({
-        image: new URL(
-          "../../fixtures/img/llamaindex-white.png",
-          import.meta.url,
-        ),
+        image: imageUrl,
       }),
     ];
     const clipEmbedding = new ClipEmbedding();
@@ -80,12 +75,8 @@ await test("clip embedding", async (t) => {
       }),
     );
     const clipEmbedding = new ClipEmbedding();
-    const imgUrl = new URL(
-      "../../fixtures/img/llamaindex-white.png",
-      import.meta.url,
-    );
     assert.equal(getter.mock.callCount(), 0);
-    const vec = await clipEmbedding.getImageEmbedding(imgUrl);
+    const vec = await clipEmbedding.getImageEmbedding(imageUrl);
     assert.ok(vec);
     assert.ok(getter.mock.callCount() > 0);
   });

e2e/package.json

@@ -10,7 +10,7 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^9.2.0",
-    "@huggingface/transformers": "^3.0.2",
+    "@huggingface/transformers": "^3.5.0",
     "@llamaindex/anthropic": "workspace:*",
     "@llamaindex/clip": "workspace:*",
     "@llamaindex/core": "workspace:*",

examples/CHANGELOG.md

@@ -1,5 +1,23 @@
 # examples
 
+## 0.3.8
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+  - llamaindex@0.10.1
+  - @llamaindex/clip@0.0.51
+  - @llamaindex/deepinfra@0.0.51
+  - @llamaindex/deepseek@0.0.11
+  - @llamaindex/fireworks@0.0.11
+  - @llamaindex/groq@0.0.66
+  - @llamaindex/huggingface@0.1.5
+  - @llamaindex/jinaai@0.0.11
+  - @llamaindex/perplexity@0.0.8
+  - @llamaindex/together@0.0.11
+  - @llamaindex/vllm@0.0.37
+
 ## 0.3.7
 
 ### Patch Changes

examples/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llamaindex/examples",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "private": true,
   "scripts": {
     "lint": "eslint .",
@@ -15,16 +15,16 @@
     "@llamaindex/astra": "^0.0.16",
     "@llamaindex/azure": "^0.1.11",
     "@llamaindex/chroma": "^0.0.16",
-    "@llamaindex/clip": "^0.0.50",
+    "@llamaindex/clip": "^0.0.51",
     "@llamaindex/cloud": "^4.0.3",
     "@llamaindex/cohere": "^0.0.16",
     "@llamaindex/core": "^0.6.2",
-    "@llamaindex/deepinfra": "^0.0.50",
+    "@llamaindex/deepinfra": "^0.0.51",
     "@llamaindex/env": "^0.1.29",
     "@llamaindex/firestore": "^1.0.9",
     "@llamaindex/google": "^0.2.3",
-    "@llamaindex/groq": "^0.0.65",
-    "@llamaindex/huggingface": "^0.1.4",
+    "@llamaindex/groq": "^0.0.66",
+    "@llamaindex/huggingface": "^0.1.5",
     "@llamaindex/milvus": "^0.1.11",
     "@llamaindex/mistral": "^0.1.2",
     "@llamaindex/mixedbread": "^0.0.16",
@@ -32,7 +32,7 @@
     "@llamaindex/elastic-search": "^0.1.2",
     "@llamaindex/node-parser": "^2.0.2",
     "@llamaindex/ollama": "^0.1.2",
-    "@llamaindex/openai": "^0.3.2",
+    "@llamaindex/openai": "^0.3.3",
     "@llamaindex/pinecone": "^0.1.2",
     "@llamaindex/portkey-ai": "^0.0.44",
     "@llamaindex/postgres": "^0.0.45",
@@ -41,15 +41,15 @@
     "@llamaindex/replicate": "^0.0.44",
     "@llamaindex/upstash": "^0.0.16",
     "@llamaindex/vercel": "^0.1.2",
-    "@llamaindex/vllm": "^0.0.36",
+    "@llamaindex/vllm": "^0.0.37",
     "@llamaindex/voyage-ai": "^1.0.8",
     "@llamaindex/weaviate": "^0.0.16",
     "@llamaindex/workflow": "^1.0.3",
-    "@llamaindex/deepseek": "^0.0.10",
-    "@llamaindex/fireworks": "^0.0.10",
-    "@llamaindex/together": "^0.0.10",
-    "@llamaindex/jinaai": "^0.0.10",
-    "@llamaindex/perplexity": "^0.0.7",
+    "@llamaindex/deepseek": "^0.0.11",
+    "@llamaindex/fireworks": "^0.0.11",
+    "@llamaindex/together": "^0.0.11",
+    "@llamaindex/jinaai": "^0.0.11",
+    "@llamaindex/perplexity": "^0.0.8",
     "@llamaindex/supabase": "^0.1.1",
     "@llamaindex/tools": "^0.0.5",
     "@notionhq/client": "^2.2.15",
@@ -60,7 +60,7 @@
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
     "js-tiktoken": "^1.0.14",
-    "llamaindex": "^0.10.0",
+    "llamaindex": "^0.10.1",
     "mongodb": "6.7.0",
     "postgres": "^3.4.4",
     "wikipedia": "^2.1.2",

packages/autotool/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/autotool
 
+## 7.0.1
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 7.0.0
 
 ### Patch Changes

packages/autotool/examples/01_node/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/autotool-01-node-example
 
+## 0.0.102
+
+### Patch Changes
+
+- llamaindex@0.10.1
+- @llamaindex/autotool@7.0.1
+
 ## 0.0.101
 
 ### Patch Changes

packages/autotool/examples/01_node/package.json

@@ -13,5 +13,5 @@
   "scripts": {
     "start": "node --import tsx --import @llamaindex/autotool/node ./src/index.ts"
   },
-  "version": "0.0.101"
+  "version": "0.0.102"
 }

packages/autotool/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/run-llama/LlamaIndexTS.git",
     "directory": "packages/autotool"
   },
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "auto transpile your JS function to LLM Agent compatible",
   "files": [
     "dist",

packages/env/package.json

@@ -116,7 +116,7 @@
     "test": "vitest"
   },
   "devDependencies": {
-    "@huggingface/transformers": "^3.0.2",
+    "@huggingface/transformers": "^3.5.0",
     "@types/node": "^22.9.0",
     "@types/readable-stream": "^4.0.15",
     "vitest": "^2.1.5"
@@ -127,7 +127,7 @@
     "js-tiktoken": "^1.0.12"
   },
   "peerDependencies": {
-    "@huggingface/transformers": "^3.0.2",
+    "@huggingface/transformers": "^3.5.0",
     "gpt-tokenizer": "^2.5.0"
   },
   "peerDependenciesMeta": {

packages/experimental/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/experimental
 
+## 0.0.171
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.0.170
 
 ### Patch Changes

packages/experimental/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/experimental",
   "description": "Experimental package for LlamaIndexTS",
-  "version": "0.0.170",
+  "version": "0.0.171",
   "type": "module",
   "types": "dist/type/index.d.ts",
   "main": "dist/cjs/index.js",

packages/llamaindex/CHANGELOG.md

@@ -1,5 +1,12 @@
 # llamaindex
 
+## 0.10.1
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.10.0
 
 ### Minor Changes

packages/llamaindex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llamaindex",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "license": "MIT",
   "type": "module",
   "keywords": [

packages/providers/clip/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/clip
 
+## 0.0.51
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.50
 
 ### Patch Changes

packages/providers/clip/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/clip",
   "description": "Clip Embedding Adapter for LlamaIndex",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "type": "module",
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
@@ -39,7 +39,7 @@
     "dev": "bunchee --watch"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.0.2",
+    "@huggingface/transformers": "^3.5.0",
     "@llamaindex/core": "workspace:*",
     "@llamaindex/env": "workspace:*",
     "@llamaindex/openai": "workspace:*"

packages/providers/deepinfra/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/deepinfra
 
+## 0.0.51
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.50
 
 ### Patch Changes

packages/providers/deepinfra/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/deepinfra",
   "description": "Deepinfra Adapter for LlamaIndex",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/deepseek/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/deepseek
 
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.10
 
 ### Patch Changes

packages/providers/deepseek/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/deepseek",
   "description": "DeepSeek Adapter for LlamaIndex",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/fireworks/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/fireworks
 
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.10
 
 ### Patch Changes

packages/providers/fireworks/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/fireworks",
   "description": "Fireworks Adapter for LlamaIndex",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/groq/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/groq
 
+## 0.0.66
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.65
 
 ### Patch Changes

packages/providers/groq/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/groq",
   "description": "Groq Adapter for LlamaIndex",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/huggingface/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/huggingface
 
+## 0.1.5
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.1.4
 
 ### Patch Changes

packages/providers/huggingface/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/huggingface",
   "description": "Huggingface Adapter for LlamaIndex",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
@@ -40,7 +40,7 @@
   },
   "dependencies": {
     "@huggingface/inference": "^2.8.1",
-    "@huggingface/transformers": "^3.0.2",
+    "@huggingface/transformers": "^3.5.0",
     "@llamaindex/core": "workspace:*",
     "@llamaindex/env": "workspace:*",
     "@llamaindex/openai": "workspace:*"

packages/providers/huggingface/src/embedding.ts

@@ -1,4 +1,7 @@
-import type { pipeline } from "@huggingface/transformers";
+import type {
+  FeatureExtractionPipeline,
+  pipeline,
+} from "@huggingface/transformers";
 import { BaseEmbedding } from "@llamaindex/core/embeddings";
 import { Settings } from "@llamaindex/core/global";
 import {
@@ -35,9 +38,7 @@ export class HuggingFaceEmbedding extends BaseEmbedding {
   modelType: string = HuggingFaceEmbeddingModelType.XENOVA_ALL_MINILM_L6_V2;
   modelOptions: Parameters<typeof pipeline<"feature-extraction">>[2] = {};
 
-  private extractor: Awaited<
-    ReturnType<typeof pipeline<"feature-extraction">>
-  > | null = null;
+  private extractor: FeatureExtractionPipeline | null = null;
 
   constructor(params: HuggingFaceEmbeddingParams = {}) {
     super();
@@ -60,11 +61,11 @@ export class HuggingFaceEmbedding extends BaseEmbedding {
           true,
         );
       });
-      this.extractor = await pipeline(
+      this.extractor = (await pipeline(
         "feature-extraction",
         this.modelType,
         this.modelOptions,
-      );
+      )) as never;
     }
     return this.extractor;
   }

packages/providers/jinaai/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/jinaai
 
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.10
 
 ### Patch Changes

packages/providers/jinaai/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/jinaai",
   "description": "JinaAI Adapter for LlamaIndex",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/openai/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/openai
 
+## 0.3.3
+
+### Patch Changes
+
+- 96dd798: Add o3 and o4-mini models
+
 ## 0.3.2
 
 ### Patch Changes

packages/providers/openai/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/openai",
   "description": "OpenAI Adapter for LlamaIndex",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/openai/src/utils.ts

@@ -59,6 +59,9 @@ export const GPT4_MODELS = {
   "gpt-4.1": { contextWindow: 10 ** 6 },
   "gpt-4.1-mini": { contextWindow: 10 ** 6 },
   "gpt-4.1-nano": { contextWindow: 10 ** 6 },
+  "gpt-4.1-2025-04-14": { contextWindow: 10 ** 6 },
+  "gpt-4.1-mini-2025-04-14": { contextWindow: 10 ** 6 },
+  "gpt-4.1-nano-2025-04-14": { contextWindow: 10 ** 6 },
 };
 
 // NOTE we don't currently support gpt-3.5-turbo-instruct and don't plan to in the near future
@@ -100,6 +103,21 @@ export const O3_MODELS = {
   "o3-mini-2025-01-31": {
     contextWindow: 200000,
   },
+  o3: {
+    contextWindow: 200000,
+  },
+  "o3-2025-04-16": {
+    contextWindow: 200000,
+  },
+};
+
+export const O4_MODELS = {
+  "o4-mini": {
+    contextWindow: 200000,
+  },
+  "o4-mini-2025-04-16": {
+    contextWindow: 200000,
+  },
 };
 
 /**
@@ -110,6 +128,7 @@ export const ALL_AVAILABLE_OPENAI_MODELS = {
   ...GPT35_MODELS,
   ...O1_MODELS,
   ...O3_MODELS,
+  ...O4_MODELS,
 } satisfies Record<ChatModel, { contextWindow: number }>;
 
 export function isFunctionCallingModel(llm: LLM): llm is OpenAI {
@@ -130,11 +149,12 @@ export function isFunctionCallingModel(llm: LLM): llm is OpenAI {
 export function isReasoningModel(model: ChatModel | string): boolean {
   const isO1 = model.startsWith("o1");
   const isO3 = model.startsWith("o3");
-  return isO1 || isO3;
+  const isO4 = model.startsWith("o4");
+  return isO1 || isO3 || isO4;
 }
 
 export function isTemperatureSupported(model: ChatModel | string): boolean {
-  return !model.startsWith("o3");
+  return !model.startsWith("o3") && !model.startsWith("o4");
 }
 
 export type OpenAIAdditionalMetadata = object;

packages/providers/perplexity/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/perplexity
 
+## 0.0.8
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.7
 
 ### Patch Changes

packages/providers/perplexity/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/perplexity",
   "description": "Perplexity Adapter for LlamaIndex",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/together/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/together
 
+## 0.0.11
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.10
 
 ### Patch Changes

packages/providers/together/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/together",
   "description": "Together Adapter for LlamaIndex",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/providers/vllm/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @llamaindex/vllm
 
+## 0.0.37
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+
 ## 0.0.36
 
 ### Patch Changes

packages/providers/vllm/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/vllm",
   "description": "vLLM Adapter for LlamaIndex",
-  "version": "0.0.36",
+  "version": "0.0.37",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",

packages/server/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @llamaindex/server
 
+## 0.1.4
+
+### Patch Changes
+
+- llamaindex@0.10.1
+
 ## 0.1.3
 
 ### Patch Changes

packages/server/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/server",
   "description": "LlamaIndex Server",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -45,6 +45,7 @@
     "@types/node": "^22.9.0",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "llamaindex": "workspace:*",
     "eslint": "^9",
     "eslint-config-next": "15.2.3",
     "postcss": "^8.5.3",
@@ -94,7 +95,6 @@
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
     "input-otp": "^1.4.2",
-    "llamaindex": "workspace:*",
     "lucide-react": "^0.460.0",
     "next": "^15.3.0",
     "next-themes": "^0.4.3",
@@ -108,5 +108,8 @@
     "tailwind-merge": "^2.6.0",
     "vaul": "^1.1.2",
     "zod": "^3.24.2"
+  },
+  "peerDependencies": {
+    "llamaindex": "workspace:*"
   }
 }

unit/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @llamaindex/unit-test
 
+## 0.1.21
+
+### Patch Changes
+
+- Updated dependencies [96dd798]
+  - @llamaindex/openai@0.3.3
+  - llamaindex@0.10.1
+
 ## 0.1.20
 
 ### Patch Changes

unit/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@llamaindex/unit-test",
   "private": true,
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "scripts": {
     "test": "vitest run"