@elizaos/autonomous 2.0.0-alpha.72 → 2.0.0-alpha.73

package/src/api/bug-report-routes.ts

@@ -0,0 +1,161 @@
+import os from "node:os";
+import type { RouteRequestContext } from "./route-helpers";
+
+export const BUG_REPORT_REPO = "elizaos/eliza";
+const GITHUB_ISSUES_URL = `https://api.github.com/repos/${BUG_REPORT_REPO}/issues`;
+const GITHUB_NEW_ISSUE_URL = `https://github.com/${BUG_REPORT_REPO}/issues/new?template=bug_report.yml`;
+
+const BUG_REPORT_WINDOW_MS = 10 * 60 * 1000;
+const BUG_REPORT_MAX_SUBMISSIONS = 5;
+const bugReportAttempts = new Map<string, { count: number; resetAt: number }>();
+
+function sweepExpiredEntries(
+  map: Map<string, { count: number; resetAt: number }>,
+  now: number,
+  threshold: number,
+): void {
+  if (map.size <= threshold) return;
+  for (const [key, value] of map) {
+    if (now > value.resetAt) map.delete(key);
+  }
+}
+
+export function rateLimitBugReport(ip: string | null): boolean {
+  const key = ip ?? "unknown";
+  const now = Date.now();
+  sweepExpiredEntries(bugReportAttempts, now, 100);
+  const current = bugReportAttempts.get(key);
+  if (!current || now > current.resetAt) {
+    bugReportAttempts.set(key, {
+      count: 1,
+      resetAt: now + BUG_REPORT_WINDOW_MS,
+    });
+    return true;
+  }
+  if (current.count >= BUG_REPORT_MAX_SUBMISSIONS) return false;
+  current.count += 1;
+  return true;
+}
+
+export function resetBugReportRateLimit(): void {
+  bugReportAttempts.clear();
+}
+
+interface BugReportBody {
+  description: string;
+  stepsToReproduce: string;
+  expectedBehavior?: string;
+  actualBehavior?: string;
+  environment?: string;
+  nodeVersion?: string;
+  modelProvider?: string;
+  logs?: string;
+}
+
+export function sanitize(input: string, maxLen = 10_000): string {
+  return input.replace(/<[^>]*>/g, "").slice(0, maxLen);
+}
+
+function formatIssueBody(body: BugReportBody): string {
+  const sections: string[] = [];
+  sections.push(`### Description\n\n${sanitize(body.description)}`);
+  sections.push(`### Steps to Reproduce\n\n${sanitize(body.stepsToReproduce)}`);
+  if (body.expectedBehavior) {
+    sections.push(
+      `### Expected Behavior\n\n${sanitize(body.expectedBehavior)}`,
+    );
+  }
+  if (body.actualBehavior) {
+    sections.push(`### Actual Behavior\n\n${sanitize(body.actualBehavior)}`);
+  }
+  if (body.environment) {
+    sections.push(`### Environment\n\n${sanitize(body.environment, 200)}`);
+  }
+  if (body.nodeVersion) {
+    sections.push(`### Node Version\n\n${sanitize(body.nodeVersion, 200)}`);
+  }
+  if (body.modelProvider) {
+    sections.push(`### Model Provider\n\n${sanitize(body.modelProvider, 200)}`);
+  }
+  if (body.logs) {
+    sections.push(`### Logs\n\n\`\`\`\n${sanitize(body.logs, 50_000)}\n\`\`\``);
+  }
+  return sections.join("\n\n");
+}
+
+export async function handleBugReportRoutes(
+  ctx: RouteRequestContext,
+): Promise<boolean> {
+  const { req, res, method, pathname, json, error, readJsonBody } = ctx;
+
+  if (method === "GET" && pathname === "/api/bug-report/info") {
+    json(res, {
+      nodeVersion: process.version,
+      platform: os.platform(),
+    });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/bug-report") {
+    if (!rateLimitBugReport(req.socket.remoteAddress ?? null)) {
+      error(res, "Too many bug reports. Try again later.", 429);
+      return true;
+    }
+
+    const body = await readJsonBody<BugReportBody>(req, res);
+    if (!body) return true;
+
+    if (!body.description?.trim() || !body.stepsToReproduce?.trim()) {
+      error(res, "description and stepsToReproduce are required", 400);
+      return true;
+    }
+
+    const githubToken = process.env.GITHUB_TOKEN;
+    if (!githubToken) {
+      json(res, { fallback: GITHUB_NEW_ISSUE_URL });
+      return true;
+    }
+
+    try {
+      const sanitizedTitle = sanitize(body.description, 80).replace(
+        /[\r\n]+/g,
+        " ",
+      );
+      const issueBody = formatIssueBody(body);
+      const issueRes = await fetch(GITHUB_ISSUES_URL, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${githubToken}`,
+          Accept: "application/vnd.github.v3+json",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          title: `[Bug] ${sanitizedTitle}`,
+          body: issueBody,
+          labels: ["bug", "triage", "user-reported"],
+        }),
+      });
+
+      if (!issueRes.ok) {
+        error(res, `GitHub API error (${issueRes.status})`, 502);
+        return true;
+      }
+
+      const issueData = (await issueRes.json()) as { html_url?: string };
+      const url = issueData.html_url;
+      if (
+        typeof url !== "string" ||
+        !url.startsWith(`https://github.com/${BUG_REPORT_REPO}/issues/`)
+      ) {
+        error(res, "Unexpected response from GitHub API", 502);
+        return true;
+      }
+      json(res, { url });
+    } catch {
+      error(res, "Failed to create GitHub issue", 500);
+    }
+    return true;
+  }
+
+  return false;
+}

