openbot 0.4.6 → 0.5.4

package/dist/bus/types.js

@@ -1 +0,0 @@
-export {};

package/dist/harness/agent-harness.js

@@ -1,45 +0,0 @@
-import { orchestratorService } from './orchestrator.js';
-import { ensureEventId } from '../app/utils.js';
-/**
- * Standard implementation of the Agent Harness.
- * It wraps the orchestrator logic into a clean, stateful container.
- */
-export class AgentHarness {
-    constructor(options) {
-        this.eventCallbacks = [];
-        this.runId = options.runId;
-        this.agentId = options.agentId;
-        this.channelId = options.channelId;
-        this.threadId = options.threadId;
-        if (options.onEvent) {
-            this.eventCallbacks.push(options.onEvent);
-        }
-    }
-    /**
-     * Dispatches an event to the agent within this harness.
-     */
-    async dispatch(event) {
-        ensureEventId(event);
-        await orchestratorService.dispatch({
-            runId: this.runId,
-            agentId: this.agentId,
-            event,
-            channelId: this.channelId,
-            threadId: this.threadId,
-            onEvent: async (chunk, state) => {
-                // Update internal thread state if it changes (e.g. thread creation)
-                if (chunk.type === 'action:create_thread:result' && chunk.data.success) {
-                    this.threadId = chunk.data.threadId || this.threadId;
-                }
-                // Notify all observers
-                await Promise.all(this.eventCallbacks.map(cb => cb(chunk, state)));
-            }
-        });
-    }
-    /**
-     * Adds an event listener to the harness.
-     */
-    onEvent(callback) {
-        this.eventCallbacks.push(callback);
-    }
-}

package/dist/harness/agent-invoke-run.js

@@ -1,44 +0,0 @@
-import { createAgentRuntime } from './runtime-factory.js';
-/**
- * Shared `runtime.run(agent:invoke)` loop: tags chunks with `agentId`, skips echo of the
- * trigger event, optionally polls for stop, tracks last `agent:output` text.
- *
- * Does not emit `agent:run:start` / `agent:run:end` — callers bracket those.
- */
-export async function* streamTaggedAgentInvokeRuntime(options) {
-    const { target, event, state, pollInterrupt } = options;
-    const { runId, agentId } = target;
-    let lastAgentOutput;
-    const runtime = await createAgentRuntime(state);
-    for await (const chunk of runtime.run(event, { state, runId })) {
-        const interrupt = pollInterrupt?.();
-        if (interrupt) {
-            yield interrupt;
-            break;
-        }
-        if (chunk.id === event.id && chunk.type === event.type)
-            continue;
-        if (chunk.type === 'agent:output' &&
-            chunk.meta?.agentId === agentId) {
-            const content = chunk.data?.content;
-            if (typeof content === 'string' && content.trim()) {
-                lastAgentOutput = content.trim();
-            }
-        }
-        chunk.meta = { ...chunk.meta, agentId };
-        yield chunk;
-    }
-    return { lastAgentOutput };
-}
-/**
- * Drive {@link streamTaggedAgentInvokeRuntime} with a callback per chunk (dispatcher path).
- */
-export async function consumeAgentInvokeStream(options, onChunk) {
-    const gen = streamTaggedAgentInvokeRuntime(options);
-    let step = await gen.next();
-    while (!step.done) {
-        await onChunk(step.value);
-        step = await gen.next();
-    }
-    return step.value;
-}

package/dist/harness/agent-turn.js

