dsh-continual-evolve 0.10.6 → 0.12.0

package/lib/inject.js

@@ -1,412 +0,0 @@
-import { MEMORY_TYPE_KEY, isArchived, isMemoryType, VALENCE_NEGATIVE_KEY } from "./types.js";
-import { mergeHarnessStates } from "./state.js";
-import { projectKeyOf } from "./project.js";
-import { entryLine } from "./render.js";
-import { recordInjection } from "./usage.js";
-import { buildRelevanceIndex, relevanceScore, tokenize } from "./search.js";
-/** CJK-bigram tokenizer re-exported for ranking consumers (see search.ts). */
-export { tokenize };
-/** Prompt sections render at most this many entries per kind. */
-export const MAX_INJECTED_ENTRIES_PER_KIND = 6;
-/** Per-entry content budget inside the injected block (matches render.ts). */
-export const MAX_INJECTED_CONTENT_LENGTH = 180;
-/** How many `parentSession` hops a child walks to inherit entries. */
-export const MAX_PARENT_CHAIN_DEPTH = 8;
-/** Recency half-life for the injection ranking: an entry this old scores 0. */
-export const RECENCY_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
-/** At most this many recent user messages feed the relevance query. */
-export const MAX_QUERY_MESSAGES = 3;
-/** Query text handed to the relevance scorer is capped at this many chars. */
-export const MAX_QUERY_CHARS = 400;
-/**
- * The session's event log through whichever reader the running harness
- * generation exposes. Returns [] when neither is present, so every caller
- * degrades to its empty-log path rather than throwing.
- */
-export function sessionEventsOf(agent) {
-    const session = agent?.session;
-    if (session === undefined) {
-        return [];
-    }
-    if (Array.isArray(session.events)) {
-        return session.events;
-    }
-    const snapshot = session.snapshotEvents?.();
-    return Array.isArray(snapshot) ? snapshot : [];
-}
-/** Stable dictionary-order tiebreak used when two entries score equally. */
-function stableCompare(a, b) {
-    return [a.path, a.title, a.id].join("\0").localeCompare([b.path, b.title, b.id].join("\0"));
-}
-/**
- * Normalized recency in [0, 1]: 1 when the entry was just updated, decaying
- * linearly to 0 after {@link RECENCY_HALF_LIFE_MS}. Unparseable timestamps
- * score 0 (never preferred over a timestamped entry).
- */
-export function recencyScore(entry, now) {
-    const updatedAt = Date.parse(entry.updated_at);
-    if (Number.isNaN(updatedAt)) {
-        return 0;
-    }
-    const age = now - updatedAt;
-    if (age <= 0) {
-        return 1;
-    }
-    return Math.max(0, 1 - age / RECENCY_HALF_LIFE_MS);
-}
-/**
- * Negative-valence counter (P1 效价反馈): entries contradicted by later
- * assessments sink below clean ones at equal relevance/recency — the
- * behavioral analog of a confidence penalty (pi-continuous-learning's
- * contradicted −0.15), without inventing a new score axis.
- */
-function negativeValence(entry) {
-    const value = entry.metadata[VALENCE_NEGATIVE_KEY];
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
-}
-/**
- * Rank entries for injection, best first. With no query the ranking is
- * negative-valence first (contradicted entries last), then pure recency
- * (newest first). With a query, entries are scored once against a per-call
- * BM25 index (CJK bigrams; field-weighted title ×2 — see search.ts): any
- * entry with a positive score (≥1 matched token) outranks every hit-less
- * entry (score exactly 0), scores decide the order among relevant entries,
- * the negative-valence counter breaks remaining ties (contradicted entries
- * sink), recency breaks remaining ties, and the stable dictionary order is
- * the final tiebreak, so the result is deterministic. The input is never
- * mutated.
- */
-export function rankEntries(entries, query, now = Date.now()) {
-    const q = (query ?? "").trim();
-    if (q.length === 0) {
-        return [...entries].sort((a, b) => {
-            const valenceDelta = negativeValence(a) - negativeValence(b);
-            if (valenceDelta !== 0) {
-                return valenceDelta;
-            }
-            const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
-            if (recencyDelta !== 0) {
-                return recencyDelta;
-            }
-            return stableCompare(a, b);
-        });
-    }
-    // Precompute scores once: the old comparator re-tokenized both sides on
-    // every comparison (O(n log n) tokenizations); one index + one score per
-    // entry turns the pass into table lookups.
-    const index = buildRelevanceIndex(entries);
-    const scores = new Map(entries.map((entry) => [entry, relevanceScore(index, entry, q)]));
-    return [...entries].sort((a, b) => {
-        const relevanceDelta = (scores.get(b) ?? 0) - (scores.get(a) ?? 0);
-        if (relevanceDelta !== 0) {
-            return relevanceDelta;
-        }
-        const valenceDelta = negativeValence(a) - negativeValence(b);
-        if (valenceDelta !== 0) {
-            return valenceDelta;
-        }
-        const recencyDelta = recencyScore(b, now) - recencyScore(a, now);
-        if (recencyDelta !== 0) {
-            return recencyDelta;
-        }
-        return stableCompare(a, b);
-    });
-}
-function sortedEntries(entries, query) {
-    return rankEntries(entries, query);
-}
-/**
- * Extract the text of a message's content blocks without depending on the
- * dsh-llm ContentBlock type: string blocks pass through, object blocks
- * contribute their `text` field when present.
- */
-function extractBlockText(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    return content
-        .map((block) => {
-        if (typeof block === "string") {
-            return block;
-        }
-        if (block !== null && typeof block === "object" && "text" in block && typeof block.text === "string") {
-            return block.text;
-        }
-        return "";
-    })
-        .filter((text) => text.length > 0)
-        .join(" ");
-}
-/**
- * Compose the relevance query from the assembling agent's most recent direct
- * user messages (event rows whose `type` is `user/message` and whose source
- * is a human `user`, so injected plugin context and tool results never leak
- * into the query). Returns "" when nothing qualifies — the ranking then
- * falls back to pure recency.
- */
-export function recentUserText(agent, opts) {
-    const events = sessionEventsOf(agent);
-    if (events.length === 0) {
-        return "";
-    }
-    const maxMessages = opts?.maxMessages ?? MAX_QUERY_MESSAGES;
-    const maxChars = opts?.maxChars ?? MAX_QUERY_CHARS;
-    const parts = [];
-    for (let i = events.length - 1; i >= 0 && parts.length < maxMessages; i -= 1) {
-        const event = events[i];
-        if (event?.type !== "user/message") {
-            continue;
-        }
-        const source = event.data?.source;
-        if (source && source.kind !== "user") {
-            continue;
-        }
-        const text = extractBlockText(event.data?.content).trim();
-        if (text.length > 0) {
-            parts.unshift(text);
-        }
-    }
-    return parts.join(" ").slice(0, maxChars);
-}
-/** True when the state carries at least one entry of any kind. */
-export function hasAnyEntries(state) {
-    return Object.values(state.entries).some((byKind) => Object.keys(byKind).length > 0);
-}
-/** The additive prompt-notes block (empty when there are no visible prompt entries). */
-export function formatPromptEntriesSection(entries, query) {
-    const visible = entries.filter((entry) => !isArchived(entry));
-    if (visible.length === 0) {
-        return "";
-    }
-    const lines = [
-        "# Continual Harness — Prompt Notes",
-        "Supplemental prompt notes (the base system prompt is immutable). Use evolve_list for the full text of any note.",
-    ];
-    for (const entry of sortedEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        lines.push(entryLine(entry, MAX_INJECTED_CONTENT_LENGTH));
-    }
-    const overflow = visible.length - Math.min(visible.length, MAX_INJECTED_ENTRIES_PER_KIND);
-    if (overflow > 0) {
-        lines.push(`- +${overflow} more prompt notes (evolve_list)`);
-    }
-    return lines.join("\n");
-}
-/** The reusable delegation-specs block (empty when there are no visible subagent entries). */
-export function formatSubagentSpecsSection(entries, query) {
-    const visible = entries.filter((entry) => !isArchived(entry));
-    if (visible.length === 0) {
-        return "";
-    }
-    const lines = [
-        "# Continual Harness — Delegation Specs",
-        "Reusable subagent specs: when you delegate work that matches a spec, assemble the child prompt from its content. Children inherit these specs through their parent chain.",
-    ];
-    for (const entry of sortedEntries(visible, query).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        lines.push(entryLine(entry, MAX_INJECTED_CONTENT_LENGTH));
-    }
-    const overflow = visible.length - Math.min(visible.length, MAX_INJECTED_ENTRIES_PER_KIND);
-    if (overflow > 0) {
-        lines.push(`- +${overflow} more delegation specs (evolve_list)`);
-    }
-    return lines.join("\n");
-}
-/**
- * Gap B3: a lightweight directory of ALL non-archived entries across all
- * kinds — one line per entry, no content. Memory lines carry their recall
- * type (`- [memory:feedback:id] title`) so the model can judge relevance
- * from the index alone. This gives the model a zero-cost overview of what
- * exists so it can ask for full text via `evolve_list` or `/evolve list`.
- * The directory is appended after the curated top-N injection sections and
- * adds minimal tokens.
- *
- * 2026-08-22 throttle: the directory is CAPPED at {@link DEFAULT_DIRECTORY_LINES}
- * lines with the remainder folded into a single counter line — an uncapped
- * directory across a polluted global store was measured at ~2K chars of
- * every build in every project.
- *
- * 2026-09-23 relevance order: the directory is sorted by
- * {@link rankEntries} against the assembly's relevance query, so the lines
- * folded below the cap are the least relevant — not the dictionary tail.
- */
-export const DEFAULT_DIRECTORY_LINES = 15;
-/** One directory index line: memory lines carry their recall-type hook. */
-export function directoryLine(entry) {
-    if (entry.kind === "memory") {
-        const type = entry.metadata[MEMORY_TYPE_KEY];
-        const hook = isMemoryType(type) ? `:${type}` : "";
-        return `- [memory${hook}:${entry.id}] ${entry.title}`;
-    }
-    return `- [${entry.kind}:${entry.id}] ${entry.title}`;
-}
-/** Positional contract for the directory variadics: the first two arrays
- * must be the content-section kinds (prompt, subagent) — the redundancy
- * check counts exactly those as already visible. Callers pass
- * (prompt, subagent, memory, skill); any other order miscounts. */
-const CONTENT_SECTION_KINDS = 2;
-export function formatEntriesDirectory(...kindEntries) {
-    return formatEntriesDirectoryCapped(DEFAULT_DIRECTORY_LINES, ...kindEntries);
-}
-/** {@link formatEntriesDirectory} with an explicit cap (configurable). */
-export function formatEntriesDirectoryCapped(maxLines, ...kindEntries) {
-    return formatEntriesDirectoryRanked(maxLines, undefined, ...kindEntries);
-}
-/**
- * {@link formatEntriesDirectoryCapped} with a relevance query: entries are
- * ordered by {@link rankEntries} (relevance first, then recency) so the cap
- * folds the least relevant entries — never the dictionary tail. An empty
- * query degrades to the valence/recency/stable order, still deterministic.
- */
-export function formatEntriesDirectoryRanked(maxLines, query, ...kindEntries) {
-    const total = kindEntries.flat().filter((e) => !isArchived(e)).length;
-    if (total === 0) {
-        return "";
-    }
-    // Suppressed (every entry already content-visible) renders as "" — the
-    // prompt renderer then drops the section entirely.
-    const shown = rankedDirectoryEntries(maxLines, query, ...kindEntries);
-    if (shown.length === 0) {
-        return "";
-    }
-    const lines = ["# Continual Harness — Entry Directory", "All entries (use evolve_list for full text of any entry):"];
-    for (const entry of shown) {
-        lines.push(directoryLine(entry));
-    }
-    const hidden = total - shown.length;
-    if (hidden > 0) {
-        lines.push(`- …and ${hidden} more entries (evolve_list for the full index)`);
-    }
-    return lines.join("\n");
-}
-/**
- * The directory entries actually shown under the cap, in display order —
- * the single source for both the rendered text and usage accounting (so a
- * memory's injection IS its directory line even with the `:type` hook).
- * Returns [] when the directory is suppressed or empty.
- */
-export function rankedDirectoryEntries(maxLines, query, ...kindEntries) {
-    const allEntries = kindEntries.flat().filter((e) => !isArchived(e));
-    if (allEntries.length === 0) {
-        return [];
-    }
-    // Skip the directory only when EVERY entry is already content-visible.
-    // Only the first two arrays (prompt, subagent) have curated sections —
-    // memories and skills have NO content injection, so they are invisible
-    // unless the directory lists them (pre-2026-08-22 the redundancy check
-    // wrongly counted them as "already shown", hiding small stores entirely).
-    const contentVisible = kindEntries
-        .slice(0, CONTENT_SECTION_KINDS)
-        .reduce((sum, entries) => sum + Math.min(entries.filter((e) => !isArchived(e)).length, MAX_INJECTED_ENTRIES_PER_KIND), 0);
-    if (allEntries.length <= contentVisible) {
-        return [];
-    }
-    return rankEntries(allEntries, query).slice(0, Math.max(maxLines, 1));
-}
-/**
- * Walk the parent-session chain from `agent` upward and return the nearest
- * session whose local store is non-empty, if any. Children inherit their
- * ancestor's prompt notes and delegation specs; the chain walk stops at the
- * first store that has entries (deep descendants do not re-inject ancestors
- * beyond the nearest carrying store).
- */
-export function nearestLocalStateWithEntries(engine, agent) {
-    let cursor = agent;
-    for (let depth = 0; cursor !== undefined && depth < MAX_PARENT_CHAIN_DEPTH; depth += 1) {
-        const state = engine.load("local", cursor.id);
-        if (hasAnyEntries(state)) {
-            return state;
-        }
-        cursor = cursor.session?.header?.parentSession
-            ? { id: cursor.session.header.parentSession }
-            : undefined;
-    }
-    return undefined;
-}
-/**
- * The single three-store merge every injection path reads from: the global
- * store merged with this project's store (when the session cwd resolves one)
- * and the nearest carrying local store (precedence global < project < local —
- * see {@link mergeHarnessStates}). One home, so the memory section and the
- * entry directory can never disagree about what the model can see.
- */
-export function mergedInjectionState(engine, agent, opts) {
-    const globalState = engine.load("global", undefined);
-    const projectKey = opts?.projectKey ?? projectKeyOf(agent);
-    const projectState = projectKey ? engine.load("project", projectKey) : undefined;
-    const localState = nearestLocalStateWithEntries(engine, agent);
-    return mergeHarnessStates(globalState, localState, projectState ? { projectState } : undefined);
-}
-/**
- * Compose the full injected block for one assembling agent: global entries
- * merged with this project's store (when the session cwd resolves one) and
- * the nearest carrying local store (precedence global < project < local).
- * The optional `query` — when absent, derived from the agent's most recent
- * direct user messages — ranks which entries fill the per-kind cap
- * (relevance first, then recency; see {@link rankEntries}). Returns "" when
- * nothing is injectable — the prompt renderer then drops the section, so an
- * empty store adds zero tokens to every assembly.
- *
- * `opts.directoryLines` caps the entry-directory index (2026-08-22 throttle);
- * `opts.projectKey` pins the project layer explicitly (tests, tools) —
- * otherwise it is derived from the agent's session cwd, best-effort.
- * `opts.includeMemoryDirectory` (default true) drops memory lines from the
- * directory when the memory section already carries them (evolve v2) — one
- * fact, one home, so the same memories are never paid for twice.
- * Usage recording covers ALL kinds — memories and skills appear as directory
- * lines, prompts/subagents as content — and is deduped per session so the
- * counts read "how many sessions saw this", not "how many prompt builds".
- */
-export function entriesSectionText(engine, agent, query, opts) {
-    if (!agent) {
-        return "";
-    }
-    const merged = mergedInjectionState(engine, agent, opts);
-    const promptEntries = Object.values(merged.entries.prompt);
-    const subagentEntries = Object.values(merged.entries.subagent);
-    const relevanceQuery = (query ?? recentUserText(agent)).trim();
-    // Build injected text and collect which entries were included (gap B1).
-    const promptText = formatPromptEntriesSection(promptEntries, relevanceQuery);
-    const subagentText = formatSubagentSpecsSection(subagentEntries, relevanceQuery);
-    const injectedKeys = new Set();
-    // Collect keys from the visible (ranked, capped) entries that actually appear.
-    const visiblePrompt = promptEntries.filter((e) => !isArchived(e));
-    const visibleSubagent = subagentEntries.filter((e) => !isArchived(e));
-    for (const entry of rankEntries(visiblePrompt, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        injectedKeys.add(`prompt:${entry.id}`);
-    }
-    for (const entry of rankEntries(visibleSubagent, relevanceQuery).slice(0, MAX_INJECTED_ENTRIES_PER_KIND)) {
-        injectedKeys.add(`subagent:${entry.id}`);
-    }
-    // Gap B3: lightweight directory of ALL entries (id+title, one line each).
-    // Zero-cost index so the model knows what exists and can ask for full text.
-    const directoryLines = opts?.directoryLines ?? DEFAULT_DIRECTORY_LINES;
-    const promptKind = Object.values(merged.entries.prompt);
-    const subagentKind = Object.values(merged.entries.subagent);
-    // v2: memories live in their own content-carrying section, so the directory
-    // stops listing them (passing [] keeps the positional contract intact).
-    const memoryKind = (opts?.includeMemoryDirectory ?? true) ? Object.values(merged.entries.memory) : [];
-    const skillKind = Object.values(merged.entries.skill);
-    const directoryText = formatEntriesDirectoryRanked(directoryLines, relevanceQuery, promptKind, subagentKind, memoryKind, skillKind);
-    // Directory-visible keys count too: a memory's injection IS its directory
-    // line. Set semantics keep content-injected entries single-counted. Keys
-    // come from the single display-ordered source (type hooks included), not
-    // substring matching on the rendered text.
-    for (const entry of rankedDirectoryEntries(directoryLines, relevanceQuery, promptKind, subagentKind, memoryKind, skillKind)) {
-        injectedKeys.add(`${entry.kind}:${entry.id}`);
-    }
-    // Record usage durably (best-effort: failure never blocks injection).
-    // Deduped per session — see recordInjection.
-    if (injectedKeys.size > 0) {
-        try {
-            recordInjection(engine.baseDir, [...injectedKeys], agent.id);
-        }
-        catch {
-            // Usage recording is diagnostic; never interrupt the injection path.
-        }
-    }
-    const parts = [promptText, subagentText, directoryText].filter((part) => part.length > 0);
-    return parts.join("\n\n");
-}
-//# sourceMappingURL=inject.js.map

package/lib/llm-text.d.ts

@@ -1,104 +0,0 @@
-/**
- * Unified LLM text call: a shared streaming-text helper used by the review
- * gate, planner, and wrap-up assessor. Eliminates ~120 lines of duplicated
- * BlockAssembler + finish-state-check + text-extraction boilerplate.
- *
- * Every caller needs the same sequence:
- *   provider/model validation → stream → assemble → check finish → extract text
- * This module owns that sequence; callers keep only their prompt construction
- * and JSON parsing.
- */
-import type { Context } from "@deepseek-ai/cordis";
-import { type ContentBlock, type GenerateOptions, type LlmResolvedModelInfo, type Message, type ReasoningEffortId, type RequestMessage, type TokenUsage, type ToolSchema } from "@deepseek-ai/dsh-llm";
-/** Terminal outcome of one shared direct LLM call. */
-export type StreamTextOutcome = "success" | "max-tokens" | "error" | "aborted" | "empty";
-/** Host-owned session identity type used by provider routing metadata. */
-export type LlmSessionId = NonNullable<GenerateOptions["sessionId"]>;
-/** Carry the host Agent id across the plugin's direct-call boundary. */
-export declare function asLlmSessionId(value: string): LlmSessionId;
-/** Provider usage and terminal result observed after the stream settles. */
-export interface StreamTextObservation {
-    usage?: TokenUsage;
-    outcome: StreamTextOutcome;
-    /** Exact capability-derived effort used for this call; absent when no metadata was exposed. */
-    reasoningEffort?: ReasoningEffortId;
-}
-/** Diagnostic observer invoked before streamText returns or throws. */
-export type StreamTextUsageObserver = (observation: StreamTextObservation) => void;
-export interface StreamTextOptions {
-    provider: string;
-    model: string;
-    system: string;
-    prompt: string;
-    maxTokens?: number;
-    signal?: AbortSignal | undefined;
-    /** Host session identity forwarded to adapters for request routing. */
-    sessionId?: LlmSessionId;
-    /**
-     * Route A session prefix: session-derived messages sent before the
-     * trailing caller message so providers with prompt caching can serve
-     * the shared context at cache-read price. Empty/omitted keeps the
-     * legacy single-message request.
-     */
-    prefixMessages?: readonly Message[];
-    /**
-     * Observe the provider-reported usage and terminal outcome after the
-     * stream settles. The callback runs before success/error return and is
-     * diagnostic-only: throwing from it never changes the model call result.
-     */
-    onUsage?: StreamTextUsageObserver;
-}
-/** One provider request for a bounded internal agent/tool loop. */
-export interface StreamModelTurnOptions {
-    provider: string;
-    model: string;
-    messages: readonly RequestMessage[];
-    /** One-shot system slot. Omit when messages already carry the system prompt. */
-    system?: string;
-    /** Closed tool schemas for this request; omitted means no tools. */
-    tools?: readonly ToolSchema[];
-    maxTokens?: number;
-    signal?: AbortSignal | undefined;
-    /** Host session identity forwarded to adapters for request routing. */
-    sessionId?: LlmSessionId;
-    /** Require at least one text block; tool-only turns must leave this false. */
-    requireText?: boolean;
-    /** Require visible text or a tool call; reasoning-only agent turns are empty. */
-    requireTextOrToolCall?: boolean;
-    /** Same diagnostic observer contract as {@link StreamTextOptions.onUsage}. */
-    onUsage?: StreamTextUsageObserver;
-}
-/**
- * Select the lowest reasoning effort an exact model advertises.
- *
- * An enabled effort wins over a declared closing effort. The adapter-preferred
- * first enabled effort is the lowest enabled level it exposes; a closing effort
- * is only a fallback when the model publishes no enabled level. No capability
- * list means no caller-supplied effort.
- *
- * @param modelInfo - exact resolved-model metadata, when the provider exposes it.
- * @returns The selected provider-owned effort id, or `undefined` when unknown.
- */
-export declare function selectLowestReasoningEffort(modelInfo: Pick<LlmResolvedModelInfo, "reasoning"> | undefined): ReasoningEffortId | undefined;
-/**
- * Stream a single-turn text completion through `ctx.llm`. The request uses the
- * exact provider/model's lowest advertised reasoning effort, omitting the field
- * when the model exposes no reasoning metadata.
- *
- * @returns The concatenated text blocks from the response.
- * @throws On provider error, abort, max-token truncation, or empty output.
- */
-/**
- * Stream one provider/model turn and return its assembled content blocks.
- * This is the shared primitive for text callers and bounded tool loops; finish
- * state, capability-derived effort, cancellation, and usage observation stay
- * inside this boundary.
- *
- * @param ctx - DSH context providing the LLM runtime.
- * @param opts - Exact route, messages, optional tools, and output requirements.
- * @returns The assembled content blocks; caller decides how to interpret them.
- * @throws On provider error, abort, max-token truncation, or capability lookup failure.
- */
-export declare function streamModelTurn(ctx: Context, opts: StreamModelTurnOptions): Promise<ContentBlock[]>;
-export declare function streamText(ctx: Context, opts: StreamTextOptions): Promise<string>;
-//# sourceMappingURL=llm-text.d.ts.map

package/lib/llm-text.js

@@ -1,140 +0,0 @@
-import { BlockAssembler, createUserMessage, } from "@deepseek-ai/dsh-llm";
-import { EVOLVE_MESSAGE_SOURCE } from "./message-source.js";
-/** Carry the host Agent id across the plugin's direct-call boundary. */
-export function asLlmSessionId(value) {
-    return value;
-}
-const CLOSED_REASONING_EFFORTS = new Set(["disabled", "off", "none"]);
-/**
- * Select the lowest reasoning effort an exact model advertises.
- *
- * An enabled effort wins over a declared closing effort. The adapter-preferred
- * first enabled effort is the lowest enabled level it exposes; a closing effort
- * is only a fallback when the model publishes no enabled level. No capability
- * list means no caller-supplied effort.
- *
- * @param modelInfo - exact resolved-model metadata, when the provider exposes it.
- * @returns The selected provider-owned effort id, or `undefined` when unknown.
- */
-export function selectLowestReasoningEffort(modelInfo) {
-    const efforts = modelInfo?.reasoning?.efforts;
-    if (efforts !== undefined && !Array.isArray(efforts)) {
-        throw new Error("evolve: invalid model reasoning metadata");
-    }
-    if (!efforts || efforts.length === 0)
-        return undefined;
-    for (const effort of efforts) {
-        if (typeof effort?.id !== "string") {
-            throw new Error("evolve: invalid model reasoning metadata");
-        }
-    }
-    return efforts.find((effort) => !CLOSED_REASONING_EFFORTS.has(effort.id))?.id ?? efforts[0]?.id;
-}
-async function resolveReasoningEffort(ctx, opts) {
-    // The current DSH host exposes this method. Keep a capability-less test or
-    // older host usable by treating the absent query as unknown metadata.
-    if (typeof ctx.llm.resolveModelInfo !== "function")
-        return undefined;
-    const modelInfo = await ctx.llm.resolveModelInfo(opts.provider, opts.model);
-    return selectLowestReasoningEffort(modelInfo);
-}
-/**
- * Stream a single-turn text completion through `ctx.llm`. The request uses the
- * exact provider/model's lowest advertised reasoning effort, omitting the field
- * when the model exposes no reasoning metadata.
- *
- * @returns The concatenated text blocks from the response.
- * @throws On provider error, abort, max-token truncation, or empty output.
- */
-/**
- * Stream one provider/model turn and return its assembled content blocks.
- * This is the shared primitive for text callers and bounded tool loops; finish
- * state, capability-derived effort, cancellation, and usage observation stay
- * inside this boundary.
- *
- * @param ctx - DSH context providing the LLM runtime.
- * @param opts - Exact route, messages, optional tools, and output requirements.
- * @returns The assembled content blocks; caller decides how to interpret them.
- * @throws On provider error, abort, max-token truncation, or capability lookup failure.
- */
-export async function streamModelTurn(ctx, opts) {
-    const assembler = new BlockAssembler();
-    let outcome = "error";
-    let reasoningEffort;
-    try {
-        reasoningEffort = await resolveReasoningEffort(ctx, opts);
-        for await (const chunk of ctx.llm.stream({
-            provider: opts.provider,
-            model: opts.model,
-            messages: [...opts.messages],
-            ...(opts.system === undefined ? {} : { system: opts.system }),
-            ...(opts.tools === undefined ? {} : { tools: [...opts.tools] }),
-            ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
-            maxTokens: opts.maxTokens ?? 8000,
-            ...(opts.signal ? { signal: opts.signal } : {}),
-            ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
-        })) {
-            assembler.push(chunk);
-        }
-        const finish = assembler.finish;
-        if (finish.kind === "error") {
-            outcome = "error";
-            throw new Error(`evolve: LLM call failed: ${finish.failure?.message ?? "unknown"}`);
-        }
-        if (finish.kind === "aborted") {
-            outcome = "aborted";
-            throw new Error("evolve: LLM call aborted");
-        }
-        if (finish.kind === "max-tokens") {
-            outcome = "max-tokens";
-            throw new Error("evolve: LLM output budget exhausted (max-tokens)");
-        }
-        const blocks = assembler.blocks();
-        const hasText = blocks.some((block) => block.type === "text" && block.text.length > 0);
-        const hasToolCall = blocks.some((block) => block.type === "tool-call");
-        const missingRequiredOutput = (opts.requireText === true && !hasText)
-            || (opts.requireTextOrToolCall === true && !hasText && !hasToolCall);
-        outcome = blocks.length === 0 || missingRequiredOutput ? "empty" : "success";
-        return blocks;
-    }
-    finally {
-        try {
-            opts.onUsage?.({
-                ...(assembler.usage ? { usage: assembler.usage } : {}),
-                outcome,
-                ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
-            });
-        }
-        catch {
-            // Usage observation is diagnostic; its failure must not alter the model call.
-        }
-    }
-}
-export async function streamText(ctx, opts) {
-    const blocks = await streamModelTurn(ctx, {
-        provider: opts.provider,
-        model: opts.model,
-        system: opts.system,
-        messages: [
-            ...(opts.prefixMessages ?? []),
-            createUserMessage({
-                content: [{ type: "text", text: opts.prompt }],
-                source: EVOLVE_MESSAGE_SOURCE,
-            }),
-        ],
-        requireText: true,
-        ...(opts.maxTokens === undefined ? {} : { maxTokens: opts.maxTokens }),
-        ...(opts.signal ? { signal: opts.signal } : {}),
-        ...(opts.sessionId ? { sessionId: opts.sessionId } : {}),
-        ...(opts.onUsage ? { onUsage: opts.onUsage } : {}),
-    });
-    const text = blocks
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("\n");
-    if (text.length === 0) {
-        throw new Error("evolve: LLM produced no text output");
-    }
-    return text;
-}
-//# sourceMappingURL=llm-text.js.map