langfn 0.0.1

package/dist/index.js

@@ -0,0 +1,1174 @@
+import {
+  Embeddings,
+  OpenAIEmbeddings,
+  Retriever,
+  VectorStore
+} from "./chunk-LIUWQ4NY.js";
+import {
+  ChatModel,
+  OpenAIChatModel
+} from "./chunk-6NDYO7WC.js";
+import {
+  ReActAgent
+} from "./chunk-MHMMFGVC.js";
+import {
+  ToolAgent
+} from "./chunk-IDYTII3W.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/client.ts
+var LangFn = class {
+  model;
+  config;
+  constructor(config) {
+    this.model = config.model;
+    this.config = config;
+  }
+  async complete(prompt, options = {}) {
+    const cache = this._cache;
+    if (cache) {
+      const cached = await cache.get(prompt, this.model.model, this.model.provider, options.metadata);
+      if (cached) {
+        if (options.structured) {
+          const parsed = options.structured.parse(cached.content);
+          return { ...cached, parsed };
+        }
+        return cached;
+      }
+    }
+    const result = await this.model.complete({ prompt, ...options });
+    if (cache) {
+      await cache.set(prompt, this.model.model, this.model.provider, result, options.metadata);
+    }
+    if (options.structured) {
+      const parsed = options.structured.parse(result.content);
+      return { ...result, parsed };
+    }
+    return result;
+  }
+  async chat(messages, options = {}) {
+    const result = await this.model.chat({
+      messages,
+      tools: options.tools?.map((t) => t.json_schema()),
+      tool_choice: options.tool_choice,
+      ...options
+    });
+    if (options.structured) {
+      const parsed = options.structured.parse(result.message.content);
+      return { ...result, parsed };
+    }
+    return result;
+  }
+  async feedback(traceId, options) {
+    if (this.config.observability?.enabled && this.config.observability?.watchfn) {
+      this.config.observability.watchfn.track("feedback", {
+        traceId,
+        rating: options.rating,
+        comment: options.comment,
+        metadata: options.metadata || {}
+      });
+    }
+  }
+  async *stream(prompt, options = {}) {
+    yield* this.model.stream({ prompt, ...options });
+  }
+  async *streamSSE(prompt) {
+    const { toSSE } = await import("./sse-4Y3LCWWO.js");
+    yield* toSSE(this, prompt);
+  }
+  async completeBatch(prompts, options = {}) {
+    const concurrency = options.concurrency ?? 5;
+    const results = [];
+    for (let i = 0; i < prompts.length; i += concurrency) {
+      const batch = prompts.slice(i, i + concurrency);
+      const batchResults = await Promise.all(batch.map((p) => this.complete(p, options)));
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  async embed(texts) {
+    const { OpenAIEmbeddings: OpenAIEmbeddings2 } = await import("./openai-4W5RU3CU.js");
+    const { OpenAIChatModel: OpenAIChatModel2 } = await import("./openai-LHMGJO6V.js");
+    if (!this._embeddings && this.model instanceof OpenAIChatModel2) {
+      this._embeddings = new OpenAIEmbeddings2({
+        apiKey: this.model.apiKey,
+        baseUrl: this.model.baseUrl
+      });
+    }
+    const embeddings = this._embeddings;
+    if (!embeddings) throw new Error("Embeddings not configured");
+    if (typeof texts === "string") {
+      return embeddings.embedQuery(texts);
+    }
+    return embeddings.embedDocuments(texts);
+  }
+  async createReactAgent(tools, options = {}) {
+    const { ReActAgent: ReActAgent2 } = await import("./react-EKLNOUM4.js");
+    return new ReActAgent2({
+      model: this,
+      tools,
+      ...options
+    });
+  }
+  async createToolAgent(tools, options = {}) {
+    const { ToolAgent: ToolAgent2 } = await import("./tool_agent-OA4BZHA6.js");
+    return new ToolAgent2({
+      lang: this,
+      tools,
+      ...options
+    });
+  }
+  // To be implemented: chains, etc.
+};
+function langfn(config) {
+  return new LangFn(config);
+}
+
+// src/tools/base.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+var Tool = class {
+  name;
+  description;
+  schema;
+  _execute;
+  constructor(config) {
+    this.name = config.name;
+    this.description = config.description;
+    this.schema = config.schema;
+    this._execute = config.execute;
+  }
+  json_schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: zodToJsonSchema(this.schema)
+    };
+  }
+  async run(args2, context) {
+    const parsed = this.schema.parse(args2);
+    return this._execute(parsed, context || { metadata: {} });
+  }
+};
+
+// src/orchestration/chain.ts
+var Chain = class _Chain {
+  constructor(_run) {
+    this._run = _run;
+  }
+  async run(input) {
+    return this._run(input);
+  }
+  static sequential(steps) {
+    return new _Chain(async (input) => {
+      let current = input;
+      for (const step of steps) {
+        current = await step(current);
+      }
+      return current;
+    });
+  }
+  static parallel(steps) {
+    return new _Chain(async (input) => {
+      return Promise.all(steps.map((step) => step(input)));
+    });
+  }
+  static mapReduce(options) {
+    return new _Chain(async (inputs) => {
+      const mapped = await Promise.all(inputs.map(options.map));
+      return options.reduce(mapped);
+    });
+  }
+};
+
+// src/orchestration/index.ts
+var orchestration_exports = {};
+__export(orchestration_exports, {
+  Chain: () => Chain
+});
+
+// src/models/index.ts
+var models_exports = {};
+__export(models_exports, {
+  AnthropicChatModel: () => AnthropicChatModel,
+  ChatModel: () => ChatModel,
+  MockChatModel: () => MockChatModel,
+  OllamaChatModel: () => OllamaChatModel,
+  OpenAIChatModel: () => OpenAIChatModel
+});
+
+// src/models/mock.ts
+var MockChatModel = class extends ChatModel {
+  constructor(responses = []) {
+    super();
+    this.responses = responses;
+  }
+  provider = "mock";
+  model = "mock-1";
+  async complete(request) {
+    const content = this.responses.shift() || request.prompt;
+    return { content, raw: { mock: true } };
+  }
+  async chat(request) {
+    const content = this.responses.shift() || JSON.stringify({ echo: request.messages });
+    return {
+      message: { role: "assistant", content },
+      raw: { mock: true }
+    };
+  }
+  async *stream(request) {
+    const content = this.responses.shift() || request.prompt;
+    yield { type: "content", content, delta: content };
+    yield { type: "end", finish_reason: "stop" };
+  }
+};
+
+// src/models/anthropic.ts
+var AnthropicChatModel = class extends ChatModel {
+  provider = "anthropic";
+  model;
+  apiKey;
+  baseUrl;
+  version;
+  constructor(config) {
+    super();
+    this.apiKey = config.apiKey;
+    this.model = config.model || "claude-3-opus-20240229";
+    this.baseUrl = config.baseUrl || "https://api.anthropic.com/v1";
+    this.version = config.version || "2023-06-01";
+  }
+  async fetch(path, options) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": this.version,
+        "content-type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API Error ${response.status}: ${error}`);
+    }
+    return response;
+  }
+  async complete(request) {
+    const chatResp = await this.chat({
+      messages: [{ role: "user", content: request.prompt }],
+      metadata: request.metadata
+    });
+    return {
+      content: chatResp.message.content,
+      usage: chatResp.usage,
+      raw: chatResp.raw,
+      trace_id: chatResp.trace_id
+    };
+  }
+  async chat(request) {
+    let system;
+    const messages = request.messages.filter((m) => {
+      if (m.role === "system") {
+        system = m.content;
+        return false;
+      }
+      return true;
+    });
+    let tools;
+    if (request.tools && request.tools.length > 0) {
+      tools = request.tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }));
+    }
+    const body = {
+      model: this.model,
+      messages: messages.map((m) => ({
+        role: m.role === "tool" ? "user" : m.role,
+        // Mapping might need adjustment based on specific Anthropic tool use syntax
+        content: m.content
+      })),
+      max_tokens: 4096,
+      system,
+      tools
+    };
+    if (request.tool_choice) {
+      if (typeof request.tool_choice === "string" && request.tool_choice !== "auto") {
+        body.tool_choice = { type: "tool", name: request.tool_choice };
+      } else if (typeof request.tool_choice === "object") {
+        body.tool_choice = request.tool_choice;
+      } else if (request.tool_choice === "auto") {
+        body.tool_choice = { type: "auto" };
+      }
+    }
+    const response = await this.fetch("/messages", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    let content = "";
+    const tool_calls = [];
+    for (const block of data.content) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "tool_use") {
+        tool_calls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input
+        });
+      }
+    }
+    const usage = data.usage ? {
+      prompt_tokens: data.usage.input_tokens,
+      completion_tokens: data.usage.output_tokens,
+      total_tokens: data.usage.input_tokens + data.usage.output_tokens
+    } : void 0;
+    return {
+      message: {
+        role: "assistant",
+        content
+      },
+      tool_calls: tool_calls.length > 0 ? tool_calls : void 0,
+      usage,
+      raw: data
+    };
+  }
+  async *stream(request) {
+    const response = await this.fetch("/messages", {
+      method: "POST",
+      body: JSON.stringify({
+        model: this.model,
+        messages: [{ role: "user", content: request.prompt }],
+        max_tokens: 4096,
+        stream: true
+      })
+    });
+    if (!response.body) throw new Error("No response body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const dataStr = line.slice(6).trim();
+        if (dataStr === "[DONE]") continue;
+        try {
+          const event = JSON.parse(dataStr);
+          if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+            const delta = event.delta.text;
+            yield {
+              type: "content",
+              content: delta,
+              delta
+            };
+          } else if (event.type === "message_stop") {
+            yield { type: "end", finish_reason: "stop" };
+          }
+        } catch (e) {
+        }
+      }
+    }
+    yield { type: "end", finish_reason: "stop" };
+  }
+};
+
+// src/models/ollama.ts
+var OllamaChatModel = class extends ChatModel {
+  provider = "ollama";
+  model;
+  baseUrl;
+  constructor(config = {}) {
+    super();
+    this.model = config.model || "llama3";
+    this.baseUrl = config.baseUrl || "http://localhost:11434";
+  }
+  async fetch(path, options) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API Error ${response.status}: ${error}`);
+    }
+    return response;
+  }
+  async complete(request) {
+    const chatResp = await this.chat({
+      messages: [{ role: "user", content: request.prompt }],
+      metadata: request.metadata
+    });
+    return {
+      content: chatResp.message.content,
+      usage: chatResp.usage,
+      raw: chatResp.raw,
+      trace_id: chatResp.trace_id
+    };
+  }
+  async chat(request) {
+    const response = await this.fetch("/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        model: this.model,
+        messages: request.messages,
+        stream: false
+      })
+    });
+    const data = await response.json();
+    const message = data.message;
+    const usage = data.eval_count ? {
+      prompt_tokens: data.prompt_eval_count || 0,
+      completion_tokens: data.eval_count || 0,
+      total_tokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+    } : void 0;
+    return {
+      message: {
+        role: message.role,
+        content: message.content || ""
+      },
+      usage,
+      raw: data
+    };
+  }
+  async *stream(request) {
+    const response = await this.fetch("/api/chat", {
+      method: "POST",
+      body: JSON.stringify({
+        model: this.model,
+        messages: [{ role: "user", content: request.prompt }],
+        stream: true
+      })
+    });
+    if (!response.body) throw new Error("No response body");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const chunk = JSON.parse(line);
+          if (chunk.done) {
+            yield { type: "end", finish_reason: "stop" };
+            return;
+          }
+          const delta = chunk.message?.content;
+          if (delta) {
+            yield {
+              type: "content",
+              content: delta,
+              delta
+            };
+          }
+        } catch (e) {
+        }
+      }
+    }
+    yield { type: "end", finish_reason: "stop" };
+  }
+};
+
+// src/tools/index.ts
+var tools_exports = {};
+__export(tools_exports, {
+  ApiCallTool: () => ApiCallTool,
+  CalculatorTool: () => CalculatorTool,
+  Tool: () => Tool
+});
+
+// src/tools/calculator.ts
+import { z } from "zod";
+var CalculatorSchema = z.object({
+  expression: z.string().describe("The mathematical expression to evaluate (e.g., '2 + 2 * 5')")
+});
+var CalculatorTool = new Tool({
+  name: "calculator",
+  description: "Perform basic mathematical calculations.",
+  schema: CalculatorSchema,
+  execute: async (args) => {
+    try {
+      const safeExpression = args.expression.replace(/[^0-9+\-*/(). ]/g, "");
+      return String(eval(safeExpression));
+    } catch (e) {
+      return `Error: ${e.message}`;
+    }
+  }
+});
+
+// src/tools/api_call.ts
+import { z as z2 } from "zod";
+var ApiCallSchema = z2.object({
+  url: z2.string().describe("The URL to call"),
+  method: z2.string().default("GET").describe("The HTTP method (GET, POST, etc.)"),
+  headers: z2.record(z2.string()).optional().describe("HTTP headers"),
+  body: z2.any().optional().describe("Request body")
+});
+var ApiCallTool = new Tool({
+  name: "api_call",
+  description: "Make an HTTP API call to a remote service.",
+  schema: ApiCallSchema,
+  execute: async (args2) => {
+    const response = await fetch(args2.url, {
+      method: args2.method,
+      headers: args2.headers,
+      body: args2.body ? JSON.stringify(args2.body) : void 0
+    });
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  }
+});
+
+// src/agents/index.ts
+var agents_exports = {};
+__export(agents_exports, {
+  ReActAgent: () => ReActAgent,
+  ToolAgent: () => ToolAgent
+});
+
+// src/graph/index.ts
+var graph_exports = {};
+__export(graph_exports, {
+  CompiledGraph: () => CompiledGraph,
+  END: () => END,
+  StateGraph: () => StateGraph
+});
+
+// src/graph/state_graph.ts
+var END = "__end__";
+var CompiledGraph = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async invoke(state, options = {}) {
+    const maxSteps = options.maxSteps ?? 100;
+    let currentState = { ...this.config.initialState, ...state };
+    let currentNode = this.config.entrypoint;
+    for (let i = 0; i < maxSteps; i++) {
+      const fn = this.config.nodes.get(currentNode);
+      if (!fn) throw new Error(`Unknown node: ${currentNode}`);
+      currentState = await fn(currentState);
+      const router = this.config.conditionalEdges.get(currentNode);
+      if (router) {
+        const nextNode2 = router(currentState);
+        if (nextNode2 === END) return currentState;
+        currentNode = nextNode2;
+        continue;
+      }
+      const nextNode = this.config.edges.get(currentNode);
+      if (!nextNode || nextNode === END) return currentState;
+      currentNode = nextNode;
+    }
+    throw new Error("Graph exceeded max steps");
+  }
+};
+var StateGraph = class {
+  constructor(initialState) {
+    this.initialState = initialState;
+  }
+  nodes = /* @__PURE__ */ new Map();
+  edges = /* @__PURE__ */ new Map();
+  conditionalEdges = /* @__PURE__ */ new Map();
+  entrypoint;
+  addNode(name, fn) {
+    this.nodes.set(name, fn);
+    return this;
+  }
+  addEdge(from, to) {
+    this.edges.set(from, to);
+    return this;
+  }
+  addConditionalEdge(from, router) {
+    this.conditionalEdges.set(from, router);
+    return this;
+  }
+  setEntryPoint(name) {
+    this.entrypoint = name;
+    return this;
+  }
+  compile() {
+    if (!this.entrypoint) throw new Error("Entrypoint not set");
+    return new CompiledGraph({
+      initialState: this.initialState,
+      nodes: this.nodes,
+      edges: this.edges,
+      conditionalEdges: this.conditionalEdges,
+      entrypoint: this.entrypoint
+    });
+  }
+};
+
+// src/prompts/index.ts
+var prompts_exports = {};
+__export(prompts_exports, {
+  ChatPromptTemplate: () => ChatPromptTemplate,
+  FewShotPrompt: () => FewShotPrompt,
+  PromptRegistry: () => PromptRegistry,
+  PromptTemplate: () => PromptTemplate
+});
+
+// src/prompts/template.ts
+var PromptTemplate = class {
+  constructor(config) {
+    this.config = config;
+  }
+  format(variables) {
+    let result = this.config.template;
+    for (const [key, value] of Object.entries(variables)) {
+      result = result.replace(new RegExp(`{${key}}`, "g"), String(value));
+    }
+    return result;
+  }
+};
+var ChatPromptTemplate = class {
+  constructor(config) {
+    this.config = config;
+  }
+  format(variables) {
+    return this.config.messages.map((msg) => {
+      let content = msg.content;
+      for (const [key, value] of Object.entries(variables)) {
+        content = content.replace(new RegExp(`{${key}}`, "g"), String(value));
+      }
+      return { role: msg.role, content };
+    });
+  }
+};
+
+// src/prompts/registry.ts
+var PromptRegistry = class {
+  constructor(db) {
+    this.db = db;
+  }
+  tableName = "langfn_prompts";
+  async save(name, prompt, options) {
+    const record = {
+      id: `${name}:${options.version}`,
+      name,
+      version: options.version,
+      template: prompt.config.template,
+      variables: prompt.config.variables || [],
+      description: options.description,
+      tags: options.tags || [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    await this.db.upsert({
+      model: this.tableName,
+      where: [{ field: "id", operator: "eq", value: record.id }],
+      create: record,
+      update: record
+    });
+  }
+  async load(name, options = {}) {
+    const version = options.version || "latest";
+    const where = options.version ? [{ field: "id", operator: "eq", value: `${name}:${options.version}` }] : [{ field: "name", operator: "eq", value: name }];
+    const record = await this.db.findOne({
+      model: this.tableName,
+      where
+    });
+    if (!record) return null;
+    return new PromptTemplate({
+      template: record.template,
+      variables: record.variables
+    });
+  }
+  async list(tags) {
+    const where = [];
+    const records = await this.db.findMany({
+      model: this.tableName,
+      where
+    });
+    if (!tags || tags.length === 0) return records;
+    return records.filter(
+      (record) => tags.some((tag) => record.tags.includes(tag))
+    );
+  }
+};
+
+// src/prompts/few-shot.ts
+var FewShotPrompt = class {
+  constructor(config) {
+    this.config = config;
+  }
+  format(variables) {
+    const separator = this.config.exampleSeparator ?? "\n\n";
+    const exampleStrs = this.config.examples.map(
+      (ex) => `Input: ${ex.input}
+Output: ${ex.output}`
+    );
+    let res = `${this.config.prefix}${separator}${exampleStrs.join(separator)}${separator}${this.config.suffix}`;
+    for (const [key, value] of Object.entries(variables)) {
+      res = res.replace(new RegExp(`{${key}}`, "g"), String(value));
+    }
+    return res;
+  }
+};
+
+// src/memory/index.ts
+var memory_exports = {};
+__export(memory_exports, {
+  BufferMemory: () => BufferMemory,
+  SummaryMemory: () => SummaryMemory
+});
+
+// src/memory/buffer.ts
+var BufferMemory = class {
+  messages = [];
+  maxMessages;
+  constructor(options = {}) {
+    this.maxMessages = options.maxMessages ?? 10;
+  }
+  async add(message) {
+    this.messages.push(message);
+    if (this.messages.length > this.maxMessages) {
+      this.messages = this.messages.slice(-this.maxMessages);
+    }
+  }
+  async extend(messages) {
+    for (const msg of messages) {
+      await this.add(msg);
+    }
+  }
+  async get() {
+    return [...this.messages];
+  }
+  async clear() {
+    this.messages = [];
+  }
+};
+
+// src/memory/summary.ts
+var SummaryMemory = class {
+  constructor(lang, options = {}) {
+    this.lang = lang;
+    this.maxTokens = options.maxTokens ?? 2e3;
+    this.summaryPrompt = options.summaryPrompt ?? "Summarize the following conversation history concisely, retaining all key information:";
+  }
+  messages = [];
+  summary;
+  maxTokens;
+  summaryPrompt;
+  async add(message) {
+    this.messages.push(message);
+    if (this.messages.length > 10) {
+      await this.summarize();
+    }
+  }
+  async summarize() {
+    const history = this.messages.map((m) => `${m.role}: ${m.content}`).join("\n");
+    const prompt = `${this.summaryPrompt}
+
+Existing Summary: ${this.summary || "None"}
+
+New Messages:
+${history}`;
+    const response = await this.lang.complete(prompt);
+    this.summary = response.content;
+    this.messages = [];
+  }
+  async get() {
+    const history = [];
+    if (this.summary) {
+      history.push({ role: "system", content: `Previous conversation summary: ${this.summary}` });
+    }
+    history.push(...this.messages);
+    return history;
+  }
+  async clear() {
+    this.messages = [];
+    this.summary = void 0;
+  }
+};
+
+// src/rag/index.ts
+var rag_exports = {};
+__export(rag_exports, {
+  DbVectorStore: () => DbVectorStore,
+  Embeddings: () => Embeddings,
+  InMemoryVectorStore: () => InMemoryVectorStore,
+  OpenAIEmbeddings: () => OpenAIEmbeddings,
+  Retriever: () => Retriever,
+  VectorStore: () => VectorStore
+});
+
+// src/rag/memory.ts
+var InMemoryVectorStore = class extends VectorStore {
+  constructor(embeddings) {
+    super();
+    this.embeddings = embeddings;
+  }
+  documents = [];
+  vectors = [];
+  async addDocuments(documents) {
+    const texts = documents.map((doc) => doc.content);
+    const vectors = await this.embeddings.embedDocuments(texts);
+    this.documents.push(...documents);
+    this.vectors.push(...vectors);
+  }
+  async search(query, options = {}) {
+    const k = options.k ?? 4;
+    const queryVector = await this.embeddings.embedQuery(query);
+    const scores = [];
+    for (let i = 0; i < this.vectors.length; i++) {
+      const docVector = this.vectors[i];
+      const doc = this.documents[i];
+      if (options.filter) {
+        let match = true;
+        for (const [key, value] of Object.entries(options.filter)) {
+          if (doc.metadata[key] !== value) {
+            match = false;
+            break;
+          }
+        }
+        if (!match) continue;
+      }
+      const score = this.cosineSimilarity(queryVector, docVector);
+      scores.push({ score, doc });
+    }
+    return scores.sort((a, b) => b.score - a.score).slice(0, k).map((item) => ({ ...item.doc, score: item.score }));
+  }
+  cosineSimilarity(v1, v2) {
+    let dotProduct = 0;
+    let magnitude1 = 0;
+    let magnitude2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+      dotProduct += v1[i] * v2[i];
+      magnitude1 += v1[i] * v1[i];
+      magnitude2 += v2[i] * v2[i];
+    }
+    magnitude1 = Math.sqrt(magnitude1);
+    magnitude2 = Math.sqrt(magnitude2);
+    if (magnitude1 === 0 || magnitude2 === 0) return 0;
+    return dotProduct / (magnitude1 * magnitude2);
+  }
+};
+
+// src/rag/db-vector-store.ts
+var DbVectorStore = class extends VectorStore {
+  constructor(db, embeddings, namespace = "default") {
+    super();
+    this.db = db;
+    this.embeddings = embeddings;
+    this.namespace = namespace;
+  }
+  tableName = "langfn_documents";
+  async addDocuments(documents) {
+    const texts = documents.map((doc) => doc.content);
+    const vectors = await this.embeddings.embedDocuments(texts);
+    const records = documents.map((doc, i) => ({
+      id: Math.random().toString(36).substring(7),
+      content: doc.content,
+      embedding: vectors[i],
+      metadata: doc.metadata,
+      namespace: this.namespace,
+      createdAt: Date.now()
+    }));
+    await this.db.createMany({
+      model: this.tableName,
+      data: records
+    });
+  }
+  async search(query, options = {}) {
+    const k = options.k ?? 4;
+    const where = [{ field: "namespace", operator: "eq", value: this.namespace }];
+    if (options.filter) {
+      for (const [key, value] of Object.entries(options.filter)) {
+        where.push({ field: key, operator: "eq", value });
+      }
+    }
+    const records = await this.db.findMany({
+      model: this.tableName,
+      where,
+      limit: 100
+      // Get some candidates
+    });
+    if (records.length === 0) return [];
+    const queryVector = await this.embeddings.embedQuery(query);
+    const scored = records.map((record) => ({
+      doc: { content: record.content, metadata: record.metadata },
+      score: this.cosineSimilarity(queryVector, record.embedding)
+    }));
+    return scored.sort((a, b) => b.score - a.score).slice(0, k).map((item) => ({ ...item.doc, score: item.score }));
+  }
+  cosineSimilarity(v1, v2) {
+    let dotProduct = 0;
+    let magnitude1 = 0;
+    let magnitude2 = 0;
+    for (let i = 0; i < v1.length; i++) {
+      dotProduct += v1[i] * v2[i];
+      magnitude1 += v1[i] * v1[i];
+      magnitude2 += v2[i] * v2[i];
+    }
+    magnitude1 = Math.sqrt(magnitude1);
+    magnitude2 = Math.sqrt(magnitude2);
+    if (magnitude1 === 0 || magnitude2 === 0) return 0;
+    return dotProduct / (magnitude1 * magnitude2);
+  }
+};
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  ResponseCache: () => ResponseCache
+});
+
+// src/storage/cache.ts
+var ResponseCache = class {
+  constructor(db, ttl = 3600) {
+    this.db = db;
+    this.ttl = ttl;
+  }
+  tableName = "langfn_cache";
+  async generateKey(prompt, model, provider, metadata) {
+    const keyContent = `${provider}:${model}:${prompt}:${JSON.stringify(metadata || {})}`;
+    const msgUint8 = new TextEncoder().encode(keyContent);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", msgUint8);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  async get(prompt, model, provider, metadata) {
+    const key = await this.generateKey(prompt, model, provider, metadata);
+    const where = [{ field: "key", operator: "eq", value: key }];
+    const record = await this.db.findOne({
+      model: this.tableName,
+      where
+    });
+    if (!record) return null;
+    if (record.expiresAt < Math.floor(Date.now() / 1e3)) {
+      await this.db.delete({ model: this.tableName, where });
+      return null;
+    }
+    return record.value;
+  }
+  async set(prompt, model, provider, value, metadata) {
+    const key = await this.generateKey(prompt, model, provider, metadata);
+    const expiresAt = Math.floor(Date.now() / 1e3) + this.ttl;
+    const data = {
+      key,
+      value,
+      expiresAt,
+      createdAt: Math.floor(Date.now() / 1e3)
+    };
+    await this.db.upsert({
+      model: this.tableName,
+      where: [{ field: "key", operator: "eq", value: key }],
+      create: data,
+      update: data
+    });
+  }
+};
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  countMessagesTokens: () => countMessagesTokens,
+  countTokens: () => countTokens
+});
+
+// src/utils/token-counter.ts
+function countTokens(text, model = "gpt-4") {
+  return Math.ceil(text.length / 4);
+}
+function countMessagesTokens(messages, model = "gpt-4") {
+  let total = 0;
+  for (const msg of messages) {
+    total += countTokens(msg.content || "", model);
+    total += 4;
+  }
+  return total + 3;
+}
+
+// src/observability/index.ts
+var observability_exports = {};
+__export(observability_exports, {
+  TraceStorage: () => TraceStorage,
+  Tracer: () => Tracer
+});
+
+// src/observability/tracer.ts
+var Tracer = class {
+  watch;
+  constructor(options = {}) {
+    this.watch = options.watch;
+  }
+  async trace(name, metadata, fn) {
+    const traceId = Math.random().toString(36).substring(7);
+    if (this.watch) {
+      this.watch.track(name, { phase: "start", traceId, ...metadata });
+    }
+    try {
+      const result = await fn();
+      if (this.watch) {
+        this.watch.track(name, { phase: "end", traceId, ...metadata });
+      }
+      return result;
+    } catch (error) {
+      if (this.watch) {
+        this.watch.track(name, { phase: "error", traceId, error: error.message, ...metadata });
+      }
+      throw error;
+    }
+  }
+};
+
+// src/observability/storage.ts
+var TraceStorage = class {
+  constructor(db) {
+    this.db = db;
+  }
+  tableName = "langfn_traces";
+  async save(trace) {
+    await this.db.create({
+      model: this.tableName,
+      data: trace
+    });
+  }
+  async findMany(options = {}) {
+    const where = [];
+    if (options.model) {
+      where.push({ field: "model", operator: "eq", value: options.model });
+    }
+    if (options.provider) {
+      where.push({ field: "provider", operator: "eq", value: options.provider });
+    }
+    return this.db.findMany({
+      model: this.tableName,
+      where,
+      limit: options.limit,
+      offset: options.offset,
+      orderBy: [{ field: "startTime", direction: "desc" }]
+    });
+  }
+  async findOne(id) {
+    return this.db.findOne({
+      model: this.tableName,
+      where: [{ field: "id", operator: "eq", value: id }]
+    });
+  }
+};
+
+// src/http/index.ts
+var http_exports = {};
+__export(http_exports, {
+  createLangFnRouter: () => createLangFnRouter
+});
+
+// src/http/routes.ts
+function createLangFnRouter(lang) {
+  return [
+    {
+      method: "GET",
+      path: "/health",
+      handler: async () => {
+        return new Response(
+          JSON.stringify({ status: "ok", name: "langfn", version: "0.1.0" }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    },
+    {
+      method: "POST",
+      path: "/complete",
+      handler: async (request) => {
+        const body = await request.json();
+        const result = await lang.complete(body.prompt, { metadata: body.metadata });
+        return new Response(
+          JSON.stringify({
+            content: result.content,
+            trace_id: result.trace_id,
+            usage: result.usage
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    },
+    {
+      method: "POST",
+      path: "/chat",
+      handler: async (request) => {
+        const body = await request.json();
+        const result = await lang.chat(body.messages, {
+          tools: body.tools,
+          tool_choice: body.tool_choice,
+          metadata: body.metadata
+        });
+        return new Response(
+          JSON.stringify({
+            message: result.message,
+            tool_calls: result.tool_calls,
+            trace_id: result.trace_id,
+            usage: result.usage
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    }
+  ];
+}
+
+// src/structured/index.ts
+var structured_exports = {};
+__export(structured_exports, {
+  StructuredOutput: () => StructuredOutput
+});
+
+// src/structured/output.ts
+var StructuredOutput = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  parse(text) {
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("No JSON object found in output");
+    }
+    try {
+      const data = JSON.parse(jsonMatch[0]);
+      return this.schema.parse(data);
+    } catch (e) {
+      throw new Error(`Failed to parse structured output: ${e.message}`);
+    }
+  }
+  getSchema() {
+    return this.schema;
+  }
+};
+export {
+  Chain,
+  ChatModel,
+  LangFn,
+  Tool,
+  agents_exports as agents,
+  graph_exports as graph,
+  http_exports as http,
+  langfn,
+  memory_exports as memory,
+  models_exports as models,
+  observability_exports as observability,
+  orchestration_exports as orchestration,
+  prompts_exports as prompts,
+  rag_exports as rag,
+  storage_exports as storage,
+  structured_exports as structured,
+  tools_exports as tools,
+  utils_exports as utils
+};