package/src/api/character-routes.ts

@@ -0,0 +1,421 @@
+import type { AgentRuntime } from "@elizaos/core";
+import { logger, ModelType } from "@elizaos/core";
+import type { RouteRequestContext } from "./route-helpers";
+
+interface CharacterGenerateContext {
+  name?: string;
+  system?: string;
+  bio?: string;
+  topics?: string[];
+  style?: { all?: string[]; chat?: string[]; post?: string[] };
+  postExamples?: string[];
+}
+
+type CharacterGenerateField =
+  | "bio"
+  | "system"
+  | "style"
+  | "chatExamples"
+  | "postExamples";
+type CharacterGenerateMode = "append" | "replace";
+
+interface AgentConfigLike {
+  id?: string;
+  default?: boolean;
+  name?: string;
+  bio?: string[];
+  system?: string;
+  adjectives?: string[];
+  topics?: string[];
+  style?: {
+    all?: string[];
+    chat?: string[];
+    post?: string[];
+  };
+  messageExamples?: unknown;
+  postExamples?: string[];
+}
+
+export interface AutonomousConfigLike {
+  agents?: {
+    list?: AgentConfigLike[];
+  };
+}
+
+interface CharacterParseIssueLike {
+  path: Array<string | number>;
+  message: string;
+}
+
+interface CharacterParseErrorLike {
+  issues: CharacterParseIssueLike[];
+}
+
+type CharacterValidationResult =
+  | { success: true }
+  | { success: false; error: CharacterParseErrorLike };
+
+export interface CharacterRouteState {
+  runtime: AgentRuntime | null;
+  agentName: string;
+  config?: AutonomousConfigLike;
+}
+
+export interface CharacterRouteContext extends RouteRequestContext {
+  state: CharacterRouteState;
+  pickRandomNames: (count: number) => string[];
+  saveConfig?: (config: AutonomousConfigLike) => void;
+  validateCharacter: (
+    body: Record<string, unknown>,
+  ) => CharacterValidationResult;
+}
+
+function syncRuntimeCharacterToConfig(
+  state: CharacterRouteState,
+  saveConfig?: (config: AutonomousConfigLike) => void,
+): void {
+  const runtime = state.runtime;
+  const config = state.config;
+  if (!runtime || !config) return;
+
+  if (!config.agents) config.agents = {};
+  const existingList = config.agents.list ?? [];
+  const primaryAgent: AgentConfigLike = existingList[0] ?? {
+    id: "main",
+    default: true,
+  };
+  const character = runtime.character;
+  const nextAgent: AgentConfigLike = {
+    ...primaryAgent,
+    ...(character.name ? { name: character.name } : {}),
+    ...(Array.isArray(character.bio) ? { bio: [...character.bio] } : {}),
+    ...(typeof character.system === "string"
+      ? { system: character.system }
+      : {}),
+    ...(Array.isArray(character.adjectives)
+      ? { adjectives: [...character.adjectives] }
+      : {}),
+    ...(Array.isArray((character as { topics?: string[] }).topics)
+      ? { topics: [...((character as { topics?: string[] }).topics ?? [])] }
+      : {}),
+    ...(character.style
+      ? {
+          style: {
+            ...(Array.isArray(character.style.all)
+              ? { all: [...character.style.all] }
+              : {}),
+            ...(Array.isArray(character.style.chat)
+              ? { chat: [...character.style.chat] }
+              : {}),
+            ...(Array.isArray(character.style.post)
+              ? { post: [...character.style.post] }
+              : {}),
+          },
+        }
+      : {}),
+    ...(Array.isArray(character.postExamples)
+      ? { postExamples: [...character.postExamples] }
+      : {}),
+    ...(Array.isArray(character.messageExamples)
+      ? {
+          messageExamples: JSON.parse(
+            JSON.stringify(character.messageExamples),
+          ),
+        }
+      : {}),
+  };
+
+  config.agents.list = [nextAgent, ...existingList.slice(1)];
+  saveConfig?.(config);
+}
+
+function buildCharacterSummary(ctx: CharacterGenerateContext): string {
+  return [
+    ctx.name ? `Name: ${ctx.name}` : "",
+    ctx.system ? `System prompt: ${ctx.system}` : "",
+    ctx.bio ? `Bio: ${ctx.bio}` : "",
+    ctx.topics?.length ? `Topics: ${ctx.topics.join(", ")}` : "",
+    ctx.style?.all?.length ? `Style rules: ${ctx.style.all.join("; ")}` : "",
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function buildGeneratePrompt(
+  field: CharacterGenerateField,
+  context: CharacterGenerateContext,
+  mode: CharacterGenerateMode | undefined,
+): string {
+  const charSummary = buildCharacterSummary(context);
+
+  if (field === "bio") {
+    return `Given this character:\n${charSummary}\n\nWrite a concise, compelling bio for this character (3-4 short paragraphs, one per line). Use their current interests and info to expand the bio into something more interesting and unique. Just output the bio lines, nothing else. Match the character's voice and personality.`;
+  }
+
+  if (field === "system") {
+    return `Given this character:\n${charSummary}\n\nWrite a system prompt that defines how this AI agent should behave. The system prompt should be written in first person, describing the agent's personality, communication style, and core behaviors. Include specific guidelines about tone, language style (formal/casual), and any unique quirks. Keep it concise but comprehensive (2-4 paragraphs). Just output the system prompt text, nothing else.`;
+  }
+
+  if (field === "style") {
+    const existing =
+      mode === "append" && context.style?.all?.length
+        ? `\nExisting style rules (add to these, don't repeat):\n${context.style.all.join("\n")}`
+        : "";
+    return `Given this character:\n${charSummary}${existing}\n\nGenerate 4-6 communication style rules for this character. Output a JSON object with keys "all", "chat", "post", each containing an array of short rule strings. Just output the JSON, nothing else.`;
+  }
+
+  if (field === "chatExamples") {
+    return `Given this character:\n${charSummary}\n\nGenerate 3 example chat conversations showing how this character responds. Output strict JSON only, with no markdown fences and no explanation. The JSON must be an array of conversation groups using this exact schema:\n[\n  {\n    "examples": [\n      { "name": "{{user1}}", "content": { "text": "..." } },\n      { "name": "${context.name?.trim() || "{{agentName}}"}", "content": { "text": "..." } }\n    ]\n  }\n]\n\nEach conversation should contain 2-4 turns. Use the "name" field, not "user" or "role". Use content.text strings only.`;
+  }
+
+  const existing =
+    mode === "append" && context.postExamples?.length
+      ? `\nExisting posts (add new ones, don't repeat):\n${context.postExamples.join("\n")}`
+      : "";
+  return `Given this character:\n${charSummary}${existing}\n\nGenerate 3-5 example social media posts this character would write. Output a JSON array of strings. Just output the JSON array, nothing else.`;
+}
+
+const CHARACTER_SCHEMA_FIELDS = [
+  {
+    key: "name",
+    type: "string",
+    label: "Name",
+    description: "Agent display name",
+    maxLength: 100,
+  },
+  {
+    key: "username",
+    type: "string",
+    label: "Username",
+    description: "Agent username for platforms",
+    maxLength: 50,
+  },
+  {
+    key: "bio",
+    type: "string | string[]",
+    label: "Bio",
+    description: "Biography — single string or array of points",
+  },
+  {
+    key: "system",
+    type: "string",
+    label: "System Prompt",
+    description: "System prompt defining core behavior",
+    maxLength: 10000,
+  },
+  {
+    key: "adjectives",
+    type: "string[]",
+    label: "Adjectives",
+    description: "Personality adjectives (e.g. curious, witty)",
+  },
+  {
+    key: "topics",
+    type: "string[]",
+    label: "Topics",
+    description: "Conversation topics the agent is knowledgeable about",
+  },
+  {
+    key: "style",
+    type: "object",
+    label: "Style",
+    description: "Communication style guides",
+    children: [
+      {
+        key: "all",
+        type: "string[]",
+        label: "All",
+        description: "Style guidelines for all responses",
+      },
+      {
+        key: "chat",
+        type: "string[]",
+        label: "Chat",
+        description: "Style guidelines for chat responses",
+      },
+      {
+        key: "post",
+        type: "string[]",
+        label: "Post",
+        description: "Style guidelines for social media posts",
+      },
+    ],
+  },
+  {
+    key: "messageExamples",
+    type: "array",
+    label: "Message Examples",
+    description: "Example conversations demonstrating the agent's voice",
+  },
+  {
+    key: "postExamples",
+    type: "string[]",
+    label: "Post Examples",
+    description: "Example social media posts",
+  },
+] as const;
+
+export async function handleCharacterRoutes(
+  ctx: CharacterRouteContext,
+): Promise<boolean> {
+  const {
+    req,
+    res,
+    method,
+    pathname,
+    state,
+    saveConfig,
+    readJsonBody,
+    json,
+    error,
+    pickRandomNames,
+    validateCharacter,
+  } = ctx;
+
+  if (method === "GET" && pathname === "/api/character") {
+    const runtime = state.runtime;
+    const merged: Record<string, unknown> = {};
+    if (runtime) {
+      const character = runtime.character;
+      if (character.name) merged.name = character.name;
+      if (character.username) merged.username = character.username;
+      if (character.bio) merged.bio = character.bio;
+      if (character.system) merged.system = character.system;
+      if (character.adjectives) merged.adjectives = character.adjectives;
+      if (Array.isArray((character as { topics?: string[] }).topics)) {
+        merged.topics = (character as { topics?: string[] }).topics;
+      }
+      if (character.style) merged.style = character.style;
+      if (character.messageExamples) {
+        merged.messageExamples = character.messageExamples;
+      }
+      if (character.postExamples) {
+        merged.postExamples = character.postExamples;
+      }
+    }
+
+    json(res, { character: merged, agentName: state.agentName });
+    return true;
+  }
+
+  if (method === "PUT" && pathname === "/api/character") {
+    const body = await readJsonBody<Record<string, unknown>>(req, res);
+    if (!body) return true;
+
+    const result = validateCharacter(body);
+    if (!result.success && "error" in result) {
+      const issues = result.error.issues.map((issue) => ({
+        path: issue.path.join("."),
+        message: issue.message,
+      }));
+      json(res, { ok: false, validationErrors: issues }, 422);
+      return true;
+    }
+
+    if (state.runtime) {
+      const character = state.runtime.character;
+      if (body.name != null) character.name = String(body.name);
+      if (body.username != null) character.username = String(body.username);
+      if (body.bio != null) {
+        character.bio = Array.isArray(body.bio)
+          ? (body.bio as string[])
+          : [String(body.bio)];
+      }
+      if (body.system != null) character.system = String(body.system);
+      if (body.adjectives != null) {
+        character.adjectives = body.adjectives as string[];
+      }
+      if (body.topics != null) {
+        (character as { topics?: string[] }).topics = body.topics as string[];
+      }
+      if (body.style != null) {
+        character.style = body.style as NonNullable<typeof character.style>;
+      }
+      if (body.messageExamples != null) {
+        character.messageExamples = body.messageExamples as NonNullable<
+          typeof character.messageExamples
+        >;
+      }
+      if (body.postExamples != null) {
+        character.postExamples = body.postExamples as string[];
+      }
+    }
+
+    try {
+      syncRuntimeCharacterToConfig(state, saveConfig);
+    } catch (err) {
+      error(
+        res,
+        err instanceof Error
+          ? `Failed to persist character: ${err.message}`
+          : "Failed to persist character",
+        500,
+      );
+      return true;
+    }
+
+    if (body.name) state.agentName = String(body.name);
+    json(res, { ok: true, character: body, agentName: state.agentName });
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/character/random-name") {
+    const names = pickRandomNames(1);
+    json(res, { name: names[0] ?? "Reimu" });
+    return true;
+  }
+
+  if (method === "POST" && pathname === "/api/character/generate") {
+    const body = await readJsonBody<{
+      field: CharacterGenerateField;
+      context: CharacterGenerateContext;
+      mode?: CharacterGenerateMode;
+    }>(req, res);
+    if (!body) return true;
+
+    if (!body.field || !body.context) {
+      error(res, "field and context are required", 400);
+      return true;
+    }
+
+    const runtime = state.runtime;
+    if (!runtime) {
+      error(res, "Agent runtime not available. Start the agent first.", 503);
+      return true;
+    }
+
+    if (
+      body.field !== "bio" &&
+      body.field !== "system" &&
+      body.field !== "style" &&
+      body.field !== "chatExamples" &&
+      body.field !== "postExamples"
+    ) {
+      error(res, `Unknown field: ${body.field}`, 400);
+      return true;
+    }
+
+    const prompt = buildGeneratePrompt(body.field, body.context, body.mode);
+
+    try {
+      const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt,
+        temperature: 0.8,
+        maxTokens: 1500,
+      });
+      json(res, { generated: String(result) });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "generation failed";
+      logger.error(`[character-generate] ${message}`);
+      error(res, message, 500);
+    }
+    return true;
+  }
+
+  if (method === "GET" && pathname === "/api/character/schema") {
+    json(res, { fields: CHARACTER_SCHEMA_FIELDS });
+    return true;
+  }
+
+  return false;
+}