create-principles-disciple 1.82.0 → 1.83.0

package/console/dist/server/models/OverviewConsoleModel.js

@@ -1,202 +0,0 @@
-import * as path from 'path';
-import { OperatorHealthReadModel, PainChainReadModel, PruningReadModel, RuntimeStateManager, } from '@principles/core/runtime-v2';
-import { EventLogReadModel } from './EventLogReadModel.js';
-export class OverviewConsoleModel {
-    workspaceDir;
-    stateDir;
-    healthReadModel = null;
-    painChainReadModel = null;
-    pruningReadModel = null;
-    stateManager = null;
-    eventLogReadModel = null;
-    ownsHealthReadModel = false;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = path.join(workspaceDir, '.state');
-    }
-    async getHealth() {
-        const snapshot = await this.getHealthReadModel().getSnapshot();
-        const pruningSummary = this.getPruningReadModel().getHealthSummary();
-        const { byStatus } = pruningSummary;
-        const gfiSnapshot = snapshot.gfi;
-        const activeGfi = gfiSnapshot.active;
-        return {
-            status: snapshot.overallStatus,
-            gfi: {
-                current: activeGfi?.currentGfi ?? 0,
-                stage: activeGfi?.stage ?? 'stable',
-                peakToday: activeGfi?.dailyGfiPeak ?? 0,
-                threshold: activeGfi?.policy?.criticalThreshold ?? 0,
-            },
-            trust: {
-                stage: 0,
-                score: 0,
-            },
-            principles: {
-                candidate: byStatus.candidate ?? 0,
-                probation: byStatus.probation ?? 0,
-                active: byStatus.active ?? 0,
-                deprecated: byStatus.deprecated ?? 0,
-            },
-            queue: {
-                pending: snapshot.candidateLedger.orphanCandidateCount,
-                inProgress: await this.getInProgressCount(),
-                completed: snapshot.totalTaskCount,
-            },
-        };
-    }
-    async getOverview(_days) {
-        const snapshot = await this.getHealthReadModel().getSnapshot();
-        const pruningSummary = this.getPruningReadModel().getHealthSummary();
-        const { byStatus } = pruningSummary;
-        const principleActive = (byStatus.active ?? 0) + (byStatus.candidate ?? 0);
-        const principlePending = (byStatus.probation ?? 0) + (byStatus.deprecated ?? 0);
-        const gfiSnapshot = snapshot.gfi;
-        const activeGfi = gfiSnapshot.active;
-        const eventLog = this.getEventLogReadModel();
-        const [gateBlocksToday, painEventsToday] = await Promise.all([
-            eventLog.countEventsByTypeToday('gate_block'),
-            eventLog.countEventsByTypeToday('pain_signal'),
-        ]);
-        const health = {
-            status: snapshot.overallStatus,
-            gfi: {
-                current: activeGfi?.currentGfi ?? 0,
-                stage: activeGfi?.stage ?? 'stable',
-                peakToday: activeGfi?.dailyGfiPeak ?? 0,
-                threshold: activeGfi?.policy?.criticalThreshold ?? 0,
-            },
-            trust: {
-                stage: 0,
-                score: 0,
-            },
-            principles: {
-                candidate: byStatus.candidate ?? 0,
-                probation: byStatus.probation ?? 0,
-                active: byStatus.active ?? 0,
-                deprecated: byStatus.deprecated ?? 0,
-            },
-            queue: {
-                pending: snapshot.candidateLedger.orphanCandidateCount,
-                inProgress: await this.getInProgressCount(),
-                completed: snapshot.totalTaskCount,
-            },
-        };
-        return {
-            workspaceDir: this.workspaceDir,
-            generatedAt: snapshot.generatedAt,
-            dataFreshness: snapshot.overallStatus === 'error' ? 'error' : 'fresh',
-            summary: {
-                repeatErrorRate: 0,
-                userCorrectionRate: 0,
-                pendingSamples: byStatus.candidate ?? 0,
-                approvedSamples: byStatus.active ?? 0,
-                painEvents: painEventsToday,
-                principleEventCount: principleActive + principlePending,
-                gateBlocks: gateBlocksToday,
-                taskOutcomes: snapshot.totalTaskCount,
-            },
-            health,
-            dailyTrend: await this.getDailyTrend(),
-            topRegressions: [],
-            sampleQueue: {
-                counters: byStatus,
-                preview: [],
-            },
-        };
-    }
-    async getInProgressCount() {
-        try {
-            const mgr = this.getStateManager();
-            const tasks = await mgr.listTasks({ status: 'leased' });
-            return tasks.length;
-        }
-        catch {
-            return 0;
-        }
-    }
-    async getDailyTrend() {
-        const eventLog = this.getEventLogReadModel();
-        const trend = [];
-        for (let i = 6; i >= 0; i--) {
-            const date = new Date();
-            date.setDate(date.getDate() - i);
-            const [day] = date.toISOString().split('T');
-            const [toolCalls, failures, painEvents] = await Promise.all([
-                eventLog.countEventsByTypeAndDate('tool_call', day),
-                eventLog.countEventsByCategoryAndDate('failure', day),
-                eventLog.countEventsByTypeAndDate('pain_signal', day),
-            ]);
-            trend.push({
-                day,
-                toolCalls,
-                failures,
-                userCorrections: 0,
-                painEvents,
-            });
-        }
-        return trend;
-    }
-    dispose() {
-        if (this.healthReadModel && this.ownsHealthReadModel) {
-            this.healthReadModel.close().catch((err) => {
-                console.error('[OverviewConsoleModel] Failed to close health read model:', err);
-            });
-        }
-        if (this.painChainReadModel) {
-            this.painChainReadModel.close().catch((err) => {
-                console.error('[OverviewConsoleModel] Failed to close pain chain read model:', err);
-            });
-        }
-        if (this.stateManager) {
-            this.stateManager.close().catch((err) => {
-                console.error('[OverviewConsoleModel] Failed to close state manager:', err);
-            });
-        }
-        if (this.eventLogReadModel) {
-            this.eventLogReadModel.dispose();
-        }
-    }
-    getHealthReadModel() {
-        if (!this.healthReadModel) {
-            const painChainReadModel = this.getPainChainReadModel();
-            const pruningReadModel = this.getPruningReadModel();
-            this.healthReadModel = new OperatorHealthReadModel({
-                workspaceDir: this.workspaceDir,
-                painChainReadModel,
-                pruningReadModel,
-            });
-            this.ownsHealthReadModel = true;
-        }
-        return this.healthReadModel;
-    }
-    getPainChainReadModel() {
-        if (!this.painChainReadModel) {
-            this.painChainReadModel = new PainChainReadModel({
-                workspaceDir: this.workspaceDir,
-                stateManager: this.getStateManager(),
-            });
-        }
-        return this.painChainReadModel;
-    }
-    getPruningReadModel() {
-        if (!this.pruningReadModel) {
-            this.pruningReadModel = new PruningReadModel({
-                workspaceDir: this.workspaceDir,
-            });
-        }
-        return this.pruningReadModel;
-    }
-    getStateManager() {
-        if (!this.stateManager) {
-            this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-        }
-        return this.stateManager;
-    }
-    getEventLogReadModel() {
-        if (!this.eventLogReadModel) {
-            this.eventLogReadModel = new EventLogReadModel(this.stateDir);
-        }
-        return this.eventLogReadModel;
-    }
-}

