@tellet/create 0.8.0

package/template/lib/engine/default.ts

@@ -0,0 +1,227 @@
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import { getToolsForAgent, callMCPTool } from "@/lib/mcp/client";
+import { getConfig } from "@/lib/tellet";
+import type { AgentConfig } from "./index";
+import type { StreamChunk } from "@/lib/providers";
+
+interface BuiltinTool {
+  name: string;
+  description: string;
+  input_schema: Anthropic.Tool.InputSchema;
+  execute: (input: Record<string, unknown>) => Promise<string>;
+}
+
+export interface AgentStreamOptions {
+  agent: AgentConfig;
+  messages: { role: "user" | "assistant"; content: string }[];
+  builtinTools?: BuiltinTool[];
+  onToolStart?: (toolName: string) => void;
+  onToolEnd?: (toolName: string) => void;
+}
+
+export async function streamAgentWithTools(
+  options: AgentStreamOptions
+): Promise<ReadableStream<StreamChunk>> {
+  const { agent, messages, builtinTools = [], onToolStart, onToolEnd } = options;
+  const config = getConfig();
+  const provider = agent.provider || config.llm.provider;
+
+  // Collect tools: builtin + MCP
+  const mcpTools = await getToolsForAgent(agent.id);
+  const allTools: Anthropic.Tool[] = [
+    ...builtinTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema,
+    })),
+    ...mcpTools,
+  ];
+
+  if (provider === "openai") {
+    return streamOpenAI(agent, messages, allTools, builtinTools);
+  }
+  return streamAnthropic(agent, messages, allTools, builtinTools, onToolStart, onToolEnd);
+}
+
+async function streamAnthropic(
+  agent: AgentConfig,
+  messages: { role: "user" | "assistant"; content: string }[],
+  tools: Anthropic.Tool[],
+  builtinTools: BuiltinTool[],
+  onToolStart?: (name: string) => void,
+  onToolEnd?: (name: string) => void
+): Promise<ReadableStream<StreamChunk>> {
+  let _client: Anthropic | null = null;
+  function getClient() {
+    if (!_client) _client = new Anthropic();
+    return _client;
+  }
+
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        let currentMessages: Anthropic.MessageParam[] = messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+        }));
+
+        // Agentic loop
+        while (true) {
+          const hasTools = tools.length > 0;
+          const response = await getClient().messages.create({
+            model: agent.model,
+            max_tokens: 2048,
+            system: agent.systemPrompt,
+            messages: currentMessages,
+            ...(hasTools ? { tools } : {}),
+          });
+
+          let hasToolUse = false;
+          const toolResults: Anthropic.ToolResultBlockParam[] = [];
+
+          for (const block of response.content) {
+            if (block.type === "text" && block.text) {
+              controller.enqueue({ text: block.text });
+            }
+
+            if (block.type === "tool_use") {
+              hasToolUse = true;
+              onToolStart?.(block.name);
+
+              let result: string;
+              const builtin = builtinTools.find((t) => t.name === block.name);
+              if (builtin) {
+                result = await builtin.execute(block.input as Record<string, unknown>);
+              } else {
+                result = await callMCPTool(block.name, block.input as Record<string, unknown>);
+              }
+
+              onToolEnd?.(block.name);
+              toolResults.push({
+                type: "tool_result",
+                tool_use_id: block.id,
+                content: result,
+              });
+            }
+          }
+
+          if (!hasToolUse) break;
+
+          currentMessages = [
+            ...currentMessages,
+            { role: "assistant", content: response.content },
+            { role: "user", content: toolResults },
+          ];
+        }
+
+        controller.close();
+      } catch (err) {
+        controller.enqueue({
+          text: `Error: ${err instanceof Error ? err.message : "Agent failed"}`,
+        });
+        controller.close();
+      }
+    },
+  });
+}
+
+async function streamOpenAI(
+  agent: AgentConfig,
+  messages: { role: "user" | "assistant"; content: string }[],
+  tools: Anthropic.Tool[],
+  builtinTools: BuiltinTool[]
+): Promise<ReadableStream<StreamChunk>> {
+  let _client: OpenAI | null = null;
+  function getClient() {
+    if (!_client) _client = new OpenAI();
+    return _client;
+  }
+
+  // Convert Anthropic tool format to OpenAI
+  const openaiTools: OpenAI.ChatCompletionTool[] = tools.map((t) => ({
+    type: "function" as const,
+    function: {
+      name: t.name,
+      description: t.description || "",
+      parameters: t.input_schema as Record<string, unknown>,
+    },
+  }));
+
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        let currentMessages: OpenAI.ChatCompletionMessageParam[] = [
+          { role: "system", content: agent.systemPrompt },
+          ...messages.map((m) => ({
+            role: m.role as "user" | "assistant",
+            content: m.content,
+          })),
+        ];
+
+        while (true) {
+          const hasTools = openaiTools.length > 0;
+          const response = await getClient().chat.completions.create({
+            model: agent.model,
+            max_tokens: 2048,
+            messages: currentMessages,
+            ...(hasTools ? { tools: openaiTools } : {}),
+          });
+
+          const choice = response.choices[0];
+          if (!choice) break;
+
+          if (choice.message.content) {
+            controller.enqueue({ text: choice.message.content });
+          }
+
+          if (choice.finish_reason === "tool_calls" && choice.message.tool_calls) {
+            const toolMessages: OpenAI.ChatCompletionMessageParam[] = [
+              { role: "assistant" as const, tool_calls: choice.message.tool_calls, content: choice.message.content },
+            ];
+
+            for (const call of choice.message.tool_calls) {
+              if (call.type !== "function") continue;
+              const fn = call as OpenAI.ChatCompletionMessageToolCall & { type: "function"; function: { name: string; arguments: string } };
+              const input = JSON.parse(fn.function.arguments);
+              const builtin = builtinTools.find((t) => t.name === fn.function.name);
+              let result: string;
+
+              if (builtin) {
+                result = await builtin.execute(input);
+              } else {
+                result = await callMCPTool(fn.function.name, input);
+              }
+
+              toolMessages.push({
+                role: "tool" as const,
+                tool_call_id: call.id,
+                content: result,
+              });
+            }
+
+            currentMessages = [...currentMessages, ...toolMessages];
+            continue;
+          }
+
+          break;
+        }
+
+        controller.close();
+      } catch (err) {
+        controller.enqueue({
+          text: `Error: ${err instanceof Error ? err.message : "Agent failed"}`,
+        });
+        controller.close();
+      }
+    },
+  });
+}
+
+// Legacy simple stream (no tools)
+export async function streamAgent(
+  agent: AgentConfig,
+  messages: { role: "user" | "assistant"; content: string }[]
+) {
+  return streamAgentWithTools({ agent, messages });
+}

