@tellet/create 0.8.0

package/template/lib/orchestrator/executor.ts

@@ -0,0 +1,202 @@
+import { createServerSupabase } from "@/lib/supabase";
+import { addDocument, searchKnowledge, listDocuments, deleteDocument } from "@/lib/mcp/knowledge";
+import { runScheduledAgent } from "@/lib/scheduler";
+import { TOOL_REGISTRY, getToolById } from "@/lib/mcp/registry";
+import fs from "fs";
+import path from "path";
+
+export async function executeTool(
+  name: string,
+  input: Record<string, unknown>
+): Promise<string> {
+  const supabase = await createServerSupabase();
+
+  switch (name) {
+    case "list_agents": {
+      const { data } = await supabase
+        .from("agents")
+        .select("id, name, role, status, model")
+        .order("created_at");
+      return JSON.stringify(data || []);
+    }
+
+    case "get_stats": {
+      const [
+        { count: conversations },
+        { count: messages },
+        { data: agents },
+        { data: costData },
+      ] = await Promise.all([
+        supabase.from("conversations").select("*", { count: "exact", head: true }),
+        supabase.from("messages").select("*", { count: "exact", head: true }),
+        supabase.from("agents").select("id, status"),
+        supabase.from("activity_log").select("cost_usd"),
+      ]);
+      const activeAgents = (agents || []).filter((a) => a.status === "active").length;
+      const totalCost = (costData || []).reduce(
+        (sum, r) => sum + Number(r.cost_usd || 0),
+        0
+      );
+      return JSON.stringify({
+        conversations: conversations || 0,
+        messages: messages || 0,
+        activeAgents,
+        totalAgents: agents?.length || 0,
+        estimatedCost: `$${totalCost.toFixed(2)}`,
+      });
+    }
+
+    case "update_agent_prompt": {
+      const { agent_id, system_prompt } = input as {
+        agent_id: string;
+        system_prompt: string;
+      };
+      const { error } = await supabase
+        .from("agents")
+        .update({ system_prompt })
+        .eq("id", agent_id);
+      if (error) return JSON.stringify({ error: error.message });
+      return JSON.stringify({ success: true, agent_id });
+    }
+
+    case "update_site_content": {
+      const configPath = path.join(process.cwd(), "tellet.json");
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+
+      const updates = input as Record<string, unknown>;
+      if (updates.tagline) config.site.tagline = updates.tagline;
+      if (updates.subtitle) config.site.subtitle = updates.subtitle;
+      if (updates.cta) config.site.cta = updates.cta;
+      if (updates.features) config.site.features = updates.features;
+      if (updates.faq) config.site.faq = updates.faq;
+
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      return JSON.stringify({
+        success: true,
+        message: "Site content updated. Rebuild to see changes.",
+      });
+    }
+
+    case "get_recent_conversations": {
+      const limit = (input.limit as number) || 10;
+      const { data } = await supabase
+        .from("conversations")
+        .select("id, channel, created_at, agents(name, role), messages(count)")
+        .order("created_at", { ascending: false })
+        .limit(limit);
+      return JSON.stringify(data || []);
+    }
+
+    case "add_knowledge": {
+      const { title, content, category } = input as {
+        title: string;
+        content: string;
+        category?: string;
+      };
+      return addDocument(title, content, category);
+    }
+
+    case "search_knowledge": {
+      return searchKnowledge(input.query as string);
+    }
+
+    case "list_knowledge": {
+      return listDocuments();
+    }
+
+    case "delete_knowledge": {
+      return deleteDocument(input.document_id as string);
+    }
+
+    case "run_agent_task": {
+      const result = await runScheduledAgent(
+        input.agent_id as string,
+        input.task as string
+      );
+      return JSON.stringify(result);
+    }
+
+    case "manage_schedule": {
+      const configPath = path.join(process.cwd(), "tellet.json");
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      const agentIdx = config.agents.findIndex(
+        (a: { id: string }) => a.id === input.agent_id
+      );
+      if (agentIdx === -1) return JSON.stringify({ error: "Agent not found" });
+
+      config.agents[agentIdx].schedule = {
+        enabled: input.enabled as boolean,
+        cron: (input.cron as string) || config.agents[agentIdx].schedule?.cron || "0 9 * * *",
+        task: (input.task as string) || config.agents[agentIdx].schedule?.task || "",
+      };
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      return JSON.stringify({ success: true, schedule: config.agents[agentIdx].schedule });
+    }
+
+    case "list_available_tools": {
+      return JSON.stringify(
+        TOOL_REGISTRY.map((t) => ({
+          id: t.id,
+          name: t.name,
+          description: t.description,
+          category: t.category,
+          requiredKeys: t.envKeys.map((k) => k.key),
+          compatibleRoles: t.compatibleRoles,
+        }))
+      );
+    }
+
+    case "install_tool": {
+      const toolId = input.tool_id as string;
+      const agentIds = (input.agent_ids as string[]) || [];
+      const tool = getToolById(toolId);
+      if (!tool) return JSON.stringify({ error: `Tool "${toolId}" not found in marketplace` });
+
+      const configPath = path.join(process.cwd(), "tellet.json");
+      const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+
+      // Add tool to tools section
+      if (!config.tools) config.tools = {};
+      config.tools[toolId] = {
+        type: "mcp",
+        package: tool.package,
+        description: tool.description,
+        env: Object.fromEntries(tool.envKeys.map((k) => [k.key, `\${${k.key}}`])),
+      };
+
+      // Assign to agents
+      if (agentIds.length > 0) {
+        for (const aid of agentIds) {
+          const agent = config.agents.find((a: { id: string }) => a.id === aid);
+          if (agent) {
+            if (!agent.tools) agent.tools = [];
+            if (!agent.tools.includes(toolId)) agent.tools.push(toolId);
+          }
+        }
+      } else {
+        // Auto-assign to compatible agents
+        for (const agent of config.agents) {
+          if (tool.compatibleRoles.includes(agent.role)) {
+            if (!agent.tools) agent.tools = [];
+            if (!agent.tools.includes(toolId)) agent.tools.push(toolId);
+          }
+        }
+      }
+
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+      const envInstructions = tool.envKeys
+        .map((k) => `  ${k.key}=${k.placeholder}`)
+        .join("\n");
+
+      return JSON.stringify({
+        success: true,
+        tool: tool.name,
+        message: `Installed ${tool.name}. Add these to your .env:\n${envInstructions}`,
+      });
+    }
+
+    default:
+      return JSON.stringify({ error: `Unknown tool: ${name}` });
+  }
+}

