@mnemom/smoltbot 2.0.1

package/dist/lib/models.js

@@ -0,0 +1,189 @@
+/**
+ * Known Anthropic model definitions with their specifications.
+ * These are used when configuring the smoltbot provider.
+ */
+export const ANTHROPIC_MODELS = {
+    // Claude Opus 4.5 (latest flagship)
+    "claude-opus-4-5-20251101": {
+        id: "claude-opus-4-5-20251101",
+        name: "Claude Opus 4.5",
+        reasoning: true,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 64000,
+        cost: {
+            input: 5,
+            output: 25,
+            cacheRead: 0.5,
+            cacheWrite: 6.25,
+        },
+    },
+    // Claude Sonnet 4.5
+    "claude-sonnet-4-5-20250929": {
+        id: "claude-sonnet-4-5-20250929",
+        name: "Claude Sonnet 4.5",
+        reasoning: true,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 64000,
+        cost: {
+            input: 3,
+            output: 15,
+            cacheRead: 0.3,
+            cacheWrite: 3.75,
+        },
+    },
+    // Claude Haiku 4.5
+    "claude-haiku-4-5-20251001": {
+        id: "claude-haiku-4-5-20251001",
+        name: "Claude Haiku 4.5",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 64000,
+        cost: {
+            input: 0.8,
+            output: 4,
+            cacheRead: 0.08,
+            cacheWrite: 1,
+        },
+    },
+    // Legacy models (Claude 3.5)
+    "claude-3-5-sonnet-20241022": {
+        id: "claude-3-5-sonnet-20241022",
+        name: "Claude 3.5 Sonnet",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 8192,
+        cost: {
+            input: 3,
+            output: 15,
+            cacheRead: 0.3,
+            cacheWrite: 3.75,
+        },
+    },
+    "claude-3-5-haiku-20241022": {
+        id: "claude-3-5-haiku-20241022",
+        name: "Claude 3.5 Haiku",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 8192,
+        cost: {
+            input: 0.8,
+            output: 4,
+            cacheRead: 0.08,
+            cacheWrite: 1,
+        },
+    },
+    // Claude 3 Opus (legacy)
+    "claude-3-opus-20240229": {
+        id: "claude-3-opus-20240229",
+        name: "Claude 3 Opus",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 4096,
+        cost: {
+            input: 15,
+            output: 75,
+            cacheRead: 1.5,
+            cacheWrite: 18.75,
+        },
+    },
+    "claude-3-haiku-20240307": {
+        id: "claude-3-haiku-20240307",
+        name: "Claude 3 Haiku",
+        reasoning: false,
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 4096,
+        cost: {
+            input: 0.25,
+            output: 1.25,
+            cacheRead: 0.03,
+            cacheWrite: 0.3,
+        },
+    },
+};
+/**
+ * Get model definition by ID
+ * Returns the definition if known, or creates a basic one if unknown
+ */
+export function getModelDefinition(modelId) {
+    const known = ANTHROPIC_MODELS[modelId];
+    if (known) {
+        return known;
+    }
+    // Create a basic definition for unknown models
+    // This allows smoltbot to work with new models not yet in our registry
+    return {
+        id: modelId,
+        name: formatModelName(modelId),
+        reasoning: modelId.includes("opus") || modelId.includes("sonnet"),
+        input: ["text", "image"],
+        contextWindow: 200000,
+        maxTokens: 64000,
+    };
+}
+/**
+ * Check if a model ID is a known Anthropic model
+ */
+export function isKnownModel(modelId) {
+    return modelId in ANTHROPIC_MODELS;
+}
+/**
+ * Check if a model ID looks like an Anthropic model
+ */
+export function isAnthropicModel(modelId) {
+    return modelId.startsWith("claude-");
+}
+/**
+ * Format a model ID into a human-readable name
+ * e.g., "claude-opus-4-5-20251101" -> "Claude Opus 4.5"
+ */
+export function formatModelName(modelId) {
+    // First check known models
+    const known = ANTHROPIC_MODELS[modelId];
+    if (known) {
+        return known.name;
+    }
+    // Try to parse the model ID
+    // Pattern: claude-{tier}-{version}-{date}
+    // e.g., claude-opus-4-5-20251101
+    const parts = modelId.split("-");
+    if (parts[0] !== "claude" || parts.length < 3) {
+        return modelId; // Return as-is if we can't parse
+    }
+    const tier = parts[1]; // opus, sonnet, haiku
+    const tierCapitalized = tier.charAt(0).toUpperCase() + tier.slice(1);
+    // Try to extract version (e.g., "4-5" -> "4.5")
+    if (parts.length >= 4 && /^\d+$/.test(parts[2]) && /^\d+$/.test(parts[3])) {
+        return `Claude ${tierCapitalized} ${parts[2]}.${parts[3]}`;
+    }
+    // Fallback for older naming (e.g., claude-3-opus-20240229)
+    if (/^\d+$/.test(parts[1])) {
+        const version = parts[1];
+        const tierName = parts[2];
+        const tierCap = tierName.charAt(0).toUpperCase() + tierName.slice(1);
+        return `Claude ${version} ${tierCap}`;
+    }
+    return `Claude ${tierCapitalized}`;
+}
+/**
+ * Get all known model IDs
+ */
+export function getAllKnownModelIds() {
+    return Object.keys(ANTHROPIC_MODELS);
+}
+/**
+ * Get the latest model for each tier
+ */
+export function getLatestModels() {
+    return [
+        ANTHROPIC_MODELS["claude-opus-4-5-20251101"],
+        ANTHROPIC_MODELS["claude-sonnet-4-5-20250929"],
+        ANTHROPIC_MODELS["claude-haiku-4-5-20251001"],
+    ];
+}

