@alejandroroman/agent-kit 0.1.3 → 0.2.0

package/dist/telemetry/index.js

@@ -0,0 +1,82 @@
+import * as path from "path";
+import * as os from "os";
+import { trace } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { SimpleSpanProcessor, ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import * as Sentry from "@sentry/node";
+import { createLogger } from "../logger.js";
+import { TelemetryDb } from "./db.js";
+import { SQLiteSpanProcessor } from "./sqlite-processor.js";
+const log = createLogger("telemetry");
+const DEFAULT_DB_PATH = path.join(os.homedir(), ".agent-kit", "telemetry.db");
+let sdk;
+let telemetryDb;
+/** Get the TelemetryDb instance (available after initTelemetry with a dbPath) */
+export function getTelemetryDb() {
+    return telemetryDb;
+}
+export function initTelemetry(config = {}) {
+    const { enabled = process.env.OTEL_ENABLED !== "false", serviceName = process.env.OTEL_SERVICE_NAME ?? "agent-kit", otlpEndpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT, sentryDsn, dbPath = DEFAULT_DB_PATH, sampleRate, } = config;
+    if (!enabled) {
+        log.info("telemetry disabled");
+        return async () => { };
+    }
+    // Guard against double initialization
+    if (sdk) {
+        log.warn("telemetry already initialized, shutting down previous instance");
+        sdk.shutdown().catch(() => { });
+        sdk = undefined;
+        telemetryDb = undefined;
+    }
+    const spanProcessors = [];
+    // SQLite span processor (local persistence)
+    if (dbPath) {
+        try {
+            telemetryDb = new TelemetryDb(dbPath);
+            spanProcessors.push(new SQLiteSpanProcessor(telemetryDb));
+            log.info({ dbPath }, "SQLite span processor enabled");
+        }
+        catch (err) {
+            log.error({ err, dbPath }, "failed to initialize SQLite span processor");
+        }
+    }
+    // OTLP exporter (optional — for Grafana/Jaeger)
+    if (otlpEndpoint) {
+        spanProcessors.push(new SimpleSpanProcessor(new OTLPTraceExporter({ url: otlpEndpoint })));
+        log.info({ endpoint: otlpEndpoint }, "OTLP exporter enabled");
+    }
+    // Console exporter for dev (when no OTLP endpoint)
+    if (!otlpEndpoint && process.env.OTEL_DEBUG === "true") {
+        spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+    }
+    // Sentry error tracking (optional)
+    if (sentryDsn) {
+        Sentry.init({
+            dsn: sentryDsn,
+            tracesSampleRate: sampleRate ?? 1.0,
+            release: process.env.npm_package_version,
+            environment: process.env.NODE_ENV ?? "development",
+        });
+        log.info("Sentry initialized");
+    }
+    sdk = new NodeSDK({
+        serviceName,
+        spanProcessors,
+    });
+    sdk.start();
+    log.info({ serviceName }, "telemetry initialized");
+    return async () => {
+        if (sdk) {
+            await sdk.shutdown();
+            log.info("telemetry shut down");
+        }
+        await Sentry.close(2000);
+    };
+}
+export function getTracer(name) {
+    return trace.getTracer(name);
+}
+export { ATTR } from "./types.js";
+export { TelemetryDb } from "./db.js";
+export { SQLiteSpanProcessor } from "./sqlite-processor.js";

package/dist/telemetry/sanitize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sanitize span attributes before persisting:
+ * 1. Redact values matching known secret patterns
+ * 2. Truncate long string values (unless key is in the safe list)
+ */
+export declare function sanitizeAttributes(attrs: Record<string, unknown>): Record<string, unknown>;

package/dist/telemetry/sanitize.js

@@ -0,0 +1,48 @@
+import { ATTR } from "./types.js";
+/**
+ * Patterns that match known secret/credential formats.
+ * If any pattern matches within a string value, the entire value is redacted.
+ */
+const SECRET_PATTERNS = [
+    /sk-[a-zA-Z0-9\-]{20,}/, // OpenAI/Anthropic API keys
+    /xoxb-[a-zA-Z0-9\-]+/, // Slack bot tokens
+    /xoxp-[a-zA-Z0-9\-]+/, // Slack user tokens
+    /xapp-[a-zA-Z0-9\-]+/, // Slack app tokens
+    /Bearer\s+[a-zA-Z0-9\-_.]+/, // Bearer tokens
+    /https?:\/\/[^@\s]+@[^\s]*sentry\.io[^\s]*/, // Sentry DSNs
+    /ghp_[a-zA-Z0-9]{36,}/, // GitHub personal access tokens
+    /gho_[a-zA-Z0-9]{36,}/, // GitHub OAuth tokens
+];
+const MAX_STRING_LENGTH = 500;
+/**
+ * ATTR keys that are controlled by our code and should never be truncated.
+ * They are still checked for secret patterns (in case a user accidentally
+ * passes a credential as e.g. an agent name).
+ */
+const SAFE_KEYS = new Set(Object.values(ATTR));
+/**
+ * Sanitize span attributes before persisting:
+ * 1. Redact values matching known secret patterns
+ * 2. Truncate long string values (unless key is in the safe list)
+ */
+export function sanitizeAttributes(attrs) {
+    const result = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        result[key] = sanitizeValue(key, value);
+    }
+    return result;
+}
+function sanitizeValue(key, value) {
+    if (typeof value !== "string")
+        return value;
+    // Check for secret patterns — always, even for safe keys
+    for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(value))
+            return "[REDACTED]";
+    }
+    // Truncate long strings, but skip safe (ATTR) keys
+    if (!SAFE_KEYS.has(key) && value.length > MAX_STRING_LENGTH) {
+        return value.slice(0, MAX_STRING_LENGTH) + "...[truncated]";
+    }
+    return value;
+}

