profclaw 2.0.0 → 2.4.0

package/dist/agents/orchestrator.js

@@ -0,0 +1,495 @@
+/**
+ * Multi-Agent Orchestrator
+ *
+ * Enables spawning, managing, and merging results from sub-agents.
+ * Supports orchestration patterns:
+ *   - Fan-out: N parallel workers + 1 synthesizer
+ *   - Pipeline: sequential agent chain (A -> B -> C)
+ *   - Debate: 2+ agents argue, 1 judges
+ *
+ * Each sub-agent gets an isolated session with scoped tool access.
+ * Parent can set token budgets, timeouts, and tool policies per child.
+ */
+import { randomUUID } from 'node:crypto';
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('Orchestrator');
+// Active orchestrations for cancellation
+const activeOrchestrations = new Map();
+/**
+ * Run a sub-agent in an isolated session.
+ */
+async function runSubAgent(config, contextInput, signal) {
+    const startTime = Date.now();
+    try {
+        const { executeAgenticChat } = await import('../chat/agentic-executor.js');
+        const { createChatToolHandler } = await import('../chat/tool-handler.js');
+        const conversationId = `orchestrator-${config.id}-${randomUUID()}`;
+        const toolHandler = await createChatToolHandler({
+            conversationId,
+            securityMode: 'full',
+        });
+        // Filter tools if restricted
+        const allTools = toolHandler.getTools();
+        const tools = config.allowedTools?.length
+            ? allTools.filter((t) => config.allowedTools.includes(t.name))
+            : allTools;
+        // Build the prompt - inject pipeline context if provided
+        let fullPrompt = config.prompt;
+        if (contextInput) {
+            fullPrompt = `Context from previous step:\n${contextInput}\n\nYour task:\n${config.prompt}`;
+        }
+        const response = await Promise.race([
+            executeAgenticChat({
+                conversationId,
+                messages: [{
+                        id: randomUUID(),
+                        role: 'user',
+                        content: fullPrompt,
+                        timestamp: new Date().toISOString(),
+                    }],
+                systemPrompt: config.systemPrompt || 'You are a focused AI agent working on a specific sub-task. Be concise and thorough.',
+                model: config.model,
+                effort: config.effort || 'medium',
+                toolHandler,
+                tools: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                })),
+            }),
+            new Promise((_, reject) => {
+                const timeout = config.timeoutMs || 300000;
+                const timer = setTimeout(() => reject(new Error(`Sub-agent "${config.name}" timed out after ${timeout}ms`)), timeout);
+                signal?.addEventListener('abort', () => {
+                    clearTimeout(timer);
+                    reject(new Error(`Sub-agent "${config.name}" cancelled`));
+                });
+            }),
+        ]);
+        return {
+            agentId: config.id,
+            agentName: config.name,
+            success: true,
+            output: response.content,
+            durationMs: Date.now() - startTime,
+            tokensUsed: response.usage?.totalTokens,
+        };
+    }
+    catch (error) {
+        return {
+            agentId: config.id,
+            agentName: config.name,
+            success: false,
+            output: '',
+            error: error instanceof Error ? error.message : String(error),
+            durationMs: Date.now() - startTime,
+        };
+    }
+}
+/**
+ * Execute a fan-out orchestration: run N agents in parallel, then synthesize.
+ */
+async function executeFanOut(config, signal) {
+    const startTime = Date.now();
+    // Run all agents in parallel
+    const results = await Promise.allSettled(config.agents.map((agent) => runSubAgent(agent, undefined, signal)));
+    const agentResults = results.map((r, i) => {
+        if (r.status === 'fulfilled')
+            return r.value;
+        return {
+            agentId: config.agents[i].id,
+            agentName: config.agents[i].name,
+            success: false,
+            output: '',
+            error: r.reason instanceof Error ? r.reason.message : String(r.reason),
+            durationMs: Date.now() - startTime,
+        };
+    });
+    // Synthesize results
+    let finalOutput = '';
+    if (config.synthesizerPrompt) {
+        const synthesisInput = agentResults
+            .filter((r) => r.success)
+            .map((r) => `[${r.agentName}]:\n${r.output}`)
+            .join('\n\n---\n\n');
+        const synthesisResult = await runSubAgent({
+            id: 'synthesizer',
+            name: 'Synthesizer',
+            prompt: `${config.synthesizerPrompt}\n\nResults from ${agentResults.filter((r) => r.success).length} agents:\n\n${synthesisInput}`,
+            model: config.agents[0]?.model,
+            effort: 'medium',
+        }, undefined, signal);
+        agentResults.push(synthesisResult);
+        finalOutput = synthesisResult.output;
+    }
+    else {
+        finalOutput = agentResults
+            .filter((r) => r.success)
+            .map((r) => `## ${r.agentName}\n${r.output}`)
+            .join('\n\n');
+    }
+    const totalTokens = agentResults.reduce((sum, r) => sum + (r.tokensUsed || 0), 0);
+    return {
+        id: config.id,
+        pattern: 'fan_out',
+        success: agentResults.some((r) => r.success),
+        agentResults,
+        finalOutput,
+        totalDurationMs: Date.now() - startTime,
+        totalTokens,
+    };
+}
+/**
+ * Execute a pipeline orchestration: A -> B -> C
+ * Output of each agent becomes context for the next.
+ */
+async function executePipeline(config, signal) {
+    const startTime = Date.now();
+    const agentResults = [];
+    let lastOutput = '';
+    for (const agent of config.agents) {
+        if (signal.aborted)
+            break;
+        const result = await runSubAgent(agent, lastOutput || undefined, signal);
+        agentResults.push(result);
+        if (!result.success && config.failFast) {
+            return {
+                id: config.id,
+                pattern: 'pipeline',
+                success: false,
+                agentResults,
+                finalOutput: '',
+                totalDurationMs: Date.now() - startTime,
+                totalTokens: agentResults.reduce((sum, r) => sum + (r.tokensUsed || 0), 0),
+                error: `Pipeline failed at step "${agent.name}": ${result.error}`,
+            };
+        }
+        if (result.success) {
+            lastOutput = result.output;
+        }
+    }
+    return {
+        id: config.id,
+        pattern: 'pipeline',
+        success: agentResults.some((r) => r.success),
+        agentResults,
+        finalOutput: lastOutput,
+        totalDurationMs: Date.now() - startTime,
+        totalTokens: agentResults.reduce((sum, r) => sum + (r.tokensUsed || 0), 0),
+    };
+}
+/**
+ * Execute a debate orchestration: agents argue, judge decides.
+ */
+async function executeDebate(config, signal) {
+    const startTime = Date.now();
+    // Run debaters in parallel
+    const debaterResults = await Promise.allSettled(config.agents.map((agent) => runSubAgent(agent, undefined, signal)));
+    const agentResults = debaterResults.map((r, i) => {
+        if (r.status === 'fulfilled')
+            return r.value;
+        return {
+            agentId: config.agents[i].id,
+            agentName: config.agents[i].name,
+            success: false,
+            output: '',
+            error: r.reason instanceof Error ? r.reason.message : String(r.reason),
+            durationMs: Date.now() - startTime,
+        };
+    });
+    // Judge the debate
+    let finalOutput = '';
+    if (config.judgePrompt) {
+        const debateInput = agentResults
+            .filter((r) => r.success)
+            .map((r) => `[${r.agentName}] argues:\n${r.output}`)
+            .join('\n\n---\n\n');
+        const judgeResult = await runSubAgent({
+            id: 'judge',
+            name: 'Judge',
+            prompt: `${config.judgePrompt}\n\nArguments:\n\n${debateInput}`,
+            model: config.agents[0]?.model,
+            effort: 'high',
+        }, undefined, signal);
+        agentResults.push(judgeResult);
+        finalOutput = judgeResult.output;
+    }
+    else {
+        finalOutput = agentResults.filter((r) => r.success).map((r) => r.output).join('\n\n');
+    }
+    return {
+        id: config.id,
+        pattern: 'debate',
+        success: agentResults.some((r) => r.success),
+        agentResults,
+        finalOutput,
+        totalDurationMs: Date.now() - startTime,
+        totalTokens: agentResults.reduce((sum, r) => sum + (r.tokensUsed || 0), 0),
+    };
+}
+// Public API
+/**
+ * Execute an orchestration.
+ */
+export async function orchestrate(config) {
+    const abortController = new AbortController();
+    activeOrchestrations.set(config.id, abortController);
+    // Overall timeout
+    let timeoutHandle;
+    if (config.timeoutMs) {
+        timeoutHandle = setTimeout(() => abortController.abort(), config.timeoutMs);
+    }
+    log.info(`Starting orchestration: ${config.name} (${config.pattern}) with ${config.agents.length} agents`);
+    try {
+        let result;
+        switch (config.pattern) {
+            case 'fan_out':
+                result = await executeFanOut(config, abortController.signal);
+                break;
+            case 'pipeline':
+                result = await executePipeline(config, abortController.signal);
+                break;
+            case 'debate':
+                result = await executeDebate(config, abortController.signal);
+                break;
+            case 'custom':
+                // Custom: just run all in parallel (same as fan_out without synthesis)
+                result = await executeFanOut({ ...config, synthesizerPrompt: undefined }, abortController.signal);
+                break;
+            default:
+                throw new Error(`Unknown orchestration pattern: ${config.pattern}`);
+        }
+        log.info(`Orchestration complete: ${config.name} - ${result.success ? 'success' : 'failed'} in ${result.totalDurationMs}ms (${result.totalTokens} tokens)`);
+        return result;
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        activeOrchestrations.delete(config.id);
+    }
+}
+/**
+ * Cancel a running orchestration.
+ */
+export function cancelOrchestration(id) {
+    const controller = activeOrchestrations.get(id);
+    if (controller) {
+        controller.abort();
+        activeOrchestrations.delete(id);
+        log.info(`Cancelled orchestration: ${id}`);
+        return true;
+    }
+    return false;
+}
+/**
+ * List active orchestrations.
+ */
+export function listActiveOrchestrations() {
+    return [...activeOrchestrations.keys()];
+}
+const DEFAULT_ORCHESTRATOR_CONFIG = {
+    maxConcurrent: 3,
+    timeoutMs: 300_000,
+};
+// Singleton instance
+let _instance;
+/**
+ * Class-based orchestrator for fan-out parallel sub-agent tasks.
+ *
+ * The caller provides an `apiCall` function that wraps the actual LLM API —
+ * following the same injected-client pattern used by ContextCompactor.
+ *
+ * Usage:
+ * ```ts
+ * const orch = getAgentOrchestrator({ maxConcurrent: 2 });
+ * const results = await orch.dispatch([
+ *   { description: 'Summarise file A', prompt: '...' },
+ *   { description: 'Summarise file B', prompt: '...' },
+ * ], myApiCall);
+ * console.log(orch.synthesize(results));
+ * ```
+ */
+export class AgentOrchestrator {
+    tasks = new Map();
+    config;
+    /** Number of tasks currently in the 'running' state. */
+    running = 0;
+    /** Cancelled task IDs — checked before executing. */
+    cancelled = new Set();
+    constructor(config) {
+        this.config = { ...DEFAULT_ORCHESTRATOR_CONFIG, ...config };
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    /**
+     * Dispatch multiple sub-tasks in parallel, respecting `maxConcurrent`.
+     * Resolves when every task has either completed, failed, or timed out.
+     */
+    async dispatch(taskDefs, apiCall) {
+        // Build task objects
+        const newTasks = taskDefs.map((def) => ({
+            id: randomUUID(),
+            description: def.description,
+            prompt: def.prompt,
+            status: 'pending',
+            tokensUsed: 0,
+        }));
+        for (const task of newTasks) {
+            this.tasks.set(task.id, task);
+        }
+        // Semaphore: release a "slot" whenever a task finishes so the next one starts.
+        const queue = [...newTasks];
+        const workers = [];
+        const next = () => {
+            const task = queue.shift();
+            if (!task)
+                return Promise.resolve();
+            if (this.cancelled.has(task.id)) {
+                task.status = 'failed';
+                task.error = 'Task was cancelled before it started';
+                return next();
+            }
+            this.running++;
+            return this.runTask(task, apiCall).then(() => {
+                this.running--;
+                return next();
+            });
+        };
+        // Seed up to maxConcurrent workers.
+        const concurrency = Math.min(this.config.maxConcurrent, newTasks.length);
+        for (let i = 0; i < concurrency; i++) {
+            workers.push(next());
+        }
+        await Promise.all(workers);
+        return newTasks;
+    }
+    /**
+     * Run a single sub-agent task with timeout and cancellation support.
+     * Mutates `task` in place and returns it.
+     */
+    async runTask(task, apiCall) {
+        if (this.cancelled.has(task.id)) {
+            task.status = 'failed';
+            task.error = 'Task was cancelled';
+            task.completedAt = Date.now();
+            return task;
+        }
+        task.status = 'running';
+        task.startedAt = Date.now();
+        const timeoutMs = this.config.timeoutMs;
+        try {
+            const result = await Promise.race([
+                apiCall(task.prompt),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Task "${task.description}" timed out after ${timeoutMs}ms`)), timeoutMs)),
+            ]);
+            // Re-check cancellation — task may have been cancelled while the API call was in flight.
+            if (this.cancelled.has(task.id)) {
+                task.status = 'failed';
+                task.error = 'Task was cancelled';
+            }
+            else {
+                task.status = 'completed';
+                task.result = result;
+            }
+        }
+        catch (error) {
+            task.status = 'failed';
+            task.error = error instanceof Error ? error.message : String(error);
+            log.warn(`Sub-agent task failed: ${task.description} — ${task.error}`);
+        }
+        finally {
+            task.completedAt = Date.now();
+        }
+        return task;
+    }
+    /**
+     * Return a snapshot of all tasks tracked by this orchestrator.
+     */
+    getStatus() {
+        return [...this.tasks.values()];
+    }
+    /**
+     * Mark a task as cancelled.  If it is still pending it will be skipped
+     * entirely; if it is already running the next post-API-call check will
+     * mark it failed.
+     */
+    cancel(taskId) {
+        this.cancelled.add(taskId);
+        const task = this.tasks.get(taskId);
+        if (task && task.status === 'pending') {
+            task.status = 'failed';
+            task.error = 'Task was cancelled';
+            task.completedAt = Date.now();
+            log.info(`Cancelled pending task: ${taskId}`);
+        }
+    }
+    /**
+     * Build a markdown summary of completed task results.
+     *
+     * ```markdown
+     * ## Task Results
+     * ### 1. Summarise file A ✓
+     * <result text>
+     * ### 2. Summarise file B ✗
+     * Error: timed out after 300000ms
+     * ```
+     */
+    synthesize(tasks) {
+        const lines = ['## Task Results', ''];
+        tasks.forEach((task, index) => {
+            const marker = task.status === 'completed' ? '✓' : '✗';
+            lines.push(`### ${index + 1}. ${task.description} ${marker}`);
+            if (task.status === 'completed' && task.result) {
+                lines.push(task.result);
+            }
+            else if (task.status === 'failed') {
+                lines.push(`Error: ${task.error ?? 'Unknown error'}`);
+            }
+            else {
+                lines.push(`Status: ${task.status}`);
+            }
+            lines.push('');
+        });
+        return lines.join('\n').trimEnd();
+    }
+    /**
+     * Wait until all currently-tracked tasks have left the 'pending' or
+     * 'running' state, or until the optional `timeoutMs` elapses.
+     *
+     * Resolves with the current task snapshot once settled.
+     */
+    async waitAll(timeoutMs) {
+        const poll = () => [...this.tasks.values()].every((t) => t.status === 'completed' || t.status === 'failed');
+        if (poll())
+            return this.getStatus();
+        const deadline = timeoutMs ? Date.now() + timeoutMs : Infinity;
+        const INTERVAL = 50;
+        return new Promise((resolve) => {
+            const check = () => {
+                if (poll()) {
+                    resolve(this.getStatus());
+                    return;
+                }
+                if (Date.now() >= deadline) {
+                    resolve(this.getStatus());
+                    return;
+                }
+                setTimeout(check, INTERVAL);
+            };
+            setTimeout(check, INTERVAL);
+        });
+    }
+}
+/**
+ * Return a lazily-created singleton `AgentOrchestrator`.
+ * Pass `config` on first call to customise defaults; subsequent calls with
+ * a different config will replace the singleton.
+ */
+export function getAgentOrchestrator(config) {
+    if (!_instance || config) {
+        _instance = new AgentOrchestrator(config);
+    }
+    return _instance;
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/agents/output-truncator.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tool Output Truncator
+ *
+ * Caps large tool results (file reads, command output, logs, web content) to a
+ * configurable char budget before they reach the model. The head and the tail
+ * are kept (errors and summaries usually live at the end), the middle is
+ * replaced by an explicit marker, and the full result is kept in the
+ * ResultStore so the model can fetch a range with `fetch_result`.
+ */
+import type { ResultStore } from './result-store.js';
+export interface TruncationConfig {
+    /** Max chars of a result sent to the model */
+    maxChars: number;
+    /** Fraction of the budget spent on the head (rest goes to the tail) */
+    headRatio: number;
+    /** Max chars returned by a single fetch_result call */
+    fetchMaxChars: number;
+}
+export declare function getTruncationConfig(): TruncationConfig;
+/** Truncation is on unless PROFCLAW_TOOL_OUTPUT_TRUNCATION is off/0/false/no. */
+export declare function isTruncationEnabled(): boolean;
+export interface TruncatedText {
+    text: string;
+    truncated: boolean;
+    /** Number of chars removed from the middle */
+    omitted: number;
+}
+/**
+ * Keep the head and tail of `text`, replacing the middle with a marker.
+ */
+export declare function truncateText(text: string, maxChars: number, headRatio?: number, hint?: string): TruncatedText;
+export interface TruncatedResult {
+    /** Value to hand to the model (original reference when nothing was cut) */
+    value: unknown;
+    truncated: boolean;
+    omitted: number;
+}
+/**
+ * Truncate an arbitrary tool result. Long string fields are shortened in place
+ * so the object shape survives; if the whole payload is still over budget
+ * (e.g. a huge array), it falls back to truncating the JSON text.
+ */
+export declare function truncateResult(result: unknown, config?: TruncationConfig, hint?: string): TruncatedResult;
+/**
+ * Truncate `result` if needed. When truncation happens the FULL result is
+ * saved in `store` under `toolCallId` so `fetch_result` can page through it.
+ */
+export declare function truncateAndStore(store: ResultStore, toolCallId: string, result: unknown, config?: TruncationConfig): Promise<TruncatedResult>;
+export interface ResultRange {
+    resultId: string;
+    offset: number;
+    length: number;
+    totalChars: number;
+    content: string;
+    hasMore: boolean;
+}
+/** Read a char range of a stored full result (JSON text of the original). */
+export declare function readStoredRange(store: ResultStore, resultId: string, offset: number, length: number, config?: TruncationConfig): Promise<ResultRange | null>;
+//# sourceMappingURL=output-truncator.d.ts.map

package/dist/agents/output-truncator.js

@@ -0,0 +1,128 @@
+/**
+ * Tool Output Truncator
+ *
+ * Caps large tool results (file reads, command output, logs, web content) to a
+ * configurable char budget before they reach the model. The head and the tail
+ * are kept (errors and summaries usually live at the end), the middle is
+ * replaced by an explicit marker, and the full result is kept in the
+ * ResultStore so the model can fetch a range with `fetch_result`.
+ */
+import { readFile } from 'node:fs/promises';
+const DEFAULT_MAX_CHARS = 12_000;
+const DEFAULT_HEAD_RATIO = 0.7;
+function readPositiveInt(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function getTruncationConfig() {
+    const maxChars = readPositiveInt('PROFCLAW_TOOL_OUTPUT_MAX_CHARS', DEFAULT_MAX_CHARS);
+    const rawRatio = Number.parseFloat(process.env.PROFCLAW_TOOL_OUTPUT_HEAD_RATIO ?? '');
+    const headRatio = Number.isFinite(rawRatio) && rawRatio > 0 && rawRatio < 1 ? rawRatio : DEFAULT_HEAD_RATIO;
+    return {
+        maxChars,
+        headRatio,
+        fetchMaxChars: readPositiveInt('PROFCLAW_TOOL_FETCH_MAX_CHARS', maxChars),
+    };
+}
+/** Truncation is on unless PROFCLAW_TOOL_OUTPUT_TRUNCATION is off/0/false/no. */
+export function isTruncationEnabled() {
+    const flag = (process.env.PROFCLAW_TOOL_OUTPUT_TRUNCATION ?? '').toLowerCase();
+    return !['off', '0', 'false', 'no'].includes(flag);
+}
+/**
+ * Keep the head and tail of `text`, replacing the middle with a marker.
+ */
+export function truncateText(text, maxChars, headRatio = DEFAULT_HEAD_RATIO, hint = '') {
+    if (text.length <= maxChars) {
+        return { text, truncated: false, omitted: 0 };
+    }
+    const headLen = Math.floor(maxChars * headRatio);
+    const tailLen = Math.max(0, maxChars - headLen);
+    const omitted = text.length - headLen - tailLen;
+    const marker = `\n[truncated ${omitted} chars${hint ? `. ${hint}` : ''}]\n`;
+    const tail = tailLen > 0 ? text.slice(text.length - tailLen) : '';
+    return { text: text.slice(0, headLen) + marker + tail, truncated: true, omitted };
+}
+function shrinkStrings(value, maxChars, headRatio, hint, stats, depth) {
+    if (typeof value === 'string') {
+        const t = truncateText(value, maxChars, headRatio, hint);
+        stats.omitted += t.omitted;
+        return t.text;
+    }
+    if (depth > 6 || value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value)) {
+        return value.map((v) => shrinkStrings(v, maxChars, headRatio, hint, stats, depth + 1));
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        out[k] = shrinkStrings(v, maxChars, headRatio, hint, stats, depth + 1);
+    }
+    return out;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value) ?? '';
+    }
+    catch {
+        return String(value);
+    }
+}
+/**
+ * Truncate an arbitrary tool result. Long string fields are shortened in place
+ * so the object shape survives; if the whole payload is still over budget
+ * (e.g. a huge array), it falls back to truncating the JSON text.
+ */
+export function truncateResult(result, config = getTruncationConfig(), hint = '') {
+    const serialized = typeof result === 'string' ? result : safeStringify(result);
+    if (serialized.length <= config.maxChars) {
+        return { value: result, truncated: false, omitted: 0 };
+    }
+    if (typeof result === 'string') {
+        const t = truncateText(result, config.maxChars, config.headRatio, hint);
+        return { value: t.text, truncated: true, omitted: t.omitted };
+    }
+    const stats = { omitted: 0 };
+    const shrunk = shrinkStrings(result, config.maxChars, config.headRatio, hint, stats, 0);
+    const shrunkSerialized = safeStringify(shrunk);
+    if (shrunkSerialized.length <= config.maxChars * 1.25 + 256 && stats.omitted > 0) {
+        return { value: shrunk, truncated: true, omitted: stats.omitted };
+    }
+    const t = truncateText(serialized, config.maxChars, config.headRatio, hint);
+    return { value: t.text, truncated: true, omitted: t.omitted };
+}
+// Store integration
+/**
+ * Truncate `result` if needed. When truncation happens the FULL result is
+ * saved in `store` under `toolCallId` so `fetch_result` can page through it.
+ */
+export async function truncateAndStore(store, toolCallId, result, config = getTruncationConfig()) {
+    const hint = `full output saved as result_id "${toolCallId}", call fetch_result with offset/length`;
+    const truncated = truncateResult(result, config, hint);
+    if (truncated.truncated) {
+        await store.store(toolCallId, result);
+    }
+    return truncated;
+}
+/** Read a char range of a stored full result (JSON text of the original). */
+export async function readStoredRange(store, resultId, offset, length, config = getTruncationConfig()) {
+    const stored = store.retrieve(resultId);
+    if (!stored)
+        return null;
+    const full = stored.fullPath ? await readFile(stored.fullPath, 'utf8') : stored.inline;
+    const start = Math.max(0, Math.min(offset, full.length));
+    const len = Math.max(1, Math.min(length, config.fetchMaxChars));
+    const content = full.slice(start, start + len);
+    return {
+        resultId,
+        offset: start,
+        length: content.length,
+        totalChars: full.length,
+        content,
+        hasMore: start + content.length < full.length,
+    };
+}
+//# sourceMappingURL=output-truncator.js.map