dayloom 0.1.0-beta.0

package/dist/init/project-payload.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectPayload = projectPayload;
+function projectPayload(payload) {
+    const files = [
+        {
+            relativePath: 'manifest.yaml',
+            content: [
+                `id: ${payload.manifest.id}`,
+                `protocol_version: "0.0.0"`,
+                `created_at: ${new Date().toISOString()}`,
+                `title: ${yamlString(payload.manifest.title)}`,
+                '',
+            ].join('\n'),
+        },
+        { relativePath: 'canon/premise.md', content: payload.canon['premise.md'] },
+        { relativePath: 'canon/rules.md', content: payload.canon['rules.md'] },
+        { relativePath: 'canon/style.md', content: payload.canon['style.md'] },
+        { relativePath: 'canon/user_role.md', content: payload.canon['user_role.md'] },
+        { relativePath: 'state/world.yaml', content: payload.state['world.yaml'] },
+        {
+            relativePath: 'characters/index.yaml',
+            content: yamlIdList('characters', payload.characters.map(char => char.id)),
+        },
+    ];
+    if (payload.state['calendar.yaml']) {
+        files.push({
+            relativePath: 'state/calendar.yaml',
+            content: payload.state['calendar.yaml'],
+        });
+    }
+    for (const char of payload.characters) {
+        const dir = `characters/${char.id}`;
+        files.push({ relativePath: `${dir}/profile.md`, content: char.profileMd }, {
+            relativePath: `${dir}/relationships.md`,
+            content: char.relationshipsMd ?? '# Relationships\n\n',
+        }, {
+            relativePath: `${dir}/meta.yaml`,
+            content: entityMetaYaml(char.id, 'character', char.meta),
+        }, { relativePath: `${dir}/memory.md`, content: '' }, { relativePath: `${dir}/timeline.md`, content: '' });
+    }
+    if (payload.scenes?.length) {
+        files.push({
+            relativePath: 'scenes/index.yaml',
+            content: yamlIdList('scenes', payload.scenes.map(scene => scene.id)),
+        });
+        for (const scene of payload.scenes) {
+            const dir = `scenes/${scene.id}`;
+            files.push({ relativePath: `${dir}/profile.md`, content: scene.profileMd }, {
+                relativePath: `${dir}/meta.yaml`,
+                content: entityMetaYaml(scene.id, 'scene', scene.meta),
+            }, { relativePath: `${dir}/memory.md`, content: '' }, { relativePath: `${dir}/triggers.yaml`, content: 'triggers: []\n' }, { relativePath: `${dir}/timeline.md`, content: '' });
+        }
+    }
+    return files;
+}
+function yamlIdList(key, ids) {
+    return `${key}:\n${ids.map(id => `  - ${yamlString(id)}`).join('\n')}\n`;
+}
+function entityMetaYaml(id, type, meta) {
+    const tags = meta?.tags ?? [];
+    return [
+        `id: ${yamlScalar(id)}`,
+        `type: ${type}`,
+        `status: ${yamlScalar(meta?.status ?? 'active')}`,
+        tags.length ? `tags:\n${tags.map(tag => `  - ${yamlScalar(tag)}`).join('\n')}` : 'tags: []',
+        '',
+    ].join('\n');
+}
+function yamlString(value) {
+    if (/[:#\n'"]/.test(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+function yamlScalar(value) {
+    return JSON.stringify(value);
+}

package/dist/init/promptpile-run.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPromptpileSpawnConfig = getPromptpileSpawnConfig;
+exports.runPromptpile = runPromptpile;
+exports.assertPromptpileOk = assertPromptpileOk;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const promptpile_stream_1 = require("../shared/promptpile-stream");
+const process_run_1 = require("../revise/process-run");
+const OUTPUT_PILE_FD = 3;
+function tryResolveBundledPromptpileScript() {
+    try {
+        const pkgJson = require.resolve('promptpile/package.json');
+        const script = path_1.default.join(path_1.default.dirname(pkgJson), 'dist', 'index.js');
+        return fs_1.default.existsSync(script) ? script : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getPromptpileSpawnConfig() {
+    const bin = process.env.PROMPTPILE_BIN?.trim();
+    if (bin) {
+        return { command: bin, argvPrefix: [], displayName: bin };
+    }
+    const bundled = tryResolveBundledPromptpileScript();
+    if (bundled) {
+        return {
+            command: process.execPath,
+            argvPrefix: [bundled],
+            displayName: 'node "' + bundled + '"',
+        };
+    }
+    return { command: 'promptpile', argvPrefix: [], displayName: 'promptpile' };
+}
+async function runPromptpile(session, cliArgs, options = {}) {
+    const spawnConfig = getPromptpileSpawnConfig();
+    const consumer = (0, promptpile_stream_1.createPromptpileStreamConsumer)({
+        onDelta: text => options.onDelta?.(text),
+        onError: message => {
+            throw new Error('promptpile stream error: ' + message);
+        }
+    });
+    const result = await (0, process_run_1.runProcess)(spawnConfig.command, [
+        ...spawnConfig.argvPrefix,
+        ...cliArgs,
+        '--quiet',
+        '--output-pile-fd',
+        String(OUTPUT_PILE_FD),
+        '--output-pile-format',
+        'json'
+    ], {
+        cwd: session.root,
+        quiet: options.quiet ?? true,
+        outputPile: {
+            fd: OUTPUT_PILE_FD,
+            onData: chunk => consumer.push(chunk)
+        }
+    });
+    try {
+        consumer.flush();
+    }
+    catch (e) {
+        return { ...result, error: e instanceof Error ? e : new Error(String(e)) };
+    }
+    return result;
+}
+function assertPromptpileOk(result, context) {
+    if (result.error) {
+        throw new Error(context + ': failed to run promptpile (' + result.error.message + '). ' +
+            'Check ' + getPromptpileSpawnConfig().displayName + ' is available.');
+    }
+    if (result.status !== 0) {
+        const tail = result.stderr.trim().slice(-500);
+        throw new Error(context + ': promptpile exited with code ' + result.status + (tail ? ': ' + tail : ''));
+    }
+}

package/dist/init/prompts.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPrompt = loadPrompt;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const PROMPTS_DIR = path_1.default.resolve(__dirname, '../../prompts');
+function loadPrompt(name) {
+    const filePath = path_1.default.join(PROMPTS_DIR, `${name}.system.md`);
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`Prompt not found: ${filePath}`);
+    }
+    return fs_1.default.readFileSync(filePath, 'utf8');
+}

package/dist/init/read-user-input.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUserInput = readUserInput;
+const readline_1 = __importDefault(require("readline"));
+const errors_1 = require("./errors");
+async function readMultilineInput() {
+    process.stdout.write('\nEnter your reply. Finish with Ctrl+Z then Enter (Windows), or Ctrl+D (macOS/Linux).\n');
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const lines = [];
+    for await (const line of rl) {
+        lines.push(line);
+    }
+    rl.close();
+    return lines.join('\n');
+}
+function askExitOnEmpty() {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => {
+        rl.question('Empty input. Exit? (Y/N): ', answer => {
+            rl.close();
+            resolve(/^y$/i.test(answer.trim()));
+        });
+    });
+}
+async function readUserInput() {
+    while (true) {
+        const text = (await readMultilineInput()).trim();
+        if (text) {
+            return text;
+        }
+        if (await askExitOnEmpty()) {
+            throw new errors_1.InitCancelledError();
+        }
+    }
+}

package/dist/init/scaffold.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldEmptyWorld = scaffoldEmptyWorld;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+function writeFileIfMissing(filePath, content) {
+    if (fs_1.default.existsSync(filePath)) {
+        throw new Error(`Refusing to overwrite existing file: ${filePath}`);
+    }
+    fs_1.default.writeFileSync(filePath, content, 'utf8');
+}
+function ensureDir(dirPath) {
+    fs_1.default.mkdirSync(dirPath, { recursive: true });
+}
+function scaffoldEmptyWorld(worldRoot, meta) {
+    const createdAt = meta.createdAt ?? new Date().toISOString();
+    ensureDir(worldRoot);
+    const files = [
+        [
+            'manifest.yaml',
+            [
+                `id: ${meta.id}`,
+                `protocol_version: "${constants_1.PROTOCOL_VERSION}"`,
+                `created_at: ${createdAt}`,
+                `title: ${meta.title}`,
+                '',
+            ].join('\n'),
+        ],
+        [
+            'current.yaml',
+            ['day: day_0001', 'phase: idle', 'last_committed_day: null', ''].join('\n'),
+        ],
+        ['config.yaml', '# dayloom runtime config\n\n'],
+        ['canon/premise.md', ''],
+        ['canon/rules.md', ''],
+        ['canon/style.md', ''],
+        ['canon/user_role.md', ''],
+        ['state/world.yaml', 'title: ""\n'],
+        ['state/calendar.yaml', 'current_day: day_0001\n'],
+        ['state/progress.yaml', 'arcs_active: []\n'],
+        ['state/variables.yaml', 'variables: {}\n'],
+        ['characters/index.yaml', 'characters: []\n'],
+        ['scenes/index.yaml', 'scenes: []\n'],
+        ['arcs/index.yaml', 'arcs: []\n'],
+        ['memory/short_term.md', ''],
+        ['memory/long_term.md', ''],
+        ['memory/facts.yaml', 'facts: []\n'],
+        ['memory/unresolved_threads.yaml', 'threads: []\n'],
+        ['memory/important_events.yaml', 'events: []\n'],
+        ['logs/state_changes.jsonl', ''],
+        ['logs/generation_trace.md', ''],
+        ['logs/errors.md', ''],
+    ];
+    for (const [rel, content] of files) {
+        const filePath = path_1.default.join(worldRoot, rel);
+        ensureDir(path_1.default.dirname(filePath));
+        writeFileIfMissing(filePath, content);
+    }
+    ensureDir(path_1.default.join(worldRoot, 'days'));
+    ensureDir(path_1.default.join(worldRoot, 'exports', 'diaries'));
+    ensureDir(path_1.default.join(worldRoot, 'exports', 'summaries'));
+}

package/dist/init/session.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanMessageIndices = scanMessageIndices;
+exports.appendUserMessage = appendUserMessage;
+exports.getLatestAssistantText = getLatestAssistantText;
+exports.buildTranscript = buildTranscript;
+exports.createSession = createSession;
+exports.writeOpeningAssistant = writeOpeningAssistant;
+exports.createFinalizeSession = createFinalizeSession;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const prompts_1 = require("./prompts");
+const MESSAGE_PATTERN = /^\[(\d+)\](.+)\.md$/i;
+function scanMessageIndices(messagesDir) {
+    if (!fs_1.default.existsSync(messagesDir)) {
+        return [];
+    }
+    const indices = new Set();
+    for (const name of fs_1.default.readdirSync(messagesDir)) {
+        const m = name.match(MESSAGE_PATTERN);
+        if (m) {
+            indices.add(parseInt(m[1], 10));
+        }
+    }
+    return [...indices].sort((a, b) => a - b);
+}
+function appendUserMessage(messagesDir, content) {
+    const indices = scanMessageIndices(messagesDir);
+    const maxIdx = indices.length > 0 ? Math.max(...indices) : -1;
+    let nextIdx = maxIdx + 1;
+    let filePath = path_1.default.join(messagesDir, `[${nextIdx}]user.md`);
+    while (fs_1.default.existsSync(filePath)) {
+        nextIdx += 1;
+        filePath = path_1.default.join(messagesDir, `[${nextIdx}]user.md`);
+    }
+    fs_1.default.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+}
+function getLatestAssistantText(messagesDir) {
+    const files = fs_1.default
+        .readdirSync(messagesDir)
+        .filter(n => /^\[\d+\]assistant\.md$/i.test(n))
+        .sort((a, b) => {
+        const ia = parseInt(a.match(/^\[(\d+)\]/)[1], 10);
+        const ib = parseInt(b.match(/^\[(\d+)\]/)[1], 10);
+        return ia - ib;
+    });
+    if (files.length === 0) {
+        throw new Error('No assistant message found in session');
+    }
+    const last = files[files.length - 1];
+    return fs_1.default.readFileSync(path_1.default.join(messagesDir, last), 'utf8');
+}
+function buildTranscript(messagesDir) {
+    const entries = fs_1.default
+        .readdirSync(messagesDir)
+        .map(name => {
+        const m = name.match(MESSAGE_PATTERN);
+        if (!m) {
+            return null;
+        }
+        const idx = parseInt(m[1], 10);
+        const role = m[2];
+        const content = fs_1.default.readFileSync(path_1.default.join(messagesDir, name), 'utf8');
+        return { idx, role, content };
+    })
+        .filter((e) => e !== null)
+        .sort((a, b) => a.idx - b.idx || a.role.localeCompare(b.role));
+    return entries
+        .map(e => `## [${e.idx}] ${e.role}\n\n${e.content}`)
+        .join('\n\n');
+}
+function createSession() {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-init-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    fs_1.default.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'promptpile.toml'), constants_1.PROMPTPILE_TOML, 'utf8');
+    const systemPrompt = (0, prompts_1.loadPrompt)('init-interviewer');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), systemPrompt, 'utf8');
+    return { root, messagesDir, round: 0 };
+}
+function writeOpeningAssistant(messagesDir, opening) {
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]assistant.md'), opening, 'utf8');
+}
+function createFinalizeSession(transcript) {
+    const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'dayloom-finalize-'));
+    const messagesDir = path_1.default.join(root, 'messages');
+    fs_1.default.mkdirSync(messagesDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(root, 'promptpile.toml'), constants_1.PROMPTPILE_TOML, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[0]system.md'), (0, prompts_1.loadPrompt)('init-finalize'), 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(messagesDir, '[1]user.md'), transcript, 'utf8');
+    return { root, messagesDir, round: 0 };
+}

