@alejandroroman/agent-kit 0.1.4 → 0.2.1

package/dist/telemetry/types.d.ts

@@ -0,0 +1,30 @@
+export declare const ATTR: {
+    readonly AGENT: "agent.name";
+    readonly SOURCE: "agent.source";
+    readonly RUN_ID: "agent.run_id";
+    readonly MODEL: "llm.model";
+    readonly PROVIDER: "llm.provider";
+    readonly INPUT_TOKENS: "llm.tokens.input";
+    readonly OUTPUT_TOKENS: "llm.tokens.output";
+    readonly CACHE_READ_TOKENS: "llm.tokens.cache_read";
+    readonly CACHE_CREATION_TOKENS: "llm.tokens.cache_creation";
+    readonly LATENCY_MS: "llm.latency_ms";
+    readonly STOP_REASON: "llm.stop_reason";
+    readonly TOOL_NAME: "tool.name";
+    readonly TOOL_STATUS: "tool.status";
+    readonly TOOL_DURATION_MS: "tool.duration_ms";
+    readonly SKILL_NAME: "skill.name";
+    readonly SKILL_TOOLS_LOADED: "skill.tools_loaded";
+    readonly ITERATION: "agent.iteration";
+    readonly JOB_ID: "cron.job_id";
+    readonly SCHEDULE: "cron.schedule";
+    readonly CHANNEL: "slack.channel";
+    readonly THREAD_TS: "slack.thread_ts";
+    readonly TOKENS_BEFORE: "compaction.tokens_before";
+    readonly TOKENS_AFTER: "compaction.tokens_after";
+    readonly FALLBACK_ORIGINAL: "llm.fallback.original_model";
+    readonly FALLBACK_MODEL: "llm.fallback.model";
+    readonly FALLBACK_ERROR: "llm.fallback.error";
+    readonly SUPPRESSED: "agent.suppressed";
+    readonly SPAWN_CHILD: "agent.spawn.child";
+};

package/dist/telemetry/types.js

@@ -0,0 +1,31 @@
+// Span attribute keys — centralized to avoid typos
+export const ATTR = {
+    AGENT: "agent.name",
+    SOURCE: "agent.source",
+    RUN_ID: "agent.run_id",
+    MODEL: "llm.model",
+    PROVIDER: "llm.provider",
+    INPUT_TOKENS: "llm.tokens.input",
+    OUTPUT_TOKENS: "llm.tokens.output",
+    CACHE_READ_TOKENS: "llm.tokens.cache_read",
+    CACHE_CREATION_TOKENS: "llm.tokens.cache_creation",
+    LATENCY_MS: "llm.latency_ms",
+    STOP_REASON: "llm.stop_reason",
+    TOOL_NAME: "tool.name",
+    TOOL_STATUS: "tool.status",
+    TOOL_DURATION_MS: "tool.duration_ms",
+    SKILL_NAME: "skill.name",
+    SKILL_TOOLS_LOADED: "skill.tools_loaded",
+    ITERATION: "agent.iteration",
+    JOB_ID: "cron.job_id",
+    SCHEDULE: "cron.schedule",
+    CHANNEL: "slack.channel",
+    THREAD_TS: "slack.thread_ts",
+    TOKENS_BEFORE: "compaction.tokens_before",
+    TOKENS_AFTER: "compaction.tokens_after",
+    FALLBACK_ORIGINAL: "llm.fallback.original_model",
+    FALLBACK_MODEL: "llm.fallback.model",
+    FALLBACK_ERROR: "llm.fallback.error",
+    SUPPRESSED: "agent.suppressed",
+    SPAWN_CHILD: "agent.spawn.child",
+};

package/dist/tools/builtin/index.d.ts

@@ -2,7 +2,9 @@ import { ToolRegistry } from "../registry.js";
 import { readFileTool } from "./read-file.js";
 import { writeFileTool } from "./write-file.js";
 import { runCommandTool } from "./run-command.js";
+import { createUpdateAgentConfigTool, createManageCronTool } from "./self-config.js";
 export { readFileTool, writeFileTool, runCommandTool };