package/console/dist/server/models/PipelineStatsModel.d.ts

@@ -1,35 +0,0 @@
-export type PipelineStageStatus = 'normal' | 'slow' | 'stuck';
-export interface PipelineStage {
-    id: string;
-    name: string;
-    status: PipelineStageStatus;
-    count: number;
-    avgDuration: number | null;
-    lastProcessed: string | null;
-    gapMinutes: number | null;
-}
-export interface Bottleneck {
-    fromStage: string;
-    toStage: string;
-    gapMinutes: number;
-    severity: 'warning' | 'critical';
-    description: string;
-}
-export interface PipelineStats {
-    generatedAt: string;
-    stages: PipelineStage[];
-    bottlenecks: Bottleneck[];
-    totalProcessed: number;
-    throughput: number;
-}
-export declare class PipelineStatsModel {
-    private readonly workspaceDir;
-    private readonly stateDir;
-    private eventLog;
-    private runtime;
-    constructor(workspaceDir: string);
-    getPipelineStats(): Promise<PipelineStats>;
-    private getEventLogReadModel;
-    private getRuntime;
-    dispose(): void;
-}

package/console/dist/server/models/PipelineStatsModel.js

@@ -1,129 +0,0 @@
-import * as path from 'path';
-import { EventLogReadModel } from './EventLogReadModel.js';
-import { RuntimeStateManager } from '@principles/core/runtime-v2';
-const STAGE_CONFIG = [
-    { id: 'pain_signal', name: 'Pain Signal', eventTypes: ['pain_signal'] },
-    { id: 'task_created', name: 'Task Created', eventTypes: ['diagnosis_task', 'heartbeat_diagnosis', 'evolution_task'] },
-    { id: 'candidate_generated', name: 'Candidate Generated', eventTypes: ['principle_candidate'] },
-    { id: 'principle_added', name: 'Principle Added', eventTypes: ['rule_promotion'] },
-];
-const THRESHOLD_MINUTES = {
-    slow: 15,
-    stuck: 30,
-    bottleneckWarning: 5,
-    bottleneckCritical: 15,
-};
-const noop = () => { };
-export class PipelineStatsModel {
-    workspaceDir;
-    stateDir;
-    eventLog = null;
-    runtime = null;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = path.join(workspaceDir, '.state');
-    }
-    async getPipelineStats() {
-        const eventLog = this.getEventLogReadModel();
-        const now = new Date();
-        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-        const todayISO = today.toISOString();
-        const stages = [];
-        const bottlenecks = [];
-        let totalProcessed = 0;
-        const stageEvents = await Promise.all(STAGE_CONFIG.map(async (config) => {
-            const events = await eventLog.getEventsByTypes(config.eventTypes, 1000);
-            const todayEvents = events.filter(e => e.ts >= todayISO);
-            return { config, events: todayEvents, allEvents: events };
-        }));
-        for (let i = 0; i < stageEvents.length; i++) {
-            const { config, events: todayEvents, allEvents } = stageEvents[i];
-            const count = todayEvents.length;
-            totalProcessed += count;
-            const [firstEvent] = allEvents;
-            const lastProcessed = firstEvent ? firstEvent.ts : null;
-            let gapMinutes = null;
-            let status = 'normal';
-            if (lastProcessed) {
-                const lastTime = new Date(lastProcessed);
-                gapMinutes = (now.getTime() - lastTime.getTime()) / (1000 * 60);
-                if (gapMinutes > THRESHOLD_MINUTES.stuck) {
-                    status = 'stuck';
-                }
-                else if (gapMinutes > THRESHOLD_MINUTES.slow) {
-                    status = 'slow';
-                }
-            }
-            else if (count === 0) {
-                status = 'stuck';
-            }
-            let avgDuration = null;
-            if (allEvents.length > 1) {
-                const timestamps = allEvents.map(e => new Date(e.ts).getTime());
-                const intervals = [];
-                for (let j = 0; j < timestamps.length - 1; j++) {
-                    intervals.push(timestamps[j] - timestamps[j + 1]);
-                }
-                avgDuration = intervals.reduce((a, b) => a + b, 0) / intervals.length;
-            }
-            stages.push({
-                id: config.id,
-                name: config.name,
-                status,
-                count,
-                avgDuration,
-                lastProcessed,
-                gapMinutes,
-            });
-            if (i < stageEvents.length - 1) {
-                const currentLastProcessed = lastProcessed;
-                const [nextFirstEvent] = stageEvents[i + 1].allEvents;
-                const nextLastProcessed = nextFirstEvent?.ts ?? null;
-                if (currentLastProcessed && nextLastProcessed) {
-                    const currentTime = new Date(currentLastProcessed);
-                    const nextTime = new Date(nextLastProcessed);
-                    const gap = (nextTime.getTime() - currentTime.getTime()) / (1000 * 60);
-                    if (gap > THRESHOLD_MINUTES.bottleneckWarning) {
-                        bottlenecks.push({
-                            fromStage: config.name,
-                            toStage: stageEvents[i + 1].config.name,
-                            gapMinutes: gap,
-                            severity: gap > THRESHOLD_MINUTES.bottleneckCritical ? 'critical' : 'warning',
-                            description: `从 ${config.name} 到 ${stageEvents[i + 1].config.name} 延迟 ${Math.floor(gap)} 分钟`,
-                        });
-                    }
-                }
-            }
-        }
-        const throughput = totalProcessed / 24;
-        return {
-            generatedAt: now.toISOString(),
-            stages,
-            bottlenecks,
-            totalProcessed,
-            throughput: Math.round(throughput * 10) / 10,
-        };
-    }
-    getEventLogReadModel() {
-        if (!this.eventLog) {
-            this.eventLog = new EventLogReadModel(this.stateDir);
-        }
-        return this.eventLog;
-    }
-    getRuntime() {
-        if (!this.runtime) {
-            this.runtime = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-        }
-        return this.runtime;
-    }
-    dispose() {
-        if (this.eventLog) {
-            this.eventLog.dispose();
-            this.eventLog = null;
-        }
-        if (this.runtime) {
-            this.runtime.close().catch(noop);
-            this.runtime = null;
-        }
-    }
-}

