@cerebriline/core 4.100.240

package/dist/extensions/tools/image-generation.d.ts

@@ -0,0 +1,183 @@
+/**
+ * A tool that makes a picture.
+ *
+ * Cline can write the CSS for a theme and the loader for a sprite, and then has
+ * nothing to say about what either one looks like. Every visual question --
+ * "which of these layouts", "an icon for this app", "a placeholder texture" --
+ * left the session: the user generated the asset somewhere else and came back
+ * with a path. That is the gap mann1x/cline#53 describes.
+ *
+ * The half of it that already worked is the display: a tool result may carry an
+ * `image` content part, the browser tool has returned screenshots that way for
+ * a while, and the webview renders them inline. What was missing was anything
+ * that produces one.
+ *
+ * The wire format is the OpenAI images API (`POST {endpoint}/images/generations`)
+ * because it is the one every local server already speaks -- LocalAI, an
+ * Automatic1111 or ComfyUI shim, a llama.cpp image build -- as well as the
+ * hosted services. Deliberately not Ollama-specific: this fork's own Ollama
+ * refuses image models outright ("image generation models are not currently
+ * supported"), so a tool that only spoke to Ollama would have no backend at all
+ * on Linux.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+import { normalizeBaseUrl } from "./media-endpoint";
+export { normalizeBaseUrl };
+/**
+ * A text part, optionally followed by an image the model can actually see.
+ *
+ * Declared here as it is in `browser.ts`, and for the same reason: this is the
+ * shape a tool result takes, not something `@cerebriline/shared` publishes.
+ */
+export type ToolOutput = string | Array<{
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mediaType: string;
+}>;
+export declare const GENERATE_IMAGE_TOOL_NAME = "generate_image";
+export declare const GENERATE_IMAGE_TOOL_DESCRIPTION = "Generate an image from a text description and save it into the workspace. Use it for visual work you would otherwise have to ask the user to do elsewhere: an app icon, a placeholder texture or sprite, a logo, a background, or a mockup of a layout or theme you are about to build.\n\nThe image is written to a file and, if you can see images, returned to you as well \u2014 so you can look at what you made and generate again with a changed prompt if it is wrong.\n\nArguments:\n- `prompt` \u2014 what to draw. Describe the subject, the style and the background. Say \"flat vector icon, solid background, no text\" rather than \"an icon\": these models render text badly, so ask for lettering only when you must.\n- `path` \u2014 where to save it, relative to the workspace. Optional; defaults to a file under `.cline/generated-images/`. Give a real path when the image is an asset the project will use.\n- `size` \u2014 `WxH` in pixels, e.g. `1024x1024`. Optional, and the backend may round it.\n\nThis costs real time \u2014 seconds to a minute per image \u2014 and on a hosted backend it costs money. Generate one image and look at it before generating variations.";
+export declare const GENERATE_IMAGE_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: "What to draw, including style and background. Be specific; avoid asking for text in the image.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Where to save it, relative to the workspace. Optional; defaults to a file under .cline/generated-images/.";
+        };
+        readonly size: {
+            readonly type: "string";
+            readonly description: "Pixel size as \"WIDTHxHEIGHT\", e.g. \"1024x1024\". Optional.";
+        };
+    };
+    readonly required: readonly ["prompt"];
+};
+export interface GenerateImageToolInput {
+    prompt?: unknown;
+    path?: unknown;
+    size?: unknown;
+}
+/**
+ * Where images are generated and what to call the model there.
+ *
+ * Read per call rather than captured once: the settings behind these can change
+ * mid-session, and a tool built at session start would go on using the endpoint
+ * that was configured then.
+ */
+export interface ImageGenerationEndpoint {
+    /** Base URL, with or without a trailing `/v1`. */
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+    /** Default for calls that do not ask for a size. */
+    size?: string;
+}
+/**
+ * The image models an OpenAI-compatible `/v1/models` listing offers.
+ *
+ * Every server answering that route returns `{data: [{id}]}`, and a plain one
+ * says nothing more -- so an entry that carries no hint is kept, because
+ * guessing which of a local server's models draws is worse than a longer list.
+ * Servers that do say get taken at their word: pollinations.ai returns 388
+ * models, of which 36 generate images, and a picker holding the other 352 is a
+ * picker nobody scrolls.
+ */
+export declare function selectImageGenerationModels(payload: unknown): string[];
+export interface GenerateImageToolOptions {
+    cwd: string;
+    /**
+     * May be asynchronous: a host that resolves the endpoint against the
+     * session's own provider has to ask that server what it serves.
+     */
+    getEndpoint: () => ImageGenerationEndpoint | undefined | Promise<ImageGenerationEndpoint | undefined>;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    fetchImpl?: typeof fetch;
+    /** Milliseconds before a generation is abandoned. Defaults to 3 minutes. */
+    timeoutMs?: number;
+    onError?: (message: string, error: unknown) => void;
+}
+/**
+ * A filename that says what the image is.
+ *
+ * From the prompt rather than a counter, because these accumulate in a
+ * directory nobody curates and `image-4.png` tells you nothing a month later.
+ */
+export declare function defaultImagePath(prompt: string, now: number): string;
+/** What the bytes should be called, for the paths this tool chose itself. */
+export declare function extensionForMediaType(mediaType: string): string;
+/**
+ * Keep the written file inside the workspace.
+ *
+ * The path comes from the model, and `../../.ssh/authorized_keys` is a path.
+ * Resolved and compared rather than pattern-matched, so a symlinked prefix or a
+ * doubled separator cannot slip past.
+ */
+export declare function resolveInsideWorkspace(cwd: string, relativePath: string): string | undefined;
+/** `"1024x1024"` and nothing else -- a backend given nonsense returns nonsense. */
+export declare function parseSize(size: unknown): string | undefined;
+export interface ImagesApiResponse {
+    data?: Array<{
+        b64_json?: string;
+        url?: string;
+        /** What the bytes actually are, when the server bothers to say. */
+        media_type?: string;
+        revised_prompt?: string;
+    }>;
+    error?: {
+        message?: string;
+    } | string;
+}
+/**
+ * What the bytes are, according to the bytes.
+ *
+ * Trusted ahead of anything the server said, because most say nothing and one
+ * of them is wrong: `gen.pollinations.ai` answers `/v1/images/generations` with
+ * a JPEG in `b64_json` and no `media_type` at all. Assuming PNG there writes
+ * JPEG bytes into a `.png` and tells the model it is looking at a PNG.
+ */
+export declare function sniffMediaType(data: Buffer): string | undefined;
+export declare function readGeneratedImage(body: ImagesApiResponse, fetchImpl: typeof fetch, signal: AbortSignal | undefined): Promise<{
+    data: Buffer;
+    mediaType: string;
+} | {
+    error: string;
+}>;
+/**
+ * Write the image and say what happened, for every tool that makes one.
+ *
+ * A path the model chose is the model's business, extension and all. One the
+ * tool made up says `.png` before anything knows what came back, and a vector
+ * model returns an SVG.
+ */
+export declare function saveAndReportImage(input: {
+    image: {
+        data: Buffer;
+        mediaType: string;
+    };
+    /** "Generated" or "Edited": the first word of the report. */
+    verb: string;
+    askedPath: string | undefined;
+    requestedPath: string;
+    absolutePath: string;
+    size?: string;
+    revisedPrompt?: string;
+    writeFile: (absolutePath: string, data: Buffer) => Promise<void>;
+    context: {
+        metadata?: Record<string, unknown>;
+        emitUpdate?: (update: unknown) => void;
+    } | undefined;
+}): Promise<ToolOutput>;
+/**
+ * Create the `generate_image` tool.
+ *
+ * The host is expected to omit this tool entirely when no endpoint is
+ * configured; `getEndpoint` returning nothing is handled anyway, because the
+ * setting can be cleared while a session is running and the model would
+ * otherwise get a stack trace where an explanation belongs.
+ */
+export declare function createGenerateImageTool(options: GenerateImageToolOptions): AgentTool;