package/template/lib/orchestrator/tools.ts

@@ -0,0 +1,245 @@
+import type Anthropic from "@anthropic-ai/sdk";
+
+export const orchestratorTools: Anthropic.Tool[] = [
+  {
+    name: "list_agents",
+    description:
+      "List all AI agents in the company with their name, role, status, and model.",
+    input_schema: {
+      type: "object" as const,
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "get_stats",
+    description:
+      "Get company statistics: total conversations, messages, active agents, and estimated cost.",
+    input_schema: {
+      type: "object" as const,
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "update_agent_prompt",
+    description:
+      "Update an agent's system prompt. Use this when the owner wants to change how an agent behaves.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        agent_id: {
+          type: "string",
+          description: "The agent ID to update",
+        },
+        system_prompt: {
+          type: "string",
+          description: "The new system prompt for the agent",
+        },
+      },
+      required: ["agent_id", "system_prompt"],
+    },
+  },
+  {
+    name: "update_site_content",
+    description:
+      "Update the website content. Can update tagline, subtitle, features, FAQ, or CTA. Only include fields that need to change.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        tagline: {
+          type: "string",
+          description: "New tagline for the website",
+        },
+        subtitle: {
+          type: "string",
+          description: "New subtitle for the website",
+        },
+        cta: {
+          type: "string",
+          description: "New call-to-action text",
+        },
+        features: {
+          type: "array",
+          description: "New features list",
+          items: {
+            type: "object",
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              icon: { type: "string" },
+            },
+            required: ["title", "description", "icon"],
+          },
+        },
+        faq: {
+          type: "array",
+          description: "New FAQ list",
+          items: {
+            type: "object",
+            properties: {
+              question: { type: "string" },
+              answer: { type: "string" },
+            },
+            required: ["question", "answer"],
+          },
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "get_recent_conversations",
+    description:
+      "Get recent conversations with message counts and agent info.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of conversations to return (default 10)",
+        },
+      },
+      required: [],
+    },
+  },
+  {
+    name: "add_knowledge",
+    description:
+      "Add a document to the company knowledge base. Agents use this to answer customer questions accurately.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        title: {
+          type: "string",
+          description: "Document title (e.g. 'Refund Policy')",
+        },
+        content: {
+          type: "string",
+          description: "Full document content",
+        },
+        category: {
+          type: "string",
+          description: "Category: policy, product, faq, or general",
+        },
+      },
+      required: ["title", "content"],
+    },
+  },
+  {
+    name: "search_knowledge",
+    description:
+      "Search the knowledge base to check what information agents have access to.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        query: {
+          type: "string",
+          description: "Search query",
+        },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "list_knowledge",
+    description:
+      "List all documents in the knowledge base.",
+    input_schema: {
+      type: "object" as const,
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "delete_knowledge",
+    description:
+      "Delete a document from the knowledge base by ID.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        document_id: {
+          type: "string",
+          description: "The document ID to delete",
+        },
+      },
+      required: ["document_id"],
+    },
+  },
+  {
+    name: "run_agent_task",
+    description:
+      "Run a specific agent with a task immediately. Use this when the owner asks to have an agent do something right now.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        agent_id: {
+          type: "string",
+          description: "The agent ID to run",
+        },
+        task: {
+          type: "string",
+          description: "The task description for the agent",
+        },
+      },
+      required: ["agent_id", "task"],
+    },
+  },
+  {
+    name: "manage_schedule",
+    description:
+      "Enable or disable scheduled tasks for an agent. Updates tellet.json.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        agent_id: {
+          type: "string",
+          description: "The agent ID",
+        },
+        enabled: {
+          type: "boolean",
+          description: "Enable or disable the schedule",
+        },
+        cron: {
+          type: "string",
+          description: "Cron expression (e.g. '0 9 * * *' for daily at 9am)",
+        },
+        task: {
+          type: "string",
+          description: "The recurring task description",
+        },
+      },
+      required: ["agent_id", "enabled"],
+    },
+  },
+  {
+    name: "list_available_tools",
+    description:
+      "List all tools available in the tellet marketplace that can be installed.",
+    input_schema: {
+      type: "object" as const,
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "install_tool",
+    description:
+      "Install a tool from the marketplace and assign it to agents. Updates tellet.json. The owner will need to set the required API key in .env.",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        tool_id: {
+          type: "string",
+          description: "Tool ID from the marketplace (e.g. 'stripe', 'email', 'github')",
+        },
+        agent_ids: {
+          type: "array",
+          items: { type: "string" },
+          description: "Agent IDs to assign this tool to",
+        },
+      },
+      required: ["tool_id"],
+    },
+  },
+];