package/dist/lib/openclaw.d.ts

@@ -0,0 +1,131 @@
+export declare const OPENCLAW_DIR: string;
+export declare const OPENCLAW_CONFIG_FILE: string;
+export declare const AUTH_PROFILES_FILE: string;
+export interface AuthProfile {
+    type: "api_key" | "oauth";
+    provider: string;
+    key?: string;
+}
+export interface AuthProfilesFile {
+    version: number;
+    profiles: Record<string, AuthProfile>;
+    lastGood?: Record<string, string>;
+    usageStats?: Record<string, unknown>;
+}
+export interface ModelDefinition {
+    id: string;
+    name: string;
+    reasoning?: boolean;
+    input?: string[];
+    contextWindow?: number;
+    maxTokens?: number;
+    cost?: {
+        input: number;
+        output: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    };
+}
+export interface SmoltbotProvider {
+    baseUrl: string;
+    apiKey: string;
+    api: string;
+    models: ModelDefinition[];
+}
+export interface OpenClawConfig {
+    meta?: {
+        lastTouchedVersion?: string;
+        lastTouchedAt?: string;
+    };
+    wizard?: Record<string, unknown>;
+    update?: Record<string, unknown>;
+    auth?: {
+        profiles?: Record<string, {
+            provider: string;
+            mode: string;
+        }>;
+    };
+    models?: {
+        mode?: string;
+        providers?: Record<string, SmoltbotProvider>;
+    };
+    agents?: {
+        defaults?: {
+            workspace?: string;
+            compaction?: Record<string, unknown>;
+            maxConcurrent?: number;
+            subagents?: Record<string, unknown>;
+            model?: {
+                primary?: string;
+            };
+            models?: Record<string, unknown>;
+        };
+    };
+    messages?: Record<string, unknown>;
+    commands?: Record<string, unknown>;
+    gateway?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface OpenClawDetectionResult {
+    installed: boolean;
+    hasApiKey: boolean;
+    isOAuth: boolean;
+    apiKey?: string;
+    currentModel?: string;
+    currentModelId?: string;
+    currentProvider?: string;
+    smoltbotAlreadyConfigured: boolean;
+    error?: string;
+}
+/**
+ * Check if OpenClaw is installed
+ */
+export declare function openclawExists(): boolean;
+/**
+ * Load and parse auth-profiles.json
+ */
+export declare function loadAuthProfiles(): AuthProfilesFile | null;
+/**
+ * Get the Anthropic API key from auth-profiles.json
+ */
+export declare function getAnthropicApiKey(): {
+    key: string | null;
+    isOAuth: boolean;
+};
+/**
+ * Load openclaw.json config
+ */
+export declare function loadOpenClawConfig(): OpenClawConfig | null;
+/**
+ * Save openclaw.json config (preserves all existing fields)
+ */
+export declare function saveOpenClawConfig(config: OpenClawConfig): void;
+/**
+ * Get the current default model from OpenClaw config
+ * Returns both the full model path (provider/model) and parsed parts
+ */
+export declare function getCurrentModel(): {
+    fullPath: string | null;
+    provider: string | null;
+    modelId: string | null;
+};
+/**
+ * Check if smoltbot provider is already configured
+ */
+export declare function isSmoltbotConfigured(): boolean;
+/**
+ * Get the existing smoltbot provider config
+ */
+export declare function getSmoltbotProvider(): SmoltbotProvider | null;
+/**
+ * Comprehensive detection of OpenClaw setup
+ */
+export declare function detectOpenClaw(): OpenClawDetectionResult;
+/**
+ * Configure the smoltbot provider in OpenClaw config
+ */
+export declare function configureSmoltbotProvider(apiKey: string, models: ModelDefinition[]): void;
+/**
+ * Set the default model in OpenClaw config
+ */
+export declare function setDefaultModel(modelPath: string): void;

package/dist/lib/openclaw.js

@@ -0,0 +1,219 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+// OpenClaw paths
+export const OPENCLAW_DIR = path.join(os.homedir(), ".openclaw");
+export const OPENCLAW_CONFIG_FILE = path.join(OPENCLAW_DIR, "openclaw.json");
+export const AUTH_PROFILES_FILE = path.join(OPENCLAW_DIR, "agents", "main", "agent", "auth-profiles.json");
+/**
+ * Check if OpenClaw is installed
+ */
+export function openclawExists() {
+    return fs.existsSync(OPENCLAW_DIR) && fs.existsSync(OPENCLAW_CONFIG_FILE);
+}
+/**
+ * Load and parse auth-profiles.json
+ */
+export function loadAuthProfiles() {
+    if (!fs.existsSync(AUTH_PROFILES_FILE)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(AUTH_PROFILES_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the Anthropic API key from auth-profiles.json
+ */
+export function getAnthropicApiKey() {
+    const profiles = loadAuthProfiles();
+    if (!profiles) {
+        return { key: null, isOAuth: false };
+    }
+    // Look for anthropic:default or any anthropic profile
+    const anthropicProfile = profiles.profiles["anthropic:default"] ||
+        Object.values(profiles.profiles).find((p) => p.provider === "anthropic");
+    if (!anthropicProfile) {
+        return { key: null, isOAuth: false };
+    }
+    if (anthropicProfile.type === "oauth" || !anthropicProfile.key) {
+        return { key: null, isOAuth: true };
+    }
+    return { key: anthropicProfile.key, isOAuth: false };
+}
+/**
+ * Load openclaw.json config
+ */
+export function loadOpenClawConfig() {
+    if (!fs.existsSync(OPENCLAW_CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(OPENCLAW_CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save openclaw.json config (preserves all existing fields)
+ */
+export function saveOpenClawConfig(config) {
+    // Update meta timestamp
+    if (!config.meta) {
+        config.meta = {};
+    }
+    config.meta.lastTouchedAt = new Date().toISOString();
+    fs.writeFileSync(OPENCLAW_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+/**
+ * Get the current default model from OpenClaw config
+ * Returns both the full model path (provider/model) and parsed parts
+ */
+export function getCurrentModel() {
+    const config = loadOpenClawConfig();
+    if (!config) {
+        return { fullPath: null, provider: null, modelId: null };
+    }
+    const primary = config.agents?.defaults?.model?.primary;
+    if (!primary) {
+        return { fullPath: null, provider: null, modelId: null };
+    }
+    // Parse provider/model format (e.g., "anthropic/claude-opus-4-5-20251101")
+    const parts = primary.split("/");
+    if (parts.length === 2) {
+        return {
+            fullPath: primary,
+            provider: parts[0],
+            modelId: parts[1],
+        };
+    }
+    // No provider prefix, assume it's just the model ID
+    return {
+        fullPath: primary,
+        provider: null,
+        modelId: primary,
+    };
+}
+/**
+ * Check if smoltbot provider is already configured
+ */
+export function isSmoltbotConfigured() {
+    const config = loadOpenClawConfig();
+    return !!config?.models?.providers?.smoltbot;
+}
+/**
+ * Get the existing smoltbot provider config
+ */
+export function getSmoltbotProvider() {
+    const config = loadOpenClawConfig();
+    return config?.models?.providers?.smoltbot || null;
+}
+/**
+ * Comprehensive detection of OpenClaw setup
+ */
+export function detectOpenClaw() {
+    // Check if OpenClaw is installed
+    if (!openclawExists()) {
+        return {
+            installed: false,
+            hasApiKey: false,
+            isOAuth: false,
+            smoltbotAlreadyConfigured: false,
+            error: "OpenClaw is not installed. Install from https://openclaw.ai",
+        };
+    }
+    // Check auth profile
+    const { key, isOAuth } = getAnthropicApiKey();
+    if (isOAuth) {
+        return {
+            installed: true,
+            hasApiKey: false,
+            isOAuth: true,
+            smoltbotAlreadyConfigured: isSmoltbotConfigured(),
+            error: "OAuth authentication detected. smoltbot only supports API key authentication.\n" +
+                "To use smoltbot, add an API key to your Anthropic auth profile.",
+        };
+    }
+    if (!key) {
+        return {
+            installed: true,
+            hasApiKey: false,
+            isOAuth: false,
+            smoltbotAlreadyConfigured: isSmoltbotConfigured(),
+            error: "No Anthropic API key found in auth-profiles.json.\n" +
+                "Run `openclaw auth` to configure your API key.",
+        };
+    }
+    // Get current model
+    const { fullPath, provider, modelId } = getCurrentModel();
+    return {
+        installed: true,
+        hasApiKey: true,
+        isOAuth: false,
+        apiKey: key,
+        currentModel: fullPath || undefined,
+        currentModelId: modelId || undefined,
+        currentProvider: provider || undefined,
+        smoltbotAlreadyConfigured: isSmoltbotConfigured(),
+    };
+}
+/**
+ * Configure the smoltbot provider in OpenClaw config
+ */
+export function configureSmoltbotProvider(apiKey, models) {
+    const config = loadOpenClawConfig();
+    if (!config) {
+        throw new Error("Could not load OpenClaw config");
+    }
+    // Ensure models section exists
+    if (!config.models) {
+        config.models = {};
+    }
+    if (!config.models.providers) {
+        config.models.providers = {};
+    }
+    // Set mode to merge if not set
+    if (!config.models.mode) {
+        config.models.mode = "merge";
+    }
+    // Configure smoltbot provider
+    config.models.providers.smoltbot = {
+        baseUrl: "https://gateway.mnemom.ai/anthropic",
+        apiKey: apiKey,
+        api: "anthropic-messages",
+        models: models,
+    };
+    saveOpenClawConfig(config);
+}
+/**
+ * Set the default model in OpenClaw config
+ */
+export function setDefaultModel(modelPath) {
+    const config = loadOpenClawConfig();
+    if (!config) {
+        throw new Error("Could not load OpenClaw config");
+    }
+    // Ensure agents.defaults.model section exists
+    if (!config.agents) {
+        config.agents = {};
+    }
+    if (!config.agents.defaults) {
+        config.agents.defaults = {};
+    }
+    if (!config.agents.defaults.model) {
+        config.agents.defaults.model = {};
+    }
+    // Also add to models map if not present
+    if (!config.agents.defaults.models) {
+        config.agents.defaults.models = {};
+    }
+    config.agents.defaults.model.primary = modelPath;
+    config.agents.defaults.models[modelPath] = {};
+    saveOpenClawConfig(config);
+}

package/dist/lib/prompt.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ask a yes/no question with a default answer
+ * @param question The question to ask
+ * @param defaultYes If true, default is Yes (Y/n), otherwise default is No (y/N)
+ * @returns Promise<boolean> - true for yes, false for no
+ */
+export declare function askYesNo(question: string, defaultYes?: boolean): Promise<boolean>;
+/**
+ * Check if running in non-interactive mode (no TTY)
+ */
+export declare function isInteractive(): boolean;

package/dist/lib/prompt.js

@@ -0,0 +1,40 @@
+import * as readline from "node:readline";
+/**
+ * Ask a yes/no question with a default answer
+ * @param question The question to ask
+ * @param defaultYes If true, default is Yes (Y/n), otherwise default is No (y/N)
+ * @returns Promise<boolean> - true for yes, false for no
+ */
+export async function askYesNo(question, defaultYes = true) {
+    const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} ${suffix} `, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === "") {
+                // Use default
+                resolve(defaultYes);
+            }
+            else if (normalized === "y" || normalized === "yes") {
+                resolve(true);
+            }
+            else if (normalized === "n" || normalized === "no") {
+                resolve(false);
+            }
+            else {
+                // Invalid input, use default
+                resolve(defaultYes);
+            }
+        });
+    });
+}
+/**
+ * Check if running in non-interactive mode (no TTY)
+ */
+export function isInteractive() {
+    return process.stdin.isTTY === true;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@mnemom/smoltbot",
+  "version": "2.0.1",
+  "description": "Transparent AI agent tracing - AAP compliant",
+  "type": "module",
+  "bin": {
+    "smoltbot": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "files": ["dist", "!dist/__tests__", "README.md", "LICENSE"],
+  "keywords": ["ai", "agent", "transparency", "aap", "alignment", "tracing", "observability"],
+  "author": "Mnemom.ai",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mnemom/smoltbot"
+  },
+  "homepage": "https://mnemom.ai",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}