package/dist/telemetry/sqlite-processor.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "@opentelemetry/api";
+import type { SpanProcessor, Span, ReadableSpan } from "@opentelemetry/sdk-trace-base";
+import type { TelemetryDb } from "./db.js";
+export declare class SQLiteSpanProcessor implements SpanProcessor {
+    private db;
+    constructor(db: TelemetryDb);
+    onStart(_span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/telemetry/sqlite-processor.js

@@ -0,0 +1,108 @@
+import { SpanStatusCode } from "@opentelemetry/api";
+import { sanitizeAttributes } from "./sanitize.js";
+import { ATTR } from "./types.js";
+const SPAN_KIND_MAP = {
+    0: "internal",
+    1: "server",
+    2: "client",
+    3: "producer",
+    4: "consumer",
+};
+const STATUS_MAP = {
+    [SpanStatusCode.UNSET]: "unset",
+    [SpanStatusCode.OK]: "ok",
+    [SpanStatusCode.ERROR]: "error",
+};
+/** Convert OTel HrTime [seconds, nanoseconds] to milliseconds */
+function hrToMs(hr) {
+    return hr[0] * 1000 + hr[1] / 1e6;
+}
+/**
+ * Generate an error fingerprint from exception info.
+ * Prefers: error_type + first file + line from stack trace.
+ * Fallback: error_type + message.
+ */
+function generateFingerprint(errorType, message, stack) {
+    const type = errorType ?? "Error";
+    if (stack) {
+        // Try to extract file:line from first stack frame
+        // Match patterns like: at Object.<anonymous> (src/agent/loop.ts:42:10)
+        // or: at src/agent/loop.ts:42:10
+        const frameMatch = stack.match(/(?:at\s+(?:.*?\s+)?(?:\()?)((?:[a-zA-Z]:)?[^:(\s]+):(\d+)/);
+        if (frameMatch) {
+            const file = frameMatch[1];
+            const line = frameMatch[2];
+            return `${type}:${file}:${line}`;
+        }
+    }
+    return `${type}:${message}`;
+}
+export class SQLiteSpanProcessor {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    onStart(_span, _parentContext) {
+        // no-op
+    }
+    onEnd(span) {
+        const ctx = span.spanContext();
+        const traceId = ctx.traceId;
+        const spanId = ctx.spanId;
+        const parentSpanId = span.parentSpanContext?.spanId ?? null;
+        const agent = span.attributes[ATTR.AGENT];
+        const source = span.attributes[ATTR.SOURCE];
+        const startTime = hrToMs(span.startTime);
+        const endTime = hrToMs(span.endTime);
+        const durationMs = hrToMs(span.duration);
+        const kind = SPAN_KIND_MAP[span.kind] ?? "internal";
+        const status = STATUS_MAP[span.status.code] ?? "unset";
+        // Serialize all span events for storage
+        const serializedEvents = span.events.map((e) => ({
+            name: e.name,
+            time: hrToMs(e.time),
+            attributes: e.attributes ?? {},
+        }));
+        // Insert span
+        this.db.insertSpan({
+            trace_id: traceId,
+            span_id: spanId,
+            parent_span_id: parentSpanId,
+            name: span.name,
+            kind,
+            status,
+            agent: agent ?? null,
+            source: source ?? null,
+            start_time: startTime,
+            end_time: endTime,
+            duration_ms: durationMs,
+            attributes: JSON.stringify(sanitizeAttributes(span.attributes)),
+            events: JSON.stringify(serializedEvents),
+        });
+        // Extract exception events and write to errors table
+        for (const event of span.events) {
+            if (event.name === "exception") {
+                const errorType = event.attributes?.["exception.type"];
+                const message = event.attributes?.["exception.message"] ?? "Unknown error";
+                const stack = event.attributes?.["exception.stacktrace"];
+                const fingerprint = generateFingerprint(errorType, message, stack);
+                this.db.insertError({
+                    trace_id: traceId,
+                    span_id: spanId,
+                    fingerprint,
+                    error_type: errorType ?? null,
+                    message,
+                    stack: stack ?? null,
+                    agent: agent ?? null,
+                    source: source ?? null,
+                });
+            }
+        }
+    }
+    async shutdown() {
+        this.db.close();
+    }
+    async forceFlush() {
+        // Writes are synchronous with better-sqlite3, nothing to flush
+    }
+}

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/dist/tools/registry.js

@@ -1,3 +1,5 @@
+import { createLogger } from "../logger.js";
+const log = createLogger("tools");
 export class ToolRegistry {
     tools = new Map();
     register(tool) {
@@ -5,7 +7,12 @@ export class ToolRegistry {
     }
     resolve(names) {
         return names
-            .map((name) => this.tools.get(name))
+            .map((name) => {
+            const tool = this.tools.get(name);
+            if (!tool)
+                log.warn(`Unknown tool "${name}" — skipping`);
+            return tool;
+        })
             .filter((tool) => !!tool);
     }
     list() {

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@alejandroroman/agent-kit",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
-    ".": "./dist/index.js",
-    "./bootstrap": "./dist/bootstrap.js"
+    ".": "./dist/index.js"
   },
   "bin": {
     "agent-kit": "./dist/cli.js"
@@ -13,23 +12,16 @@
   "files": [
     "dist/"
   ],
-  "scripts": {
-    "build": "pnpm --filter @agent-kit/memory run build && tsc && cp -r packages/memory/dist dist/_memory && sed -i '' 's|from \"@agent-kit/memory\"|from \"../../_memory/index.js\"|g' dist/tools/builtin/memory.js",
-    "prepublishOnly": "pnpm run build",
-    "cli": "tsx src/cli.ts",
-    "dev": "doppler run -- tsx src/index.ts",
-    "dev:local": "tsx src/index.ts",
-    "memory": "doppler run -- pnpm --filter @agent-kit/memory start",
-    "ledger": "doppler run -- pnpm --filter @agent-kit/ledger ledger",
-    "dev:dashboard": "pnpm --filter @agent-kit/dashboard dev",
-    "agent:validate": "tsx src/scripts/validate-agent-cli.ts",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "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",
@@ -37,17 +29,31 @@
     "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"
   },
   "devDependencies": {
-    "@agent-kit/memory": "workspace:*",
     "@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"
+    "vitest": "^4.0.18",
+    "@agent-kit/memory": "0.1.0"
+  },
+  "scripts": {
+    "build": "pnpm --filter @agent-kit/memory run build && tsc && cp -r packages/memory/dist dist/_memory && node -e \"const f='dist/tools/builtin/memory.js',s=require('fs');s.writeFileSync(f,s.readFileSync(f,'utf8').replaceAll('from \\\"@agent-kit/memory\\\"','from \\\"../../_memory/index.js\\\"'))\"",
+    "cli": "tsx src/cli.ts",
+    "dev": "doppler run -- tsx src/index.ts",
+    "dev:local": "tsx src/index.ts",
+    "memory": "doppler run -- pnpm --filter @agent-kit/memory start",
+    "ledger": "doppler run -- pnpm --filter @agent-kit/ledger ledger",
+    "dev:dashboard": "pnpm --filter @agent-kit/dashboard dev",
+    "agent:validate": "tsx src/scripts/validate-agent-cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}