package/template/lib/providers/anthropic.ts

@@ -0,0 +1,41 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { LLMProvider, StreamParams, StreamChunk } from "./index";
+
+let _client: Anthropic | null = null;
+function getClient() {
+  if (!_client) _client = new Anthropic();
+  return _client;
+}
+
+export const anthropicProvider: LLMProvider = {
+  id: "anthropic",
+
+  async stream(params: StreamParams): Promise<ReadableStream<StreamChunk>> {
+    const stream = getClient().messages.stream({
+      model: params.model,
+      max_tokens: params.maxTokens || 2048,
+      system: params.system,
+      messages: params.messages,
+    });
+
+    return new ReadableStream({
+      async start(controller) {
+        stream.on("text", (text) => {
+          controller.enqueue({ text });
+        });
+        await stream.finalMessage();
+        controller.close();
+      },
+    });
+  },
+
+  estimateCost(inputTokens: number, outputTokens: number, model: string): number {
+    const rates: Record<string, { input: number; output: number }> = {
+      "claude-sonnet-4-6": { input: 3, output: 15 },
+      "claude-haiku-4-5": { input: 0.25, output: 1.25 },
+      "claude-opus-4-6": { input: 15, output: 75 },
+    };
+    const r = rates[model] || rates["claude-sonnet-4-6"];
+    return (inputTokens * r.input + outputTokens * r.output) / 1_000_000;
+  },
+};

package/template/lib/providers/index.ts

@@ -0,0 +1,36 @@
+export interface LLMMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
+export interface StreamParams {
+  model: string;
+  system: string;
+  messages: LLMMessage[];
+  maxTokens?: number;
+}
+
+export interface StreamChunk {
+  text: string;
+}
+
+export interface LLMProvider {
+  id: string;
+  stream(params: StreamParams): Promise<ReadableStream<StreamChunk>>;
+  estimateCost(inputTokens: number, outputTokens: number, model: string): number;
+}
+
+import { anthropicProvider } from "./anthropic";
+import { openaiProvider } from "./openai";
+
+const providers: Record<string, LLMProvider> = {
+  anthropic: anthropicProvider,
+  openai: openaiProvider,
+};
+
+export function getProvider(id?: string): LLMProvider {
+  const providerId = id || "anthropic";
+  const provider = providers[providerId];
+  if (!provider) throw new Error(`Unknown LLM provider: ${providerId}`);
+  return provider;
+}

package/template/lib/providers/openai.ts

