apteva 0.4.41 → 0.4.48

package/src/openapi.ts

@@ -1006,6 +1006,40 @@ while (true) {
         },
       },
     },
+    "/tasks/{agentId}": {
+      post: {
+        tags: ["Tasks"],
+        summary: "Create a task on an agent",
+        description: "Create a new task on a running agent. The agent must have the tasks feature enabled.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID to create the task on" },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  title: { type: "string", description: "Task title" },
+                  description: { type: "string", description: "Task description" },
+                  type: { type: "string", enum: ["once", "recurring"], default: "once" },
+                  priority: { type: "integer", minimum: 1, maximum: 10, default: 5 },
+                  execute_at: { type: "string", format: "date-time", description: "Scheduled execution time (for one-time tasks)" },
+                  recurrence: { type: "string", description: "Cron expression (for recurring tasks)" },
+                },
+                required: ["title"],
+              },
+            },
+          },
+        },
+        responses: {
+          "201": { description: "Task created successfully" },
+          "400": { description: "Agent is not running or invalid input" },
+          "404": { description: "Agent not found" },
+        },
+      },
+    },
     "/tasks/{agentId}/{taskId}": {
       get: {
         tags: ["Tasks"],
@@ -1033,6 +1067,68 @@ while (true) {
           "404": { description: "Agent not found" },
         },
       },
+      put: {
+        tags: ["Tasks"],
+        summary: "Update a task on an agent",
+        description: "Update an existing task on a running agent.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to update" },
+        ],
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  title: { type: "string" },
+                  description: { type: "string" },
+                  type: { type: "string", enum: ["once", "recurring"] },
+                  priority: { type: "integer", minimum: 1, maximum: 10 },
+                  execute_at: { type: "string", format: "date-time" },
+                  recurrence: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+        responses: {
+          "200": { description: "Task updated" },
+          "400": { description: "Agent is not running or invalid input" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
+      delete: {
+        tags: ["Tasks"],
+        summary: "Delete a task on an agent",
+        description: "Delete a task from a running agent.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to delete" },
+        ],
+        responses: {
+          "200": { description: "Task deleted" },
+          "400": { description: "Agent is not running" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
+    },
+    "/tasks/{agentId}/{taskId}/execute": {
+      post: {
+        tags: ["Tasks"],
+        summary: "Execute a task immediately",
+        description: "Immediately execute a task on a running agent, regardless of its schedule.",
+        parameters: [
+          { name: "agentId", in: "path", required: true, schema: { type: "string" }, description: "Agent ID" },
+          { name: "taskId", in: "path", required: true, schema: { type: "string" }, description: "Task ID to execute" },
+        ],
+        responses: {
+          "200": { description: "Task execution started" },
+          "400": { description: "Agent is not running" },
+          "404": { description: "Agent or task not found" },
+        },
+      },
     },
     "/mcp/servers": {
       get: {

package/src/providers.ts

@@ -12,9 +12,9 @@ export const PROVIDERS = {
     docsUrl: "https://console.anthropic.com/settings/keys",
     testEndpoint: "https://api.anthropic.com/v1/messages",
     models: [
-      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", recommended: true },
-      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5" },
-      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)" },
+      { value: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", recommended: true, input_cost: 3, output_cost: 15, cache_creation_cost: 3.75, cache_read_cost: 0.3 },
+      { value: "claude-sonnet-4-5", label: "Claude Sonnet 4.5", input_cost: 3, output_cost: 15, cache_creation_cost: 3.75, cache_read_cost: 0.3 },
+      { value: "claude-haiku-4-5", label: "Claude Haiku 4.5 (Fast)", input_cost: 0.8, output_cost: 4, cache_creation_cost: 1, cache_read_cost: 0.08 },
     ],
   },
   openai: {
@@ -26,8 +26,8 @@ export const PROVIDERS = {
     docsUrl: "https://platform.openai.com/api-keys",
     testEndpoint: "https://api.openai.com/v1/models",
     models: [
-      { value: "gpt-4o", label: "GPT-4o", recommended: true },
-      { value: "gpt-4o-mini", label: "GPT-4o Mini (Fast)" },
+      { value: "gpt-4o", label: "GPT-4o", recommended: true, input_cost: 2.5, output_cost: 10 },
+      { value: "gpt-4o-mini", label: "GPT-4o Mini (Fast)", input_cost: 0.15, output_cost: 0.6 },
     ],
   },
   groq: {
@@ -39,8 +39,8 @@ export const PROVIDERS = {
     docsUrl: "https://console.groq.com/keys",
     testEndpoint: "https://api.groq.com/openai/v1/models",
     models: [
-      { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B", recommended: true },
-      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Fast)" },
+      { value: "llama-3.3-70b-versatile", label: "Llama 3.3 70B", recommended: true, input_cost: 0, output_cost: 0 },
+      { value: "llama-3.1-8b-instant", label: "Llama 3.1 8B (Fast)", input_cost: 0, output_cost: 0 },
     ],
   },
   gemini: {
@@ -52,8 +52,8 @@ export const PROVIDERS = {
     docsUrl: "https://aistudio.google.com/app/apikey",
     testEndpoint: "https://generativelanguage.googleapis.com/v1/models",
     models: [
-      { value: "gemini-3-pro-preview", label: "Gemini 3 Pro Preview (Latest)", recommended: true },
-      { value: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview (Fast)" },
+      { value: "gemini-3-pro-preview", label: "Gemini 3 Pro Preview (Latest)", recommended: true, input_cost: 2, output_cost: 12 },
+      { value: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview (Fast)", input_cost: 0.5, output_cost: 3 },
     ],
   },
   xai: {
@@ -65,8 +65,8 @@ export const PROVIDERS = {
     docsUrl: "https://console.x.ai/",
     testEndpoint: "https://api.x.ai/v1/models",
     models: [
-      { value: "grok-2", label: "Grok 2", recommended: true },
-      { value: "grok-2-mini", label: "Grok 2 Mini (Fast)" },
+      { value: "grok-2", label: "Grok 2", recommended: true, input_cost: 2, output_cost: 10 },
+      { value: "grok-2-mini", label: "Grok 2 Mini (Fast)", input_cost: 0.3, output_cost: 1 },
     ],
   },
   together: {
@@ -78,8 +78,8 @@ export const PROVIDERS = {
     docsUrl: "https://api.together.xyz/settings/api-keys",
     testEndpoint: "https://api.together.xyz/v1/models",
     models: [
-      { value: "moonshotai/Kimi-K2.5", label: "Kimi K2.5", recommended: true },
-      { value: "moonshotai/Kimi-K2-Thinking", label: "Kimi K2 Thinking (Reasoning)" },
+      { value: "moonshotai/Kimi-K2.5", label: "Kimi K2.5", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "moonshotai/Kimi-K2-Thinking", label: "Kimi K2 Thinking (Reasoning)", input_cost: 1, output_cost: 4 },
     ],
   },
   fireworks: {
@@ -91,10 +91,10 @@ export const PROVIDERS = {
     docsUrl: "https://fireworks.ai/api-keys",
     testEndpoint: "https://api.fireworks.ai/inference/v1/models",
     models: [
-      { value: "accounts/fireworks/models/kimi-k2p5", label: "Kimi K2.5", recommended: true },
-      { value: "accounts/fireworks/models/kimi-k2-thinking", label: "Kimi K2 Thinking (Reasoning)" },
-      { value: "accounts/fireworks/models/minimax-m2p5", label: "MiniMax M2.5" },
-      { value: "accounts/fireworks/models/glm-5", label: "GLM 5" },
+      { value: "accounts/fireworks/models/kimi-k2p5", label: "Kimi K2.5", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/kimi-k2-thinking", label: "Kimi K2 Thinking (Reasoning)", input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/minimax-m2p5", label: "MiniMax M2.5", input_cost: 1, output_cost: 4 },
+      { value: "accounts/fireworks/models/glm-5", label: "GLM 5", input_cost: 1, output_cost: 4 },
     ],
   },
   moonshot: {
@@ -106,8 +106,24 @@ export const PROVIDERS = {
     docsUrl: "https://platform.moonshot.cn/console/api-keys",
     testEndpoint: "https://api.moonshot.cn/v1/models",
     models: [
-      { value: "moonshot-v1-128k", label: "Kimi 128K", recommended: true },
-      { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)" },
+      { value: "moonshot-v1-128k", label: "Kimi 128K", recommended: true, input_cost: 1, output_cost: 4 },
+      { value: "moonshot-v1-32k", label: "Kimi 32K (Fast)", input_cost: 0.5, output_cost: 2 },
+    ],
+  },
+  venice: {
+    id: "venice",
+    name: "Venice",
+    displayName: "Venice AI",
+    type: "llm" as const,
+    envVar: "VENICE_API_KEY",
+    docsUrl: "https://docs.venice.ai/overview/pricing",
+    testEndpoint: "https://api.venice.ai/api/v1/models",
+    models: [
+      { value: "llama-3.3-70b", label: "Llama 3.3 70B", recommended: true, input_cost: 0.7, output_cost: 2.8 },
+      { value: "olafangensan-glm-4.7-flash-heretic", label: "GLM 4.7 Flash Heretic", input_cost: 0.14, output_cost: 0.8 },
+      { value: "qwen3-235b-a22b-instruct-2507", label: "Qwen 3 235B Instruct", input_cost: 0.15, output_cost: 0.75 },
+      { value: "deepseek-v3.2", label: "DeepSeek V3.2", input_cost: 0.4, output_cost: 1 },
+      { value: "venice-uncensored", label: "Venice Uncensored 1.1", input_cost: 0.2, output_cost: 0.9 },
     ],
   },
   ollama: {
@@ -122,11 +138,11 @@ export const PROVIDERS = {
     defaultBaseUrl: "http://localhost:11434",
     models: [
       // Default models - actual list fetched dynamically from Ollama
-      { value: "llama3.3", label: "Llama 3.3 (70B)", recommended: true },
-      { value: "llama3.2", label: "Llama 3.2 (3B)" },
-      { value: "qwen2.5", label: "Qwen 2.5" },
-      { value: "mistral", label: "Mistral" },
-      { value: "deepseek-r1", label: "DeepSeek R1" },
+      { value: "llama3.3", label: "Llama 3.3 (70B)", recommended: true, input_cost: 0, output_cost: 0 },
+      { value: "llama3.2", label: "Llama 3.2 (3B)", input_cost: 0, output_cost: 0 },
+      { value: "qwen2.5", label: "Qwen 2.5", input_cost: 0, output_cost: 0 },
+      { value: "mistral", label: "Mistral", input_cost: 0, output_cost: 0 },
+      { value: "deepseek-r1", label: "DeepSeek R1", input_cost: 0, output_cost: 0 },
     ],
   },
   // Browser Providers
@@ -217,6 +233,21 @@ export const PROVIDERS = {
 
 export type ProviderId = keyof typeof PROVIDERS;
 
+/** Get cost per 1M tokens for a given provider + model. Returns { input_cost, output_cost, cache_creation_cost, cache_read_cost } in USD. */
+export function getModelCost(provider: string, model: string): { input_cost: number; output_cost: number; cache_creation_cost: number; cache_read_cost: number } {
+  const providerDef = PROVIDERS[provider as ProviderId];
+  if (!providerDef || !("models" in providerDef)) return { input_cost: 0, output_cost: 0, cache_creation_cost: 0, cache_read_cost: 0 };
+  const modelDef = (providerDef.models as ReadonlyArray<{ value: string; input_cost?: number; output_cost?: number; cache_creation_cost?: number; cache_read_cost?: number }>)
+    .find(m => m.value === model);
+  if (!modelDef) return { input_cost: 0, output_cost: 0, cache_creation_cost: 0, cache_read_cost: 0 };
+  return {
+    input_cost: modelDef.input_cost ?? 0,
+    output_cost: modelDef.output_cost ?? 0,
+    cache_creation_cost: modelDef.cache_creation_cost ?? 0,
+    cache_read_cost: modelDef.cache_read_cost ?? 0,
+  };
+}
+
 // Provider Keys Management
 export const ProviderKeys = {
   // Save an API key (encrypts before storing)

package/src/routes/api/agent-utils.ts

@@ -1,7 +1,7 @@
 import { spawn } from "bun";
 import { join } from "path";
 import { homedir } from "os";
-import { mkdirSync, existsSync, rmSync } from "fs";
+import { mkdirSync, existsSync, rmSync, writeFileSync, readFileSync } from "fs";
 import { agentProcesses, agentsStarting, getBinaryPathForAgent, getBinaryStatus, BIN_DIR, telemetryBroadcaster, isShuttingDown, type TelemetryEvent } from "../../server";
 import { AgentDB, McpServerDB, SkillDB, SubscriptionDB, TelemetryDB, generateId, getMultiAgentConfig, getOperatorConfig, type Agent, type Project } from "../../db";
 import { ProviderKeys, PROVIDERS, type ProviderId } from "../../providers";
@@ -337,7 +337,6 @@ export function buildAgentConfig(agent: Agent, providerKey: string) {
       const baseUrl = process.env.PUBLIC_URL || `http://localhost:${process.env.PORT || 4280}`;
       return {
         enabled: multiAgentConfig.enabled,
-        mode: multiAgentConfig.mode || "worker",
         group: multiAgentConfig.group || agent.project_id || undefined,
         // This agent's reachable URL for peer communication
         url: `http://localhost:${agent.port}`,
@@ -545,7 +544,9 @@ export async function startAgentProcess(
 
     // Build environment with provider key and agent API key
     // CONFIG_PATH ensures each agent has its own config file (prevents sharing)
+    // Remove stale persisted config — platform is source of truth and pushes fresh config after boot
     const agentConfigPath = join(agentDataDir, "agent-config.json");
+    rmSync(agentConfigPath, { force: true });
     const env: Record<string, string> = {
       ...process.env as Record<string, string>,
       PORT: String(port),
@@ -566,8 +567,19 @@ export async function startAgentProcess(
     // Get binary path dynamically (allows hot-reload of new binary versions)
     const binaryPath = getBinaryPathForAgent();
 
+    // Write VERSION file so the binary knows its version (ldflags not set in npm builds)
+    try {
+      const { dirname } = await import("path");
+      const pkgJsonPath = require.resolve("@apteva/agent-linux-x64/package.json");
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      if (pkg.version) {
+        writeFileSync(join(agentDataDir, "VERSION"), pkg.version);
+      }
+    } catch {}
+
     const proc = spawn({
       cmd: [binaryPath],
+      cwd: agentDataDir,
       env,
       stdout: "ignore",
       stderr: "ignore",
@@ -645,6 +657,15 @@ export async function startAgentProcess(
   }
 }
 
+// Strip legacy "mode" field from multi-agent config
+function cleanFeatures(features: Agent["features"]): Agent["features"] {
+  if (features.agents && typeof features.agents === "object") {
+    const { mode, ...rest } = features.agents as any;
+    return { ...features, agents: rest };
+  }
+  return features;
+}
+
 // Transform DB agent to API response format (camelCase for frontend compatibility)
 // Uses batch queries + light MCP loading (no decryption) for performance
 export function toApiAgent(agent: Agent) {
@@ -688,7 +709,7 @@ export function toApiAgent(agent: Agent) {
     systemPrompt: agent.system_prompt,
     status: agent.status,
     port: agent.port,
-    features: agent.features,
+    features: cleanFeatures(agent.features),
     mcpServers: agent.mcp_servers,
     mcpServerDetails,
     skills: agent.skills,
@@ -735,7 +756,7 @@ export function toApiAgentsBatch(agents: Agent[]) {
     return {
       id: agent.id, name: agent.name, model: agent.model, provider: agent.provider,
       systemPrompt: agent.system_prompt, status: agent.status, port: agent.port,
-      features: agent.features, mcpServers: agent.mcp_servers, mcpServerDetails,
+      features: cleanFeatures(agent.features), mcpServers: agent.mcp_servers, mcpServerDetails,
       skills: agent.skills, skillDetails, subscriptions, projectId: agent.project_id,
       createdAt: agent.created_at, updatedAt: agent.updated_at,
     };

package/src/routes/api/agents.ts

@@ -270,6 +270,25 @@ export async function handleAgentRoutes(
     });
   }
 
+  // ==================== SHARE LINK ====================
+
+  // GET /api/agents/:id/share-token - Get the share token for this agent
+  const shareTokenMatch = path.match(/^\/api\/agents\/([^/]+)\/share-token$/);
+  if (shareTokenMatch && method === "GET") {
+    const agent = AgentDB.findById(shareTokenMatch[1]);
+    if (!agent) {
+      return json({ error: "Agent not found" }, 404);
+    }
+
+    const { getShareToken } = await import("../share");
+    const token = getShareToken(agent.id);
+    if (!token) {
+      return json({ error: "Could not generate share token" }, 500);
+    }
+
+    return json({ token });
+  }
+
   // ==================== AGENT LIFECYCLE ====================
 
   // POST /api/agents/:id/start - Start an agent
@@ -840,7 +859,6 @@ export async function handleAgentRoutes(
           id: a.id,
           name: a.name,
           url: `http://localhost:${a.port}`,
-          mode: agentConfig.mode || "worker",
           group: agentConfig.group || a.project_id,
         };
       });

package/src/routes/api/meta-agent.ts

@@ -117,6 +117,8 @@ Be concise. Use markdown formatting.`,
         port: metaAgent.port,
         provider: metaAgent.provider,
         model: metaAgent.model,
+        features: metaAgent.features,
+        systemPrompt: metaAgent.system_prompt,
       },
     });
   }

package/src/routes/api/system.ts

@@ -1,5 +1,5 @@
 import { json } from "./helpers";
-import { META_AGENT_ENABLED, fetchFromAgent, startAgentProcess, setAgentStatus } from "./agent-utils";
+import { META_AGENT_ENABLED, fetchFromAgent, agentFetch, startAgentProcess, setAgentStatus } from "./agent-utils";
 import { AgentDB } from "../../db";
 import { ProviderKeys } from "../../providers";
 import { agentProcesses, getBinaryStatus, BIN_DIR } from "../../server";
@@ -44,6 +44,7 @@ export async function handleSystemRoutes(
     return json({
       projects: process.env.PROJECTS_ENABLED === "true",
       metaAgent: process.env.META_AGENT_ENABLED === "true",
+      costTracking: process.env.COST_TRACKING_ENABLED !== "false",
     });
   }
 
@@ -180,6 +181,94 @@ export async function handleSystemRoutes(
     return json({ task: { ...data, agentId: agent.id, agentName: agent.name } });
   }
 
+  // POST /api/tasks/:agentId/:taskId/execute - Execute a task immediately
+  const executeTaskMatch = path.match(/^\/api\/tasks\/([^/]+)\/([^/]+)\/execute$/);
+  if (executeTaskMatch && method === "POST") {
+    const [, agentId, taskId] = executeTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}/execute`, {
+        method: "POST",
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to execute task: ${err}` }, 500);
+    }
+  }
+
+  // POST /api/tasks/:agentId - Create a task on an agent
+  const createTaskMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+  if (createTaskMatch && method === "POST") {
+    const agentId = createTaskMatch[1];
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const body = await req.json();
+      const res = await agentFetch(agentId, agent.port, "/tasks", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data, 201);
+    } catch (err) {
+      return json({ error: `Failed to create task: ${err}` }, 500);
+    }
+  }
+
+  // PUT /api/tasks/:agentId/:taskId - Update a task on an agent
+  if (singleTaskMatch && method === "PUT") {
+    const [, agentId, taskId] = singleTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const body = await req.json();
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to update task: ${err}` }, 500);
+    }
+  }
+
+  // DELETE /api/tasks/:agentId/:taskId - Delete a task on an agent
+  if (singleTaskMatch && method === "DELETE") {
+    const [, agentId, taskId] = singleTaskMatch;
+    const agent = AgentDB.findById(agentId);
+    if (!agent) return json({ error: "Agent not found" }, 404);
+    if (agent.status !== "running" || !agent.port) return json({ error: "Agent is not running" }, 400);
+
+    try {
+      const res = await agentFetch(agentId, agent.port, `/tasks/${taskId}`, {
+        method: "DELETE",
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json();
+      if (!res.ok) return json({ error: data.error || `HTTP ${res.status}` }, res.status);
+      return json(data);
+    } catch (err) {
+      return json({ error: `Failed to delete task: ${err}` }, 500);
+    }
+  }
+
   // GET /api/dashboard - Get dashboard statistics
   if (path === "/api/dashboard" && method === "GET") {
     const url = new URL(req.url);

package/src/routes/api/telemetry.ts

@@ -1,5 +1,6 @@
 import { json } from "./helpers";
-import { TelemetryDB } from "../../db";
+import { TelemetryDB, AgentDB } from "../../db";
+import { getModelCost } from "../../providers";
 import { telemetryBroadcaster, type TelemetryEvent } from "../../server";
 
 export async function handleTelemetryRoutes(
@@ -33,8 +34,41 @@ export async function handleTelemetryRoutes(
         return json({ error: "agent_id and events are required" }, 400);
       }
 
+      // Debug: log raw incoming events
+      for (const event of body.events) {
+        if (event.category === "LLM") {
+          console.log(`[telemetry] RAW LLM event from ${body.agent_id}: ${JSON.stringify(event)}`);
+        }
+      }
+
       // Filter out debug events - too noisy
       const filteredEvents = body.events.filter(e => e.level !== "debug");
+
+      // Compute cost per LLM event if cost tracking is enabled
+      const costTrackingEnabled = process.env.COST_TRACKING_ENABLED !== "false";
+      if (costTrackingEnabled) {
+        const agent = AgentDB.findById(body.agent_id);
+        if (agent) {
+          const pricing = getModelCost(agent.provider, agent.model);
+          for (const event of filteredEvents) {
+            if (event.category === "LLM" && event.data) {
+              const inputTokens = (event.data.input_tokens as number) || 0;
+              const outputTokens = (event.data.output_tokens as number) || 0;
+              const cacheCreationTokens = (event.data.cache_creation_tokens as number) || 0;
+              const cacheReadTokens = (event.data.cache_read_tokens as number) || 0;
+              const reasoningTokens = (event.data.reasoning_tokens as number) || 0;
+              (event as any).cost = (
+                inputTokens * pricing.input_cost +
+                outputTokens * pricing.output_cost +
+                cacheCreationTokens * pricing.cache_creation_cost +
+                cacheReadTokens * pricing.cache_read_cost +
+                reasoningTokens * pricing.output_cost
+              ) / 1_000_000;
+            }
+          }
+        }
+      }
+
       const inserted = TelemetryDB.insertBatch(body.agent_id, filteredEvents);
 
       // Broadcast to SSE clients
@@ -116,7 +150,7 @@ export async function handleTelemetryRoutes(
       project_id: projectIdParam === "null" ? null : projectIdParam || undefined,
       since: url.searchParams.get("since") || undefined,
       until: url.searchParams.get("until") || undefined,
-      group_by: (url.searchParams.get("group_by") as "agent" | "day") || undefined,
+      group_by: (url.searchParams.get("group_by") as "agent" | "day" | "project") || undefined,
     });
     return json({ usage });
   }
@@ -129,6 +163,8 @@ export async function handleTelemetryRoutes(
     const stats = TelemetryDB.getStats({
       agentId,
       projectId: projectIdParam === "null" ? null : projectIdParam || undefined,
+      since: url.searchParams.get("since") || undefined,
+      until: url.searchParams.get("until") || undefined,
     });
     return json({ stats });
   }

package/src/routes/share.ts

@@ -0,0 +1,85 @@
+import { createHash } from "crypto";
+import { AgentDB, type Agent } from "../db";
+import { agentFetch } from "./api/agent-utils";
+
+function deriveShareToken(apiKey: string, agentId: string): string {
+  return createHash("sha256")
+    .update(apiKey + ":" + agentId + ":share")
+    .digest("hex")
+    .substring(0, 32);
+}
+
+function findAgentByShareToken(token: string): Agent | null {
+  const agents = AgentDB.findAll();
+  for (const agent of agents) {
+    const apiKey = AgentDB.getApiKey(agent.id);
+    if (!apiKey) continue;
+    if (deriveShareToken(apiKey, agent.id) === token) return agent;
+  }
+  return null;
+}
+
+/** Get the share token for an agent (used by API route for the UI) */
+export function getShareToken(agentId: string): string | null {
+  const apiKey = AgentDB.getApiKey(agentId);
+  if (!apiKey) return null;
+  return deriveShareToken(apiKey, agentId);
+}
+
+export async function handleShareRequest(req: Request, path: string): Promise<Response | null> {
+  // Match /share/<32 hex chars> sub-paths for API calls
+  const infoMatch = path.match(/^\/share\/([a-f0-9]{32})\/info$/);
+  const chatMatch = path.match(/^\/share\/([a-f0-9]{32})\/chat$/);
+
+  if (!infoMatch && !chatMatch) return null;
+
+  const token = (infoMatch || chatMatch)![1];
+  const agent = findAgentByShareToken(token);
+
+  // Intentionally vague 404 — don't reveal whether token exists
+  if (!agent) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  // GET /share/:token/info — agent info (no secrets)
+  if (infoMatch && req.method === "GET") {
+    return Response.json({
+      name: agent.name,
+      status: agent.status,
+    });
+  }
+
+  // POST /share/:token/chat — proxy to agent
+  if (chatMatch && req.method === "POST") {
+    if (agent.status !== "running" || !agent.port) {
+      return Response.json({ error: "Agent is currently offline" }, { status: 503 });
+    }
+
+    try {
+      const body = await req.json();
+      const response = await agentFetch(agent.id, agent.port, "/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return Response.json({ error: `Agent error: ${errorText}` }, { status: response.status });
+      }
+
+      return new Response(response.body, {
+        status: 200,
+        headers: {
+          "Content-Type": response.headers.get("Content-Type") || "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        },
+      });
+    } catch (err) {
+      return Response.json({ error: "Failed to connect to agent" }, { status: 500 });
+    }
+  }
+
+  return null;
+}