package/dist/init/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/next/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectNextState = exports.formatNextStatus = exports.describeNextAction = exports.InitCancelledError = void 0;
+exports.runNext = runNext;
+const daily_1 = require("../daily");
+const i18n_1 = require("../i18n");
+const init_1 = require("../init");
+const errors_1 = require("../init/errors");
+Object.defineProperty(exports, "InitCancelledError", { enumerable: true, get: function () { return errors_1.InitCancelledError; } });
+const play_1 = require("../play");
+const read_user_input_1 = require("../revise/read-user-input");
+const settle_1 = require("../settle");
+const inspect_1 = require("./inspect");
+Object.defineProperty(exports, "describeNextAction", { enumerable: true, get: function () { return inspect_1.describeNextAction; } });
+Object.defineProperty(exports, "formatNextStatus", { enumerable: true, get: function () { return inspect_1.formatNextStatus; } });
+Object.defineProperty(exports, "inspectNextState", { enumerable: true, get: function () { return inspect_1.inspectNextState; } });
+async function runNext(dir, options = {}) {
+    const t = options.t ?? (0, i18n_1.createTranslator)('en');
+    const state = (0, inspect_1.inspectNextState)(dir);
+    process.stdout.write(`${(0, inspect_1.formatNextStatus)(state, t)}\n`);
+    if (options.statusOnly)
+        return { state, action: state.action, executed: false };
+    process.stdout.write(`${(0, inspect_1.describeNextAction)(state, t)}\n`);
+    if (options.confirm && !(await (0, read_user_input_1.askYesNo)(t('next.proceed', { action: state.action })))) {
+        process.stdout.write(`${t('next.cancelled')}\n`);
+        return { state, action: state.action, executed: false };
+    }
+    switch (state.action) {
+        case 'init': {
+            const initOptions = {
+                id: options.id,
+                title: options.title,
+                maxRounds: options.maxRounds,
+                keepSessionOnError: options.keepSession,
+            };
+            const worldRoot = options.quick
+                ? (0, init_1.initWorldQuick)(state.worldRoot, initOptions)
+                : await (0, init_1.initWorldInteractive)(state.worldRoot, initOptions);
+            process.stdout.write(`${t('next.initialized', { worldRoot })}\n`);
+            break;
+        }
+        case 'daily':
+            await (0, daily_1.dailyInteractive)(state.worldRoot, commonAiOptions(options));
+            break;
+        case 'play':
+            await (0, play_1.playInteractive)(state.worldRoot, {
+                keepSession: options.keepSession,
+                maxToolRounds: options.maxToolRounds,
+                maxEventRounds: options.maxEventRounds,
+                mcpBaseUrl: options.mcpBaseUrl,
+                mcpToken: options.mcpToken,
+            });
+            break;
+        case 'settle': {
+            const result = await (0, settle_1.settleWithAi)(state.worldRoot, commonAiOptions(options));
+            process.stdout.write(`${result.description}\n`);
+            if (result.applied)
+                process.stdout.write(`${t('cli.settle.settled', { day: result.day, nextDay: result.nextDay })}\n`);
+            else if (result.proposalPath) {
+                process.stdout.write(`${t('cli.settle.generatedProposal', { proposalPath: result.proposalPath })}\n${t('cli.settle.reviewProposal')}\n`);
+            }
+            else {
+                process.stdout.write(`${t('cli.common.dryRunOnly')}\n`);
+            }
+            break;
+        }
+    }
+    return { state, action: state.action, executed: true };
+}
+function commonAiOptions(options) {
+    return {
+        dryRun: options.dryRun,
+        yes: options.yes,
+        keepSession: options.keepSession,
+        maxToolRounds: options.maxToolRounds,
+        mcpBaseUrl: options.mcpBaseUrl,
+        mcpToken: options.mcpToken,
+    };
+}