@@ -0,0 +1,46 @@
+import OpenAI from "openai";
+import type { LLMProvider, StreamParams, StreamChunk } from "./index";
+
+let _client: OpenAI | null = null;
+function getClient() {
+  if (!_client) _client = new OpenAI();
+  return _client;
+}
+
+export const openaiProvider: LLMProvider = {
+  id: "openai",
+
+  async stream(params: StreamParams): Promise<ReadableStream<StreamChunk>> {
+    const stream = await getClient().chat.completions.create({
+      model: params.model,
+      max_tokens: params.maxTokens || 2048,
+      messages: [
+        { role: "system", content: params.system },
+        ...params.messages,
+      ],
+      stream: true,
+    });
+
+    return new ReadableStream({
+      async start(controller) {
+        for await (const chunk of stream) {
+          const text = chunk.choices[0]?.delta?.content;
+          if (text) {
+            controller.enqueue({ text });
+          }
+        }
+        controller.close();
+      },
+    });
+  },
+
+  estimateCost(inputTokens: number, outputTokens: number, model: string): number {
+    const rates: Record<string, { input: number; output: number }> = {
+      "gpt-4.1": { input: 2, output: 8 },
+      "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+      "gpt-4.1-nano": { input: 0.1, output: 0.4 },
+    };
+    const r = rates[model] || rates["gpt-4.1"];
+    return (inputTokens * r.input + outputTokens * r.output) / 1_000_000;
+  },
+};

package/template/lib/scheduler.ts

@@ -0,0 +1,115 @@
+import { getConfig } from "./tellet";
+import { streamAgentWithTools } from "./engine";
+import { searchKnowledge } from "./mcp/knowledge";
+import { createServerSupabase } from "./supabase";
+import type Anthropic from "@anthropic-ai/sdk";
+
+interface ScheduleResult {
+  agentId: string;
+  agentName: string;
+  task: string;
+  response: string;
+  timestamp: string;
+}
+
+const builtinTools = [
+  {
+    name: "search_knowledge",
+    description: "Search the company knowledge base",
+    input_schema: {
+      type: "object" as const,
+      properties: {
+        query: { type: "string", description: "Search query" },
+      },
+      required: ["query"],
+    } as Anthropic.Tool.InputSchema,
+    execute: async (input: Record<string, unknown>) => {
+      return searchKnowledge(input.query as string);
+    },
+  },
+];
+
+export async function runScheduledAgent(
+  agentId: string,
+  task?: string
+): Promise<ScheduleResult> {
+  const config = getConfig();
+  const supabase = await createServerSupabase();
+
+  const { data: agent } = await supabase
+    .from("agents")
+    .select("*")
+    .eq("id", agentId)
+    .single();
+
+  if (!agent) throw new Error(`Agent "${agentId}" not found`);
+
+  const agentConfig = config.agents.find((a) => a.id === agentId);
+  const prompt =
+    task ||
+    (agentConfig as { schedule?: { task?: string } })?.schedule?.task ||
+    `Perform your regular scheduled duties as ${agent.role}.`;
+
+  const stream = await streamAgentWithTools({
+    agent: {
+      id: agent.id,
+      name: agent.name,
+      role: agent.role,
+      model: agent.model,
+      provider: agent.config?.provider as string | undefined,
+      systemPrompt: agent.system_prompt,
+      channels: [],
+      tools: agent.config?.tools || [],
+    },
+    messages: [{ role: "user", content: prompt }],
+    builtinTools,
+  });
+
+  let response = "";
+  const reader = stream.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    response += value.text;
+  }
+
+  // Log activity
+  await supabase.from("activity_log").insert({
+    agent_id: agentId,
+    action: "scheduled_task",
+    summary: `[Scheduled] ${response.slice(0, 120)}${response.length > 120 ? "..." : ""}`,
+  });
+
+  return {
+    agentId,
+    agentName: agent.name,
+    task: prompt,
+    response,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export async function runAllScheduledAgents(): Promise<ScheduleResult[]> {
+  const config = getConfig();
+  const results: ScheduleResult[] = [];
+
+  for (const agent of config.agents) {
+    const schedule = (agent as { schedule?: { enabled?: boolean } }).schedule;
+    if (!schedule?.enabled) continue;
+
+    try {
+      const result = await runScheduledAgent(agent.id);
+      results.push(result);
+    } catch (err) {
+      results.push({
+        agentId: agent.id,
+        agentName: agent.name,
+        task: "scheduled",
+        response: `Error: ${err instanceof Error ? err.message : "Failed"}`,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+
+  return results;
+}