package/template/lib/engine/index.ts

@@ -0,0 +1,17 @@
+export interface AgentConfig {
+  id: string;
+  name: string;
+  role: string;
+  model: string;
+  provider?: string;
+  systemPrompt: string;
+  channels: string[];
+  tools: string[];
+}
+
+export function defineAgent(config: AgentConfig): AgentConfig {
+  return config;
+}
+
+export { streamAgent, streamAgentWithTools } from "./default";
+export type { AgentStreamOptions } from "./default";

package/template/lib/mcp/client.ts

@@ -0,0 +1,97 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { getConfig } from "@/lib/tellet";
+import type Anthropic from "@anthropic-ai/sdk";
+
+interface MCPConnection {
+  client: Client;
+  tools: Anthropic.Tool[];
+}
+
+const connections = new Map<string, MCPConnection>();
+
+export async function connectMCPServer(
+  name: string,
+  command: string,
+  args: string[],
+  env?: Record<string, string>
+): Promise<MCPConnection> {
+  if (connections.has(name)) return connections.get(name)!;
+
+  const transport = new StdioClientTransport({
+    command,
+    args,
+    env: { ...process.env, ...env } as Record<string, string>,
+  });
+
+  const client = new Client({ name: `tellet-${name}`, version: "1.0.0" });
+  await client.connect(transport);
+
+  const { tools: mcpTools } = await client.listTools();
+
+  const tools: Anthropic.Tool[] = mcpTools.map((t) => ({
+    name: `${name}__${t.name}`,
+    description: t.description || "",
+    input_schema: (t.inputSchema || { type: "object", properties: {} }) as Anthropic.Tool.InputSchema,
+  }));
+
+  const conn = { client, tools };
+  connections.set(name, conn);
+  return conn;
+}
+
+export async function callMCPTool(
+  qualifiedName: string,
+  input: Record<string, unknown>
+): Promise<string> {
+  const [serverName, toolName] = qualifiedName.split("__", 2);
+  const conn = connections.get(serverName);
+  if (!conn) throw new Error(`MCP server "${serverName}" not connected`);
+
+  const result = await conn.client.callTool({ name: toolName, arguments: input });
+  return typeof result.content === "string"
+    ? result.content
+    : JSON.stringify(result.content);
+}
+
+export async function getToolsForAgent(agentId: string): Promise<Anthropic.Tool[]> {
+  const config = getConfig();
+  const agentConfig = config.agents.find((a) => a.id === agentId);
+  if (!agentConfig) return [];
+
+  const tools: Anthropic.Tool[] = [];
+  const agentTools = (agentConfig as { tools?: string[] }).tools || [];
+
+  for (const toolId of agentTools) {
+    const toolConfig = (config as { tools?: Record<string, { type: string; package?: string; env?: Record<string, string>; description?: string }> }).tools?.[toolId];
+    if (!toolConfig) continue;
+
+    if (toolConfig.type === "builtin") {
+      // Built-in tools are handled separately (e.g., search_knowledge)
+      continue;
+    }
+
+    if (toolConfig.type === "mcp" && toolConfig.package) {
+      try {
+        const conn = await connectMCPServer(
+          toolId,
+          "npx",
+          ["-y", toolConfig.package],
+          toolConfig.env
+        );
+        tools.push(...conn.tools);
+      } catch (err) {
+        console.error(`Failed to connect MCP server "${toolId}":`, err);
+      }
+    }
+  }
+
+  return tools;
+}
+
+export async function disconnectAll(): Promise<void> {
+  for (const [, conn] of connections) {
+    await conn.client.close();
+  }
+  connections.clear();
+}