package/dist/extensions/tools/index.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Default Tools
+ *
+ * This module provides a set of configurable default tools for agents.
+ */
+export { validateWithZod, zodToJsonSchema } from "@cerebriline/shared";
+export { createPlanModeCommandGuardExtension, PLAN_MODE_COMMAND_GUARD_EXTENSION_NAME, type PlanModeCommandGuardOptions, } from "./command-guard-extension";
+export { ALL_DEFAULT_TOOL_NAMES, DefaultToolNames } from "./constants";
+export { createApplyPatchTool, createAskQuestionTool, createAwkTool, createDefaultTools, createEditorTool, createExtractDocumentTool, createGrepTool, createReadFilesTool, createSearchTool, createSedTool, createShellTool, createSkillsTool, createSubmitAndExitTool, createWebFetchTool, } from "./definitions";
+export { type ApplyPatchExecutorOptions, type AwkExecutorOptions, CommandExitError, computePatchChanges, createApplyPatchExecutor, createAwkExecutor, createDefaultExecutors, createDefaultShellExecutor, createDocumentExtractExecutor, createEditorExecutor, createFileReadExecutor, createGrepExecutor, createReadReceipts, createSearchExecutor, createSedExecutor, createShellExecutor, createWebFetchExecutor, DEFAULT_EXTRACTION_DIR, type DefaultExecutorsOptions, DOCUMENT_EXTENSIONS, type DocumentExtractExecutorOptions, type EditorExecutorOptions, type FileReadExecutorOptions, type GrepExecutorOptions, PATCH_MARKERS, PatchActionType, type PatchFileChange, type ReadReceipts, RunCommandExecutionController, type RunningCommandRegistration, type SearchExecutorOptions, type SedExecutorOptions, type ShellExecutorOptions, type WebFetchExecutorOptions, } from "./executors/index";
+export { MAX_COMMAND_OUTPUT_CHARS, MAX_READ_REFUSAL_CHARS, truncateCommandOutput, } from "./executors/output-limits";
+export { DEFAULT_MODEL_TOOL_ROUTING_RULES, resolveToolRoutingConfig, type ToolRoutingRule, } from "./model-tool-routing";
+export { createDefaultToolsWithPreset, createToolPoliciesWithPreset, resolveToolPresetName, type ToolPolicyPresetName, type ToolPresetName, ToolPresets, } from "./presets";
+export { commandText, createSecretRedactor, describeQaCredentials, type NormalizedQaCredentials, normalizeQaCredentials, QA_CREDENTIAL_MIN_VALUE_LENGTH, QA_CREDENTIAL_NAME_PATTERN, type QaCredential, qaCredentialNames, type RejectedQaCredential, referencedCredentialNames, resolveCredentialEnv, } from "./qa-credentials";
+export { type BuiltinToolAvailabilityContext, getCoreAcpToolNames, getCoreBuiltinToolCatalog, getCoreDefaultEnabledToolIds, getCoreHeadlessToolNames, isCoreBuiltinToolAvailable, isSkillsToolAvailable, resolveCoreSelectedToolIds, resolveToolClientType, type ToolCatalogEntry, type ToolClientType, } from "./runtime";
+export { type ApplyPatchInput, ApplyPatchInputSchema, type AskQuestionInput, AskQuestionInputSchema, AwkInputSchema, type AwkToolInput, type EditFileInput, EditFileInputSchema, type ExtractDocumentInput, ExtractDocumentInputSchema, type FetchWebContentInput, FetchWebContentInputSchema, GrepInputSchema, type GrepToolInput, type ReadFileRequest, ReadFileRequestSchema, type ReadFilesInput, ReadFilesInputSchema, type RunCommandsInput, RunCommandsInputSchema, type SearchCodebaseInput, SearchCodebaseInputSchema, SedInputSchema, type SedToolInput, type SkillsInput, SkillsInputSchema, type StructuredCommandInput, StructuredCommandInputSchema, type SubmitInput, SubmitInputSchema, type WebFetchRequest, WebFetchRequestSchema, } from "./schemas";
+export { buildTaskProgressReminder, buildTaskProgressState, DEFAULT_TASK_PROGRESS_REMINDER_INTERVAL, parseTaskProgress, readTaskProgress, TASK_PROGRESS_PARAM, TASK_PROGRESS_PARAM_DESCRIPTION, type TaskProgressItem, type TaskProgressState, TaskProgressTracker, type TaskProgressTrackerOptions, withTaskProgressCapture, withTaskProgressParam, } from "./task-progress";
+export { TEAM_TOOL_NAMES } from "./team/team-tools";
+export type { ApplyPatchExecutor, AskQuestionExecutor, AwkExecutor, CreateDefaultToolsOptions, DefaultToolName, DefaultToolsConfig, EditorExecutor, FileReadExecutor, GrepExecutor, SearchExecutor, SedExecutor, ShellExecutionOptions, ShellExecutor, SkillsExecutor, SkillsExecutorSkillMetadata, SkillsExecutorWithMetadata, ToolExecutors, ToolOperationResult, VerifySubmitExecutor, WebFetchExecutor, } from "./types";
+import { type AgentTool } from "@cerebriline/shared";
+import { type DefaultExecutorsOptions } from "./executors/index";
+import type { CreateDefaultToolsOptions, ToolExecutors } from "./types";
+/**
+ * Options for creating default tools with built-in executors
+ */
+export interface CreateBuiltinToolsOptions extends Omit<CreateDefaultToolsOptions, "executors"> {
+    /**
+     * Configuration for the built-in executors. `bash.shell` is used when the
+     * top-level `shell` option is not set; the top-level option takes precedence.
+     */
+    executorOptions?: DefaultExecutorsOptions;
+    /**
+     * Optional executor overrides/additions for tools without built-ins.
+     * An overriding `bash` executor replaces the built-in one wholesale: it
+     * decides its own shell, and the resolved `shell` option only shapes the
+     * run_commands description. Overriders must honor that shell themselves
+     * to keep the description truthful.
+     */
+    executors?: Partial<ToolExecutors>;
+}
+/**
+ * Create default tools with built-in Node.js executors
+ *
+ * This is a convenience function that creates the default tools with
+ * working implementations using Node.js built-in modules.
+ *
+ * @example
+ * ```typescript
+ * import { Agent, createBuiltinTools } from "@cerebriline/core"
+ *
+ * const tools = createBuiltinTools({
+ *   cwd: "/path/to/project",
+ *   enableBash: true,
+ *   enableWebFetch: false, // Disable web fetching
+ *   executorOptions: {
+ *     bash: { timeoutMs: 60000 },
+ *   },
+ * })
+ *
+ * const agent = new Agent({
+ *   providerId: "anthropic",
+ *   modelId: "claude-sonnet-4-20250514",
+ *   systemPrompt: "You are a coding assistant.",
+ *   tools,
+ * })
+ * ```
+ */
+export declare function createBuiltinTools(options?: CreateBuiltinToolsOptions): AgentTool[];