@@ -1,99 +0,0 @@
-import { ensureEventId } from '../app/utils.js';
-import { storageService } from '../services/storage.js';
-import { createAgentRuntime } from './runtime-factory.js';
-const TODO_RESULT_MAX_CHARS = 12000;
-const readThreadState = (state) => state.threadDetails?.state ?? {};
-const readTodos = (state) => {
-    const raw = readThreadState(state).todos;
-    return Array.isArray(raw) ? raw : [];
-};
-function truncateTodoResult(text, maxChars = TODO_RESULT_MAX_CHARS) {
-    const trimmed = text.trim();
-    if (!trimmed)
-        return undefined;
-    if (trimmed.length <= maxChars)
-        return trimmed;
-    return `${trimmed.slice(0, maxChars)}\n…[truncated]`;
-}
-function resolveTodoIdForWorker(todos, workerId, delegationTodoId) {
-    if (delegationTodoId && todos.some((t) => t.id === delegationTodoId)) {
-        return delegationTodoId;
-    }
-    const inProgress = todos.find((t) => t.status === 'in_progress' && t.assignee === workerId);
-    if (inProgress)
-        return inProgress.id;
-    const assigned = todos.find((t) => (t.status === 'pending' || t.status === 'in_progress') && t.assignee === workerId);
-    return assigned?.id;
-}
-export async function recordWorkerTodoResult(state, workerId, output, delegationTodoId) {
-    if (!state.threadId)
-        return;
-    const result = truncateTodoResult(output ?? '');
-    if (!result)
-        return;
-    const todos = readTodos(state);
-    if (todos.length === 0)
-        return;
-    const todoId = resolveTodoIdForWorker(todos, workerId, delegationTodoId);
-    if (!todoId)
-        return;
-    const prior = todos.find((t) => t.id === todoId);
-    if (prior?.result === result)
-        return;
-    const now = Date.now();
-    const next = todos.map((t) => (t.id === todoId ? { ...t, result, updatedAt: now } : t));
-    await storageService.patchThreadState({
-        channelId: state.channelId,
-        threadId: state.threadId,
-        state: { todos: next },
-    });
-}
-export function makeInternalInvoke(content, threadId) {
-    return ensureEventId({
-        type: 'agent:invoke',
-        data: { role: 'user', content },
-        meta: { threadId, internal: true },
-    });
-}
-/**
- * Run one agent turn (no dispatcher chaining). Yields all runtime events for
- * persistence/streaming; returns the last non-empty `agent:output` text.
- */
-export async function* runAgentTurn(options) {
-    const { runId, channelId, threadId, agentId, event, delegationTodoId } = options;
-    const target = { runId, agentId, channelId, threadId };
-    let state;
-    try {
-        state = await storageService.getOpenBotState({ ...target, event });
-    }
-    catch (error) {
-        if (error.code === 'AGENT_NOT_FOUND') {
-            return undefined;
-        }
-        throw error;
-    }
-    yield { type: 'agent:run:start', data: { ...target } };
-    let lastAgentOutput;
-    try {
-        const runtime = await createAgentRuntime(state);
-        for await (const chunk of runtime.run(event, { state, runId })) {
-            if (chunk.id === event.id && chunk.type === event.type)
-                continue;
-            if (chunk.type === 'agent:output' &&
-                chunk.meta?.agentId === agentId) {
-                const content = chunk.data?.content;
-                if (typeof content === 'string' && content.trim()) {
-                    lastAgentOutput = content.trim();
-                }
-            }
-            chunk.meta = { ...chunk.meta, agentId };
-            yield chunk;
-        }
-    }
-    finally {
-        const stateAfterRun = await storageService.getOpenBotState({ ...target, event });
-        yield { type: 'agent:run:end', data: { ...target } };
-        await recordWorkerTodoResult(stateAfterRun, agentId, lastAgentOutput, delegationTodoId);
-    }
-    return lastAgentOutput;
-}

package/dist/harness/channel-participants.js

@@ -1,40 +0,0 @@
-/**
- * Channel `participants` (from `state.json`) scope which agents may collaborate
- * in that channel. Used for system-prompt hints and dispatch guards.
- */
-/** Multi-participant channel: user messages always route to the orchestrator. */
-export function isMultiAgentChannel(participants) {
-    return participants.length > 1;
-}
-/** Solo DM: exactly one participant and it is the acting agent (no peer bots). */
-export function isDmSoloChannel(participants, actingAgentId) {
-    return participants.length === 1 && participants[0] === actingAgentId;
-}
-/**
- * Resolve which agent handles an incoming user message.
- * Multi-participant channels always route to the orchestrator (hub-and-spoke).
- */
-export function resolveMessageTargetAgent(participants, orchestratorAgentId, requestedAgentId) {
-    if (isMultiAgentChannel(participants)) {
-        return orchestratorAgentId;
-    }
-    if (participants.length === 1) {
-        return requestedAgentId || participants[0];
-    }
-    return requestedAgentId || orchestratorAgentId;
-}
-/**
- * When `participants` is non-empty, todo dispatch targets must appear
- * in that list. Solo DM forbids targeting any agent other than yourself (for
- * chained steps); there are no peer bots.
- */
-export function isParticipantDispatchAllowed(participants, actingAgentId, targetAgentId) {
-    if (participants.length === 0)
-        return true;
-    if (!participants.includes(targetAgentId))
-        return false;
-    if (isDmSoloChannel(participants, actingAgentId) && targetAgentId !== actingAgentId) {
-        return false;
-    }
-    return true;
-}

