myaiforone 1.0.0

package/src/gemini-executor.ts

@@ -0,0 +1,212 @@
+/**
+ * Google Gemini executor — uses the Gemini REST API (generativelanguage.googleapis.com).
+ *
+ * Executor format: "gemini:gemini-2.5-flash", "gemini:gemini-2.5-pro", etc.
+ *
+ * Gemini's API differs from OpenAI's:
+ *   - Auth via API key in query string (not Bearer token)
+ *   - Different request/response schema (contents[], not messages[])
+ *   - Streaming uses SSE with different event shape
+ */
+
+import { log } from "./logger.js";
+
+const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+
+// ─── Options ────────────────────────────────────────────────────
+export interface GeminiOptions {
+  model: string;          // "gemini-2.5-flash", "gemini-2.5-pro", etc.
+  apiKey: string;
+  systemPrompt: string;
+  message: string;
+  timeout?: number;       // default: 300000 (5 min)
+  temperature?: number;   // default: 0.7
+  maxTokens?: number;     // default: 4096
+}
+
+// ─── Response types ─────────────────────────────────────────────
+interface GeminiResponse {
+  candidates?: Array<{
+    content: { parts: Array<{ text: string }>; role: string };
+    finishReason: string;
+  }>;
+  usageMetadata?: {
+    promptTokenCount: number;
+    candidatesTokenCount: number;
+    totalTokenCount: number;
+  };
+  error?: { code: number; message: string; status: string };
+}
+
+// ─── Execute (non-streaming) ────────────────────────────────────
+export async function executeGemini(opts: GeminiOptions): Promise<string> {
+  const timeout = opts.timeout || 300_000;
+
+  log.info(`[Gemini] Executing ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const url = `${GEMINI_BASE_URL}/models/${opts.model}:generateContent?key=${opts.apiKey}`;
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        system_instruction: {
+          parts: [{ text: opts.systemPrompt }],
+        },
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: opts.message }],
+          },
+        ],
+        generationConfig: {
+          temperature: opts.temperature ?? 0.7,
+          maxOutputTokens: opts.maxTokens ?? 4096,
+        },
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      log.error(`[Gemini] Error ${res.status}: ${errText}`);
+      try {
+        const errJson = JSON.parse(errText);
+        throw new Error(`Gemini API error ${res.status}: ${errJson.error?.message || errText}`);
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith("Gemini")) throw e;
+        throw new Error(`Gemini API error ${res.status}: ${errText}`);
+      }
+    }
+
+    const data = await res.json() as GeminiResponse;
+
+    if (data.error) {
+      throw new Error(`Gemini error: ${data.error.message}`);
+    }
+
+    const response = data.candidates?.[0]?.content?.parts
+      ?.map(p => p.text)
+      .join("") || "";
+
+    if (data.usageMetadata) {
+      log.debug(`[Gemini] ${opts.model} usage: ${data.usageMetadata.promptTokenCount}+${data.usageMetadata.candidatesTokenCount} tokens`);
+    }
+
+    log.info(`[Gemini] Response from ${opts.model}: ${response.slice(0, 200)}`);
+    return response;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Stream ─────────────────────────────────────────────────────
+export async function* streamGemini(opts: GeminiOptions): AsyncGenerator<string> {
+  const timeout = opts.timeout || 300_000;
+
+  log.info(`[Gemini] Streaming ${opts.model}: ${opts.message.slice(0, 200)}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const url = `${GEMINI_BASE_URL}/models/${opts.model}:streamGenerateContent?key=${opts.apiKey}&alt=sse`;
+
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        system_instruction: {
+          parts: [{ text: opts.systemPrompt }],
+        },
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: opts.message }],
+          },
+        ],
+        generationConfig: {
+          temperature: opts.temperature ?? 0.7,
+          maxOutputTokens: opts.maxTokens ?? 4096,
+        },
+      }),
+      signal: controller.signal,
+    });
+
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`Gemini API error ${res.status}: ${errText}`);
+    }
+
+    const reader = res.body?.getReader();
+    if (!reader) throw new Error("No response body");
+
+    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) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+
+        const jsonStr = trimmed.slice(6);
+        try {
+          const chunk = JSON.parse(jsonStr) as GeminiResponse;
+          const text = chunk.candidates?.[0]?.content?.parts
+            ?.map(p => p.text)
+            .join("");
+          if (text) {
+            yield text;
+          }
+        } catch { /* skip unparseable lines */ }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Health check ───────────────────────────────────────────────
+export async function checkGeminiHealth(
+  apiKey: string,
+  model?: string,
+): Promise<{ ok: boolean; error?: string; models?: string[] }> {
+  try {
+    const res = await fetch(
+      `${GEMINI_BASE_URL}/models?key=${apiKey}`,
+      { signal: AbortSignal.timeout(10_000) },
+    );
+
+    if (res.status === 400 || res.status === 403) {
+      return { ok: false, error: "Gemini: Invalid API key" };
+    }
+
+    if (!res.ok) {
+      return { ok: false, error: `Gemini: API returned ${res.status}` };
+    }
+
+    const data = await res.json() as { models?: Array<{ name: string; displayName: string }> };
+    const models = data.models
+      ?.map(m => m.name.replace("models/", ""))
+      .filter(m => m.startsWith("gemini")) || [];
+
+    if (model && !models.some(m => m === model || m.startsWith(model))) {
+      return { ok: false, error: `Model "${model}" not found. Available: ${models.slice(0, 10).join(", ")}` };
+    }
+
+    return { ok: true, models: models.slice(0, 20) };
+  } catch (err) {
+    return { ok: false, error: `Gemini: ${err}` };
+  }
+}