package/console/dist/server/models/SampleConsoleModel.d.ts

@@ -1,21 +0,0 @@
-import type { SampleDetail, SamplesListOutput, SampleReviewInput } from '../types/index.js';
-export declare class SampleConsoleModel {
-    private readonly workspaceDir;
-    private stateManager;
-    private intakeService;
-    private initPromise;
-    constructor(workspaceDir: string);
-    private ensureInitialized;
-    private getIntakeService;
-    listSamples(filters?: {
-        status?: string;
-        page?: number;
-        pageSize?: number;
-    }): Promise<SamplesListOutput>;
-    getSampleDetail(sampleId: string): Promise<SampleDetail | null>;
-    reviewSample(sampleId: string, input: SampleReviewInput): Promise<{
-        success: boolean;
-        reviewStatus: string;
-    }>;
-    dispose(): void;
-}

package/console/dist/server/models/SampleConsoleModel.js

@@ -1,188 +0,0 @@
-import * as path from 'path';
-import { RuntimeStateManager, CandidateIntakeService, PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
-function mapReviewStatus(status) {
-    switch (status) {
-        case 'consumed': return 'approved';
-        case 'expired': return 'rejected';
-        default: return 'pending';
-    }
-}
-export class SampleConsoleModel {
-    workspaceDir;
-    stateManager = null;
-    intakeService = null;
-    initPromise = null;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-    }
-    async ensureInitialized() {
-        if (this.initPromise) {
-            await this.initPromise;
-            return this.stateManager;
-        }
-        this.stateManager = new RuntimeStateManager({ workspaceDir: this.workspaceDir });
-        this.initPromise = this.stateManager.initialize().catch((err) => {
-            this.stateManager = null;
-            this.initPromise = null;
-            throw err;
-        });
-        await this.initPromise;
-        return this.stateManager;
-    }
-    async getIntakeService() {
-        if (!this.intakeService) {
-            const mgr = await this.ensureInitialized();
-            const stateDir = path.join(this.workspaceDir, '.state');
-            const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir });
-            this.intakeService = new CandidateIntakeService({
-                stateManager: mgr,
-                ledgerAdapter,
-            });
-        }
-        return this.intakeService;
-    }
-    async listSamples(filters = {}) {
-        const mgr = await this.ensureInitialized();
-        const page = Math.max(1, filters.page ?? 1);
-        const pageSize = Math.min(Math.max(1, filters.pageSize ?? 20), 100);
-        const tasks = await mgr.listTasks();
-        const allCandidates = [];
-        for (const task of tasks) {
-            const candidates = await mgr.getCandidatesByTaskId(task.taskId);
-            for (const c of candidates) {
-                const reviewStatus = mapReviewStatus(c.status);
-                if (filters.status && filters.status !== 'all' && reviewStatus !== filters.status) {
-                    continue;
-                }
-                allCandidates.push({
-                    sampleId: c.candidateId,
-                    taskId: c.taskId,
-                    title: c.title,
-                    description: c.description,
-                    reviewStatus,
-                    confidence: c.confidence ?? null,
-                    createdAt: c.createdAt,
-                });
-            }
-        }
-        allCandidates.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-        const counters = {};
-        for (const item of allCandidates) {
-            counters[item.reviewStatus] = (counters[item.reviewStatus] ?? 0) + 1;
-        }
-        const total = allCandidates.length;
-        const offset = (page - 1) * pageSize;
-        const items = allCandidates.slice(offset, offset + pageSize);
-        return {
-            counters,
-            items,
-            pagination: {
-                page,
-                pageSize,
-                total,
-                totalPages: total === 0 ? 0 : Math.ceil(total / pageSize),
-            },
-        };
-    }
-    async getSampleDetail(sampleId) {
-        const mgr = await this.ensureInitialized();
-        const candidate = await mgr.getCandidate(sampleId);
-        if (!candidate)
-            return null;
-        const reviewStatus = mapReviewStatus(candidate.status);
-        let artifactContent = null;
-        let recommendation = null;
-        try {
-            const artifact = await mgr.getArtifact(candidate.artifactId);
-            if (artifact) {
-                try {
-                    artifactContent = JSON.parse(artifact.contentJson);
-                }
-                catch {
-                    artifactContent = { raw: artifact.contentJson };
-                }
-            }
-        }
-        catch {
-            // artifact may not be available
-        }
-        try {
-            if (candidate.sourceRecommendationJson) {
-                const parsed = JSON.parse(candidate.sourceRecommendationJson);
-                if (parsed && typeof parsed === 'object') {
-                    recommendation = {
-                        title: typeof parsed.title === 'string' ? parsed.title : undefined,
-                        text: typeof parsed.text === 'string' ? parsed.text : undefined,
-                        triggerPattern: typeof parsed.triggerPattern === 'string' ? parsed.triggerPattern : undefined,
-                        action: typeof parsed.action === 'string' ? parsed.action : undefined,
-                        abstractedPrinciple: typeof parsed.abstractedPrinciple === 'string' ? parsed.abstractedPrinciple : undefined,
-                    };
-                }
-            }
-        }
-        catch {
-            // recommendation parsing failed
-        }
-        return {
-            sampleId: candidate.candidateId,
-            taskId: candidate.taskId,
-            title: candidate.title,
-            description: candidate.description,
-            reviewStatus,
-            confidence: candidate.confidence ?? null,
-            createdAt: candidate.createdAt,
-            artifactContent,
-            recommendation,
-        };
-    }
-    async reviewSample(sampleId, input) {
-        const mgr = await this.ensureInitialized();
-        const candidate = await mgr.getCandidate(sampleId);
-        if (!candidate) {
-            throw new Error(`Sample ${sampleId} not found`);
-        }
-        if (candidate.status !== 'pending') {
-            throw new Error(`Sample is not pending (current status: ${candidate.status})`);
-        }
-        if (input.decision === 'approved') {
-            const transitioned = await mgr.transitionCandidateStatus(sampleId, 'pending', 'consumed');
-            if (!transitioned) {
-                throw new Error('Failed to transition sample status to consumed');
-            }
-            try {
-                const intake = await this.getIntakeService();
-                await intake.intake(sampleId);
-            }
-            catch (intakeErr) {
-                try {
-                    await mgr.updateCandidateStatus(sampleId, { status: 'pending' });
-                }
-                catch (rollbackErr) {
-                    const combinedError = new Error(`Intake failed and rollback also failed. Sample ${sampleId} may be in inconsistent state.`);
-                    combinedError.cause = { intakeErr, rollbackErr };
-                    throw combinedError;
-                }
-                throw intakeErr;
-            }
-            return { success: true, reviewStatus: 'approved' };
-        }
-        if (input.decision === 'rejected') {
-            const transitioned = await mgr.transitionCandidateStatus(sampleId, 'pending', 'expired');
-            if (!transitioned) {
-                throw new Error('Failed to transition sample status to expired');
-            }
-            return { success: true, reviewStatus: 'rejected' };
-        }
-        throw new Error(`Invalid decision: ${input.decision}`);
-    }
-    dispose() {
-        if (this.stateManager) {
-            this.stateManager.close().catch((err) => {
-                console.error('[SampleConsoleModel] Failed to close state manager:', err);
-            });
-            this.stateManager = null;
-        }
-        this.intakeService = null;
-        this.initPromise = null;
-    }
-}