package/dist/next/inspect.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectNextState = inspectNextState;
+exports.formatNextStatus = formatNextStatus;
+exports.describeNextAction = describeNextAction;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const i18n_1 = require("../i18n");
+function inspectNextState(dir) {
+    const worldRoot = path_1.default.resolve(dir);
+    const manifestPath = path_1.default.join(worldRoot, 'manifest.yaml');
+    if (!fs_1.default.existsSync(manifestPath)) {
+        return { kind: 'uninitialized', worldRoot, action: 'init' };
+    }
+    const currentPath = path_1.default.join(worldRoot, 'current.yaml');
+    if (!fs_1.default.existsSync(currentPath))
+        throw new Error('World save missing current.yaml');
+    const current = fs_1.default.readFileSync(currentPath, 'utf8');
+    const day = readYamlScalar(current, 'day', 'current.yaml');
+    const phase = readPhase(readYamlScalar(current, 'phase', 'current.yaml'));
+    const lastCommittedDay = readOptionalYamlScalar(current, 'last_committed_day');
+    return {
+        kind: 'initialized',
+        worldRoot,
+        day,
+        phase,
+        lastCommittedDay,
+        action: actionForPhase(phase),
+    };
+}
+function formatNextStatus(state, t = (0, i18n_1.createTranslator)('en')) {
+    const lines = [t('next.world', { worldRoot: state.worldRoot })];
+    if (state.kind === 'uninitialized') {
+        lines.push(t('next.currentUninitialized'));
+        lines.push(t('next.nextAction', { action: 'init' }));
+        lines.push(t('next.recommendedCommand'));
+        lines.push(`  dayloom init -d ${state.worldRoot}`);
+        return lines.join('\n');
+    }
+    lines.push(t('next.currentPhase', { day: state.day, phase: state.phase }));
+    if (state.lastCommittedDay)
+        lines.push(t('next.lastCommittedDay', { lastCommittedDay: state.lastCommittedDay }));
+    lines.push(t('next.nextAction', { action: state.action }));
+    lines.push(t('next.recommendedCommand'));
+    lines.push(`  dayloom ${state.action} -d ${state.worldRoot}`);
+    return lines.join('\n');
+}
+function describeNextAction(state, t = (0, i18n_1.createTranslator)('en')) {
+    switch (state.action) {
+        case 'init':
+            return t('next.actionInit');
+        case 'daily':
+            return t('next.actionDaily');
+        case 'play':
+            return state.kind === 'initialized' && state.phase === 'playing'
+                ? t('next.actionPlayContinue')
+                : t('next.actionPlayStart');
+        case 'settle':
+            return t('next.actionSettle');
+    }
+}
+function actionForPhase(phase) {
+    switch (phase) {
+        case 'idle':
+            return 'daily';
+        case 'planned':
+        case 'playing':
+            return 'play';
+        case 'settling':
+            return 'settle';
+    }
+}
+function readPhase(value) {
+    if (value === 'idle' || value === 'planned' || value === 'playing' || value === 'settling')
+        return value;
+    throw new Error(`Unsupported current phase for next: ${value}`);
+}
+function readYamlScalar(text, key, label) {
+    const match = text.match(new RegExp(`^${key}:\\s*(\\S+)\\s*$`, 'm'));
+    if (!match)
+        throw new Error(`${label} missing ${key}`);
+    return match[1];
+}
+function readOptionalYamlScalar(text, key) {
+    const match = text.match(new RegExp(`^${key}:\\s*(\\S+)\\s*$`, 'm'));
+    return match?.[1];
+}

package/dist/play/ai.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callPlayAi = callPlayAi;
+const promptpile_loop_1 = require("../daily/promptpile-loop");
+const session_1 = require("./session");
+async function callPlayAi(prompt, userContent, toolsFile, baseUrl, token, maxToolRounds, onDelta = () => undefined) { const session = (0, session_1.createPlayAiSession)(prompt, userContent, toolsFile); try {
+    return await (0, promptpile_loop_1.runPromptpileUntilText)(session, baseUrl, token, maxToolRounds, onDelta);
+}
+finally {
+    (0, session_1.cleanupPlayAiSession)(session);
+} }