package/src/goals.ts

@@ -0,0 +1,240 @@
+import cron from "node-cron";
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { AppConfig, GoalConfig, McpServerConfig } from "./config.js";
+import type { InboundMessage } from "./channels/types.js";
+import type { ResolvedRoute } from "./router.js";
+import type { ChannelDriver } from "./channels/types.js";
+import { executeAgent } from "./executor.js";
+import { log } from "./logger.js";
+
+// ─── Budget tracking ─────────────────────────────────────────────────
+
+export interface BudgetState {
+  spent: number;
+  limit: number;
+  executions: number;
+}
+
+function todayKey(): string {
+  return new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+}
+
+export function budgetPath(agentHome: string, date?: string): string {
+  const goalsDir = join(agentHome, "goals");
+  return join(goalsDir, `budget-${date || todayKey()}.json`);
+}
+
+export function readBudget(agentHome: string, dailyLimit: number): BudgetState {
+  const path = budgetPath(agentHome);
+  if (!existsSync(path)) {
+    return { spent: 0, limit: dailyLimit, executions: 0 };
+  }
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8")) as BudgetState;
+    // Always use the configured limit (in case it changed)
+    data.limit = dailyLimit;
+    return data;
+  } catch {
+    return { spent: 0, limit: dailyLimit, executions: 0 };
+  }
+}
+
+export function writeBudget(agentHome: string, budget: BudgetState): void {
+  const goalsDir = join(agentHome, "goals");
+  mkdirSync(goalsDir, { recursive: true });
+  const path = budgetPath(agentHome);
+  writeFileSync(path, JSON.stringify(budget, null, 2));
+}
+
+export function isBudgetExhausted(budget: BudgetState): boolean {
+  return budget.spent >= budget.limit;
+}
+
+// ─── Goal log ────────────────────────────────────────────────────────
+
+function goalLogPath(agentHome: string): string {
+  const goalsDir = join(agentHome, "goals");
+  return join(goalsDir, `log-${todayKey()}.jsonl`);
+}
+
+function logGoalExecution(
+  agentHome: string,
+  goalId: string,
+  status: "executed" | "skipped-budget" | "error",
+  details?: Record<string, unknown>,
+): void {
+  const goalsDir = join(agentHome, "goals");
+  mkdirSync(goalsDir, { recursive: true });
+  const entry = {
+    ts: new Date().toISOString(),
+    goalId,
+    status,
+    ...details,
+  };
+  try {
+    appendFileSync(goalLogPath(agentHome), JSON.stringify(entry) + "\n");
+  } catch { /* ignore */ }
+}
+
+// ─── Goal prompt builder ─────────────────────────────────────────────
+
+export function buildGoalPrompt(goal: GoalConfig, budgetRemaining: number, budgetLimit: number): string {
+  const lines: string[] = [
+    `[AUTONOMOUS GOAL: ${goal.id}]`,
+    `Description: ${goal.description}`,
+  ];
+  if (goal.successCriteria) lines.push(`Success Criteria: ${goal.successCriteria}`);
+  if (goal.instructions) lines.push(`Instructions: ${goal.instructions}`);
+  lines.push(`Budget remaining today: $${budgetRemaining.toFixed(2)} of $${budgetLimit.toFixed(2)}`);
+  lines.push(`[/AUTONOMOUS GOAL]`);
+  lines.push("");
+  lines.push("Evaluate this goal. Take action if needed. Report what you did or found.");
+  return lines.join("\n");
+}
+
+// ─── Execute a single goal (used by cron and trigger endpoint) ───────
+
+export async function executeGoal(
+  agentId: string,
+  agent: AppConfig["agents"][string],
+  goal: GoalConfig,
+  baseDir: string,
+  driverMap: Map<string, ChannelDriver>,
+  mcpRegistry?: Record<string, McpServerConfig>,
+  claudeAccounts?: Record<string, string>,
+  globalDefaults?: { skills?: string[]; mcps?: string[]; prompts?: string[]; promptTrigger?: string },
+): Promise<{ status: string; response: string }> {
+  const agentHome = agent.agentHome || resolve(baseDir, agent.memoryDir, "..");
+
+  // Check budget
+  const dailyLimit = goal.budget?.maxDailyUsd ?? Infinity;
+  const budget = readBudget(agentHome, dailyLimit);
+
+  if (dailyLimit !== Infinity && isBudgetExhausted(budget)) {
+    logGoalExecution(agentHome, goal.id, "skipped-budget", {
+      spent: budget.spent,
+      limit: budget.limit,
+    });
+    return { status: "skipped-budget", response: `Budget exhausted ($${budget.spent.toFixed(2)}/$${budget.limit.toFixed(2)})` };
+  }
+
+  // Build the goal prompt
+  const budgetRemaining = dailyLimit === Infinity
+    ? Infinity
+    : Math.max(0, dailyLimit - budget.spent);
+  const prompt = buildGoalPrompt(goal, budgetRemaining, dailyLimit);
+
+  // Build synthetic message
+  const syntheticMsg: InboundMessage = {
+    id: `goal-${goal.id}-${Date.now()}`,
+    channel: "goals",
+    chatId: `goal-${goal.id}`,
+    chatType: "group",
+    sender: "goals-runner",
+    senderName: "Autonomous Goal",
+    text: prompt,
+    timestamp: Date.now(),
+    isFromMe: false,
+    isGroup: true,
+    raw: { type: "goal", goalId: goal.id },
+  };
+
+  const route: ResolvedRoute = {
+    agentId,
+    agentConfig: agent,
+    route: agent.routes[0],
+  };
+
+  // Execute the agent
+  const response = await executeAgent(route, syntheticMsg, baseDir, mcpRegistry, claudeAccounts, globalDefaults);
+
+  // Track cost
+  let cost = 0;
+  try {
+    const parsed = JSON.parse(response);
+    if (parsed.total_cost_usd) cost = parsed.total_cost_usd;
+  } catch { /* not JSON */ }
+
+  // Update budget
+  if (dailyLimit !== Infinity) {
+    budget.spent += cost;
+    budget.executions += 1;
+    writeBudget(agentHome, budget);
+  }
+
+  // Log execution
+  logGoalExecution(agentHome, goal.id, "executed", {
+    cost,
+    responseLength: response.length,
+  });
+
+  // Send report to channel(s) if configured
+  if (goal.reportTo) {
+    const targets = Array.isArray(goal.reportTo) ? goal.reportTo : [goal.reportTo];
+    for (const target of targets) {
+      const [channelName, ...chatIdParts] = target.split(":");
+      const chatId = chatIdParts.join(":");
+      const driver = driverMap.get(channelName);
+      if (driver && chatId) {
+        try {
+          const report = `[Goal: ${goal.id}]\n${response}`;
+          await driver.send({ text: report, chatId });
+        } catch (err) {
+          log.error(`Failed to send goal report for ${agentId}/${goal.id} to ${target}: ${err}`);
+        }
+      }
+    }
+  }
+
+  log.info(`Goal completed: ${agentId}/${goal.id} (${response.length} chars)`);
+  return { status: "executed", response };
+}
+
+// ─── Goals runner ────────────────────────────────────────────────────
+
+const activeTasks: cron.ScheduledTask[] = [];
+
+export function startGoals(
+  config: AppConfig,
+  driverMap: Map<string, ChannelDriver>,
+  baseDir: string,
+  mcpRegistry?: Record<string, McpServerConfig>,
+): void {
+  for (const [agentId, agent] of Object.entries(config.agents)) {
+    // Only agents that are autonomous-capable with enabled goals
+    if (agent.autonomousCapable === false) continue;
+    if (!agent.goals?.length) continue;
+
+    const agentHome = agent.agentHome || resolve(baseDir, agent.memoryDir, "..");
+
+    for (const goal of agent.goals) {
+      if (!goal.enabled) continue;
+
+      if (!cron.validate(goal.heartbeat)) {
+        log.error(`Invalid goal heartbeat for ${agentId}/${goal.id}: "${goal.heartbeat}"`);
+        continue;
+      }
+
+      const task = cron.schedule(goal.heartbeat, async () => {
+        log.info(`Goal heartbeat fired: ${agentId}/${goal.id}`);
+        try {
+          await executeGoal(agentId, agent, goal, baseDir, driverMap, mcpRegistry, config.service.claudeAccounts, { skills: config.defaultSkills, mcps: config.defaultMcps, prompts: config.defaultPrompts, promptTrigger: config.promptTrigger });
+        } catch (err) {
+          log.error(`Goal execution failed for ${agentId}/${goal.id}: ${err}`);
+          logGoalExecution(agentHome, goal.id, "error", { error: String(err) });
+        }
+      });
+
+      activeTasks.push(task);
+      log.info(`Goal scheduled: ${agentId}/${goal.id} — "${goal.heartbeat}" — ${goal.description.slice(0, 60)}`);
+    }
+  }
+}
+
+export function stopGoals(): void {
+  for (const task of activeTasks) {
+    task.stop();
+  }
+  activeTasks.length = 0;
+}