package/dist/harness/constants.js

@@ -1,2 +0,0 @@
-/** Built-in orchestrator agent id (`~/.openbot/agents/system/AGENT.md` overrides instructions). */
-export const ORCHESTRATOR_AGENT_ID = 'system';

package/dist/harness/context-meter.js

@@ -1,97 +0,0 @@
-import { OPENBOT_SYSTEM_PROMPT } from '../plugins/openbot/system-prompt.js';
-import { ORCHESTRATOR_AGENT_ID, estimateTokens, } from './context.js';
-import { reconstructHistory } from './history.js';
-/** Reserved headroom for model output when computing fill percentage. */
-export const CONTEXT_METER_OUTPUT_RESERVE = 4096;
-const DEFAULT_CONTEXT_LIMIT = 128000;
-const MODEL_CONTEXT_LIMITS = {
-    'gpt-4o': 128000,
-    'gpt-4o-mini': 128000,
-    'gpt-4-turbo': 128000,
-    'gpt-4': 128000,
-    'gpt-3.5-turbo': 16385,
-    'claude-3-5-sonnet-20240620': 200000,
-    'claude-3-5-sonnet-20241022': 200000,
-    'claude-3-opus-20240229': 200000,
-    'claude-3-haiku-20240307': 200000,
-};
-export function getModelContextLimit(modelString) {
-    const modelId = modelString.split('/').slice(1).join('/');
-    if (MODEL_CONTEXT_LIMITS[modelId])
-        return MODEL_CONTEXT_LIMITS[modelId];
-    if (modelId.includes('claude'))
-        return 200000;
-    return DEFAULT_CONTEXT_LIMIT;
-}
-function buildInstructions(state) {
-    if (state.agentId === ORCHESTRATOR_AGENT_ID) {
-        return state.agentDetails?.instructions?.trim() || OPENBOT_SYSTEM_PROMPT;
-    }
-    return OPENBOT_SYSTEM_PROMPT;
-}
-function estimateMessagesTokens(messages) {
-    if (messages.length === 0)
-        return 0;
-    return estimateTokens(JSON.stringify(messages));
-}
-function estimateToolsTokens(tools) {
-    const names = Object.keys(tools);
-    if (names.length === 0)
-        return 0;
-    return estimateTokens(JSON.stringify(tools));
-}
-function applyTrigger(messages, trigger) {
-    const triggerContent = trigger?.data?.content?.trim();
-    if (!triggerContent || !trigger)
-        return messages;
-    const role = (trigger.data?.role || 'user');
-    const last = messages[messages.length - 1];
-    const alreadyLast = last &&
-        last.role === role &&
-        typeof last.content === 'string' &&
-        last.content.trim() === triggerContent;
-    if (alreadyLast)
-        return messages;
-    return [...messages, { role, content: triggerContent }];
-}
-function computePercent(used, limit) {
-    const budget = Math.max(limit - CONTEXT_METER_OUTPUT_RESERVE, 1);
-    return Math.min(100, Math.round((used / budget) * 100));
-}
-export async function computeContextMeter(options) {
-    const { state, storage, modelString, contextEngine, toolDefinitions = {}, trigger, lastUsage, } = options;
-    const limit = getModelContextLimit(modelString);
-    const instructions = buildInstructions(state);
-    const contextBlock = await contextEngine.buildContext(state, storage);
-    const systemTokens = estimateTokens([instructions, contextBlock].filter(Boolean).join('\n\n'));
-    const events = await storage.getEvents({
-        channelId: state.channelId,
-        threadId: state.threadId,
-    });
-    const messages = applyTrigger(reconstructHistory(events), trigger);
-    const historyTokens = estimateMessagesTokens(messages);
-    const toolsTokens = estimateToolsTokens(toolDefinitions);
-    let used = systemTokens + historyTokens + toolsTokens;
-    let estimated = true;
-    if (lastUsage?.input && lastUsage.input > 0) {
-        used = lastUsage.input;
-        estimated = false;
-    }
-    return {
-        model: modelString,
-        limit,
-        used,
-        percent: computePercent(used, limit),
-        estimated,
-        breakdown: {
-            system: systemTokens,
-            history: historyTokens,
-            tools: toolsTokens,
-        },
-        messageCount: messages.length,
-        ...(lastUsage ? { lastUsage } : {}),
-    };
-}
-export function contextMeterEvent(snapshot, meta) {
-    return { type: 'client:ui:context-meter', data: snapshot, meta };
-}