package/console/dist/server/models/ThinkingModelsConsoleModel.d.ts

@@ -1,22 +0,0 @@
-export interface ThinkingOsDirective {
-    id: string;
-    name: string;
-    trigger: string;
-    must: string;
-    forbidden: string;
-}
-export interface ThinkingModelOverview {
-    totalModels: number;
-    models: ThinkingOsDirective[];
-    source: 'workspace' | 'none';
-}
-export declare class ThinkingModelsConsoleModel {
-    private readonly workspaceDir;
-    private cachedOverview;
-    private cacheTimestamp;
-    private static readonly CACHE_TTL_MS;
-    constructor(workspaceDir: string);
-    getOverview(): ThinkingModelOverview;
-    getModelDetail(modelId: string): ThinkingOsDirective | null;
-    dispose(): void;
-}

package/console/dist/server/models/ThinkingModelsConsoleModel.js

@@ -1,75 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-function extractTag(content, tagName) {
-    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, 'i');
-    const match = content.match(regex);
-    if (!match)
-        return '';
-    return match[1].trim().replace(/\s+/g, ' ');
-}
-function parseThinkingOsMd(content) {
-    const directives = [];
-    const directiveRegex = /<directive\s+([^>]*)>([\s\S]*?)<\/directive>/gi;
-    let match = null; // eslint-disable-line no-useless-assignment
-    while ((match = directiveRegex.exec(content)) !== null) {
-        const [, attrs, body] = match;
-        const idMatch = /id="([^"]+)"/i.exec(attrs);
-        const nameMatch = /name="([^"]+)"/i.exec(attrs);
-        if (!idMatch)
-            continue;
-        directives.push({
-            id: idMatch[1],
-            name: nameMatch ? nameMatch[1] : '',
-            trigger: extractTag(body, 'trigger'),
-            must: extractTag(body, 'must'),
-            forbidden: extractTag(body, 'forbidden'),
-        });
-    }
-    return directives;
-}
-export class ThinkingModelsConsoleModel {
-    workspaceDir;
-    cachedOverview = null;
-    cacheTimestamp = 0;
-    static CACHE_TTL_MS = 5000;
-    constructor(workspaceDir) {
-        this.workspaceDir = workspaceDir;
-    }
-    getOverview() {
-        const now = Date.now();
-        if (this.cachedOverview && (now - this.cacheTimestamp) < ThinkingModelsConsoleModel.CACHE_TTL_MS) {
-            return this.cachedOverview;
-        }
-        const candidates = [
-            path.join(this.workspaceDir, 'THINKING_OS.md'),
-            path.join(this.workspaceDir, '.state', 'THINKING_OS.md'),
-            path.join(this.workspaceDir, '.pd', 'THINKING_OS.md'),
-        ];
-        for (const filePath of candidates) {
-            if (fs.existsSync(filePath)) {
-                try {
-                    const content = fs.readFileSync(filePath, 'utf8');
-                    const models = parseThinkingOsMd(content);
-                    if (models.length > 0) {
-                        this.cachedOverview = { totalModels: models.length, models, source: 'workspace' };
-                        this.cacheTimestamp = now;
-                        return this.cachedOverview;
-                    }
-                }
-                catch {
-                    // try next candidate
-                }
-            }
-        }
-        this.cachedOverview = { totalModels: 0, models: [], source: 'none' };
-        this.cacheTimestamp = now;
-        return this.cachedOverview;
-    }
-    getModelDetail(modelId) {
-        const overview = this.getOverview();
-        return overview.models.find(m => m.id === modelId) ?? null;
-    }
-    dispose() {
-        this.cachedOverview = null;
-    }
-}

package/console/dist/server/routes/agents.d.ts

@@ -1,3 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare function handleAgentsRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;
-export declare function disposeAgentModels(): void;