package/template/lib/mcp/knowledge.ts

@@ -0,0 +1,84 @@
+import OpenAI from "openai";
+import { createServerSupabase } from "@/lib/supabase";
+
+let _openai: OpenAI | null = null;
+function getOpenAI() {
+  if (!_openai) _openai = new OpenAI();
+  return _openai;
+}
+
+async function embed(text: string): Promise<number[]> {
+  const res = await getOpenAI().embeddings.create({
+    model: "text-embedding-3-small",
+    input: text,
+  });
+  return res.data[0].embedding;
+}
+
+export async function searchKnowledge(query: string): Promise<string> {
+  try {
+    const embedding = await embed(query);
+    const supabase = await createServerSupabase();
+
+    const { data, error } = await supabase.rpc("match_documents", {
+      query_embedding: JSON.stringify(embedding),
+      match_count: 3,
+      match_threshold: 0.5,
+    });
+
+    if (error || !data || data.length === 0) {
+      return JSON.stringify({ results: [], message: "No matching documents found." });
+    }
+
+    return JSON.stringify({
+      results: data.map((d: { title: string; content: string; similarity: number }) => ({
+        title: d.title,
+        content: d.content,
+        relevance: Math.round(d.similarity * 100) + "%",
+      })),
+    });
+  } catch {
+    return JSON.stringify({ results: [], message: "Knowledge base not configured yet." });
+  }
+}
+
+export async function addDocument(
+  title: string,
+  content: string,
+  category?: string
+): Promise<string> {
+  try {
+    const embedding = await embed(`${title}\n${content}`);
+    const supabase = await createServerSupabase();
+
+    const { error } = await supabase.from("documents").insert({
+      title,
+      content,
+      category: category || "general",
+      embedding: JSON.stringify(embedding),
+    });
+
+    if (error) return JSON.stringify({ error: error.message });
+    return JSON.stringify({ success: true, title });
+  } catch (err) {
+    return JSON.stringify({ error: err instanceof Error ? err.message : "Failed to add document" });
+  }
+}
+
+export async function deleteDocument(documentId: string): Promise<string> {
+  const supabase = await createServerSupabase();
+  const { error } = await supabase.from("documents").delete().eq("id", documentId);
+  if (error) return JSON.stringify({ error: error.message });
+  return JSON.stringify({ success: true });
+}
+
+export async function listDocuments(): Promise<string> {
+  const supabase = await createServerSupabase();
+  const { data, error } = await supabase
+    .from("documents")
+    .select("id, title, category, created_at")
+    .order("created_at", { ascending: false });
+
+  if (error) return JSON.stringify({ error: error.message });
+  return JSON.stringify({ documents: data || [] });
+}

