@moltium/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1631 @@
+// src/logger.ts
+import winston from "winston";
+var logLevel = process.env.LOG_LEVEL || "info";
+function createLogger(label) {
+  return winston.createLogger({
+    level: logLevel,
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.label({ label }),
+      winston.format.printf(({ timestamp, level, label: label2, message, ...meta }) => {
+        const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+        return `${timestamp} [${label2}] ${level}: ${message}${metaStr}`;
+      })
+    ),
+    transports: [new winston.transports.Console()]
+  });
+}
+
+// src/agent/scheduler.ts
+var logger = createLogger("Scheduler");
+var Scheduler = class {
+  jobs = [];
+  timers = /* @__PURE__ */ new Map();
+  running = false;
+  addJob(job) {
+    this.jobs.push(job);
+    logger.debug(`Job registered: ${job.name} (every ${job.intervalMs}ms)`);
+  }
+  removeJob(name) {
+    this.jobs = this.jobs.filter((j) => j.name !== name);
+    const timer = this.timers.get(name);
+    if (timer) {
+      clearInterval(timer);
+      this.timers.delete(name);
+    }
+  }
+  start() {
+    if (this.running) return;
+    this.running = true;
+    for (const job of this.jobs) {
+      const timer = setInterval(async () => {
+        try {
+          logger.debug(`Running job: ${job.name}`);
+          await job.handler();
+          job.lastRun = Date.now();
+        } catch (error) {
+          logger.error(`Job failed: ${job.name}`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }, job.intervalMs);
+      this.timers.set(job.name, timer);
+    }
+    logger.info(`Scheduler started with ${this.jobs.length} jobs`);
+  }
+  stop() {
+    this.running = false;
+    for (const [name, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+    logger.info("Scheduler stopped");
+  }
+  isRunning() {
+    return this.running;
+  }
+  getJobs() {
+    return [...this.jobs];
+  }
+};
+
+// src/actions/registry.ts
+var ActionRegistry = class {
+  actions = /* @__PURE__ */ new Map();
+  register(action) {
+    if (this.actions.has(action.name)) {
+      throw new Error(`Action "${action.name}" is already registered`);
+    }
+    this.actions.set(action.name, action);
+  }
+  unregister(name) {
+    this.actions.delete(name);
+  }
+  get(name) {
+    return this.actions.get(name);
+  }
+  has(name) {
+    return this.actions.has(name);
+  }
+  list() {
+    return Array.from(this.actions.values());
+  }
+  listNames() {
+    return Array.from(this.actions.keys());
+  }
+};
+
+// src/actions/ActionHandler.ts
+var logger2 = createLogger("ActionHandler");
+var ActionExecutionError = class extends Error {
+  constructor(message, actionName, recoverable = true) {
+    super(message);
+    this.actionName = actionName;
+    this.recoverable = recoverable;
+    this.name = "ActionExecutionError";
+  }
+};
+var ActionHandler = class {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async execute(actionName, context) {
+    const action = this.registry.get(actionName);
+    if (!action) {
+      throw new ActionExecutionError(
+        `Action "${actionName}" not found in registry`,
+        actionName,
+        false
+      );
+    }
+    logger2.info(`Executing action: ${actionName}`);
+    try {
+      const result = await action.execute(context);
+      logger2.info(`Action completed: ${actionName}`, { success: result.success });
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger2.error(`Action failed: ${actionName}`, { error: message });
+      throw new ActionExecutionError(
+        `Action "${actionName}" failed: ${message}`,
+        actionName
+      );
+    }
+  }
+  getAvailableActions() {
+    return this.registry.list().map((action) => ({
+      name: action.name,
+      description: action.description
+    }));
+  }
+};
+
+// src/actions/built-in/social.ts
+var postSocialUpdateAction = {
+  name: "post_social_update",
+  description: "Post a status update to configured social platforms",
+  async execute(context) {
+    const { content, platforms } = context.parameters;
+    if (!content) {
+      return { success: false, error: "Missing required parameter: content" };
+    }
+    const results = {};
+    const socialAdapters = context.agent?.socialAdapters || {};
+    const targetPlatforms = platforms || Object.keys(socialAdapters);
+    for (const platform of targetPlatforms) {
+      const adapter = socialAdapters[platform];
+      if (!adapter) continue;
+      try {
+        const result = await adapter.post(content);
+        results[platform] = result;
+      } catch (error) {
+        results[platform] = {
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+    return { success: true, data: results };
+  }
+};
+var respondToMentionAction = {
+  name: "respond_to_mention",
+  description: "Respond to a social platform mention",
+  async execute(context) {
+    const { mentionId, content, platform } = context.parameters;
+    if (!mentionId || !content || !platform) {
+      return { success: false, error: "Missing required parameters: mentionId, content, platform" };
+    }
+    const adapter = context.agent?.socialAdapters?.[platform];
+    if (!adapter) {
+      return { success: false, error: `No adapter configured for platform: ${platform}` };
+    }
+    const result = await adapter.reply(mentionId, content);
+    return { success: true, data: result };
+  }
+};
+var dmUserAction = {
+  name: "dm_user",
+  description: "Send a direct message to a user on a social platform",
+  async execute(context) {
+    const { userId, content, platform } = context.parameters;
+    if (!userId || !content || !platform) {
+      return { success: false, error: "Missing required parameters: userId, content, platform" };
+    }
+    return {
+      success: false,
+      error: `DM not yet implemented for platform: ${platform}`
+    };
+  }
+};
+var scheduleTaskAction = {
+  name: "schedule_task",
+  description: "Schedule a task for later execution",
+  async execute(context) {
+    const { taskName, delay, parameters } = context.parameters;
+    if (!taskName || delay === void 0) {
+      return { success: false, error: "Missing required parameters: taskName, delay" };
+    }
+    const scheduledTask = {
+      taskName,
+      executeAt: Date.now() + delay * 1e3,
+      parameters: parameters || {}
+    };
+    await context.memory.store(`scheduled:${taskName}:${Date.now()}`, scheduledTask);
+    return { success: true, data: scheduledTask };
+  }
+};
+
+// src/actions/built-in/index.ts
+var builtInActions = [
+  postSocialUpdateAction,
+  respondToMentionAction,
+  dmUserAction,
+  scheduleTaskAction
+];
+
+// src/llm/prompt.ts
+function buildSystemPrompt(config) {
+  const parts = [];
+  parts.push(`You are ${config.name}, an autonomous AI agent.`);
+  if (config.type) {
+    parts.push(`Your role: ${config.type}.`);
+  }
+  if (config.personality.bio) {
+    parts.push(`
+Background:
+${config.personality.bio}`);
+  }
+  if (config.personality.traits.length > 0) {
+    parts.push(`
+Personality traits: ${config.personality.traits.join(", ")}`);
+  }
+  if (config.llm.systemPrompt) {
+    parts.push(`
+${config.llm.systemPrompt}`);
+  }
+  return parts.join("\n");
+}
+function buildDecisionPrompt(context, availableActions) {
+  const actionList = availableActions.map((a) => `- ${a.name}: ${a.description}`).join("\n");
+  return `Given the current context, decide what action to take next.
+
+Available actions:
+${actionList}
+
+Current context:
+${JSON.stringify(context, null, 2)}
+
+Respond with a JSON object:
+{
+  "action": "<action_name>",
+  "reasoning": "<brief explanation>",
+  "parameters": { <any parameters for the action> }
+}`;
+}
+function buildSkillPrompt(skillName, skillDescription, parameters) {
+  return `Execute the following skill: ${skillName}
+
+Instructions:
+${skillDescription}
+
+Parameters:
+${JSON.stringify(parameters, null, 2)}
+
+Execute these instructions step by step and return the result as a JSON object:
+{
+  "success": true/false,
+  "data": { <result data> },
+  "reasoning": "<what you did and why>"
+}`;
+}
+
+// src/actions/interpreter.ts
+var logger3 = createLogger("MarkdownInterpreter");
+var LLMInterpretationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LLMInterpretationError";
+  }
+};
+function createMarkdownAction(name, description, llmProvider) {
+  return {
+    name,
+    description,
+    execute: async (context) => {
+      logger3.info(`Interpreting markdown skill: ${name}`);
+      const prompt = buildSkillPrompt(name, description, context.parameters);
+      try {
+        const response = await llmProvider.generateText(prompt, {
+          temperature: 0.7,
+          maxTokens: 2048
+        });
+        const jsonMatch = response.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+          throw new LLMInterpretationError(
+            `LLM did not return valid JSON for skill "${name}"`
+          );
+        }
+        const result = JSON.parse(jsonMatch[0]);
+        return {
+          success: result.success ?? true,
+          data: result.data || result
+        };
+      } catch (error) {
+        if (error instanceof LLMInterpretationError) throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        logger3.error(`Markdown skill interpretation failed: ${name}`, { error: message });
+        throw new LLMInterpretationError(
+          `Failed to interpret skill "${name}": ${message}`
+        );
+      }
+    }
+  };
+}
+
+// src/memory/Memory.ts
+var Memory = class {
+};
+
+// src/memory/shortterm.ts
+var ShortTermMemory = class extends Memory {
+  cache = /* @__PURE__ */ new Map();
+  store_ = /* @__PURE__ */ new Map();
+  experiences = [];
+  async remember(key, value, ttl) {
+    this.cache.set(key, {
+      value,
+      expiresAt: ttl ? Date.now() + ttl * 1e3 : void 0
+    });
+  }
+  async recall(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  async forget(key) {
+    this.cache.delete(key);
+  }
+  async store(key, value) {
+    this.store_.set(key, value);
+  }
+  async retrieve(key) {
+    return this.store_.get(key);
+  }
+  async delete(key) {
+    this.store_.delete(key);
+  }
+  async addExperience(experience) {
+    this.experiences.push(experience);
+  }
+  async queryExperiences(query, limit = 10) {
+    const queryLower = query.toLowerCase();
+    return this.experiences.filter(
+      (exp) => exp.type.toLowerCase().includes(queryLower) || exp.action.toLowerCase().includes(queryLower)
+    ).slice(-limit);
+  }
+  async clear() {
+    this.cache.clear();
+    this.store_.clear();
+    this.experiences = [];
+  }
+};
+
+// src/llm/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/llm/Provider.ts
+var LLMProvider = class {
+};
+
+// src/llm/anthropic.ts
+var AnthropicProvider = class extends LLMProvider {
+  name = "anthropic";
+  client;
+  model;
+  constructor(apiKey, model = "claude-sonnet-4-20250514") {
+    super();
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+  async generateText(prompt, options) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options?.maxTokens || 2048,
+      messages: [{ role: "user", content: prompt }],
+      ...options?.systemPrompt ? { system: options.systemPrompt } : {},
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...options?.stopSequences ? { stop_sequences: options.stopSequences } : {}
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    return textBlock ? textBlock.text : "";
+  }
+  async generateStructured(prompt, schema, options) {
+    const structuredPrompt = `${prompt}
+
+Respond with a JSON object matching this schema:
+${JSON.stringify(schema, null, 2)}
+
+Respond with valid JSON only, no other text.`;
+    const text = await this.generateText(structuredPrompt, options);
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("LLM did not return valid JSON");
+    }
+    return JSON.parse(jsonMatch[0]);
+  }
+  async chat(messages, options) {
+    const systemMessages = messages.filter((m) => m.role === "system");
+    const chatMessages = messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: m.content }));
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options?.maxTokens || 2048,
+      messages: chatMessages,
+      ...systemMessages.length > 0 ? { system: systemMessages.map((m) => m.content).join("\n") } : {},
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    return { role: "assistant", content: textBlock ? textBlock.text : "" };
+  }
+  async *streamGenerate(prompt, options) {
+    const stream = this.client.messages.stream({
+      model: this.model,
+      max_tokens: options?.maxTokens || 2048,
+      messages: [{ role: "user", content: prompt }],
+      ...options?.systemPrompt ? { system: options.systemPrompt } : {},
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+    });
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield event.delta.text;
+      }
+    }
+  }
+};
+
+// src/llm/openai.ts
+import OpenAI from "openai";
+var OpenAIProvider = class extends LLMProvider {
+  name = "openai";
+  client;
+  model;
+  constructor(apiKey, model = "gpt-4o") {
+    super();
+    this.client = new OpenAI({ apiKey });
+    this.model = model;
+  }
+  async generateText(prompt, options) {
+    const messages = [];
+    if (options?.systemPrompt) {
+      messages.push({ role: "system", content: options.systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      max_tokens: options?.maxTokens || 2048,
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {},
+      ...options?.stopSequences ? { stop: options.stopSequences } : {}
+    });
+    return response.choices[0]?.message?.content || "";
+  }
+  async generateStructured(prompt, schema, options) {
+    const structuredPrompt = `${prompt}
+
+Respond with a JSON object matching this schema:
+${JSON.stringify(schema, null, 2)}
+
+Respond with valid JSON only, no other text.`;
+    const text = await this.generateText(structuredPrompt, options);
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("LLM did not return valid JSON");
+    }
+    return JSON.parse(jsonMatch[0]);
+  }
+  async chat(messages, options) {
+    const openaiMessages = messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: openaiMessages,
+      max_tokens: options?.maxTokens || 2048,
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+    });
+    return { role: "assistant", content: response.choices[0]?.message?.content || "" };
+  }
+  async *streamGenerate(prompt, options) {
+    const messages = [];
+    if (options?.systemPrompt) {
+      messages.push({ role: "system", content: options.systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt });
+    const stream = await this.client.chat.completions.create({
+      model: this.model,
+      messages,
+      max_tokens: options?.maxTokens || 2048,
+      stream: true,
+      ...options?.temperature !== void 0 ? { temperature: options.temperature } : {}
+    });
+    for await (const chunk of stream) {
+      const delta = chunk.choices[0]?.delta?.content;
+      if (delta) yield delta;
+    }
+  }
+};
+
+// src/social/moltbook.ts
+import axios from "axios";
+
+// src/social/SocialAdapter.ts
+var SocialAdapter = class {
+};
+
+// src/social/moltbook.ts
+var MoltbookAdapter = class extends SocialAdapter {
+  platform = "moltbook";
+  client;
+  config;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.client = axios.create({
+      baseURL: config.baseUrl || "https://api.moltbook.com",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async connect() {
+    await this.client.get("/me");
+  }
+  async disconnect() {
+  }
+  async post(content) {
+    const response = await this.client.post("/posts", { content });
+    return {
+      id: response.data.id,
+      url: response.data.url,
+      timestamp: new Date(response.data.created_at)
+    };
+  }
+  async reply(postId, content) {
+    const response = await this.client.post(`/posts/${postId}/replies`, { content });
+    return {
+      id: response.data.id,
+      parentId: postId,
+      url: response.data.url,
+      timestamp: new Date(response.data.created_at)
+    };
+  }
+  async like(postId) {
+    await this.client.post(`/posts/${postId}/like`);
+  }
+  async follow(userId) {
+    await this.client.post(`/users/${userId}/follow`);
+  }
+  async getMentions() {
+    const response = await this.client.get("/mentions");
+    return response.data.mentions.map((m) => ({
+      id: m.id,
+      authorId: m.author_id,
+      authorName: m.author_name,
+      content: m.content,
+      timestamp: new Date(m.created_at),
+      platform: "moltbook"
+    }));
+  }
+  async getFeed(options) {
+    const params = {};
+    if (options?.limit) params.limit = options.limit;
+    if (options?.cursor) params.cursor = options.cursor;
+    if (options?.since) params.since = options.since.toISOString();
+    const response = await this.client.get("/feed", { params });
+    return response.data.posts.map((p) => ({
+      id: p.id,
+      authorId: p.author_id,
+      authorName: p.author_name,
+      content: p.content,
+      timestamp: new Date(p.created_at),
+      platform: "moltbook",
+      likes: p.likes_count,
+      replies: p.replies_count,
+      reposts: p.reposts_count,
+      mentions: p.mentions || [],
+      url: p.url
+    }));
+  }
+  async getProfile(userId) {
+    const response = await this.client.get(`/users/${userId}`);
+    return {
+      id: response.data.id,
+      name: response.data.name,
+      bio: response.data.bio,
+      followers: response.data.followers_count,
+      following: response.data.following_count,
+      platform: "moltbook"
+    };
+  }
+};
+
+// src/social/twitter.ts
+var TwitterAdapter = class extends SocialAdapter {
+  platform = "twitter";
+  config;
+  client;
+  // twitter-api-v2 client
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  async connect() {
+    const { TwitterApi } = await import("twitter-api-v2");
+    this.client = new TwitterApi({
+      appKey: this.config.credentials.apiKey,
+      appSecret: this.config.credentials.apiSecret,
+      accessToken: this.config.credentials.accessToken,
+      accessSecret: this.config.credentials.accessSecret
+    });
+    await this.client.v2.me();
+  }
+  async disconnect() {
+    this.client = null;
+  }
+  async post(content) {
+    const tweet = await this.client.v2.tweet(content);
+    return {
+      id: tweet.data.id,
+      url: `https://twitter.com/i/status/${tweet.data.id}`,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async reply(tweetId, content) {
+    const tweet = await this.client.v2.reply(content, tweetId);
+    return {
+      id: tweet.data.id,
+      parentId: tweetId,
+      url: `https://twitter.com/i/status/${tweet.data.id}`,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async like(tweetId) {
+    const me = await this.client.v2.me();
+    await this.client.v2.like(me.data.id, tweetId);
+  }
+  async follow(userId) {
+    const me = await this.client.v2.me();
+    await this.client.v2.follow(me.data.id, userId);
+  }
+  async getMentions() {
+    const me = await this.client.v2.me();
+    const mentions = await this.client.v2.userMentionTimeline(me.data.id, {
+      max_results: 20,
+      expansions: ["author_id"],
+      "tweet.fields": ["created_at"],
+      "user.fields": ["name", "username"]
+    });
+    const users = /* @__PURE__ */ new Map();
+    if (mentions.includes?.users) {
+      for (const user of mentions.includes.users) {
+        users.set(user.id, user.username);
+      }
+    }
+    return (mentions.data?.data || []).map((tweet) => ({
+      id: tweet.id,
+      authorId: tweet.author_id,
+      authorName: users.get(tweet.author_id) || "unknown",
+      content: tweet.text,
+      timestamp: new Date(tweet.created_at),
+      platform: "twitter"
+    }));
+  }
+  async getFeed(options) {
+    const me = await this.client.v2.me();
+    const timeline = await this.client.v2.userTimeline(me.data.id, {
+      max_results: options?.limit || 20,
+      "tweet.fields": ["created_at", "public_metrics"]
+    });
+    return (timeline.data?.data || []).map((tweet) => ({
+      id: tweet.id,
+      authorId: me.data.id,
+      authorName: me.data.username,
+      content: tweet.text,
+      timestamp: new Date(tweet.created_at),
+      platform: "twitter",
+      likes: tweet.public_metrics?.like_count,
+      replies: tweet.public_metrics?.reply_count,
+      reposts: tweet.public_metrics?.retweet_count
+    }));
+  }
+  async getProfile(userId) {
+    const user = await this.client.v2.user(userId, {
+      "user.fields": ["description", "public_metrics"]
+    });
+    return {
+      id: user.data.id,
+      name: user.data.name,
+      bio: user.data.description,
+      followers: user.data.public_metrics?.followers_count,
+      following: user.data.public_metrics?.following_count,
+      platform: "twitter"
+    };
+  }
+};
+
+// src/agent/Agent.ts
+var logger4 = createLogger("Agent");
+var Agent = class {
+  config;
+  state = "idle";
+  llm;
+  memory_;
+  scheduler;
+  actionRegistry;
+  actionHandler;
+  hooks = {};
+  tickTimer;
+  systemPrompt;
+  socialAdapters = {};
+  constructor(config, hooks) {
+    this.config = config;
+    this.hooks = hooks || {};
+    this.memory_ = new ShortTermMemory();
+    this.scheduler = new Scheduler();
+    this.actionRegistry = new ActionRegistry();
+    this.actionHandler = new ActionHandler(this.actionRegistry);
+    this.systemPrompt = buildSystemPrompt(config);
+  }
+  get name() {
+    return this.config.name;
+  }
+  getState() {
+    return this.state;
+  }
+  getMemory() {
+    return this.memory_;
+  }
+  getLLM() {
+    return this.llm;
+  }
+  getActionRegistry() {
+    return this.actionRegistry;
+  }
+  // ── Configuration Methods ──
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  appendSystemPrompt(additional) {
+    this.systemPrompt += "\n\n" + additional;
+  }
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  setHooks(hooks) {
+    this.hooks = hooks;
+  }
+  mergeHooks(hooks) {
+    this.hooks = { ...this.hooks, ...hooks };
+  }
+  setMemory(memory) {
+    this.memory_ = memory;
+  }
+  async preloadMemory(entries) {
+    for (const [key, value] of Object.entries(entries)) {
+      await this.memory_.remember(key, value);
+    }
+  }
+  registerAction(action) {
+    this.actionRegistry.register(action);
+  }
+  // ── Lifecycle ──
+  async init() {
+    this.state = "initializing";
+    logger4.info(`Initializing agent: ${this.config.name}`);
+    this.initLLM();
+    this.registerActions();
+    await this.initSocialAdapters();
+    if (this.hooks.onInit) {
+      await this.hooks.onInit(this);
+    }
+    logger4.info(`Agent initialized: ${this.config.name}`);
+  }
+  async start() {
+    if (this.state !== "initializing" && this.state !== "idle") {
+      throw new Error(`Cannot start agent in state: ${this.state}`);
+    }
+    if (this.state === "idle") {
+      await this.init();
+    }
+    this.state = "running";
+    logger4.info(`Agent started: ${this.config.name}`);
+    if (this.hooks.onStart) {
+      await this.hooks.onStart(this);
+    }
+    this.scheduler.start();
+    if (this.config.behaviors.autonomous) {
+      this.startAutonomousLoop();
+    }
+  }
+  async stop() {
+    this.state = "stopping";
+    logger4.info(`Stopping agent: ${this.config.name}`);
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = void 0;
+    }
+    this.scheduler.stop();
+    for (const adapter of Object.values(this.socialAdapters)) {
+      await adapter.disconnect();
+    }
+    if (this.hooks.onShutdown) {
+      await this.hooks.onShutdown(this);
+    }
+    this.state = "stopped";
+    logger4.info(`Agent stopped: ${this.config.name}`);
+  }
+  // ── Decision Loop ──
+  async think() {
+    const context = await this.gatherContext();
+    const availableActions = this.actionHandler.getAvailableActions();
+    const prompt = buildDecisionPrompt(context, availableActions);
+    const decision = await this.llm.generateStructured(
+      prompt,
+      {
+        type: "object",
+        properties: {
+          action: { type: "string" },
+          reasoning: { type: "string" },
+          parameters: { type: "object" }
+        },
+        required: ["action", "reasoning", "parameters"]
+      },
+      { systemPrompt: this.systemPrompt, temperature: this.config.llm.temperature }
+    );
+    logger4.debug(`Decision: ${decision.action} \u2014 ${decision.reasoning}`);
+    return decision;
+  }
+  async act(actionName, parameters = {}) {
+    const context = {
+      agent: this,
+      memory: this.memory_,
+      llm: this.llm,
+      parameters
+    };
+    return this.actionHandler.execute(actionName, context);
+  }
+  async learn(experience) {
+    await this.memory_.addExperience(experience);
+  }
+  async tick() {
+    if (this.state !== "running") return;
+    try {
+      if (this.hooks.onTick) {
+        await this.hooks.onTick(this);
+      }
+      if (this.isSleeping()) return;
+      const decision = await this.think();
+      const result = await this.act(decision.action, decision.parameters);
+      await this.learn({
+        type: "action",
+        action: decision.action,
+        result,
+        timestamp: /* @__PURE__ */ new Date(),
+        context: { reasoning: decision.reasoning }
+      });
+      if (this.config.webhooks?.onAction) {
+        await this.fireWebhook("onAction", decision, result);
+      }
+    } catch (error) {
+      logger4.error(`Tick error: ${error instanceof Error ? error.message : error}`);
+      if (this.hooks.onError && error instanceof Error) {
+        await this.hooks.onError(error, this);
+      }
+    }
+  }
+  // ── Markdown skill registration ──
+  registerMarkdownSkills(skills) {
+    for (const skill of skills) {
+      const action = createMarkdownAction(skill.name, skill.description, this.llm);
+      this.actionRegistry.register(action);
+    }
+  }
+  // ── Internal ──
+  initLLM() {
+    const { provider, apiKey, model } = this.config.llm;
+    switch (provider) {
+      case "anthropic":
+        this.llm = new AnthropicProvider(apiKey, model);
+        break;
+      case "openai":
+        this.llm = new OpenAIProvider(apiKey, model);
+        break;
+      default:
+        throw new Error(`Unsupported LLM provider: ${provider}`);
+    }
+  }
+  registerActions() {
+    for (const action of builtInActions) {
+      if (this.config.actions.includes(action.name)) {
+        this.actionRegistry.register(action);
+      }
+    }
+    if (this.config.customActions) {
+      for (const action of this.config.customActions) {
+        this.actionRegistry.register(action);
+      }
+    }
+  }
+  async initSocialAdapters() {
+    const { social } = this.config;
+    if (social.moltbook?.enabled) {
+      const adapter = new MoltbookAdapter(social.moltbook);
+      try {
+        await adapter.connect();
+        this.socialAdapters["moltbook"] = adapter;
+        logger4.info("Moltbook adapter connected");
+      } catch (error) {
+        logger4.warn(`Failed to connect Moltbook adapter: ${error}`);
+      }
+    }
+    if (social.twitter?.enabled) {
+      const adapter = new TwitterAdapter(social.twitter);
+      try {
+        await adapter.connect();
+        this.socialAdapters["twitter"] = adapter;
+        logger4.info("Twitter adapter connected");
+      } catch (error) {
+        logger4.warn(`Failed to connect Twitter adapter: ${error}`);
+      }
+    }
+  }
+  startAutonomousLoop() {
+    const actionsPerHour = typeof this.config.behaviors.actionsPerHour === "function" ? this.config.behaviors.actionsPerHour({}) : this.config.behaviors.actionsPerHour || 5;
+    const intervalMs = Math.floor(36e5 / actionsPerHour);
+    this.tickTimer = setInterval(() => this.tick(), intervalMs);
+    logger4.info(`Autonomous loop started: ~${actionsPerHour} actions/hour (every ${intervalMs}ms)`);
+  }
+  isSleeping() {
+    const schedule = this.config.behaviors.sleepSchedule;
+    if (!schedule) return false;
+    const now = /* @__PURE__ */ new Date();
+    const hour = now.getHours();
+    if (schedule.start > schedule.end) {
+      return hour >= schedule.start || hour < schedule.end;
+    }
+    return hour >= schedule.start && hour < schedule.end;
+  }
+  async gatherContext() {
+    return {
+      agentName: this.config.name,
+      agentType: this.config.type,
+      currentTime: (/* @__PURE__ */ new Date()).toISOString(),
+      state: this.state,
+      personality: this.config.personality.traits
+    };
+  }
+  async fireWebhook(event, ...args) {
+    try {
+      const hook = this.config.webhooks?.[event];
+      if (typeof hook === "function") {
+        await hook(...args);
+      } else if (typeof hook === "string") {
+        const { default: axios2 } = await import("axios");
+        await axios2.post(hook, { event, data: args });
+      }
+    } catch (error) {
+      logger4.error(`Webhook ${event} failed: ${error}`);
+    }
+  }
+};
+
+// src/config/ConfigLoader.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+
+// src/config/MarkdownParser.ts
+import matter from "gray-matter";
+var MarkdownParser = class {
+  parse(markdown) {
+    const { data: frontmatter, content } = matter(markdown);
+    const sections = this.parseSections(content);
+    const identity = this.findSection(sections, "Identity");
+    const bio = this.findSection(sections, "Bio");
+    const social = this.findSection(sections, "Social Platforms");
+    const behaviors = this.findSection(sections, "Behaviors");
+    const memory = this.findSection(sections, "Memory");
+    const skills = this.findSection(sections, "Skills");
+    const scheduling = this.findSection(sections, "Scheduling");
+    const identityData = this.parseIdentity(identity);
+    const bioText = bio ? bio.content.trim() : identityData?.personality?.bio || "";
+    const config = {
+      ...identityData,
+      personality: {
+        traits: identityData?.personality?.traits || [],
+        bio: bioText
+      },
+      ...social ? { social: this.parseSocial(social) } : {},
+      ...behaviors ? { behaviors: this.parseBehaviors(behaviors) } : {},
+      ...memory ? { memory: this.parseMemory(memory) } : {},
+      actions: [],
+      ...frontmatter
+    };
+    if (skills) {
+      config.actions = skills.children.map((s) => this.toSnakeCase(s.title));
+    }
+    return config;
+  }
+  parseSkills(markdown) {
+    const { content } = matter(markdown);
+    const sections = this.parseSections(content);
+    const skills = this.findSection(sections, "Skills");
+    if (!skills) return [];
+    return skills.children.map((child) => ({
+      name: this.toSnakeCase(child.title),
+      description: child.content.trim()
+    }));
+  }
+  parseSections(content) {
+    const lines = content.split("\n");
+    const root = [];
+    const stack = [];
+    for (const line of lines) {
+      const match = line.match(/^(#{1,6})\s+(.+)/);
+      if (match) {
+        const level = match[1].length;
+        const title = match[2].trim();
+        const section = { title, level, content: "", children: [] };
+        while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+          stack.pop();
+        }
+        if (stack.length === 0) {
+          root.push(section);
+        } else {
+          stack[stack.length - 1].section.children.push(section);
+        }
+        stack.push({ level, section });
+      } else if (stack.length > 0) {
+        stack[stack.length - 1].section.content += line + "\n";
+      }
+    }
+    return root;
+  }
+  findSection(sections, title) {
+    for (const section of sections) {
+      if (section.title.toLowerCase() === title.toLowerCase()) return section;
+      const found = this.findSection(section.children, title);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  parseIdentity(section) {
+    if (!section) return void 0;
+    const fields = this.parseKeyValueLines(section.content);
+    return {
+      name: fields["name"] || "Unnamed Agent",
+      type: fields["type"],
+      personality: {
+        traits: (fields["personality"] || "").split(",").map((t) => t.trim()).filter(Boolean),
+        bio: ""
+      }
+    };
+  }
+  parseSocial(section) {
+    const social = {};
+    for (const child of section.children) {
+      const platform = child.title.toLowerCase();
+      const fields = this.parseKeyValueLines(child.content);
+      social[platform] = {
+        enabled: fields["enabled"] === "true",
+        ...fields
+      };
+    }
+    return social;
+  }
+  parseBehaviors(section) {
+    const fields = this.parseKeyValueLines(section.content);
+    return {
+      autonomous: fields["autonomous"] === "true",
+      decisionMaking: fields["decision_making"] || "llm-driven",
+      actionsPerHour: fields["actions_per_hour"] ? parseInt(fields["actions_per_hour"], 10) : void 0,
+      sleepSchedule: fields["sleep_schedule"] ? this.parseSleepSchedule(fields["sleep_schedule"]) : void 0
+    };
+  }
+  parseMemory(section) {
+    const fields = this.parseKeyValueLines(section.content);
+    return {
+      type: fields["type"] || "memory",
+      retention: fields["retention"]
+    };
+  }
+  parseSleepSchedule(value) {
+    const match = value.match(/(\d{1,2}):?\d{0,2}\s*-\s*(\d{1,2}):?\d{0,2}\s*(.*)?/);
+    if (!match) return { start: 22, end: 6 };
+    return {
+      start: parseInt(match[1], 10),
+      end: parseInt(match[2], 10),
+      timezone: match[3]?.trim() || void 0
+    };
+  }
+  parseKeyValueLines(content) {
+    const result = {};
+    for (const line of content.split("\n")) {
+      const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*):\s*(.+)/);
+      if (match) {
+        result[match[1].trim()] = match[2].trim();
+      }
+    }
+    return result;
+  }
+  toSnakeCase(str) {
+    return str.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+  }
+};
+
+// src/config/types.ts
+import { z } from "zod";
+var AgentConfigSchema = z.object({
+  name: z.string().min(1),
+  type: z.string().optional(),
+  personality: z.object({
+    traits: z.array(z.string()),
+    bio: z.string()
+  }).passthrough(),
+  llm: z.object({
+    provider: z.enum(["anthropic", "openai"]),
+    model: z.string(),
+    apiKey: z.string(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+    systemPrompt: z.string().optional()
+  }),
+  social: z.record(z.unknown()).optional(),
+  behaviors: z.object({
+    autonomous: z.boolean(),
+    decisionMaking: z.enum(["llm-driven", "rule-based", "hybrid"]),
+    actionsPerHour: z.number().optional(),
+    sleepSchedule: z.object({
+      start: z.number(),
+      end: z.number(),
+      timezone: z.string().optional()
+    }).optional()
+  }),
+  memory: z.object({
+    type: z.enum(["memory", "redis", "postgres", "hybrid"]),
+    retention: z.string().optional()
+  }).passthrough(),
+  actions: z.array(z.string())
+}).passthrough();
+
+// src/config/validator.ts
+var ConfigValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "ConfigValidationError";
+  }
+};
+function validateConfig(config) {
+  const result = AgentConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => ({
+      path: issue.path.join("."),
+      message: issue.message
+    }));
+    throw new ConfigValidationError(
+      `Invalid agent configuration:
+${issues.map((i) => `  - ${i.path}: ${i.message}`).join("\n")}`,
+      issues
+    );
+  }
+  return result.data;
+}
+
+// src/config/ConfigLoader.ts
+var ConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var ConfigLoader = class {
+  markdownParser = new MarkdownParser();
+  async load(directory) {
+    const codeConfigPath = resolve(directory, "agent.config.ts");
+    const mdConfigPath = resolve(directory, "agent.md");
+    if (existsSync(codeConfigPath)) {
+      return { config: await this.loadCode(codeConfigPath), type: "code" };
+    }
+    if (existsSync(mdConfigPath)) {
+      return { config: await this.loadMarkdown(mdConfigPath), type: "markdown" };
+    }
+    throw new ConfigurationError(
+      `No agent configuration found in ${directory}. Expected agent.config.ts or agent.md`
+    );
+  }
+  async loadCode(filePath) {
+    try {
+      const { createJiti } = await import("jiti");
+      const jiti = createJiti(pathToFileURL(filePath).href, {
+        interopDefault: true,
+        moduleCache: false
+      });
+      const module = await jiti.import(filePath);
+      const config = module.default || module;
+      return validateConfig(config);
+    } catch (error) {
+      if (error instanceof Error && error.name === "ConfigValidationError") throw error;
+      throw new ConfigurationError(`Failed to load code config from ${filePath}: ${error}`);
+    }
+  }
+  async loadMarkdown(filePath) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const partialConfig = this.markdownParser.parse(content);
+      const config = {
+        ...partialConfig,
+        llm: partialConfig.llm || {
+          provider: process.env.LLM_PROVIDER || "anthropic",
+          model: process.env.LLM_MODEL || "claude-sonnet-4-20250514",
+          apiKey: process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || ""
+        }
+      };
+      return validateConfig(config);
+    } catch (error) {
+      if (error instanceof Error && error.name === "ConfigValidationError") throw error;
+      throw new ConfigurationError(`Failed to load markdown config from ${filePath}: ${error}`);
+    }
+  }
+};
+
+// src/memory/longterm.ts
+var logger5 = createLogger("LongTermMemory");
+var LongTermMemory = class extends Memory {
+  redisConfig;
+  postgresConfig;
+  redis = null;
+  pg = null;
+  initialized = false;
+  constructor(options = {}) {
+    super();
+    this.redisConfig = options.redis;
+    this.postgresConfig = options.postgres;
+  }
+  async init() {
+    if (this.initialized) return;
+    if (this.redisConfig) {
+      await this.initRedis();
+    }
+    if (this.postgresConfig) {
+      await this.initPostgres();
+    }
+    this.initialized = true;
+  }
+  // ── Redis: Short-term cache operations ──
+  async remember(key, value, ttl) {
+    await this.ensureRedis();
+    const serialized = JSON.stringify(value);
+    const prefixedKey = this.redisKey(key);
+    if (ttl) {
+      await this.redis.setex(prefixedKey, ttl, serialized);
+    } else {
+      const defaultTtl = this.redisConfig?.ttl || 86400;
+      await this.redis.setex(prefixedKey, defaultTtl, serialized);
+    }
+  }
+  async recall(key) {
+    await this.ensureRedis();
+    const data = await this.redis.get(this.redisKey(key));
+    if (data === null) return void 0;
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  async forget(key) {
+    await this.ensureRedis();
+    await this.redis.del(this.redisKey(key));
+  }
+  // ── Postgres: Persistent storage operations ──
+  async store(key, value) {
+    await this.ensurePostgres();
+    const table = this.pgTable();
+    await this.pg.query(
+      `INSERT INTO ${table} (key, value, updated_at)
+       VALUES ($1, $2, NOW())
+       ON CONFLICT (key) DO UPDATE SET value = $2, updated_at = NOW()`,
+      [key, JSON.stringify(value)]
+    );
+  }
+  async retrieve(key) {
+    await this.ensurePostgres();
+    const table = this.pgTable();
+    const result = await this.pg.query(
+      `SELECT value FROM ${table} WHERE key = $1`,
+      [key]
+    );
+    if (result.rows.length === 0) return void 0;
+    try {
+      return JSON.parse(result.rows[0].value);
+    } catch {
+      return result.rows[0].value;
+    }
+  }
+  async delete(key) {
+    await this.ensurePostgres();
+    const table = this.pgTable();
+    await this.pg.query(`DELETE FROM ${table} WHERE key = $1`, [key]);
+  }
+  // ── Postgres: Experience/semantic storage ──
+  async addExperience(experience) {
+    await this.ensurePostgres();
+    const table = this.pgExperienceTable();
+    await this.pg.query(
+      `INSERT INTO ${table} (type, action, result, context, timestamp)
+       VALUES ($1, $2, $3, $4, $5)`,
+      [
+        experience.type,
+        experience.action,
+        JSON.stringify(experience.result),
+        JSON.stringify(experience.context || {}),
+        experience.timestamp
+      ]
+    );
+  }
+  async queryExperiences(query, limit = 20) {
+    await this.ensurePostgres();
+    const table = this.pgExperienceTable();
+    const result = await this.pg.query(
+      `SELECT type, action, result, context, timestamp FROM ${table}
+       WHERE action ILIKE $1 OR context::text ILIKE $1
+       ORDER BY timestamp DESC
+       LIMIT $2`,
+      [`%${query}%`, limit]
+    );
+    return result.rows.map((row) => ({
+      type: row.type,
+      action: row.action,
+      result: typeof row.result === "string" ? JSON.parse(row.result) : row.result,
+      context: typeof row.context === "string" ? JSON.parse(row.context) : row.context,
+      timestamp: new Date(row.timestamp)
+    }));
+  }
+  async clear() {
+    if (this.redis) {
+      const prefix = this.redisConfig?.keyPrefix || "moltium:";
+      const keys = await this.redis.keys(`${prefix}*`);
+      if (keys.length > 0) {
+        await this.redis.del(...keys);
+      }
+    }
+    if (this.pg) {
+      await this.pg.query(`DELETE FROM ${this.pgTable()}`);
+      await this.pg.query(`DELETE FROM ${this.pgExperienceTable()}`);
+    }
+  }
+  async disconnect() {
+    if (this.redis) {
+      await this.redis.quit();
+      this.redis = null;
+    }
+    if (this.pg) {
+      await this.pg.end();
+      this.pg = null;
+    }
+    this.initialized = false;
+  }
+  // ── Schema setup (call once to create tables) ──
+  async ensureSchema() {
+    await this.ensurePostgres();
+    const table = this.pgTable();
+    const expTable = this.pgExperienceTable();
+    const schema = this.postgresConfig?.schema || "public";
+    await this.pg.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
+    await this.pg.query(`
+      CREATE TABLE IF NOT EXISTS ${table} (
+        key TEXT PRIMARY KEY,
+        value JSONB NOT NULL,
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `);
+    await this.pg.query(`
+      CREATE TABLE IF NOT EXISTS ${expTable} (
+        id SERIAL PRIMARY KEY,
+        type TEXT NOT NULL,
+        action TEXT NOT NULL,
+        result JSONB NOT NULL,
+        context JSONB DEFAULT '{}',
+        timestamp TIMESTAMPTZ NOT NULL,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      )
+    `);
+    await this.pg.query(`
+      CREATE INDEX IF NOT EXISTS idx_${this.sanitizeName()}_experiences_action
+      ON ${expTable} (action)
+    `);
+    await this.pg.query(`
+      CREATE INDEX IF NOT EXISTS idx_${this.sanitizeName()}_experiences_timestamp
+      ON ${expTable} (timestamp DESC)
+    `);
+  }
+  // ── Internal helpers ──
+  async initRedis() {
+    if (!this.redisConfig) throw new Error("Redis config not provided");
+    try {
+      const { default: Redis } = await import("ioredis");
+      this.redis = new Redis(this.redisConfig.url);
+      logger5.info("Redis connection established");
+    } catch (error) {
+      logger5.error(`Failed to connect to Redis: ${error}`);
+      throw error;
+    }
+  }
+  async initPostgres() {
+    if (!this.postgresConfig) throw new Error("Postgres config not provided");
+    try {
+      const pg = await import("pg");
+      const Pool = pg.default?.Pool || pg.Pool;
+      this.pg = new Pool({
+        connectionString: this.postgresConfig.url
+      });
+      await this.pg.query("SELECT 1");
+      logger5.info("Postgres connection established");
+    } catch (error) {
+      logger5.error(`Failed to connect to Postgres: ${error}`);
+      throw error;
+    }
+  }
+  async ensureRedis() {
+    if (!this.redis) {
+      if (!this.redisConfig) {
+        throw new Error("Redis not configured. Provide redis config in memory settings.");
+      }
+      await this.initRedis();
+    }
+  }
+  async ensurePostgres() {
+    if (!this.pg) {
+      if (!this.postgresConfig) {
+        throw new Error("Postgres not configured. Provide postgres config in memory settings.");
+      }
+      await this.initPostgres();
+    }
+  }
+  redisKey(key) {
+    const prefix = this.redisConfig?.keyPrefix || "moltium:";
+    return `${prefix}${key}`;
+  }
+  pgTable() {
+    const schema = this.postgresConfig?.schema || "public";
+    const table = this.postgresConfig?.tableName || "moltium_memory";
+    return `${schema}.${table}`;
+  }
+  pgExperienceTable() {
+    const schema = this.postgresConfig?.schema || "public";
+    const table = this.postgresConfig?.tableName || "moltium_memory";
+    return `${schema}.${table}_experiences`;
+  }
+  sanitizeName() {
+    return (this.postgresConfig?.tableName || "moltium_memory").replace(/[^a-z0-9_]/g, "_");
+  }
+};
+
+// src/server/app.ts
+import express from "express";
+
+// src/server/routes.ts
+import { Router } from "express";
+function createRoutes(agent) {
+  const router = Router();
+  router.get("/health", (_req, res) => {
+    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  });
+  router.get("/status", (_req, res) => {
+    res.json({
+      name: agent.name,
+      state: agent.getState(),
+      type: agent.config.type || "general",
+      uptime: process.uptime(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  });
+  router.post("/message", async (req, res) => {
+    try {
+      const { message } = req.body;
+      if (!message) {
+        res.status(400).json({ error: "Missing message field" });
+        return;
+      }
+      const response = await agent.getLLM().generateText(message, {
+        systemPrompt: `You are ${agent.name}. ${agent.config.personality.bio}`,
+        temperature: agent.config.llm.temperature
+      });
+      res.json({ response });
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  });
+  router.post("/action", async (req, res) => {
+    try {
+      const { action, parameters } = req.body;
+      if (!action) {
+        res.status(400).json({ error: "Missing action field" });
+        return;
+      }
+      const result = await agent.act(action, parameters || {});
+      res.json(result);
+    } catch (error) {
+      res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  });
+  router.get("/config", (_req, res) => {
+    const safeConfig = {
+      name: agent.config.name,
+      type: agent.config.type,
+      personality: agent.config.personality,
+      behaviors: {
+        autonomous: agent.config.behaviors.autonomous,
+        decisionMaking: agent.config.behaviors.decisionMaking,
+        actionsPerHour: typeof agent.config.behaviors.actionsPerHour === "function" ? "(dynamic)" : agent.config.behaviors.actionsPerHour,
+        sleepSchedule: agent.config.behaviors.sleepSchedule
+      },
+      memory: { type: agent.config.memory.type },
+      actions: agent.config.actions
+    };
+    res.json(safeConfig);
+  });
+  router.post("/shutdown", async (_req, res) => {
+    res.json({ message: "Shutting down..." });
+    await agent.stop();
+    process.exit(0);
+  });
+  return router;
+}
+
+// src/server/middleware.ts
+var logger6 = createLogger("Server");
+function requestLogger(req, _res, next) {
+  logger6.debug(`${req.method} ${req.path}`);
+  next();
+}
+function errorHandler(err, _req, res, _next) {
+  logger6.error(`Server error: ${err.message}`);
+  res.status(500).json({ error: err.message });
+}
+function authMiddleware(req, res, next) {
+  const authToken = process.env.AGENT_AUTH_TOKEN;
+  if (!authToken) {
+    next();
+    return;
+  }
+  const provided = req.headers.authorization?.replace("Bearer ", "");
+  if (provided !== authToken) {
+    res.status(401).json({ error: "Unauthorized" });
+    return;
+  }
+  next();
+}
+
+// src/server/app.ts
+var logger7 = createLogger("Server");
+function createApp(agent) {
+  const app = express();
+  app.use(express.json());
+  app.use(requestLogger);
+  app.use(authMiddleware);
+  app.use(createRoutes(agent));
+  app.use(errorHandler);
+  return app;
+}
+async function startServer(agent, options = {}) {
+  const port = options.port || parseInt(process.env.PORT || "3000", 10);
+  const host = options.host || "0.0.0.0";
+  const app = createApp(agent);
+  await agent.start();
+  app.listen(port, host, () => {
+    logger7.info(`Agent "${agent.name}" running at http://${host}:${port}`);
+  });
+  const shutdown = async () => {
+    logger7.info("Received shutdown signal");
+    await agent.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  ActionHandler,
+  ActionRegistry,
+  Agent,
+  AnthropicProvider,
+  ConfigLoader,
+  LLMProvider,
+  LongTermMemory,
+  MarkdownParser,
+  Memory,
+  MoltbookAdapter,
+  OpenAIProvider,
+  Scheduler,
+  ShortTermMemory,
+  SocialAdapter,
+  TwitterAdapter,
+  buildDecisionPrompt,
+  buildSkillPrompt,
+  buildSystemPrompt,
+  builtInActions,
+  createApp,
+  createLogger,
+  createMarkdownAction,
+  createRoutes,
+  startServer,
+  validateConfig
+};
+//# sourceMappingURL=index.mjs.map