+export { createUpdateAgentConfigTool, createManageCronTool };
 interface BuiltinRegistryOptions {
     allowedCommands?: string[];
     allowedPaths?: string[];

package/dist/tools/builtin/index.js

@@ -4,7 +4,9 @@ import { createWriteFileTool, writeFileTool } from "./write-file.js";
 import { createRunCommandTool, runCommandTool } from "./run-command.js";
 import { createMemoryTools } from "./memory.js";
 import { createWebSearchTool } from "./web-search.js";
+import { createUpdateAgentConfigTool, createManageCronTool } from "./self-config.js";
 export { readFileTool, writeFileTool, runCommandTool };
+export { createUpdateAgentConfigTool, createManageCronTool };
 export function createBuiltinRegistry(options = {}) {
     const registry = new ToolRegistry();
     registry.register(createReadFileTool(options.allowedPaths));

package/dist/tools/builtin/self-config.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from "../types.js";
+import type { ConfigWriter } from "../../config/writer.js";
+export declare function createUpdateAgentConfigTool(agentName: string, writer: ConfigWriter): Tool;
+export declare function createManageCronTool(agentName: string, writer: ConfigWriter): Tool;

package/dist/tools/builtin/self-config.js

@@ -0,0 +1,182 @@
+import cron from "node-cron";
+import { createLogger } from "../../logger.js";
+const log = createLogger("tools:self-config");
+const ALLOWED_CONFIG_FIELDS = [
+    "displayName", "emoji", "avatar", "model",
+    "maxIterations", "maxTokens", "heartbeat",
+];
+function pickAllowed(input) {
+    const result = {};
+    for (const key of ALLOWED_CONFIG_FIELDS) {
+        if (key in input)
+            result[key] = input[key];
+    }
+    return result;
+}
+export function createUpdateAgentConfigTool(agentName, writer) {
+    return {
+        name: "update_agent_config",
+        description: `Update your own agent configuration. Allowed fields: ${ALLOWED_CONFIG_FIELDS.join(", ")}. Fields like tools, skills, sandbox, and slack cannot be changed.`,
+        parameters: {
+            type: "object",
+            properties: {
+                displayName: { type: "string", description: "Your display name" },
+                emoji: { type: "string", description: "Your emoji icon" },
+                avatar: { type: "string", description: "URL to your avatar image" },
+                model: { type: "string", description: "Model alias to use (must be a configured alias)" },
+                maxIterations: { type: "number", description: "Max agent loop iterations" },
+                maxTokens: { type: "number", description: "Max tokens per response" },
+                heartbeat: {
+                    type: "object",
+                    description: "Heartbeat settings (partial update)",
+                    properties: {
+                        enabled: { type: "boolean" },
+                        intervalMinutes: { type: "number" },
+                        model: { type: "string" },
+                    },
+                },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const updates = pickAllowed(args);
+                if (Object.keys(updates).length === 0) {
+                    return "Error: No allowed fields provided. Allowed: " + ALLOWED_CONFIG_FIELDS.join(", ");
+                }
+                // Pre-validate model alias if provided
+                if (updates.model) {
+                    const config = writer.read();
+                    if (config.models) {
+                        const aliases = config.models.map((m) => m.alias);
+                        if (!aliases.includes(updates.model)) {
+                            return `Error: Unknown model alias "${updates.model}". Available: ${aliases.join(", ")}`;
+                        }
+                    }
+                }
+                await writer.mutate((config) => {
+                    const agent = config.agents[agentName];
+                    if (!agent)
+                        throw new Error(`Agent "${agentName}" not found in config`);
+                    for (const [key, value] of Object.entries(updates)) {
+                        if (key === "heartbeat" && typeof value === "object" && value !== null) {
+                            agent.heartbeat = { ...agent.heartbeat, ...value };
+                        }
+                        else {
+                            agent[key] = value;
+                        }
+                    }
+                });
+                const fields = Object.keys(updates).join(", ");
+                log.info({ agent: agentName, fields }, "agent config updated");
+                return `Updated ${agentName} config: ${fields}`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    };
+}
+const MIN_CRON_INTERVAL_MINUTES = 5;
+function isTooFrequent(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length < 5)
+        return false;
+    const minuteField = parts[0];
+    if (minuteField === "*")
+        return true;
+    const stepMatch = minuteField.match(/^\*\/(\d+)$/);
+    if (stepMatch && parseInt(stepMatch[1], 10) < MIN_CRON_INTERVAL_MINUTES)
+        return true;
+    return false;
+}
+export function createManageCronTool(agentName, writer) {
+    return {
+        name: "manage_cron",
+        description: "Manage your own cron jobs. Actions: list, create, update, delete. You can only manage jobs that belong to you.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: { type: "string", enum: ["list", "create", "update", "delete"], description: "The operation to perform" },
+                id: { type: "string", description: "Cron job ID (required for create/update/delete)" },
+                schedule: { type: "string", description: "Cron schedule expression (create/update)" },
+                prompt: { type: "string", description: "The prompt to run (create/update)" },
+                enabled: { type: "boolean", description: "Whether the job is enabled (create/update)" },
+            },
+            required: ["action"],
+        },
+        execute: async (args) => {
+            try {
+                const action = args.action;
+                if (action === "list") {
+                    const config = writer.read();
+                    const jobs = (config.cron ?? []).filter((j) => j.agent === agentName);
+                    return JSON.stringify(jobs, null, 2);
+                }
+                const id = args.id;
+                if (!id)
+                    return "Error: id is required for create/update/delete";
+                if (action === "create") {
+                    const schedule = args.schedule;
+                    const prompt = args.prompt;
+                    const enabled = args.enabled ?? true;
+                    if (!schedule || !prompt)
+                        return "Error: schedule and prompt are required for create";
+                    if (!cron.validate(schedule))
+                        return `Error: Invalid cron schedule "${schedule}"`;
+                    if (isTooFrequent(schedule))
+                        return `Error: Schedule runs too frequently. Minimum interval is ${MIN_CRON_INTERVAL_MINUTES} minutes.`;
+                    await writer.mutate((config) => {
+                        config.cron = config.cron ?? [];
+                        if (config.cron.some((j) => j.id === id)) {
+                            throw new Error(`Cron job "${id}" already exists`);
+                        }
+                        config.cron.push({ id, agent: agentName, schedule, prompt, enabled });
+                    });
+                    log.info({ agent: agentName, jobId: id }, "cron job created");
+                    return `Created cron job "${id}"`;
+                }
+                if (action === "update") {
+                    if (args.schedule) {
+                        const schedule = args.schedule;
+                        if (!cron.validate(schedule))
+                            return `Error: Invalid cron schedule "${schedule}"`;
+                        if (isTooFrequent(schedule))
+                            return `Error: Schedule runs too frequently. Minimum interval is ${MIN_CRON_INTERVAL_MINUTES} minutes.`;
+                    }
+                    await writer.mutate((config) => {
+                        const job = (config.cron ?? []).find((j) => j.id === id);
+                        if (!job)
+                            throw new Error(`Cron job "${id}" not found`);
+                        if (job.agent !== agentName)
+                            throw new Error(`Cron job "${id}" belongs to "${job.agent}", not "${agentName}"`);
+                        if (args.schedule)
+                            job.schedule = args.schedule;
+                        if (args.prompt)
+                            job.prompt = args.prompt;
+                        if (args.enabled !== undefined)
+                            job.enabled = args.enabled;
+                    });
+                    log.info({ agent: agentName, jobId: id }, "cron job updated");
+                    return `Updated cron job "${id}"`;
+                }
+                if (action === "delete") {
+                    await writer.mutate((config) => {
+                        const idx = (config.cron ?? []).findIndex((j) => j.id === id);
+                        if (idx === -1)
+                            throw new Error(`Cron job "${id}" not found`);
+                        if (config.cron[idx].agent !== agentName) {
+                            throw new Error(`Cron job "${id}" belongs to "${config.cron[idx].agent}", not "${agentName}"`);
+                        }
+                        config.cron.splice(idx, 1);
+                    });
+                    log.info({ agent: agentName, jobId: id }, "cron job deleted");
+                    return `Deleted cron job "${id}"`;
+                }
+                return `Error: Unknown action "${action}"`;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alejandroroman/agent-kit",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -27,8 +27,14 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",
-    "@modelcontextprotocol/sdk": "^1.12.1",
     "@clack/prompts": "^1.0.1",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/context-async-hooks": "^2.6.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/sdk-node": "^0.213.0",
+    "@opentelemetry/sdk-trace-base": "^2.6.0",
+    "@sentry/node": "^10.42.0",
     "@slack/bolt": "^4.6.0",
     "better-sqlite3": "^11.9.1",
     "nanoid": "^5.1.5",
@@ -36,6 +42,7 @@
     "openai": "^6.24.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
+    "sharp": "0.33.5",
     "sqlite-vec": "^0.1.6",
     "twitter-api-v2": "^1.29.0",
     "zod": "^4.3.6"
@@ -45,6 +52,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.3.0",
     "@types/node-cron": "^3.0.11",
+    "@types/sharp": "^0.32.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"