icopilot 2.2.0

package/dist/agents/aggregator.js

@@ -0,0 +1,187 @@
+const NEGATIVE_PATTERNS = [
+    /\bdo not\b/i,
+    /\bdon't\b/i,
+    /\bnot\b/i,
+    /\bnever\b/i,
+    /\bavoid\b/i,
+    /\bskip\b/i,
+    /\bdisable\b/i,
+    /\bremove\b/i,
+    /\breject\b/i,
+];
+const CONFLICTING_PHRASES = [
+    [/\benable\b/i, /\bdisable\b/i],
+    [/\badd\b/i, /\bremove\b/i],
+    [/\buse\b/i, /\bavoid\b/i],
+    [/\balways\b/i, /\bnever\b/i],
+    [/\binclude\b/i, /\bexclude\b/i],
+    [/\bsync\b/i, /\basync\b/i],
+];
+export function aggregateResults(results) {
+    const sources = unique(results.map((result) => result.name.trim()).filter(Boolean));
+    if (results.length === 0) {
+        return {
+            summary: ['## Summary', '- No agent results available.'].join('\n'),
+            details: [],
+            conflicts: [],
+            sources,
+        };
+    }
+    const details = results.map((result) => ({
+        result,
+        points: extractPoints(result.output),
+    }));
+    const pointIndex = new Map();
+    for (const detail of details) {
+        for (const point of detail.points) {
+            const existing = pointIndex.get(point.normalized);
+            if (existing) {
+                existing.mentions += 1;
+                existing.confidence = Math.max(existing.confidence, detail.result.confidence ?? 0);
+                if (!existing.sources.includes(detail.result.name)) {
+                    existing.sources.push(detail.result.name);
+                }
+                continue;
+            }
+            pointIndex.set(point.normalized, {
+                point,
+                mentions: 1,
+                sources: [detail.result.name],
+                confidence: detail.result.confidence ?? 0,
+            });
+        }
+    }
+    const uniquePoints = [...pointIndex.values()].sort((left, right) => right.mentions - left.mentions ||
+        right.confidence - left.confidence ||
+        right.point.original.length - left.point.original.length);
+    const summaryLines = uniquePoints.slice(0, 5).map(({ point, sources: pointSources }) => {
+        const suffix = pointSources.length > 1 ? ` _(sources: ${pointSources.join(', ')})_` : '';
+        return `- ${point.original}${suffix}`;
+    });
+    const conflictMessages = detectConflicts(details);
+    return {
+        summary: [
+            '## Summary',
+            ...(summaryLines.length > 0 ? summaryLines : ['- No shared recommendations found.']),
+        ].join('\n'),
+        details: details.map((detail) => formatDetailSection(detail)),
+        conflicts: conflictMessages,
+        sources,
+    };
+}
+function formatDetailSection(detail) {
+    const metadata = [];
+    if (typeof detail.result.confidence === 'number') {
+        metadata.push(`confidence: ${formatConfidence(detail.result.confidence)}`);
+    }
+    if (typeof detail.result.tokens === 'number') {
+        metadata.push(`tokens: ${detail.result.tokens}`);
+    }
+    const header = `### ${detail.result.name}`;
+    const meta = metadata.length > 0 ? `${metadata.join(' • ')}` : undefined;
+    const lines = detail.points.length > 0
+        ? detail.points.map((point) => `- ${point.original}`)
+        : ['- No actionable points extracted.'];
+    return [header, meta, ...lines].filter((line) => Boolean(line)).join('\n');
+}
+function detectConflicts(details) {
+    const conflicts = new Set();
+    for (let index = 0; index < details.length; index += 1) {
+        for (let compareIndex = index + 1; compareIndex < details.length; compareIndex += 1) {
+            const left = details[index];
+            const right = details[compareIndex];
+            for (const leftPoint of left.points) {
+                for (const rightPoint of right.points) {
+                    if (leftPoint.normalized === rightPoint.normalized)
+                        continue;
+                    if (leftPoint.subject !== rightPoint.subject)
+                        continue;
+                    if (!isConflict(leftPoint.original, rightPoint.original))
+                        continue;
+                    conflicts.add(`- Conflict between **${left.result.name}** and **${right.result.name}** on _${leftPoint.subject}_: "${leftPoint.original}" vs "${rightPoint.original}"`);
+                }
+            }
+        }
+    }
+    return [...conflicts];
+}
+function isConflict(left, right) {
+    const leftNegative = hasNegativeIntent(left);
+    const rightNegative = hasNegativeIntent(right);
+    if (leftNegative !== rightNegative) {
+        return true;
+    }
+    return CONFLICTING_PHRASES.some(([first, second]) => (first.test(left) && second.test(right)) || (second.test(left) && first.test(right)));
+}
+function hasNegativeIntent(value) {
+    return NEGATIVE_PATTERNS.some((pattern) => pattern.test(value));
+}
+function extractPoints(output) {
+    const segments = output
+        .split(/\r?\n+/)
+        .flatMap((line) => splitLineIntoPoints(line))
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    const seen = new Set();
+    const points = [];
+    for (const segment of segments) {
+        const original = cleanupSegment(segment);
+        if (!original)
+            continue;
+        const normalized = normalizePoint(original);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        points.push({
+            original,
+            normalized,
+            subject: deriveSubject(normalized),
+        });
+    }
+    return points;
+}
+function splitLineIntoPoints(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return [];
+    if (/^\s*[-*•]\s+/.test(line) || /^\s*\d+[.)]\s+/.test(line)) {
+        return [trimmed.replace(/^\s*(?:[-*•]|\d+[.)])\s+/, '')];
+    }
+    return trimmed
+        .split(/(?<=[.!?])\s+(?=[A-Z0-9])/)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function cleanupSegment(value) {
+    return value
+        .replace(/^#+\s*/, '')
+        .replace(/^\s*(?:[-*•]|\d+[.)])\s+/, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function normalizePoint(value) {
+    return value
+        .toLowerCase()
+        .replace(/[`*_~]/g, '')
+        .replace(/[^\w\s]/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function deriveSubject(normalized) {
+    const withoutLeadVerb = normalized.replace(/^(?:use|avoid|enable|disable|add|remove|include|exclude|always|never|do not|don t|not|skip)\s+/, '');
+    return withoutLeadVerb
+        .split(' ')
+        .filter((token) => token.length > 2)
+        .slice(0, 6)
+        .join(' ')
+        .trim();
+}
+function formatConfidence(confidence) {
+    if (confidence >= 0 && confidence <= 1) {
+        return `${Math.round(confidence * 100)}%`;
+    }
+    return `${confidence}`;
+}
+function unique(values) {
+    return [...new Set(values)];
+}

package/dist/agents/custom-agents.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseDocument } from 'yaml';
+const AGENTS_DIR = path.join('.icopilot', 'agents');
+let cachedAgents = [];
+export function loadCustomAgents(projectRoot) {
+    const resolvedRoot = path.resolve(projectRoot);
+    const agentsDir = path.join(resolvedRoot, AGENTS_DIR);
+    fs.mkdirSync(agentsDir, { recursive: true });
+    const agents = fs
+        .readdirSync(agentsDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && /\.ya?ml$/i.test(entry.name))
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((entry) => loadAgentFile(path.join(agentsDir, entry.name)));
+    cachedAgents = agents;
+    return agents.map(cloneAgent);
+}
+export function getCustomAgent(name) {
+    const match = cachedAgents.find((agent) => agent.name === name) ??
+        cachedAgents.find((agent) => agent.name.toLowerCase() === name.toLowerCase());
+    return match ? cloneAgent(match) : undefined;
+}
+export function listCustomAgents() {
+    return cachedAgents.map(cloneAgent);
+}
+function loadAgentFile(filePath) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const document = parseDocument(raw);
+    if (document.errors.length > 0) {
+        const [firstError] = document.errors;
+        throw new Error(`Invalid YAML in ${path.relative(process.cwd(), filePath)}: ${firstError?.message ?? 'parse error'}`);
+    }
+    return validateAgentDef(document.toJSON(), filePath);
+}
+function validateAgentDef(value, filePath) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${label(filePath)} must contain a YAML object`);
+    }
+    const record = value;
+    const agent = {
+        name: requiredString(record.name, 'name', filePath),
+        description: requiredString(record.description, 'description', filePath),
+        systemPrompt: requiredString(record.systemPrompt, 'systemPrompt', filePath),
+    };
+    const model = optionalString(record.model, 'model', filePath);
+    if (model)
+        agent.model = model;
+    if (record.temperature !== undefined) {
+        agent.temperature = numberInRange(record.temperature, 'temperature', filePath, 0, 2);
+    }
+    if (record.tools !== undefined) {
+        if (!Array.isArray(record.tools) ||
+            record.tools.some((tool) => typeof tool !== 'string' || tool.trim().length === 0)) {
+            throw new Error(`${label(filePath)} field "tools" must be an array of non-empty strings`);
+        }
+        agent.tools = [...new Set(record.tools.map((tool) => tool.trim()))];
+    }
+    if (record.maxTokens !== undefined) {
+        agent.maxTokens = positiveInteger(record.maxTokens, 'maxTokens', filePath);
+    }
+    return agent;
+}
+function requiredString(value, field, filePath) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label(filePath)} field "${field}" must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalString(value, field, filePath) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label(filePath)} field "${field}" must be a non-empty string`);
+    }
+    return value.trim();
+}
+function positiveInteger(value, field, filePath) {
+    if (typeof value !== 'number' || !Number.isInteger(value) || value < 1) {
+        throw new Error(`${label(filePath)} field "${field}" must be a positive integer`);
+    }
+    return value;
+}
+function numberInRange(value, field, filePath, min, max) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max) {
+        throw new Error(`${label(filePath)} field "${field}" must be a number between ${min} and ${max}`);
+    }
+    return value;
+}
+function cloneAgent(agent) {
+    return {
+        ...agent,
+        tools: agent.tools ? [...agent.tools] : undefined,
+    };
+}
+function label(filePath) {
+    return path.relative(process.cwd(), filePath) || filePath;
+}

package/dist/agents/goal-driven.js

@@ -0,0 +1,411 @@
+import { Session } from '../session/session.js';
+import { runTurn } from '../modes/turn.js';
+import { countTokensSync } from '../util/tokens.js';
+const DEFAULT_MAX_RETRIES = 3;
+export class GoalDrivenAgent {
+    session;
+    signal;
+    maxRetries;
+    runTurnImpl;
+    progress = {
+        phase: 'idle',
+        currentAttempt: 0,
+        maxAttempts: DEFAULT_MAX_RETRIES,
+        completedSteps: 0,
+        totalSteps: 0,
+    };
+    constructor(options = {}) {
+        this.session = options.session ?? new Session();
+        this.signal = options.signal ?? new AbortController().signal;
+        this.maxRetries = clampRetries(options.maxRetries ?? DEFAULT_MAX_RETRIES);
+        this.runTurnImpl = options.runTurn ?? runTurn;
+        this.progress.maxAttempts = this.maxRetries;
+    }
+    plan(goal) {
+        const normalizedGoal = normalizeGoal(goal);
+        const files = collectFiles(normalizedGoal);
+        const steps = [
+            {
+                id: 'analyze-goal',
+                description: `Analyze the current implementation, constraints, and affected surfaces for: ${normalizedGoal.description}`,
+                type: 'analyze',
+                files,
+            },
+            {
+                id: 'create-artifacts',
+                description: 'Create any new files, modules, or scaffolding required to deliver the goal end-to-end.',
+                type: 'create',
+                files,
+                dependencies: ['analyze-goal'],
+            },
+            {
+                id: 'modify-integrations',
+                description: 'Modify the existing integration points, command wiring, and supporting code needed by the goal.',
+                type: 'modify',
+                files,
+                dependencies: ['create-artifacts'],
+            },
+            {
+                id: 'test-goal',
+                description: buildTestStepDescription(normalizedGoal),
+                type: 'test',
+                files,
+                dependencies: ['modify-integrations'],
+            },
+            {
+                id: 'verify-goal',
+                description: buildVerifyStepDescription(normalizedGoal),
+                type: 'verify',
+                files,
+                dependencies: ['test-goal'],
+            },
+        ];
+        const estimatedTokens = safeTokenEstimate([
+            normalizedGoal.description,
+            normalizedGoal.constraints?.join('\n') ?? '',
+            normalizedGoal.acceptanceCriteria?.join('\n') ?? '',
+            normalizedGoal.scope?.join('\n') ?? '',
+            ...steps.map((step) => `${step.id}:${step.description}`),
+        ].join('\n'));
+        this.progress = {
+            phase: 'planned',
+            goal: normalizedGoal,
+            currentAttempt: 0,
+            maxAttempts: this.maxRetries,
+            completedSteps: 0,
+            totalSteps: steps.length,
+        };
+        return {
+            goal: normalizedGoal,
+            steps,
+            estimatedTokens,
+        };
+    }
+    async execute(plan) {
+        this.progress = {
+            ...this.progress,
+            phase: 'executing',
+            goal: plan.goal,
+            currentAttempt: 0,
+            completedSteps: 0,
+            totalSteps: plan.steps.length,
+            currentStepId: undefined,
+            lastError: undefined,
+            result: undefined,
+            verification: undefined,
+        };
+        const previousMode = this.session.state.mode;
+        const previousPrompt = this.session.state.systemPrompt;
+        setSessionMode(this.session, 'ask');
+        setSystemPrompt(this.session, buildGoalSystemPrompt(plan.goal));
+        let lastResult = null;
+        let retryFeedback = [];
+        try {
+            for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+                const stepResults = createStepResults(plan.steps, attempt);
+                this.progress.currentAttempt = attempt;
+                this.progress.phase = 'executing';
+                this.progress.completedSteps = 0;
+                this.progress.currentStepId = undefined;
+                this.progress.lastError = undefined;
+                let aborted = false;
+                for (let index = 0; index < plan.steps.length; index++) {
+                    const step = plan.steps[index];
+                    const stepResult = stepResults[index];
+                    this.progress.currentStepId = step.id;
+                    stepResult.status = 'running';
+                    try {
+                        throwIfAborted(this.signal);
+                        await this.runTurnImpl({
+                            session: this.session,
+                            userInput: buildGoalStepPrompt(plan, step, attempt, this.maxRetries, retryFeedback),
+                            signal: this.signal,
+                        });
+                        stepResult.status = 'completed';
+                        stepResult.output = findLastAssistantMessage(this.session.state.messages);
+                        this.progress.completedSteps += 1;
+                    }
+                    catch (error) {
+                        if (isAbortError(error) || this.signal.aborted) {
+                            aborted = true;
+                            stepResult.status = 'skipped';
+                            stepResult.error = 'Goal execution was aborted.';
+                            break;
+                        }
+                        stepResult.status = 'failed';
+                        stepResult.error = error instanceof Error ? error.message : String(error);
+                        this.progress.lastError = stepResult.error;
+                        break;
+                    }
+                }
+                this.progress.phase = aborted ? 'aborted' : 'verifying';
+                const summary = summarizeResult(plan.goal, stepResults, attempt, aborted);
+                const result = {
+                    goal: plan.goal,
+                    plan,
+                    success: false,
+                    attempts: attempt,
+                    summary,
+                    aborted,
+                    stepResults,
+                    verification: {
+                        ok: false,
+                        score: 0,
+                        issues: [],
+                        attempts: attempt,
+                    },
+                };
+                const verification = this.verify(plan.goal, result);
+                result.verification = verification;
+                result.success = verification.ok;
+                this.progress.verification = verification;
+                this.progress.result = result;
+                lastResult = result;
+                if (aborted) {
+                    this.progress.phase = 'aborted';
+                    return result;
+                }
+                if (verification.ok) {
+                    this.progress.phase = 'completed';
+                    return result;
+                }
+                retryFeedback = verification.issues;
+                this.progress.phase = attempt >= this.maxRetries ? 'failed' : 'executing';
+            }
+        }
+        finally {
+            setSystemPrompt(this.session, previousPrompt);
+            setSessionMode(this.session, previousMode);
+        }
+        if (lastResult) {
+            this.progress.result = lastResult;
+            return lastResult;
+        }
+        const fallbackPlan = plan.steps.length > 0 ? plan : this.plan(plan.goal);
+        const fallbackResult = {
+            goal: plan.goal,
+            plan: fallbackPlan,
+            success: false,
+            attempts: this.progress.currentAttempt,
+            summary: 'Goal execution did not run.',
+            aborted: false,
+            stepResults: createStepResults(fallbackPlan.steps, this.progress.currentAttempt || 1),
+            verification: {
+                ok: false,
+                score: 0,
+                issues: ['Goal execution did not run.'],
+                attempts: this.progress.currentAttempt || 1,
+            },
+        };
+        this.progress.phase = 'failed';
+        this.progress.result = fallbackResult;
+        this.progress.verification = fallbackResult.verification;
+        return fallbackResult;
+    }
+    verify(goal, result) {
+        const issues = [];
+        if (result.aborted) {
+            issues.push('Goal execution was aborted before completion.');
+        }
+        const failedSteps = result.stepResults.filter((step) => step.status === 'failed');
+        for (const step of failedSteps) {
+            issues.push(`Step "${step.description}" failed${step.error ? `: ${step.error}` : '.'}`);
+        }
+        const completedSteps = result.stepResults.filter((step) => step.status === 'completed');
+        if (completedSteps.length === 0) {
+            issues.push('No goal step completed successfully.');
+        }
+        if ((goal.acceptanceCriteria?.length ?? 0) > 0) {
+            const hasValidationStep = result.plan.steps.some((step) => step.type === 'test' || step.type === 'verify');
+            if (!hasValidationStep) {
+                issues.push('The plan does not include a validation step for the acceptance criteria.');
+            }
+        }
+        const hasVerifyCompletion = result.stepResults.some((step) => step.type === 'verify' && step.status === 'completed');
+        if (!hasVerifyCompletion) {
+            issues.push('The verification step did not complete successfully.');
+        }
+        const scoreBase = result.plan.steps.length > 0 ? completedSteps.length / result.plan.steps.length : 0;
+        const score = Math.max(0, Math.min(1, Math.round((scoreBase - issues.length * 0.08) * 100) / 100));
+        return {
+            ok: issues.length === 0,
+            score,
+            issues,
+            attempts: result.attempts,
+        };
+    }
+    getProgress() {
+        return {
+            ...this.progress,
+            verification: this.progress.verification
+                ? {
+                    ...this.progress.verification,
+                    issues: [...this.progress.verification.issues],
+                }
+                : undefined,
+            result: this.progress.result
+                ? {
+                    ...this.progress.result,
+                    stepResults: this.progress.result.stepResults.map((step) => ({ ...step })),
+                    verification: {
+                        ...this.progress.result.verification,
+                        issues: [...this.progress.result.verification.issues],
+                    },
+                }
+                : undefined,
+        };
+    }
+}
+function normalizeGoal(goal) {
+    return {
+        description: goal.description.trim(),
+        constraints: normalizeStringList(goal.constraints),
+        acceptanceCriteria: normalizeStringList(goal.acceptanceCriteria),
+        scope: normalizeStringList(goal.scope),
+    };
+}
+function normalizeStringList(values) {
+    if (!Array.isArray(values))
+        return undefined;
+    const normalized = values.map((value) => value.trim()).filter(Boolean);
+    return normalized.length > 0 ? normalized : undefined;
+}
+function collectFiles(goal) {
+    const files = new Set();
+    for (const entry of goal.scope ?? []) {
+        const normalized = entry.trim();
+        if (/\.[a-z0-9]+$/i.test(normalized) || normalized.includes('/') || normalized.includes('\\')) {
+            files.add(normalized);
+        }
+    }
+    return files.size > 0 ? [...files] : undefined;
+}
+function buildTestStepDescription(goal) {
+    const criteria = goal.acceptanceCriteria && goal.acceptanceCriteria.length > 0
+        ? `Validate these acceptance criteria: ${goal.acceptanceCriteria.join('; ')}.`
+        : 'Run or update the most relevant automated and manual checks for the goal.';
+    return `${criteria} Fix any gaps before proceeding.`;
+}
+function buildVerifyStepDescription(goal) {
+    const constraints = goal.constraints && goal.constraints.length > 0
+        ? ` Re-check constraints: ${goal.constraints.join('; ')}.`
+        : '';
+    return `Verify the end-to-end outcome, summarize the changes made, and confirm the goal is complete.${constraints}`;
+}
+function safeTokenEstimate(text) {
+    try {
+        return countTokensSync(text);
+    }
+    catch {
+        return Math.max(1, Math.ceil(text.length / 4));
+    }
+}
+function createStepResults(steps, attempt) {
+    return steps.map((step) => ({
+        stepId: step.id,
+        description: step.description,
+        type: step.type,
+        status: 'pending',
+        attempts: attempt,
+    }));
+}
+function buildGoalSystemPrompt(goal) {
+    const lines = [
+        'You are a goal-driven implementation agent.',
+        'Plan, implement, test, and verify the requested feature end-to-end.',
+        'Use the available tools to inspect code, make changes, run tests, and confirm the result.',
+        'Keep changes aligned to the stated scope and constraints.',
+        '',
+        `Goal: ${goal.description}`,
+    ];
+    if (goal.scope?.length) {
+        lines.push(`Scope: ${goal.scope.join('; ')}`);
+    }
+    if (goal.constraints?.length) {
+        lines.push(`Constraints: ${goal.constraints.join('; ')}`);
+    }
+    if (goal.acceptanceCriteria?.length) {
+        lines.push(`Acceptance criteria: ${goal.acceptanceCriteria.join('; ')}`);
+    }
+    return lines.join('\n');
+}
+function buildGoalStepPrompt(plan, step, attempt, maxAttempts, retryFeedback) {
+    const lines = [
+        `Goal attempt ${attempt} of ${maxAttempts}.`,
+        `Goal: ${plan.goal.description}`,
+        `Current step (${step.type}): ${step.description}`,
+    ];
+    if (step.files?.length) {
+        lines.push(`Relevant files: ${step.files.join(', ')}`);
+    }
+    if (step.dependencies?.length) {
+        lines.push(`Step dependencies already satisfied: ${step.dependencies.join(', ')}`);
+    }
+    if (retryFeedback.length > 0) {
+        lines.push(`Retry guidance: ${retryFeedback.join(' | ')}`);
+    }
+    if (plan.goal.acceptanceCriteria?.length) {
+        lines.push(`Acceptance criteria: ${plan.goal.acceptanceCriteria.join('; ')}`);
+    }
+    if (plan.goal.constraints?.length) {
+        lines.push(`Constraints: ${plan.goal.constraints.join('; ')}`);
+    }
+    lines.push('Do the work for this step now and report the concrete outcome.');
+    return lines.join('\n');
+}
+function summarizeResult(goal, stepResults, attempt, aborted) {
+    const completed = stepResults.filter((step) => step.status === 'completed').length;
+    const failed = stepResults.filter((step) => step.status === 'failed').length;
+    const skipped = stepResults.filter((step) => step.status === 'skipped').length;
+    const status = aborted ? 'aborted' : failed > 0 ? 'failed' : 'completed';
+    return `${goal.description} — ${status} on attempt ${attempt} (${completed} completed, ${failed} failed, ${skipped} skipped).`;
+}
+function findLastAssistantMessage(messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message?.role !== 'assistant') {
+            continue;
+        }
+        if (typeof message.content === 'string') {
+            return message.content;
+        }
+        if (Array.isArray(message.content)) {
+            return message.content
+                .map((part) => {
+                if (typeof part === 'string')
+                    return part;
+                return 'text' in part && typeof part.text === 'string' ? part.text : '';
+            })
+                .join('\n');
+        }
+    }
+    return '';
+}
+function setSessionMode(session, mode) {
+    if (typeof session.setMode === 'function') {
+        session.setMode(mode);
+        return;
+    }
+    session.state.mode = mode;
+}
+function setSystemPrompt(session, prompt) {
+    if (typeof session.setSystemPrompt === 'function') {
+        session.setSystemPrompt(prompt);
+        return;
+    }
+    session.state.systemPrompt = prompt;
+}
+function clampRetries(value) {
+    if (!Number.isFinite(value))
+        return DEFAULT_MAX_RETRIES;
+    return Math.max(1, Math.min(Math.trunc(value), DEFAULT_MAX_RETRIES));
+}
+function throwIfAborted(signal) {
+    if (signal.aborted) {
+        throw new DOMException('Aborted', 'AbortError');
+    }
+}
+function isAbortError(error) {
+    return Boolean((error instanceof DOMException && error.name === 'AbortError') ||
+        (error instanceof Error && error.name === 'AbortError'));
+}