langfn 0.0.1

package/README.md

@@ -0,0 +1,32 @@
+# LangFn (TypeScript)
+
+Comprehensive AI Development SDK for LLM-based workflows.
+
+## Features
+
+- **Model Abstraction**: Unified interface for OpenAI, Anthropic, Ollama, and more.
+- **Orchestration**: Sequential, Parallel, and Map-Reduce chains.
+- **Graph Workflows**: Stateful workflows with `StateGraph`.
+- **Agents**: Functional `ToolAgent` and `ReActAgent`.
+- **Structured Output**: Type-safe output parsing with Zod.
+- **RAG**: Embeddings and Vector Store support.
+- **Observability**: Built-in tracing.
+
+## Usage
+
+```typescript
+import { langfn, models } from "langfn";
+
+const lang = langfn({
+  model: new models.OpenAIChatModel({
+    apiKey: process.env.OPENAI_API_KEY
+  })
+});
+
+const response = await lang.complete("Hello world");
+console.log(response.content);
+```
+
+## Documentation
+
+See the [main documentation](https://docs.superfunctions.dev/langfn) for more details.

package/dist/chunk-6NDYO7WC.js

@@ -0,0 +1,131 @@
+// src/models/base.ts
+var ChatModel = class {
+};
+
+// src/models/openai.ts
+var OpenAIChatModel = class extends ChatModel {
+  provider = "openai";
+  model;
+  apiKey;
+  baseUrl;
+  organization;
+  project;
+  constructor(config) {
+    super();
+    this.apiKey = config.apiKey;
+    this.model = config.model || "gpt-4-turbo-preview";
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+    this.organization = config.organization;
+    this.project = config.project;
+  }
+  async fetch(path, options) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`,
+      ...this.organization ? { "OpenAI-Organization": this.organization } : {},
+      ...this.project ? { "OpenAI-Project": this.project } : {}
+    };
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      ...options,
+      headers: {
+        ...headers,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI 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 body = {
+      model: this.model,
+      messages: request.messages,
+      tools: request.tools,
+      tool_choice: request.tool_choice
+    };
+    const response = await this.fetch("/chat/completions", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const data = await response.json();
+    const choice = data.choices[0];
+    const message = choice.message;
+    const tool_calls = message.tool_calls?.map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      arguments: JSON.parse(tc.function.arguments)
+    }));
+    const usage = data.usage ? {
+      prompt_tokens: data.usage.prompt_tokens,
+      completion_tokens: data.usage.completion_tokens,
+      total_tokens: data.usage.total_tokens
+    } : void 0;
+    return {
+      message: {
+        role: message.role,
+        content: message.content || ""
+      },
+      tool_calls,
+      usage,
+      raw: data
+    };
+  }
+  async *stream(request) {
+    const response = await this.fetch("/chat/completions", {
+      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() === "" || line.trim() === "data: [DONE]") continue;
+        if (!line.startsWith("data: ")) continue;
+        try {
+          const data = JSON.parse(line.slice(6));
+          const delta = data.choices[0]?.delta?.content;
+          if (delta) {
+            yield {
+              type: "content",
+              content: delta,
+              delta
+            };
+          }
+        } catch (e) {
+          console.warn("Failed to parse stream chunk", e);
+        }
+      }
+    }
+    yield { type: "end", finish_reason: "stop" };
+  }
+};
+
+export {
+  ChatModel,
+  OpenAIChatModel
+};

package/dist/chunk-IDYTII3W.js

@@ -0,0 +1,47 @@
+// src/agents/tool_agent.ts
+var ToolAgent = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async run(prompt, options = {}) {
+    const max_iterations = this.options.max_iterations ?? 5;
+    const messages = [];
+    if (options.system) {
+      messages.push({ role: "system", content: options.system });
+    }
+    messages.push({ role: "user", content: prompt });
+    const tool_map = Object.fromEntries(this.options.tools.map((t) => [t.name, t]));
+    for (let i = 0; i < max_iterations; i++) {
+      const resp = await this.options.lang.chat(messages, {
+        tools: this.options.tools
+      });
+      const assistant_msg = resp.message;
+      if (resp.tool_calls) {
+        assistant_msg.tool_calls = resp.tool_calls.map((c) => ({
+          id: c.id,
+          type: "function",
+          function: { name: c.name, arguments: JSON.stringify(c.arguments) }
+        }));
+      }
+      messages.push(assistant_msg);
+      if (!resp.tool_calls || resp.tool_calls.length === 0) {
+        return { messages, output: resp.message.content };
+      }
+      for (const call of resp.tool_calls) {
+        const tool = tool_map[call.name];
+        if (!tool) throw new Error(`Unknown tool: ${call.name}`);
+        const result = await tool.run(call.arguments);
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: JSON.stringify(result)
+        });
+      }
+    }
+    throw new Error("Max iterations exceeded");
+  }
+};
+
+export {
+  ToolAgent
+};

package/dist/chunk-LIUWQ4NY.js

@@ -0,0 +1,49 @@
+// src/rag/base.ts
+var Embeddings = class {
+};
+var VectorStore = class {
+};
+var Retriever = class {
+};
+
+// src/rag/openai.ts
+var OpenAIEmbeddings = class extends Embeddings {
+  apiKey;
+  model;
+  baseUrl;
+  constructor(config) {
+    super();
+    this.apiKey = config.apiKey;
+    this.model = config.model || "text-embedding-3-small";
+    this.baseUrl = config.baseUrl || "https://api.openai.com/v1";
+  }
+  async embedQuery(text) {
+    const res = await this.embedDocuments([text]);
+    return res[0];
+  }
+  async embedDocuments(texts) {
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        input: texts,
+        model: this.model
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI Embeddings Error: ${await response.text()}`);
+    }
+    const data = await response.json();
+    return data.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
+  }
+};
+
+export {
+  Embeddings,
+  VectorStore,
+  Retriever,
+  OpenAIEmbeddings
+};

