run-dmcp 0.1.0

package/dist/tools/ability.js

@@ -0,0 +1,238 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { validateGameExists } from "./game.js";
+import { getCharacter } from "./character.js";
+export function createAbility(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    const ownerId = params.ownerType === "template" ? null : (params.ownerId || null);
+    db.prepare(`
+    INSERT INTO abilities (id, game_id, owner_id, owner_type, name, description, category, cost, cooldown, effects, requirements, tags, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, ownerId, params.ownerType, params.name, params.description || "", params.category || null, JSON.stringify(params.cost || {}), params.cooldown ?? null, JSON.stringify(params.effects || []), JSON.stringify(params.requirements || {}), JSON.stringify(params.tags || []), now);
+    return {
+        id,
+        gameId: params.gameId,
+        ownerId,
+        ownerType: params.ownerType,
+        name: params.name,
+        description: params.description || "",
+        category: params.category || null,
+        cost: params.cost || {},
+        cooldown: params.cooldown ?? null,
+        currentCooldown: 0,
+        effects: params.effects || [],
+        requirements: params.requirements || {},
+        tags: params.tags || [],
+        createdAt: now,
+    };
+}
+export function getAbility(id) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM abilities WHERE id = ?`).get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        description: row.description,
+        category: row.category,
+        cost: safeJsonParse(row.cost || "{}", {}),
+        cooldown: row.cooldown,
+        currentCooldown: row.current_cooldown,
+        effects: safeJsonParse(row.effects || "[]", []),
+        requirements: safeJsonParse(row.requirements || "{}", {}),
+        tags: safeJsonParse(row.tags || "[]", []),
+        createdAt: row.created_at,
+    };
+}
+export function updateAbility(id, updates) {
+    const db = getDatabase();
+    const current = getAbility(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newDescription = updates.description ?? current.description;
+    const newCategory = updates.category !== undefined ? updates.category : current.category;
+    const newCost = updates.cost ?? current.cost;
+    const newCooldown = updates.cooldown !== undefined ? updates.cooldown : current.cooldown;
+    const newEffects = updates.effects ?? current.effects;
+    const newRequirements = updates.requirements ?? current.requirements;
+    const newTags = updates.tags ?? current.tags;
+    db.prepare(`
+    UPDATE abilities
+    SET name = ?, description = ?, category = ?, cost = ?, cooldown = ?, effects = ?, requirements = ?, tags = ?
+    WHERE id = ?
+  `).run(newName, newDescription, newCategory, JSON.stringify(newCost), newCooldown, JSON.stringify(newEffects), JSON.stringify(newRequirements), JSON.stringify(newTags), id);
+    return {
+        ...current,
+        name: newName,
+        description: newDescription,
+        category: newCategory,
+        cost: newCost,
+        cooldown: newCooldown,
+        effects: newEffects,
+        requirements: newRequirements,
+        tags: newTags,
+    };
+}
+export function deleteAbility(id) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM abilities WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+export function listAbilities(gameId, filter) {
+    const db = getDatabase();
+    let query = `SELECT * FROM abilities WHERE game_id = ?`;
+    const params = [gameId];
+    if (filter?.ownerType) {
+        query += ` AND owner_type = ?`;
+        params.push(filter.ownerType);
+    }
+    if (filter?.ownerId) {
+        query += ` AND owner_id = ?`;
+        params.push(filter.ownerId);
+    }
+    if (filter?.category) {
+        query += ` AND category = ?`;
+        params.push(filter.category);
+    }
+    query += ` ORDER BY name`;
+    const rows = db.prepare(query).all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        ownerId: row.owner_id,
+        ownerType: row.owner_type,
+        name: row.name,
+        description: row.description,
+        category: row.category,
+        cost: safeJsonParse(row.cost || "{}", {}),
+        cooldown: row.cooldown,
+        currentCooldown: row.current_cooldown,
+        effects: safeJsonParse(row.effects || "[]", []),
+        requirements: safeJsonParse(row.requirements || "{}", {}),
+        tags: safeJsonParse(row.tags || "[]", []),
+        createdAt: row.created_at,
+    }));
+}
+export function learnAbility(templateId, characterId) {
+    const db = getDatabase();
+    const template = getAbility(templateId);
+    if (!template || template.ownerType !== "template")
+        return null;
+    // Validate character exists before creating ability
+    const character = getCharacter(characterId);
+    if (!character) {
+        throw new Error(`Character '${characterId}' not found. Cannot learn ability without a valid character.`);
+    }
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    db.prepare(`
+    INSERT INTO abilities (id, game_id, owner_id, owner_type, name, description, category, cost, cooldown, effects, requirements, tags, created_at)
+    VALUES (?, ?, ?, 'character', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, template.gameId, characterId, template.name, template.description, template.category, JSON.stringify(template.cost), template.cooldown, JSON.stringify(template.effects), JSON.stringify(template.requirements), JSON.stringify(template.tags), now);
+    return {
+        id,
+        gameId: template.gameId,
+        ownerId: characterId,
+        ownerType: "character",
+        name: template.name,
+        description: template.description,
+        category: template.category,
+        cost: template.cost,
+        cooldown: template.cooldown,
+        currentCooldown: 0,
+        effects: template.effects,
+        requirements: template.requirements,
+        tags: template.tags,
+        createdAt: now,
+    };
+}
+export function useAbility(abilityId, _characterId) {
+    const db = getDatabase();
+    const ability = getAbility(abilityId);
+    if (!ability) {
+        return { success: false, ability: null, reason: "Ability not found" };
+    }
+    // Check cooldown
+    if (ability.currentCooldown > 0) {
+        return {
+            success: false,
+            ability,
+            reason: `Ability on cooldown (${ability.currentCooldown} rounds remaining)`,
+        };
+    }
+    // Check costs (would need character resources to validate)
+    // For now, we just set the cooldown and return success
+    // In a full implementation, we'd deduct from character resources
+    if (ability.cooldown && ability.cooldown > 0) {
+        db.prepare(`UPDATE abilities SET current_cooldown = ? WHERE id = ?`)
+            .run(ability.cooldown, abilityId);
+    }
+    return {
+        success: true,
+        ability: { ...ability, currentCooldown: ability.cooldown || 0 },
+        costsPaid: ability.cost,
+    };
+}
+export function tickCooldowns(gameId, amount = 1) {
+    const db = getDatabase();
+    // Get all abilities on cooldown
+    const rows = db.prepare(`
+    SELECT * FROM abilities WHERE game_id = ? AND current_cooldown > 0
+  `).all(gameId);
+    const updated = [];
+    for (const row of rows) {
+        const currentCooldown = row.current_cooldown;
+        const newCooldown = Math.max(0, currentCooldown - amount);
+        db.prepare(`UPDATE abilities SET current_cooldown = ? WHERE id = ?`)
+            .run(newCooldown, row.id);
+        updated.push({
+            id: row.id,
+            gameId: row.game_id,
+            ownerId: row.owner_id,
+            ownerType: row.owner_type,
+            name: row.name,
+            description: row.description,
+            category: row.category,
+            cost: safeJsonParse(row.cost || "{}", {}),
+            cooldown: row.cooldown,
+            currentCooldown: newCooldown,
+            effects: safeJsonParse(row.effects || "[]", []),
+            requirements: safeJsonParse(row.requirements || "{}", {}),
+            tags: safeJsonParse(row.tags || "[]", []),
+            createdAt: row.created_at,
+        });
+    }
+    return updated;
+}
+export function checkRequirements(abilityId, characterId) {
+    const ability = getAbility(abilityId);
+    if (!ability)
+        return null;
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    const missing = {};
+    for (const [key, required] of Object.entries(ability.requirements)) {
+        // Check attributes first, then status
+        const actual = character.attributes[key]
+            ?? character.status[key]
+            ?? 0;
+        if (actual < required) {
+            missing[key] = { required, actual };
+        }
+    }
+    return {
+        meetsRequirements: Object.keys(missing).length === 0,
+        missing,
+    };
+}

package/dist/tools/audio.d.ts

@@ -0,0 +1,24 @@
+import type { StoredAudio, StoreAudioParams, AudioListResult, VoiceReferenceResult } from "../types/index.js";
+export declare function storeAudio(params: StoreAudioParams): Promise<StoredAudio>;
+export declare function getAudio(audioId: string): StoredAudio | null;
+export declare function getAudioFilePath(audioId: string): string | null;
+export declare function getAudioData(audioId: string): {
+    audio: StoredAudio;
+    base64: string;
+} | null;
+export declare function listEntityAudio(entityId: string, entityType: string): AudioListResult;
+export declare function listGameAudio(gameId: string): StoredAudio[];
+export declare function listVoiceReferences(gameId: string, characterId?: string): StoredAudio[];
+export declare function getCharacterVoiceReferences(gameId: string, characterId: string): VoiceReferenceResult | null;
+export declare function deleteAudio(audioId: string): boolean;
+export declare function setPrimaryAudio(audioId: string): StoredAudio | null;
+export declare function updateAudioMetadata(audioId: string, updates: {
+    label?: string;
+    description?: string;
+    ttsText?: string;
+    voiceName?: string;
+    voiceDescription?: string;
+    isVoiceReference?: boolean;
+}): StoredAudio | null;
+export declare function deleteGameAudio(gameId: string): number;
+export declare function getPrimaryAudio(entityId: string, entityType: string): StoredAudio | null;

package/dist/tools/audio.js

@@ -0,0 +1,365 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase, getDataDir, withTransaction } from "../db/connection.js";
+import { writeFileSync, readFileSync, mkdirSync, existsSync, unlinkSync, rmSync, } from "fs";
+import { dirname, join, extname } from "path";
+import { getCharacter } from "./character.js";
+import { getLocation } from "./world.js";
+import { getFaction } from "./faction.js";
+// Use the same data directory as the database, but in an 'audio' subdirectory
+function getAudioDir() {
+    return join(getDataDir(), "audio");
+}
+// Helper: Validate entity exists and return its name
+function validateEntityAndGetName(entityId, entityType) {
+    let entity = null;
+    switch (entityType) {
+        case "character":
+            entity = getCharacter(entityId);
+            break;
+        case "location":
+            entity = getLocation(entityId);
+            break;
+        case "faction":
+            entity = getFaction(entityId);
+            break;
+        default:
+            // For other entity types (game, scene, narration, etc.), skip validation
+            return entityType.charAt(0).toUpperCase() + entityType.slice(1);
+    }
+    if (!entity) {
+        throw new Error(`${entityType} not found: ${entityId}`);
+    }
+    return entity.name;
+}
+// Helper: Ensure directory exists
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+// Helper: Get extension from mime type
+function getExtension(mimeType) {
+    const map = {
+        "audio/mpeg": "mp3",
+        "audio/mp3": "mp3",
+        "audio/wav": "wav",
+        "audio/wave": "wav",
+        "audio/x-wav": "wav",
+        "audio/ogg": "ogg",
+        "audio/flac": "flac",
+        "audio/aac": "aac",
+        "audio/m4a": "m4a",
+        "audio/mp4": "m4a",
+        "audio/webm": "webm",
+    };
+    return map[mimeType] || "mp3";
+}
+// Helper: Get mime type from extension
+function getMimeType(ext) {
+    const map = {
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+        ogg: "audio/ogg",
+        flac: "audio/flac",
+        aac: "audio/aac",
+        m4a: "audio/m4a",
+        webm: "audio/webm",
+    };
+    return map[ext.toLowerCase().replace(".", "")] || "audio/mpeg";
+}
+// Helper: Map database row to StoredAudio
+function mapRowToStoredAudio(row) {
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        entityId: row.entity_id,
+        entityType: row.entity_type,
+        filePath: row.file_path,
+        fileSize: row.file_size,
+        mimeType: row.mime_type,
+        durationMs: row.duration_ms,
+        sampleRate: row.sample_rate,
+        label: row.label,
+        description: row.description,
+        source: row.source,
+        sourceUrl: row.source_url,
+        ttsEngine: row.tts_engine,
+        ttsVoice: row.tts_voice,
+        ttsText: row.tts_text,
+        ttsSettings: row.tts_settings ? JSON.parse(row.tts_settings) : null,
+        isVoiceReference: row.is_voice_reference === 1,
+        voiceName: row.voice_name,
+        voiceDescription: row.voice_description,
+        isPrimary: row.is_primary === 1,
+        createdAt: row.created_at,
+    };
+}
+export async function storeAudio(params) {
+    // Validate entity exists and get its name for confirmation
+    const entityName = validateEntityAndGetName(params.entityId, params.entityType);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    let audioBuffer;
+    let mimeType;
+    let source;
+    let sourceUrl = null;
+    if (params.url) {
+        // Fetch audio from URL
+        const response = await fetch(params.url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch audio: ${response.status}`);
+        }
+        audioBuffer = Buffer.from(await response.arrayBuffer());
+        mimeType = response.headers.get("content-type") || params.mimeType || "audio/mpeg";
+        source = params.ttsEngine ? "generated" : "url";
+        sourceUrl = params.url;
+    }
+    else if (params.filePath) {
+        // Copy from local file
+        if (!existsSync(params.filePath)) {
+            throw new Error(`File not found: ${params.filePath}`);
+        }
+        audioBuffer = readFileSync(params.filePath);
+        const ext = extname(params.filePath).slice(1);
+        mimeType = params.mimeType || getMimeType(ext);
+        source = params.ttsEngine ? "generated" : "uploaded";
+    }
+    else {
+        throw new Error("Either url or filePath must be provided");
+    }
+    // Build file path
+    const ext = getExtension(mimeType);
+    const relativePath = join(params.gameId, `${params.entityType}s`, params.entityId, `${id}.${ext}`);
+    const fullPath = join(getAudioDir(), relativePath);
+    // Ensure directory exists and write file
+    ensureDir(dirname(fullPath));
+    writeFileSync(fullPath, audioBuffer);
+    // If setting as primary, unset current primary first
+    if (params.setAsPrimary) {
+        db.prepare(`
+      UPDATE stored_audio SET is_primary = 0
+      WHERE entity_id = ? AND entity_type = ?
+    `).run(params.entityId, params.entityType);
+    }
+    // Insert database record
+    const stmt = db.prepare(`
+    INSERT INTO stored_audio (
+      id, game_id, entity_id, entity_type, file_path, file_size, mime_type,
+      duration_ms, sample_rate, label, description, source, source_url,
+      tts_engine, tts_voice, tts_text, tts_settings,
+      is_voice_reference, voice_name, voice_description,
+      is_primary, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, params.gameId, params.entityId, params.entityType, relativePath, audioBuffer.length, mimeType, null, // duration_ms - would need audio parsing library
+    null, // sample_rate - would need audio parsing library
+    params.label || null, params.description || null, source, sourceUrl, params.ttsEngine || null, params.ttsVoice || null, params.ttsText || null, params.ttsSettings ? JSON.stringify(params.ttsSettings) : null, params.isVoiceReference ? 1 : 0, params.voiceName || null, params.voiceDescription || null, params.setAsPrimary ? 1 : 0, now);
+    return {
+        id,
+        gameId: params.gameId,
+        entityId: params.entityId,
+        entityType: params.entityType,
+        entityName,
+        filePath: relativePath,
+        fileSize: audioBuffer.length,
+        mimeType,
+        durationMs: null,
+        sampleRate: null,
+        label: params.label || null,
+        description: params.description || null,
+        source,
+        sourceUrl,
+        ttsEngine: params.ttsEngine || null,
+        ttsVoice: params.ttsVoice || null,
+        ttsText: params.ttsText || null,
+        ttsSettings: params.ttsSettings || null,
+        isVoiceReference: params.isVoiceReference || false,
+        voiceName: params.voiceName || null,
+        voiceDescription: params.voiceDescription || null,
+        isPrimary: params.setAsPrimary || false,
+        createdAt: now,
+    };
+}
+export function getAudio(audioId) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM stored_audio WHERE id = ?`).get(audioId);
+    if (!row)
+        return null;
+    return mapRowToStoredAudio(row);
+}
+export function getAudioFilePath(audioId) {
+    const audio = getAudio(audioId);
+    if (!audio)
+        return null;
+    const fullPath = join(getAudioDir(), audio.filePath);
+    if (!existsSync(fullPath))
+        return null;
+    return fullPath;
+}
+export function getAudioData(audioId) {
+    const audio = getAudio(audioId);
+    if (!audio)
+        return null;
+    const fullPath = join(getAudioDir(), audio.filePath);
+    if (!existsSync(fullPath))
+        return null;
+    const buffer = readFileSync(fullPath);
+    const base64 = `data:${audio.mimeType};base64,${buffer.toString("base64")}`;
+    return { audio, base64 };
+}
+export function listEntityAudio(entityId, entityType) {
+    const db = getDatabase();
+    const rows = db
+        .prepare(`
+    SELECT * FROM stored_audio
+    WHERE entity_id = ? AND entity_type = ?
+    ORDER BY is_primary DESC, created_at DESC
+  `)
+        .all(entityId, entityType);
+    const audioFiles = rows.map(mapRowToStoredAudio);
+    const primaryAudio = audioFiles.find((a) => a.isPrimary) || null;
+    return { entityId, entityType, audioFiles, primaryAudio };
+}
+export function listGameAudio(gameId) {
+    const db = getDatabase();
+    const rows = db
+        .prepare(`
+    SELECT * FROM stored_audio
+    WHERE game_id = ?
+    ORDER BY created_at DESC
+  `)
+        .all(gameId);
+    return rows.map(mapRowToStoredAudio);
+}
+export function listVoiceReferences(gameId, characterId) {
+    const db = getDatabase();
+    if (characterId) {
+        const rows = db
+            .prepare(`
+      SELECT * FROM stored_audio
+      WHERE game_id = ? AND entity_id = ? AND is_voice_reference = 1
+      ORDER BY created_at DESC
+    `)
+            .all(gameId, characterId);
+        return rows.map(mapRowToStoredAudio);
+    }
+    else {
+        const rows = db
+            .prepare(`
+      SELECT * FROM stored_audio
+      WHERE game_id = ? AND is_voice_reference = 1
+      ORDER BY entity_id, created_at DESC
+    `)
+            .all(gameId);
+        return rows.map(mapRowToStoredAudio);
+    }
+}
+export function getCharacterVoiceReferences(gameId, characterId) {
+    const character = getCharacter(characterId);
+    if (!character)
+        return null;
+    const voiceRefs = listVoiceReferences(gameId, characterId);
+    // Build full file paths for convenience (ready to pass to TTS tools)
+    const audioDir = getAudioDir();
+    const filePaths = voiceRefs
+        .map((ref) => {
+        const fullPath = join(audioDir, ref.filePath);
+        return existsSync(fullPath) ? fullPath : null;
+    })
+        .filter((p) => p !== null);
+    return {
+        gameId,
+        characterId,
+        characterName: character.name,
+        voiceReferences: voiceRefs,
+        filePaths,
+        totalCount: voiceRefs.length,
+    };
+}
+export function deleteAudio(audioId) {
+    const db = getDatabase();
+    const audio = getAudio(audioId);
+    if (!audio)
+        return false;
+    // Delete file
+    const fullPath = join(getAudioDir(), audio.filePath);
+    if (existsSync(fullPath)) {
+        unlinkSync(fullPath);
+    }
+    // Delete database record
+    const result = db.prepare(`DELETE FROM stored_audio WHERE id = ?`).run(audioId);
+    return result.changes > 0;
+}
+export function setPrimaryAudio(audioId) {
+    const audio = getAudio(audioId);
+    if (!audio)
+        return null;
+    // Unsetting the old primary and setting the new one must happen
+    // together -- a failure between the two could otherwise leave the entity
+    // with zero primaries, or briefly with two.
+    withTransaction(() => {
+        const db = getDatabase();
+        // Unset current primary
+        db.prepare(`
+      UPDATE stored_audio SET is_primary = 0
+      WHERE entity_id = ? AND entity_type = ?
+    `).run(audio.entityId, audio.entityType);
+        // Set new primary
+        db.prepare(`UPDATE stored_audio SET is_primary = 1 WHERE id = ?`).run(audioId);
+    });
+    return { ...audio, isPrimary: true };
+}
+export function updateAudioMetadata(audioId, updates) {
+    const db = getDatabase();
+    const current = getAudio(audioId);
+    if (!current)
+        return null;
+    const newLabel = updates.label !== undefined ? updates.label : current.label;
+    const newDescription = updates.description !== undefined ? updates.description : current.description;
+    const newTtsText = updates.ttsText !== undefined ? updates.ttsText : current.ttsText;
+    const newVoiceName = updates.voiceName !== undefined ? updates.voiceName : current.voiceName;
+    const newVoiceDescription = updates.voiceDescription !== undefined ? updates.voiceDescription : current.voiceDescription;
+    const newIsVoiceReference = updates.isVoiceReference !== undefined ? updates.isVoiceReference : current.isVoiceReference;
+    db.prepare(`
+    UPDATE stored_audio
+    SET label = ?, description = ?, tts_text = ?, voice_name = ?, voice_description = ?, is_voice_reference = ?
+    WHERE id = ?
+  `).run(newLabel, newDescription, newTtsText, newVoiceName, newVoiceDescription, newIsVoiceReference ? 1 : 0, audioId);
+    return {
+        ...current,
+        label: newLabel,
+        description: newDescription,
+        ttsText: newTtsText,
+        voiceName: newVoiceName,
+        voiceDescription: newVoiceDescription,
+        isVoiceReference: newIsVoiceReference,
+    };
+}
+// Cleanup helper - delete all audio for a game
+export function deleteGameAudio(gameId) {
+    const db = getDatabase();
+    // Delete files
+    const gameDir = join(getAudioDir(), gameId);
+    if (existsSync(gameDir)) {
+        rmSync(gameDir, { recursive: true, force: true });
+    }
+    // Delete records (cascade should handle this, but be explicit)
+    const result = db
+        .prepare(`DELETE FROM stored_audio WHERE game_id = ?`)
+        .run(gameId);
+    return result.changes;
+}
+// Get primary audio for an entity
+export function getPrimaryAudio(entityId, entityType) {
+    const db = getDatabase();
+    const row = db
+        .prepare(`
+    SELECT * FROM stored_audio
+    WHERE entity_id = ? AND entity_type = ? AND is_primary = 1
+  `)
+        .get(entityId, entityType);
+    if (!row)
+        return null;
+    return mapRowToStoredAudio(row);
+}

