@anvia/core 0.1.0

package/dist/loaders/index.js

@@ -0,0 +1,287 @@
+// src/loaders/index.ts
+import { readdir, readFile } from "fs/promises";
+import { isAbsolute, join } from "path";
+import { glob } from "tinyglobby";
+var FileLoader = class _FileLoader {
+  constructor(source, mode, skipErrors) {
+    this.source = source;
+    this.mode = mode;
+    this.skipErrors = skipErrors;
+  }
+  source;
+  mode;
+  skipErrors;
+  static withGlob(pattern) {
+    return new _FileLoader(
+      async function* () {
+        for (const path of await sortedGlob(pattern)) {
+          yield ok({ path });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  static withDir(directory) {
+    return new _FileLoader(
+      async function* () {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const files = entries.filter((entry) => entry.isFile()).map((entry) => join(directory, entry.name)).sort((left, right) => left.localeCompare(right));
+        for (const path of files) {
+          yield ok({ path });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  static fromBytes(bytes) {
+    return _FileLoader.fromBytesMany([bytes]);
+  }
+  static fromBytesMany(bytes) {
+    return new _FileLoader(
+      async function* () {
+        for (const value of bytes) {
+          yield ok({ path: "<memory>", bytes: toUint8Array(value) });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  read() {
+    return new _FileLoader(this.source, "read", this.skipErrors);
+  }
+  readWithPath() {
+    return new _FileLoader(this.source, "readWithPath", this.skipErrors);
+  }
+  ignoreErrors() {
+    return new _FileLoader(this.source, this.mode, true);
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const item of this.source()) {
+      const result = await mapFileResult(item, this.mode);
+      if (!result.ok && this.skipErrors) {
+        continue;
+      }
+      yield this.skipErrors && result.ok ? result.value : result;
+    }
+  }
+};
+var PdfFileLoader = class _PdfFileLoader {
+  constructor(source, mode, skipErrors) {
+    this.source = source;
+    this.mode = mode;
+    this.skipErrors = skipErrors;
+  }
+  source;
+  mode;
+  skipErrors;
+  static withGlob(pattern) {
+    return new _PdfFileLoader(
+      async function* () {
+        for (const path of await sortedGlob(pattern)) {
+          yield ok({ path });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  static withDir(directory) {
+    return new _PdfFileLoader(
+      async function* () {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const files = entries.filter((entry) => entry.isFile()).map((entry) => join(directory, entry.name)).sort((left, right) => left.localeCompare(right));
+        for (const path of files) {
+          yield ok({ path });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  static fromBytes(bytes) {
+    return _PdfFileLoader.fromBytesMany([bytes]);
+  }
+  static fromBytesMany(bytes) {
+    return new _PdfFileLoader(
+      async function* () {
+        for (const value of bytes) {
+          yield ok({ path: "<memory>", bytes: toUint8Array(value) });
+        }
+      },
+      "source",
+      false
+    );
+  }
+  read() {
+    return new _PdfFileLoader(this.source, "read", this.skipErrors);
+  }
+  readWithPath() {
+    return new _PdfFileLoader(this.source, "readWithPath", this.skipErrors);
+  }
+  byPage() {
+    const mode = this.mode === "readWithPath" ? "byPageWithPath" : "byPage";
+    return new _PdfFileLoader(this.source, mode, this.skipErrors);
+  }
+  ignoreErrors() {
+    return new _PdfFileLoader(this.source, this.mode, true);
+  }
+  async *[Symbol.asyncIterator]() {
+    for await (const item of this.source()) {
+      const results = await mapPdfResult(item, this.mode);
+      for (const result of results) {
+        if (!result.ok && this.skipErrors) {
+          continue;
+        }
+        yield this.skipErrors && result.ok ? result.value : result;
+      }
+    }
+  }
+};
+function fileToDocument(file) {
+  return {
+    id: file.path,
+    text: file.text,
+    additionalProps: {
+      source: file.path,
+      mediaType: "text/plain"
+    }
+  };
+}
+async function fileLoaderToDocuments(loader) {
+  const documents = [];
+  for await (const file of loader) {
+    documents.push(fileToDocument(file));
+  }
+  return documents;
+}
+function pdfToDocument(pdf) {
+  return {
+    id: pdf.path,
+    text: pdf.text,
+    additionalProps: {
+      source: pdf.path,
+      mediaType: "application/pdf"
+    }
+  };
+}
+async function pdfLoaderToDocuments(loader) {
+  const documents = [];
+  for await (const pdf of loader) {
+    documents.push(pdfToDocument(pdf));
+  }
+  return documents;
+}
+function pdfPageToDocument(page) {
+  return {
+    id: `${page.path}#page=${page.pageNumber}`,
+    text: page.text,
+    additionalProps: {
+      source: page.path,
+      mediaType: "application/pdf",
+      pageNumber: String(page.pageNumber)
+    }
+  };
+}
+async function pdfPageLoaderToDocuments(loader) {
+  const documents = [];
+  for await (const page of loader) {
+    documents.push(pdfPageToDocument(page));
+  }
+  return documents;
+}
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+async function sortedGlob(pattern) {
+  return (await glob(pattern, { absolute: isAbsolute(pattern), onlyFiles: true })).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function mapFileResult(item, mode) {
+  if (!item.ok) {
+    return item;
+  }
+  if (mode === "source") {
+    return item;
+  }
+  try {
+    const text = await readFileSource(item.value);
+    return mode === "read" ? ok(text) : ok({ path: item.value.path, text });
+  } catch (error) {
+    return err(error);
+  }
+}
+async function mapPdfResult(item, mode) {
+  if (!item.ok) {
+    return [item];
+  }
+  if (mode === "source") {
+    return [item];
+  }
+  try {
+    const pages = await readPdfPages(item.value);
+    if (mode === "read") {
+      return [ok(pages.map((page) => page.text).join(""))];
+    }
+    if (mode === "readWithPath") {
+      return [ok({ path: item.value.path, text: pages.map((page) => page.text).join("") })];
+    }
+    if (mode === "byPageWithPath") {
+      return pages.map((page) => ok({ path: item.value.path, ...page }));
+    }
+    return pages.map(ok);
+  } catch (error) {
+    return [err(error)];
+  }
+}
+async function readFileSource(source) {
+  if ("bytes" in source) {
+    return new TextDecoder().decode(source.bytes);
+  }
+  return readFile(source.path, "utf8");
+}
+async function readPdfPages(source) {
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const bytes = "bytes" in source ? source.bytes : toUint8Array(await readFile(source.path));
+  const document = await pdfjs.getDocument({ data: bytes }).promise;
+  const pages = [];
+  try {
+    for (let index = 1; index <= document.numPages; index += 1) {
+      const page = await document.getPage(index);
+      const content = await page.getTextContent();
+      const text = content.items.flatMap(
+        (item) => typeof item === "object" && item !== null && "str" in item ? [String(item.str)] : []
+      ).join("\n");
+      pages.push({ pageNumber: index - 1, text: text.length > 0 ? `${text}
+` : "" });
+    }
+  } finally {
+    await document.destroy();
+  }
+  return pages;
+}
+function toUint8Array(bytes) {
+  if (bytes instanceof Uint8Array) {
+    return new Uint8Array(
+      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+    );
+  }
+  return new Uint8Array(bytes);
+}
+export {
+  FileLoader,
+  PdfFileLoader,
+  fileLoaderToDocuments,
+  fileToDocument,
+  pdfLoaderToDocuments,
+  pdfPageLoaderToDocuments,
+  pdfPageToDocument,
+  pdfToDocument
+};
+//# sourceMappingURL=index.js.map

package/dist/loaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/loaders/index.ts"],"sourcesContent":["import { readdir, readFile } from \"node:fs/promises\";\nimport { isAbsolute, join } from \"node:path\";\nimport { glob } from \"tinyglobby\";\nimport type { Document } from \"../completion\";\n\nexport type LoaderResult<T> = { ok: true; value: T } | { ok: false; error: unknown };\n\nexport type FileSource = { path: string } | { path: \"<memory>\"; bytes: Uint8Array };\nexport type FileReadWithPath = { path: string; text: string };\n\nexport type PdfSource = { path: string } | { path: \"<memory>\"; bytes: Uint8Array };\nexport type PdfReadWithPath = { path: string; text: string };\nexport type PdfPage = { pageNumber: number; text: string };\nexport type PdfPageWithPath = { path: string; pageNumber: number; text: string };\n\ntype FileMode = \"source\" | \"read\" | \"readWithPath\";\ntype PdfMode = \"source\" | \"read\" | \"readWithPath\" | \"byPage\" | \"byPageWithPath\";\n\nexport class FileLoader<T = LoaderResult<FileSource>> implements AsyncIterable<T> {\n  private constructor(\n    private readonly source: () => AsyncIterable<LoaderResult<FileSource>>,\n    private readonly mode: FileMode,\n    private readonly skipErrors: boolean,\n  ) {}\n\n  static withGlob(pattern: string): FileLoader<LoaderResult<FileSource>> {\n    return new FileLoader(\n      async function* () {\n        for (const path of await sortedGlob(pattern)) {\n          yield ok({ path });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  static withDir(directory: string): FileLoader<LoaderResult<FileSource>> {\n    return new FileLoader(\n      async function* () {\n        const entries = await readdir(directory, { withFileTypes: true });\n        const files = entries\n          .filter((entry) => entry.isFile())\n          .map((entry) => join(directory, entry.name))\n          .sort((left, right) => left.localeCompare(right));\n        for (const path of files) {\n          yield ok({ path });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  static fromBytes(bytes: Uint8Array | ArrayBuffer): FileLoader<LoaderResult<FileSource>> {\n    return FileLoader.fromBytesMany([bytes]);\n  }\n\n  static fromBytesMany(\n    bytes: Array<Uint8Array | ArrayBuffer>,\n  ): FileLoader<LoaderResult<FileSource>> {\n    return new FileLoader(\n      async function* () {\n        for (const value of bytes) {\n          yield ok({ path: \"<memory>\", bytes: toUint8Array(value) });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  read(): FileLoader<LoaderResult<string>> {\n    return new FileLoader(this.source, \"read\", this.skipErrors);\n  }\n\n  readWithPath(): FileLoader<LoaderResult<FileReadWithPath>> {\n    return new FileLoader(this.source, \"readWithPath\", this.skipErrors);\n  }\n\n  ignoreErrors(): FileLoader<UnwrapLoaderResult<T>> {\n    return new FileLoader(this.source, this.mode, true) as FileLoader<UnwrapLoaderResult<T>>;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<T> {\n    for await (const item of this.source()) {\n      const result = await mapFileResult(item, this.mode);\n      if (!result.ok && this.skipErrors) {\n        continue;\n      }\n      yield (this.skipErrors && result.ok ? result.value : result) as T;\n    }\n  }\n}\n\nexport class PdfFileLoader<T = LoaderResult<PdfSource>> implements AsyncIterable<T> {\n  private constructor(\n    private readonly source: () => AsyncIterable<LoaderResult<PdfSource>>,\n    private readonly mode: PdfMode,\n    private readonly skipErrors: boolean,\n  ) {}\n\n  static withGlob(pattern: string): PdfFileLoader<LoaderResult<PdfSource>> {\n    return new PdfFileLoader(\n      async function* () {\n        for (const path of await sortedGlob(pattern)) {\n          yield ok({ path });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  static withDir(directory: string): PdfFileLoader<LoaderResult<PdfSource>> {\n    return new PdfFileLoader(\n      async function* () {\n        const entries = await readdir(directory, { withFileTypes: true });\n        const files = entries\n          .filter((entry) => entry.isFile())\n          .map((entry) => join(directory, entry.name))\n          .sort((left, right) => left.localeCompare(right));\n        for (const path of files) {\n          yield ok({ path });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  static fromBytes(bytes: Uint8Array | ArrayBuffer): PdfFileLoader<LoaderResult<PdfSource>> {\n    return PdfFileLoader.fromBytesMany([bytes]);\n  }\n\n  static fromBytesMany(\n    bytes: Array<Uint8Array | ArrayBuffer>,\n  ): PdfFileLoader<LoaderResult<PdfSource>> {\n    return new PdfFileLoader(\n      async function* () {\n        for (const value of bytes) {\n          yield ok({ path: \"<memory>\", bytes: toUint8Array(value) });\n        }\n      },\n      \"source\",\n      false,\n    );\n  }\n\n  read(): PdfFileLoader<LoaderResult<string>> {\n    return new PdfFileLoader(this.source, \"read\", this.skipErrors);\n  }\n\n  readWithPath(): PdfFileLoader<LoaderResult<PdfReadWithPath>> {\n    return new PdfFileLoader(this.source, \"readWithPath\", this.skipErrors);\n  }\n\n  byPage(\n    this: PdfFileLoader<LoaderResult<PdfReadWithPath>>,\n  ): PdfFileLoader<LoaderResult<PdfPageWithPath>>;\n  byPage(this: PdfFileLoader<PdfReadWithPath>): PdfFileLoader<PdfPageWithPath>;\n  byPage(): PdfFileLoader<LoaderResult<PdfPage>>;\n  byPage(): PdfFileLoader<LoaderResult<PdfPage> | LoaderResult<PdfPageWithPath> | PdfPageWithPath> {\n    const mode = this.mode === \"readWithPath\" ? \"byPageWithPath\" : \"byPage\";\n    return new PdfFileLoader(this.source, mode, this.skipErrors);\n  }\n\n  ignoreErrors(): PdfFileLoader<UnwrapLoaderResult<T>> {\n    return new PdfFileLoader(this.source, this.mode, true) as PdfFileLoader<UnwrapLoaderResult<T>>;\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<T> {\n    for await (const item of this.source()) {\n      const results = await mapPdfResult(item, this.mode);\n      for (const result of results) {\n        if (!result.ok && this.skipErrors) {\n          continue;\n        }\n        yield (this.skipErrors && result.ok ? result.value : result) as T;\n      }\n    }\n  }\n}\n\nexport function fileToDocument(file: FileReadWithPath): Document {\n  return {\n    id: file.path,\n    text: file.text,\n    additionalProps: {\n      source: file.path,\n      mediaType: \"text/plain\",\n    },\n  };\n}\n\nexport async function fileLoaderToDocuments(\n  loader: AsyncIterable<FileReadWithPath>,\n): Promise<Document[]> {\n  const documents: Document[] = [];\n  for await (const file of loader) {\n    documents.push(fileToDocument(file));\n  }\n  return documents;\n}\n\nexport function pdfToDocument(pdf: PdfReadWithPath): Document {\n  return {\n    id: pdf.path,\n    text: pdf.text,\n    additionalProps: {\n      source: pdf.path,\n      mediaType: \"application/pdf\",\n    },\n  };\n}\n\nexport async function pdfLoaderToDocuments(\n  loader: AsyncIterable<PdfReadWithPath>,\n): Promise<Document[]> {\n  const documents: Document[] = [];\n  for await (const pdf of loader) {\n    documents.push(pdfToDocument(pdf));\n  }\n  return documents;\n}\n\nexport function pdfPageToDocument(page: PdfPageWithPath): Document {\n  return {\n    id: `${page.path}#page=${page.pageNumber}`,\n    text: page.text,\n    additionalProps: {\n      source: page.path,\n      mediaType: \"application/pdf\",\n      pageNumber: String(page.pageNumber),\n    },\n  };\n}\n\nexport async function pdfPageLoaderToDocuments(\n  loader: AsyncIterable<PdfPageWithPath>,\n): Promise<Document[]> {\n  const documents: Document[] = [];\n  for await (const page of loader) {\n    documents.push(pdfPageToDocument(page));\n  }\n  return documents;\n}\n\ntype LoaderValue<T> = T extends { ok: true; value: infer Value } ? Value : never;\ntype UnwrapLoaderResult<T> = [LoaderValue<T>] extends [never] ? T : LoaderValue<T>;\n\nfunction ok<T>(value: T): LoaderResult<T> {\n  return { ok: true, value };\n}\n\nfunction err(error: unknown): LoaderResult<never> {\n  return { ok: false, error };\n}\n\nasync function sortedGlob(pattern: string): Promise<string[]> {\n  return (await glob(pattern, { absolute: isAbsolute(pattern), onlyFiles: true })).sort(\n    (left, right) => left.localeCompare(right),\n  );\n}\n\nasync function mapFileResult(\n  item: LoaderResult<FileSource>,\n  mode: FileMode,\n): Promise<LoaderResult<FileSource | string | FileReadWithPath>> {\n  if (!item.ok) {\n    return item;\n  }\n  if (mode === \"source\") {\n    return item;\n  }\n  try {\n    const text = await readFileSource(item.value);\n    return mode === \"read\" ? ok(text) : ok({ path: item.value.path, text });\n  } catch (error) {\n    return err(error);\n  }\n}\n\nasync function mapPdfResult(\n  item: LoaderResult<PdfSource>,\n  mode: PdfMode,\n): Promise<Array<LoaderResult<PdfSource | string | PdfReadWithPath | PdfPage | PdfPageWithPath>>> {\n  if (!item.ok) {\n    return [item];\n  }\n  if (mode === \"source\") {\n    return [item];\n  }\n  try {\n    const pages = await readPdfPages(item.value);\n    if (mode === \"read\") {\n      return [ok(pages.map((page) => page.text).join(\"\"))];\n    }\n    if (mode === \"readWithPath\") {\n      return [ok({ path: item.value.path, text: pages.map((page) => page.text).join(\"\") })];\n    }\n    if (mode === \"byPageWithPath\") {\n      return pages.map((page) => ok({ path: item.value.path, ...page }));\n    }\n    return pages.map(ok);\n  } catch (error) {\n    return [err(error)];\n  }\n}\n\nasync function readFileSource(source: FileSource): Promise<string> {\n  if (\"bytes\" in source) {\n    return new TextDecoder().decode(source.bytes);\n  }\n  return readFile(source.path, \"utf8\");\n}\n\nasync function readPdfPages(source: PdfSource): Promise<PdfPage[]> {\n  const pdfjs = await import(\"pdfjs-dist/legacy/build/pdf.mjs\");\n  const bytes = \"bytes\" in source ? source.bytes : toUint8Array(await readFile(source.path));\n  const document = await pdfjs.getDocument({ data: bytes }).promise;\n  const pages: PdfPage[] = [];\n  try {\n    for (let index = 1; index <= document.numPages; index += 1) {\n      const page = await document.getPage(index);\n      const content = await page.getTextContent();\n      const text = content.items\n        .flatMap((item) =>\n          typeof item === \"object\" && item !== null && \"str\" in item ? [String(item.str)] : [],\n        )\n        .join(\"\\n\");\n      pages.push({ pageNumber: index - 1, text: text.length > 0 ? `${text}\\n` : \"\" });\n    }\n  } finally {\n    await document.destroy();\n  }\n  return pages;\n}\n\nfunction toUint8Array(bytes: Uint8Array | ArrayBuffer): Uint8Array {\n  if (bytes instanceof Uint8Array) {\n    return new Uint8Array(\n      bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength),\n    );\n  }\n  return new Uint8Array(bytes);\n}\n"],"mappings":"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","names":[]}

package/dist/mcp/index.d.ts

@@ -0,0 +1,15 @@
+import { a as McpConnection, c as McpServer, d as McpStdioOptions, b as McpHttpOptions } from '../types-B5B8Sdl4.js';
+export { M as McpClient, e as McpToolCallContent, f as McpToolCallResult, g as McpToolDefinition } from '../types-B5B8Sdl4.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import '../types-BrxLd7ay.js';
+import '../tool-DhuBQ3yb.js';
+
+declare function connectMcp(connection: McpConnection): Promise<McpServer>;
+
+declare const mcp: {
+    stdio(options: McpStdioOptions): McpConnection;
+    http(options: McpHttpOptions): McpConnection;
+};
+
+export { McpConnection, McpHttpOptions, McpServer, McpStdioOptions, connectMcp, mcp };

package/dist/mcp/index.js

@@ -0,0 +1,9 @@
+import {
+  connectMcp,
+  mcp
+} from "../chunk-WZTPK5HV.js";
+export {
+  connectMcp,
+  mcp
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/observability/index.d.ts

@@ -0,0 +1,93 @@
+import { M as Message, d as CompletionRequest, e as CompletionResponse, n as ToolCall, U as Usage } from '../types-BrxLd7ay.js';
+
+type AgentTraceInfo = {
+    traceId?: string | undefined;
+    observationId?: string | undefined;
+};
+type AgentTraceOptions = {
+    name?: string | undefined;
+    userId?: string | undefined;
+    sessionId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tags?: string[] | undefined;
+    version?: string | undefined;
+    traceId?: string | undefined;
+    failOnObserverError?: boolean | undefined;
+};
+type AgentRunStartArgs = {
+    agentName?: string | undefined;
+    agentDescription?: string | undefined;
+    instructions?: string | undefined;
+    trace?: AgentTraceOptions | undefined;
+    prompt: Message;
+    history: Message[];
+    maxTurns: number;
+};
+type AgentRunEndArgs = {
+    output: string;
+    usage: Usage;
+    messages: Message[];
+};
+type AgentRunErrorArgs = {
+    error: unknown;
+    usage: Usage;
+    messages: Message[];
+};
+type AgentGenerationStartArgs = {
+    turn: number;
+    request: CompletionRequest;
+};
+type AgentGenerationEndArgs<RawResponse = unknown> = {
+    turn: number;
+    response: CompletionResponse<RawResponse>;
+    firstDeltaMs?: number | undefined;
+};
+type AgentGenerationErrorArgs = {
+    turn: number;
+    error: unknown;
+};
+type AgentToolStartArgs = {
+    turn: number;
+    toolCall: ToolCall;
+    toolName: string;
+    args: string;
+    internalCallId: string;
+    toolCallId?: string | undefined;
+};
+type AgentToolEndArgs = AgentToolStartArgs & {
+    result: string;
+    skipped: boolean;
+};
+type AgentToolErrorArgs = AgentToolStartArgs & {
+    error: unknown;
+};
+interface AgentGenerationObserver {
+    end(args: AgentGenerationEndArgs): void | Promise<void>;
+    error?(args: AgentGenerationErrorArgs): void | Promise<void>;
+}
+interface AgentToolObserver {
+    end(args: AgentToolEndArgs): void | Promise<void>;
+    error?(args: AgentToolErrorArgs): void | Promise<void>;
+}
+interface AgentRunObserver {
+    readonly trace?: AgentTraceInfo | undefined;
+    startGeneration?(args: AgentGenerationStartArgs): AgentGenerationObserver | undefined | Promise<AgentGenerationObserver | undefined>;
+    startTool?(args: AgentToolStartArgs): AgentToolObserver | undefined | Promise<AgentToolObserver | undefined>;
+    end(args: AgentRunEndArgs): void | Promise<void>;
+    error?(args: AgentRunErrorArgs): void | Promise<void>;
+}
+interface AgentObserver {
+    startRun(args: AgentRunStartArgs): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;
+    flush?(): void | Promise<void>;
+    shutdown?(): void | Promise<void>;
+}
+type AgentObserverRegistration = {
+    observer: AgentObserver;
+    failOnObserverError?: boolean | undefined;
+};
+type ObserveOptions = {
+    failOnObserverError?: boolean | undefined;
+};
+declare function createObserver(observer: AgentObserver): AgentObserver;
+
+export { type AgentGenerationEndArgs, type AgentGenerationErrorArgs, type AgentGenerationObserver, type AgentGenerationStartArgs, type AgentObserver, type AgentObserverRegistration, type AgentRunEndArgs, type AgentRunErrorArgs, type AgentRunObserver, type AgentRunStartArgs, type AgentToolEndArgs, type AgentToolErrorArgs, type AgentToolObserver, type AgentToolStartArgs, type AgentTraceInfo, type AgentTraceOptions, type ObserveOptions, createObserver };

package/dist/observability/index.js

@@ -0,0 +1,7 @@
+import {
+  createObserver
+} from "../chunk-S55WOHX5.js";
+export {
+  createObserver
+};
+//# sourceMappingURL=index.js.map

package/dist/observability/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/pipeline/index.d.ts

@@ -0,0 +1,51 @@
+import { A as Agent } from '../agent-C6h6YrRU.js';
+import { b as CompletionModel } from '../types-BrxLd7ay.js';
+import { Extractor } from '../extractor/index.js';
+import '../observability/index.js';
+import '../zod-schema-DJTEgQBq.js';
+import '../embeddings/index.js';
+import '../vector-store/index.js';
+import '../tool-DhuBQ3yb.js';
+import 'zod';
+
+/** Minimal interface for anything that can run as a pipeline stage. */
+interface PipelineOp<Input = unknown, Output = unknown> {
+    run(input: Input): Output | Promise<Output>;
+}
+interface PipelineBatchOptions {
+    /** Maximum number of inputs processed at the same time. */
+    concurrency: number;
+}
+type AwaitedOutput<Op> = Op extends PipelineOp<unknown, infer Output> ? Awaited<Output> : never;
+type ParallelOutput<Branches extends Record<string, PipelineOp<unknown, unknown>>> = {
+    [Key in keyof Branches]: AwaitedOutput<Branches[Key]>;
+};
+/** Runnable pipeline returned by `PipelineBuilder.build()`. */
+declare class Pipeline<Input, Output> implements PipelineOp<Input, Awaited<Output>> {
+    private readonly executor;
+    constructor(executor: (input: Input) => Output | Promise<Output>);
+    /** Run one input through the built pipeline and return the final stage output. */
+    run(input: Input): Promise<Awaited<Output>>;
+    /** Run many inputs through the same pipeline with bounded concurrency. */
+    batch<I extends Iterable<Input>>(inputs: I, options: PipelineBatchOptions): Promise<Array<Awaited<Output>>>;
+}
+/** Builds a typed pipeline from an original input type to an inferred output type. */
+declare class PipelineBuilder<Input, Output = Input> {
+    private readonly executor;
+    constructor(executor?: (input: Input) => Output | Promise<Output>);
+    /** Add a synchronous or asynchronous transform stage. */
+    step<Next>(fn: (input: Awaited<Output>) => Next | Promise<Next>): PipelineBuilder<Input, Awaited<Next>>;
+    /** Compose another pipeline operation after the current stage. */
+    use<Next>(op: PipelineOp<Awaited<Output>, Next>): PipelineBuilder<Input, Awaited<Next>>;
+    /** Run named branch operations concurrently from the current value. */
+    parallel<Branches extends Record<string, PipelineOp<Awaited<Output>, unknown>>>(branches: Branches): PipelineBuilder<Input, ParallelOutput<Branches>>;
+    /** Send the current value to an agent as text and continue with the agent output. */
+    prompt(agent: Agent<CompletionModel>): PipelineBuilder<Input, string>;
+    /** Send the current value to an extractor as text and continue with typed schema data. */
+    extract<T>(extractor: Extractor<T, CompletionModel>): PipelineBuilder<Input, T>;
+    /** Finish the builder and return a runnable pipeline. */
+    build(): Pipeline<Input, Awaited<Output>>;
+    private runStep;
+}
+
+export { Pipeline, type PipelineBatchOptions, PipelineBuilder, type PipelineOp };

package/dist/pipeline/index.js

@@ -0,0 +1,9 @@
+import {
+  Pipeline,
+  PipelineBuilder
+} from "../chunk-FI2BTRT5.js";
+export {
+  Pipeline,
+  PipelineBuilder
+};
+//# sourceMappingURL=index.js.map

package/dist/pipeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/skills/index.d.ts

@@ -0,0 +1,12 @@
+import { a as SkillLoader, b as SkillSet } from '../types-HvopERm0.js';
+export { S as Skill, c as SkillValidationError, d as SkillValidationIssue } from '../types-HvopERm0.js';
+import '../tool-DhuBQ3yb.js';
+import '../types-BrxLd7ay.js';
+
+declare function loadSkills(loaders: SkillLoader | SkillLoader[]): Promise<SkillSet>;
+
+declare const skill: {
+    local(path: string): SkillLoader;
+};
+
+export { SkillLoader, SkillSet, loadSkills, skill };

package/dist/skills/index.js

@@ -0,0 +1,16 @@
+import {
+  SkillValidationError,
+  loadSkills,
+  skill
+} from "../chunk-KSIY7KJA.js";
+import "../chunk-X6FBOU2P.js";
+import "../chunk-SRGJPXKT.js";
+import "../chunk-GNWMOSNR.js";
+import "../chunk-B4QHQN5K.js";
+import "../chunk-A7VDIZQN.js";
+export {
+  SkillValidationError,
+  loadSkills,
+  skill
+};
+//# sourceMappingURL=index.js.map

package/dist/skills/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/streaming/index.d.ts

@@ -0,0 +1,6 @@
+type ReadableStreamOptions = {
+    format?: "jsonl";
+};
+declare function toReadableStream<T>(events: AsyncIterable<T>, _options?: ReadableStreamOptions): ReadableStream<Uint8Array>;
+
+export { type ReadableStreamOptions, toReadableStream };

package/dist/streaming/index.js

@@ -0,0 +1,7 @@
+import {
+  toReadableStream
+} from "../chunk-XUUY2L2D.js";
+export {
+  toReadableStream
+};
+//# sourceMappingURL=index.js.map

package/dist/streaming/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tool/index.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { Z as ZodSchema } from '../zod-schema-DJTEgQBq.js';
+export { D as DynamicToolIndex, E as EmbedToolsOptions, T as ToolSearchDocument, a as ToolSet, c as createToolIndex, e as embedTools, i as isDynamicToolIndex } from '../zod-schema-DJTEgQBq.js';
+import { b as ToolApprovalPolicy, T as Tool } from '../tool-DhuBQ3yb.js';
+export { A as AnyTool, a as ToolApprovalContext, c as ToolApprovalRunContext, p as parseToolArgs, s as serializeToolOutput } from '../tool-DhuBQ3yb.js';
+import '../types-BrxLd7ay.js';
+import '../embeddings/index.js';
+import '../vector-store/index.js';
+
+type CreateToolOptions<InputSchema extends ZodSchema, OutputSchema extends ZodSchema | undefined = undefined> = {
+    name: string;
+    description: string;
+    input: InputSchema;
+    output?: OutputSchema;
+    approval?: ToolApprovalPolicy<z.output<InputSchema>>;
+    execute(args: z.output<InputSchema>): OutputSchema extends ZodSchema ? z.input<OutputSchema> | Promise<z.input<OutputSchema>> : unknown | Promise<unknown>;
+};
+type ToolOutput<OutputSchema extends ZodSchema | undefined> = OutputSchema extends ZodSchema ? z.output<OutputSchema> : unknown;
+declare function createTool<InputSchema extends ZodSchema, OutputSchema extends ZodSchema | undefined = undefined>(options: CreateToolOptions<InputSchema, OutputSchema>): Tool<z.output<InputSchema>, ToolOutput<OutputSchema>>;
+
+declare class ToolCallError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+declare class ToolNotFoundError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+declare class ToolJsonError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+
+type CreateThinkToolOptions = {
+    name?: string;
+    description?: string;
+};
+declare function createThinkTool(options?: CreateThinkToolOptions): Tool<{
+    thought: string;
+}, string>;
+
+export { type CreateThinkToolOptions, type CreateToolOptions, Tool, ToolApprovalPolicy, ToolCallError, ToolJsonError, ToolNotFoundError, createThinkTool, createTool };

package/dist/tool/index.js

@@ -0,0 +1,33 @@
+import {
+  createThinkTool,
+  createToolIndex,
+  embedTools,
+  isDynamicToolIndex
+} from "../chunk-X6FBOU2P.js";
+import "../chunk-SRGJPXKT.js";
+import {
+  ToolCallError,
+  ToolJsonError,
+  ToolNotFoundError,
+  ToolSet,
+  parseToolArgs,
+  serializeToolOutput
+} from "../chunk-GNWMOSNR.js";
+import {
+  createTool
+} from "../chunk-B4QHQN5K.js";
+import "../chunk-A7VDIZQN.js";
+export {
+  ToolCallError,
+  ToolJsonError,
+  ToolNotFoundError,
+  ToolSet,
+  createThinkTool,
+  createTool,
+  createToolIndex,
+  embedTools,
+  isDynamicToolIndex,
+  parseToolArgs,
+  serializeToolOutput
+};
+//# sourceMappingURL=index.js.map

package/dist/tool/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}