package/dist/chunk-MHMMFGVC.js

@@ -0,0 +1,60 @@
+// src/agents/react.ts
+var ReActAgent = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async run(prompt) {
+    const max_iterations = this.options.max_iterations ?? 10;
+    const system_prompt = this.options.system_prompt ?? "You are a helpful assistant with access to tools. Use them to answer the user's request.";
+    const messages = [
+      { role: "system", content: system_prompt },
+      { role: "user", content: prompt }
+    ];
+    const tool_map = Object.fromEntries(this.options.tools.map((t) => [t.name, t]));
+    for (let i = 0; i < max_iterations; i++) {
+      const resp = await this.options.model.chat(messages, {
+        tools: this.options.tools,
+        tool_choice: "auto"
+      });
+      const assistant_msg = resp.message;
+      if (resp.tool_calls) {
+        assistant_msg.tool_calls = resp.tool_calls.map((c) => ({
+          id: c.id,
+          type: "function",
+          function: { name: c.name, arguments: JSON.stringify(c.arguments) }
+        }));
+      }
+      messages.push(assistant_msg);
+      if (!resp.tool_calls || resp.tool_calls.length === 0) {
+        return { messages, output: resp.message.content };
+      }
+      for (const call of resp.tool_calls) {
+        const tool = tool_map[call.name];
+        let result_content;
+        if (!tool) {
+          result_content = JSON.stringify({ error: `Tool ${call.name} not found` });
+        } else {
+          try {
+            const result = await tool.run(call.arguments);
+            result_content = typeof result === "string" ? result : JSON.stringify(result);
+          } catch (e) {
+            result_content = JSON.stringify({ error: e.message });
+          }
+        }
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: result_content
+        });
+      }
+    }
+    return {
+      messages,
+      output: "I could not complete the task within the maximum number of steps."
+    };
+  }
+};
+
+export {
+  ReActAgent
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};