package/dist/tools/character.d.ts

@@ -0,0 +1,70 @@
+import type { Character, CharacterStatus, VoiceDescription, ImageGeneration } from "../types/index.js";
+export declare function createCharacter(params: {
+    gameId: string;
+    name: string;
+    isPlayer: boolean;
+    attributes?: Record<string, number>;
+    skills?: Record<string, number>;
+    status?: Partial<CharacterStatus>;
+    locationId?: string;
+    notes?: string;
+    voice?: VoiceDescription;
+    imageGen?: ImageGeneration;
+}): Character;
+export declare function getCharacter(id: string): Character | null;
+export declare function updateCharacter(id: string, updates: {
+    name?: string;
+    attributes?: Record<string, number>;
+    skills?: Record<string, number>;
+    status?: Partial<CharacterStatus>;
+    locationId?: string | null;
+    notes?: string;
+    voice?: VoiceDescription | null;
+    imageGen?: ImageGeneration | null;
+}): Character | null;
+export declare function deleteCharacter(id: string): boolean;
+export declare function listCharacters(gameId: string, filter?: {
+    isPlayer?: boolean;
+    locationId?: string;
+}): Character[];
+/**
+ * Find a character by name (case-insensitive, fuzzy match).
+ * Returns the best match or null if no reasonable match found.
+ */
+export declare function getCharacterByName(gameId: string, name: string): Character | null;
+export declare function moveCharacter(characterId: string, locationId: string | null): boolean;
+/**
+ * Modify a character's health - damage or heal in a single call.
+ * Use mode: "damage" to reduce health, mode: "heal" to restore health.
+ */
+export declare function modifyHealth(characterId: string, params: {
+    mode: "damage" | "heal";
+    amount: number;
+}): {
+    character: Character;
+    previousHealth: number;
+    newHealth: number;
+} | null;
+export declare function addCondition(characterId: string, condition: string): Character | null;
+export declare function removeCondition(characterId: string, condition: string): Character | null;
+/**
+ * Modify conditions on a character - add or remove in a single call.
+ * This consolidated function reduces the number of tool calls needed.
+ */
+export declare function modifyConditions(characterId: string, params: {
+    add?: string[];
+    remove?: string[];
+}): {
+    character: Character;
+    added: string[];
+    removed: string[];
+} | null;
+export interface CharacterSheetData {
+    character: Character;
+    locationName: string | null;
+    inventory: Array<{
+        name: string;
+        type?: string;
+    }>;
+}
+export declare function renderCharacterSheet(characterId: string): CharacterSheetData | null;