package/template/lib/mcp/registry.ts

@@ -0,0 +1,106 @@
+/**
+ * Tool Registry — pre-defined MCP tools that can be added to tellet.
+ *
+ * Usage via Orchestrator: "Add Stripe to my agents"
+ * Usage via CLI: tool selection during setup
+ */
+
+export interface ToolRegistryEntry {
+  id: string;
+  name: string;
+  description: string;
+  package: string;
+  envKeys: { key: string; description: string; placeholder: string }[];
+  compatibleRoles: string[];
+  category: string;
+}
+
+export const TOOL_REGISTRY: ToolRegistryEntry[] = [
+  {
+    id: "stripe",
+    name: "Stripe",
+    description: "Accept payments, create invoices, manage subscriptions",
+    package: "@stripe/mcp",
+    envKeys: [
+      {
+        key: "STRIPE_SECRET_KEY",
+        description: "Stripe secret key (use restricted key for safety)",
+        placeholder: "rk_live_...",
+      },
+    ],
+    compatibleRoles: ["sales", "customer_support", "operations"],
+    category: "payments",
+  },
+  {
+    id: "email",
+    name: "Email (Resend)",
+    description: "Send emails, manage contacts, campaigns",
+    package: "resend-mcp",
+    envKeys: [
+      {
+        key: "RESEND_API_KEY",
+        description: "Resend API key",
+        placeholder: "re_...",
+      },
+    ],
+    compatibleRoles: ["marketing", "customer_support", "sales"],
+    category: "communication",
+  },
+  {
+    id: "github",
+    name: "GitHub",
+    description: "Manage repos, issues, PRs",
+    package: "@modelcontextprotocol/server-github",
+    envKeys: [
+      {
+        key: "GITHUB_TOKEN",
+        description: "GitHub personal access token",
+        placeholder: "ghp_...",
+      },
+    ],
+    compatibleRoles: ["development", "operations"],
+    category: "development",
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    description: "Send messages, manage channels",
+    package: "@anthropic-ai/mcp-server-slack",
+    envKeys: [
+      {
+        key: "SLACK_BOT_TOKEN",
+        description: "Slack bot token",
+        placeholder: "xoxb-...",
+      },
+    ],
+    compatibleRoles: ["customer_support", "marketing", "operations"],
+    category: "communication",
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    description: "Manage pages, databases, documents",
+    package: "@anthropic-ai/mcp-server-notion",
+    envKeys: [
+      {
+        key: "NOTION_API_KEY",
+        description: "Notion integration token",
+        placeholder: "ntn_...",
+      },
+    ],
+    compatibleRoles: ["operations", "marketing", "development"],
+    category: "productivity",
+  },
+];
+
+export function getToolById(id: string): ToolRegistryEntry | undefined {
+  return TOOL_REGISTRY.find((t) => t.id === id);
+}
+
+export function getToolsByCategory(category: string): ToolRegistryEntry[] {
+  return TOOL_REGISTRY.filter((t) => t.category === category);
+}
+
+export function getToolsForRole(role: string): ToolRegistryEntry[] {
+  return TOOL_REGISTRY.filter((t) => t.compatibleRoles.includes(role));
+}