package/dist/harness/context.js

@@ -1,363 +0,0 @@
-import { isDmSoloChannel } from './channel-participants.js';
-export const DEFAULT_CONTEXT_BUDGET = 8000;
-/**
- * Returns the known context window budget (in tokens) for a given model string.
- * This is used to drive the context usage ring in the UI and to configure
- * the prompt pruning budget.
- */
-export const getContextBudgetForModel = (modelString) => {
-    const budgets = {
-        'openai/gpt-4o': 128000,
-        'openai/gpt-4o-mini': 128000,
-        'openai/o1-preview': 128000,
-        'openai/o1-mini': 128000,
-        'anthropic/claude-3-5-sonnet-20240620': 200000,
-        'anthropic/claude-3-5-sonnet-latest': 200000,
-        'anthropic/claude-3-opus-20240229': 200000,
-        'anthropic/claude-3-sonnet-20240229': 200000,
-        'anthropic/claude-3-haiku-20240307': 200000,
-    };
-    return budgets[modelString] || DEFAULT_CONTEXT_BUDGET;
-};
-/** Built-in orchestrator agent id (`~/.openbot/agents/system/AGENT.md` overrides instructions). */
-export const ORCHESTRATOR_AGENT_ID = 'system';
-/**
- * Cheap, dependency-free token estimator. Roughly char/4 — fine for budget
- * enforcement; can be swapped for a tokenizer-backed implementation later
- * without touching providers.
- */
-export const estimateTokens = (text) => Math.ceil((text?.length ?? 0) / 4);
-/**
- * Hard cap (in characters) on a single context item. Keeps any one provider
- * — typically the recent-events feed — from monopolising the prompt budget.
- */
-const ITEM_HARD_CHAR_CAP = 6000;
-const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars)}\n…[truncated]`;
-export class ContextEngine {
-    constructor() {
-        this.providers = [];
-        this.processors = [];
-    }
-    registerProvider(provider) {
-        this.providers.push(provider);
-    }
-    registerProcessor(processor) {
-        this.processors.push(processor);
-    }
-    async buildContext(state, storage) {
-        let items = [];
-        for (const provider of this.providers) {
-            try {
-                const providedItems = await provider.provide(state, storage);
-                for (const item of providedItems) {
-                    items.push({ ...item, content: truncate(item.content, ITEM_HARD_CHAR_CAP) });
-                }
-            }
-            catch (error) {
-                console.warn(`[ContextEngine] Provider ${provider.name} failed:`, error);
-            }
-        }
-        for (const processor of this.processors) {
-            try {
-                items = await processor.process(items, state);
-            }
-            catch (error) {
-                console.warn(`[ContextEngine] Processor ${processor.name} failed:`, error);
-            }
-        }
-        return items
-            .sort((a, b) => b.priority - a.priority)
-            .map((item) => item.content)
-            .join('\n\n');
-    }
-}
-/**
- * Default context engine. Order of providers is by emit order; final ordering
- * in the prompt is determined by `priority`. The token-budget processor runs
- * last so dropping happens after every provider has contributed.
- */
-export function createDefaultContextEngine() {
-    const engine = new ContextEngine();
-    engine.registerProvider(new EnvironmentProvider());
-    engine.registerProvider(new ChannelSpecProvider());
-    engine.registerProvider(new AgentDetailsProvider());
-    engine.registerProvider(new TodoProvider());
-    engine.registerProvider(new MemoryProvider());
-    // engine.registerProvider(new RecentEventsProvider());
-    engine.registerProcessor(new TokenBudgetProcessor());
-    return engine;
-}
-class EnvironmentProvider {
-    constructor() {
-        this.name = 'environment';
-    }
-    async provide(state) {
-        const { channelId, threadId, channelDetails, agentId, threadDetails } = state;
-        const participants = channelDetails?.participants || [];
-        const isDm = isDmSoloChannel(participants, agentId);
-        let content = '## ENVIRONMENT\n';
-        if (isDm) {
-            content += '- Mode: Direct Message (Solo)\n';
-            content += '- Context: You are in a private conversation. No other agents are present.\n';
-        }
-        else {
-            const channelName = channelDetails?.name || channelId;
-            content += `- Mode: Channel (#${channelName})\n`;
-            if (threadId) {
-                content += `- Thread: ${threadDetails?.name || threadId}\n`;
-            }
-            const peerIds = participants.filter((id) => id !== agentId);
-            if (peerIds.length > 0) {
-                content += `- Participants: ${peerIds.join(', ')}\n`;
-                content += `  (Use these plain ids for todo assignees and delegate_to_agent — no @ prefix.)\n`;
-            }
-        }
-        return [
-            {
-                id: 'environment',
-                type: 'environment',
-                priority: 110,
-                content,
-            },
-        ];
-    }
-}
-/**
- * Injects SPEC.md (`channelDetails.spec`). Kept distinct from EnvironmentProvider
- * so each block gets its own truncate budget and channel rules survive long
- * participant lists under {@link ITEM_HARD_CHAR_CAP}.
- */
-class ChannelSpecProvider {
-    constructor() {
-        this.name = 'channel-spec';
-    }
-    async provide(state) {
-        const raw = state.channelDetails?.spec;
-        const spec = typeof raw === 'string' ? raw.trim() : '';
-        if (!spec)
-            return [];
-        return [
-            {
-                id: 'channel-spec',
-                type: 'channel-spec',
-                /** Below environment (110), above agent / {@link TokenBudgetProcessor.KEEP_FLOOR}. */
-                priority: 108,
-                content: `## CHANNEL SPECIFICATION (SPEC.md)\n` +
-                    `Channel-level goals and constraints. Prefer these unless the user contradicts them.\n\n` +
-                    `${spec}`,
-            },
-        ];
-    }
-}
-class AgentDetailsProvider {
-    constructor() {
-        this.name = 'agent-details';
-    }
-    async provide(state) {
-        if (!state.agentDetails)
-            return [];
-        if (state.agentId === ORCHESTRATOR_AGENT_ID)
-            return [];
-        const instructions = state.agentDetails.instructions?.trim();
-        if (!instructions)
-            return [];
-        return [
-            {
-                id: 'agent-details',
-                type: 'agent',
-                priority: 100,
-                content: `## AGENT: ${state.agentDetails.name}\n\n${instructions}`,
-            },
-        ];
-    }
-}
-/**
- * Surfaces the shared per-thread todo list. The list lives in
- * `threadDetails.state.todos` and is owned by bus services — every agent in
- * the thread reads from the same canonical source, which is how multi-agent
- * autonomous flows stay coordinated.
- */
-class TodoProvider {
-    constructor() {
-        this.name = 'todos';
-    }
-    async provide(state) {
-        if (state.agentId !== ORCHESTRATOR_AGENT_ID)
-            return [];
-        const raw = state.threadDetails?.state?.todos;
-        const todos = Array.isArray(raw) ? raw : [];
-        if (todos.length === 0)
-            return [];
-        const DISPLAY_RESULT_CAP = 2500;
-        const marker = {
-            pending: '[ ]',
-            in_progress: '[~]',
-            done: '[x]',
-            cancelled: '[-]',
-        };
-        const formatted = todos
-            .map((t) => {
-            const assignee = t.assignee ? ` @${t.assignee}` : '';
-            let line = `- ${marker[t.status]} (${t.id})${assignee} ${t.content}`;
-            if (t.status === 'done' && t.result?.trim()) {
-                let snippet = t.result.trim();
-                if (snippet.length > DISPLAY_RESULT_CAP) {
-                    snippet = `${snippet.slice(0, DISPLAY_RESULT_CAP)}…[truncated]`;
-                }
-                line += `\n  Result: ${snippet}`;
-            }
-            return line;
-        })
-            .join('\n');
-        return [
-            {
-                id: 'todos',
-                type: 'todos',
-                priority: 92,
-                content: `## SHARED TODO PLAN (thread state)\n` +
-                    `${formatted}`,
-            },
-        ];
-    }
-}
-/**
- * Fetches relevant memories (global + active agent + active channel) and
- * surfaces them at high priority so the LLM treats them as ground truth
- * rather than chat history.
- */
-class MemoryProvider {
-    constructor() {
-        this.name = 'memory';
-    }
-    async provide(state, storage) {
-        if (!storage?.listMemories)
-            return [];
-        try {
-            const scopes = ['global', `agent:${state.agentId}`];
-            if (state.channelId)
-                scopes.push(`channel:${state.channelId}`);
-            const records = await storage.listMemories({ scopes, limit: 50 });
-            if (records.length === 0)
-                return [];
-            const formatted = records
-                .map((r) => {
-                const tags = r.tags?.length ? ` [${r.tags.join(', ')}]` : '';
-                const scopeLabel = r.scope === 'global' ? 'global' : r.scope;
-                return `- (${scopeLabel}${tags}) ${r.content}`;
-            })
-                .join('\n');
-            return [
-                {
-                    id: 'memory',
-                    type: 'memory',
-                    priority: 95,
-                    content: `## Remembered global facts\nTrust these unless the user contradicts them. Use \`forget\` to remove stale ones.\n\n${formatted}`,
-                },
-            ];
-        }
-        catch (error) {
-            console.warn('[ContextEngine] MemoryProvider failed:', error);
-            return [];
-        }
-    }
-}
-/**
- * Event types we omit from the recent-events context block. They duplicate
- * information already in the conversation history, are infrastructural
- * noise, or are too large to be useful as a tail summary.
- */
-const NOISY_EVENT_PREFIXES = [
-    'agent:invoke',
-    'agent:output',
-    'agent:run',
-    'agent:active-runs',
-    'client:ui',
-    'stream:',
-    'action:storage:get-',
-    'action:storage:patch-',
-];
-const MAX_RECENT_EVENTS = 20;
-const MAX_EVENT_DATA_CHARS = 300;
-const isNoisyEvent = (event) => NOISY_EVENT_PREFIXES.some((prefix) => event.type.startsWith(prefix));
-const summarizeEvent = (event) => {
-    const data = event.data;
-    if (data === undefined)
-        return `- ${event.type}`;
-    let payload;
-    try {
-        payload = typeof data === 'string' ? data : JSON.stringify(data);
-    }
-    catch {
-        payload = '[unserialisable]';
-    }
-    if (payload.length > MAX_EVENT_DATA_CHARS) {
-        payload = `${payload.slice(0, MAX_EVENT_DATA_CHARS)}…`;
-    }
-    return `- ${event.type}: ${payload}`;
-};
-class RecentEventsProvider {
-    constructor() {
-        this.name = 'recent-events';
-    }
-    async provide(state, storage) {
-        if (!storage)
-            return [];
-        const channelId = state.channelId;
-        const threadId = state.threadId;
-        try {
-            const events = await storage.getEvents({ channelId, threadId });
-            const filtered = events.filter((e) => !isNoisyEvent(e));
-            if (filtered.length === 0)
-                return [];
-            const formatted = filtered.slice(-MAX_RECENT_EVENTS).map(summarizeEvent).join('\n');
-            return [
-                {
-                    id: threadId ? 'thread-events' : 'channel-events',
-                    type: 'events',
-                    priority: 70,
-                    content: `## ${threadId ? 'THREAD' : 'CHANNEL'} RECENT ACTIVITIES (events)\n${formatted}`,
-                },
-            ];
-        }
-        catch (error) {
-            console.warn('[ContextEngine] Failed to fetch events:', error);
-            return [];
-        }
-    }
-}
-/**
- * Drops the lowest-priority items until the assembled prompt fits within the
- * token budget. The first item with priority >= \`keepFloor\` is always kept,
- * so the agent's own instructions can never be evicted. Stable on ties:
- * later-emitted items go first.
- */
-export class TokenBudgetProcessor {
-    constructor(budget = undefined, keepFloor = TokenBudgetProcessor.KEEP_FLOOR) {
-        this.budget = budget;
-        this.keepFloor = keepFloor;
-        this.name = 'token-budget';
-    }
-    async process(items, state) {
-        const sorted = [...items].sort((a, b) => b.priority - a.priority);
-        const out = [];
-        let used = 0;
-        const activeBudget = this.budget ?? (state.model ? getContextBudgetForModel(state.model) : TokenBudgetProcessor.DEFAULT_BUDGET);
-        for (const item of sorted) {
-            const cost = estimateTokens(item.content);
-            if (item.priority >= this.keepFloor) {
-                out.push(item);
-                used += cost;
-                continue;
-            }
-            if (used + cost <= activeBudget) {
-                out.push(item);
-                used += cost;
-            }
-        }
-        return out;
-    }
-}
-/** Soft prompt budget in tokens (matches gpt-4o-mini's reasonable system slice). */
-TokenBudgetProcessor.DEFAULT_BUDGET = DEFAULT_CONTEXT_BUDGET;
-/** Items at or above this priority are never dropped. */
-TokenBudgetProcessor.KEEP_FLOOR = 100;