package/dist/extensions/tools/jev.d.ts

@@ -0,0 +1,336 @@
+/**
+ * Jev: a second opinion with a number on it.
+ *
+ * TypeSafe's System One model, Jev, is not a chat model. It takes a piece of
+ * text -- the "state" -- and a set of typed questions, and answers each with a
+ * probability: a yes/no (`noul`), a pick among options you name (`choice`), or
+ * a rating on levels you name (`score`). Choice and score answers also carry a
+ * confidence derived from the distribution. It writes no prose, so it cannot
+ * explain an answer; what it gives is the one thing a coding model is bad at
+ * reporting about itself, which is how sure to be.
+ *
+ * Three consumers, one client:
+ *  - the `jev` tool, which the model calls when it is unsure of a reading, a
+ *    fact or a choice (the rule that tells it when is the host's);
+ *  - {@link rankQuestionOptions}, which the host runs over a model-authored
+ *    `ask_question` before the user sees it;
+ *  - {@link appraiseEscalation}, which scores a task about to be handed to the
+ *    expert, for the assessment the user and the expert both read.
+ *
+ * What the documentation says to design around, and this file does
+ * (docs/knowledge-base/jev):
+ *  - Questions in one request run in parallel and the state is billed once:
+ *    thirteen questions in one call measured ~12x cheaper and ~10x faster than
+ *    thirteen calls. So every consumer here asks everything in one request.
+ *  - The state plus the longest question must fit 32k tokens, and irrelevant
+ *    context lowers accuracy. So the state is bounded and made of named parts.
+ *  - A noul has no confidence field; its value is the signal. Here it gets the
+ *    same two-outcome confidence a choice between yes and no would, `2p - 1`
+ *    for the likelier side, so one floor reads all three kinds.
+ *  - It is literal and weak at arithmetic and multi-hop reasoning, and text in
+ *    the state can steer it. Its answers are evidence, never an instruction,
+ *    and everything here words them that way.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+export declare const JEV_TOOL_NAME = "jev";
+export declare const JEV_DEFAULT_BASE_URL = "https://api.typesafe.ai/v1";
+export declare const JEV_DEFAULT_MODEL = "jev-latest";
+/** The documented starting point for confidence-gated routing. */
+export declare const JEV_DEFAULT_FLOOR = 0.6;
+/** The documented bar for decisions that are costly to get wrong. */
+export declare const JEV_DEFAULT_HIGH_STAKES_FLOOR = 0.85;
+export declare const JEV_DEFAULT_TIMEOUT_MS = 15000;
+/**
+ * A ceiling on each named part of a state, in characters.
+ *
+ * The documented bound is 32k tokens for the state plus the longest question,
+ * and no tokenizer is published, so this cannot be checked exactly. At the
+ * usual ~4 characters a token, six parts at this size stay well inside it.
+ */
+export declare const JEV_MAX_PART_CHARS = 12000;
+export declare const JEV_MAX_QUESTIONS = 10;
+/**
+ * Which server's rules an endpoint follows.
+ *
+ * Ollama (0.35 and later, and xollama) serves the same request and answer at
+ * `/v1/systemone`, field for field, and computes score and confidence the same
+ * way. What differs is what it accepts and how it refuses (decision/ and
+ * server/routes.go upstream): the body is capped at 64 KiB, a choice at 26
+ * options, errors are 400/404/413 with `{"error": …}` instead of 401/422/429/529,
+ * no key is needed, and only a local model it has pulled can answer.
+ */
+export type JevDialect = "typesafe" | "ollama";
+/** Where Jev is and how sure an answer has to be before it counts. */
+export interface JevEndpoint {
+    /** Sent as a bearer token when set. TypeSafe needs one; Ollama none. */
+    apiKey?: string;
+    /**
+     * Defaults to {@link JEV_DEFAULT_BASE_URL}. A custom one may be a server
+     * root (`http://host:11434`), its `/v1`, or the full `/v1/systemone`.
+     */
+    baseUrl?: string;
+    /** Known ahead, for tests; otherwise found by {@link detectJevDialect}. */
+    dialect?: JevDialect;
+    /** Defaults to {@link JEV_DEFAULT_MODEL}. Pin a version to keep tuned floors valid. */
+    model?: string;
+    /** Confidence at or above which an answer is acted on. */
+    floor?: number;
+    /** The same, for a question the caller marks as costly to get wrong. */
+    highStakesFloor?: number;
+    timeoutMs?: number;
+}
+export type JevQuestion = {
+    type: "noul";
+    instructions: unknown;
+    criteria?: {
+        true?: unknown;
+        false?: unknown;
+    };
+} | {
+    type: "choice";
+    instructions: unknown;
+    criteria: Record<string, unknown>;
+} | {
+    type: "score";
+    instructions: unknown;
+    criteria: unknown[];
+};
+export type JevAnswer = {
+    type: "noul";
+    noul: number;
+} | {
+    type: "choice";
+    choice: string;
+    probabilities: Record<string, number>;
+    confidence: number;
+} | {
+    type: "score";
+    score: number;
+    legend?: Record<string, string>;
+    probabilities: Record<string, number>;
+    confidence: number;
+};
+export interface JevResponse {
+    model: string;
+    answers: Record<string, JevAnswer>;
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+}
+export interface JevCallOptions {
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+    /** Waits between retries, for tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+/** A failed Jev call, worded for whoever has to act on it. */
+export declare class JevError extends Error {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}
+/** Ollama's `http.MaxBytesReader` on `/v1/systemone`. */
+export declare const OLLAMA_JEV_MAX_BODY_BYTES: number;
+/** Ollama answers each option with one letter, A to Z. */
+export declare const OLLAMA_JEV_MAX_OPTIONS = 26;
+/** The URLs an endpoint is called at. */
+export interface JevRoutes {
+    systemone: string;
+    models: string;
+    /** The server root, where Ollama answers `/api/version` and `/api/tags`. */
+    root: string;
+    /** Anything but TypeSafe's own API. */
+    custom: boolean;
+}
+/**
+ * Where to call, from what the user typed.
+ *
+ * TypeSafe's SDK takes the API base (`…/v1`), Ollama's blog post the server
+ * root (`TYPESAFE_BASE_URL=http://localhost:11434`), and a pasted curl line the
+ * full path. All three name one endpoint, so all three are accepted.
+ */
+export declare function resolveJevRoutes(baseUrl?: string): JevRoutes;
+/** Forget what was learned about each endpoint, for tests. */
+export declare function resetJevDialectCache(): void;
+/**
+ * Whether an endpoint is TypeSafe's or Ollama's, asked of the server.
+ *
+ * TypeSafe's own URL needs no asking. Any other is asked once for
+ * `/api/version`, which every Ollama answers and nothing else does; the answer
+ * is kept per server. A probe that could not connect is not kept, so a server
+ * started after the first call is still recognised, and until then the call
+ * goes out under TypeSafe's rules, which only means looser bounds.
+ */
+export declare function detectJevDialect(endpoint: Pick<JevEndpoint, "baseUrl" | "dialect">, options?: Pick<JevCallOptions, "fetchImpl" | "signal">): Promise<JevDialect>;
+/**
+ * One evaluation: a state and its questions, answered.
+ *
+ * Retries only what the API says to retry, a 429 or a 529, and inside one
+ * deadline for the whole call rather than per attempt: the SDK's default of 10 s
+ * an attempt with two retries is 30 s nobody budgeted for, and every caller
+ * here is holding up either a question to the user or an escalation.
+ */
+export declare function evaluateJev(endpoint: JevEndpoint, request: {
+    state: unknown;
+    questions: Record<string, JevQuestion>;
+}, options?: JevCallOptions): Promise<JevResponse>;
+/**
+ * The decision models an endpoint serves, for the Jev tab's picker.
+ *
+ * Ollama lists every model it has, so only those whose `capabilities` include
+ * `decision` are offered (`/api/tags`; its `/v1/models` carries no
+ * capabilities). TypeSafe's `/v1/models` is `{models: [{name}]}`; an
+ * OpenAI-shaped `{data: [{id}]}` from another compatible server is read too.
+ * Empty on any failure: the field still takes a typed name.
+ */
+export declare function listJevModels(endpoint: Pick<JevEndpoint, "apiKey" | "baseUrl" | "dialect">, options?: Pick<JevCallOptions, "fetchImpl" | "signal">): Promise<string[]>;
+/**
+ * How sure an answer is, on one 0-1 scale for all three kinds.
+ *
+ * Choice and score carry their own. A noul is a choice between two outcomes,
+ * so it gets the two-outcome form of the same measure: `2·p − 1` for the
+ * likelier side, 0 at a coin flip and 1 at certainty. At the default floor of
+ * 0.6 that asks for p ≥ 0.8 either way, which is where the documentation's own
+ * examples draw the yes and no bands.
+ */
+export declare function jevConfidence(answer: JevAnswer): number;
+/** Cut a state part to its ceiling, keeping the head and the tail. */
+export declare function boundJevText(text: string, max?: number): string;
+export declare const JEV_TOOL_DESCRIPTION = "Get a calibrated confidence score from Jev, an external scoring model, before acting on something you are not sure of. Jev reads the context you give it and answers typed questions with probabilities; it writes no text and cannot explain itself.\n\nUse it when you are unsure:\n- whether you understood the user's request \u2014 ask whether the request is ambiguous, or which of your readings it means;\n- whether a fact your answer rests on is supported by what you have read \u2014 put the source text in the context and ask whether it states the claim;\n- which approach, option or file to choose;\n- how complex the task is, before deciding to escalate or delegate it.\n\nArguments:\n- `context` \u2014 the situation, in plain text: what the user asked, what you found, what you are deciding. Only what the questions need; unrelated text makes the answers worse.\n- `questions` \u2014 1 to 10, all asked in one call. Each has an `id`, a `kind` and a `question`:\n  - `yes_no` \u2014 a yes/no question. Returns the probability of yes.\n  - `choice` \u2014 pick one of `options` (2 to 50). Include a \"none of these\" option when that is possible: a choice always picks something.\n  - `score` \u2014 rate on `levels` (2 to 10, lowest first).\n  Set `high_stakes: true` on a question whose wrong answer is costly; it must clear a higher bar.\n\nEach answer comes back as confident or unsure against the user's confidence floor. Act on a confident answer. On an unsure one, verify it yourself or ask the user \u2014 do not treat it as settled. Jev is weak at arithmetic, counting and multi-step reasoning, so check those in code, and ask one property per question rather than one broad question.";
+export declare const JEV_TOOL_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly context: {
+            readonly type: "string";
+            readonly description: "The situation Jev should judge: the request, the evidence, the decision. Only what the questions need.";
+        };
+        readonly questions: {
+            readonly type: "array";
+            readonly description: "1 to 10 questions, answered together.";
+            readonly items: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly description: "A short name for the question; the answer comes back under it.";
+                    };
+                    readonly kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["yes_no", "choice", "score"];
+                    };
+                    readonly question: {
+                        readonly type: "string";
+                    };
+                    readonly options: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "For `choice`: the options, 2 to 50.";
+                    };
+                    readonly levels: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "For `score`: the levels, lowest first, 2 to 10.";
+                    };
+                    readonly high_stakes: {
+                        readonly type: "boolean";
+                        readonly description: "Hold this answer to the higher confidence bar.";
+                    };
+                };
+                readonly required: readonly ["id", "kind", "question"];
+            };
+        };
+    };
+    readonly required: readonly ["context", "questions"];
+};
+interface ToolQuestion {
+    id: string;
+    kind: "yes_no" | "choice" | "score";
+    question: string;
+    options?: string[];
+    levels?: string[];
+    highStakes: boolean;
+}
+/** The model's questions, checked, or the reason they cannot be asked. */
+export declare function readJevToolQuestions(value: unknown): {
+    questions: ToolQuestion[];
+} | {
+    error: string;
+};
+/** One answer, worded for the model, with its verdict against the floor. */
+export declare function describeJevAnswer(question: ToolQuestion, answer: JevAnswer | undefined, floor: number): {
+    line: string;
+    sure: boolean;
+};
+export interface JevToolOptions {
+    /** Read per call; nothing means Jev is not configured. */
+    getEndpoint: () => JevEndpoint | undefined;
+    fetchImpl?: typeof fetch;
+    onError?: (message: string, error: unknown) => void;
+}
+/**
+ * Create the `jev` tool.
+ *
+ * The host omits it when Jev is not enabled or has no key; an endpoint that
+ * disappears mid-session is still answered in words rather than a stack trace.
+ */
+export declare function createJevTool(options: JevToolOptions): AgentTool;
+/** Options under this share of the probability are dropped. */
+export declare const JEV_DROP_BELOW = 0.05;
+export interface RankedOptions {
+    /** What the user is shown, in the model's order, one marked recommended at most. */
+    options: string[];
+    /** The options Jev put under {@link JEV_DROP_BELOW}, as the model wrote them. */
+    dropped: string[];
+    /** The option marked recommended, if any cleared the floor. */
+    recommended?: string;
+    confidence: number;
+    /** One line per option the user sees, for the question text. */
+    scores: {
+        option: string;
+        probability: number;
+    }[];
+}
+/**
+ * Apply Jev's answer to a question's options.
+ *
+ * Pure, so the rules are testable without a network: drop what Jev puts under
+ * 5%, but never below two options, since a question with one answer is not a
+ * question; recommend the top option only when the answer clears the floor,
+ * and then replace the model's own mark rather than add a second one, because
+ * the webview only honours a marker that appears exactly once.
+ */
+export declare function applyOptionRanking(options: readonly string[], probabilities: Readonly<Record<string, number>>, confidence: number, floor: number): RankedOptions;
+/**
+ * Ask Jev which of a question's options the user is most likely to want.
+ *
+ * One choice question over the options, judged against the conversation the
+ * host passes in. The options go in bare: a model's own "(recommended)" mark
+ * is exactly the kind of text in a state that steers the answer.
+ */
+export declare function rankQuestionOptions(endpoint: JevEndpoint, input: {
+    conversation: string;
+    question: string;
+    options: readonly string[];
+}, call?: JevCallOptions): Promise<RankedOptions>;
+/** The scores as a markdown footer for the question the user is shown. */
+export declare function describeOptionRanking(ranked: RankedOptions): string;
+export declare const JEV_COMPLEXITY_LEVELS: readonly ["Trivial: a one-line or mechanical change", "Routine: a clear change in one or two places", "Involved: several parts must change together, with some design judgement", "Hard: subtle behaviour, many interacting parts, or unclear requirements", "Very hard: needs deep expertise or research to get right"];
+/**
+ * Score a task about to be escalated, worded as lines for the assessment.
+ *
+ * Two questions in one call: how complex the task is, and whether the run so
+ * far looks stuck rather than progressing. Both are Jev's reading of the text it
+ * was given -- the user's task, the model's own reason, the harness's counts --
+ * and the lines say so, beside the measured ones rather than above them.
+ */
+export declare function appraiseEscalation(endpoint: JevEndpoint, input: {
+    task?: string;
+    goal?: string;
+    reason?: string;
+    measured?: string;
+}, call?: JevCallOptions): Promise<string[]>;
+export {};