@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/llm.d.ts

@@ -0,0 +1,652 @@
+/**
+ * The llm module of the 1.1.90 consolidation: every correlated variation of the model routing and prompt library logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the llm family: llm holds the model call core of the 1.1.57 family (the shaped request building, the provider call through the transport seam, the local model path, the stream delta parsing, the command guard with intent classification and plan drafting, the replan on fail, the step reflection, the guardrail stripping, the parse output guard, the tool briefs and the usage accounting with its budget check); modelroute holds the routing table that resolves one request to its provider with fallback routes, provider marks and revision bumps; and promptlibrary holds the template library with its variables, rendering, saving, search and removal.
+ * No provider, key or template is ever hardcoded: every route and prompt stays the user's choice, and no model call ever bypasses the consent gates.
+ */
+import type { apikeyref, baseurlconfig, commandparse, costbudget, costestimate, gatewaychatstate, gatewaychattoken, gatewayerror, gatewaykind, gatewaymodelinfo, intentkind, localmodelconfig, modelcacherecord, modelmessage, modeloutput, modelroute, parseguard, plandraft, policyevaluation, prompttemplate, providerconfig, protocolstyle, reflectnote, replanrecord, secretvaultentry, tokenstream, toolbrief, tooldef, usagerecord } from "./types.js";
+import { type fetchtransport } from "./http.js";
+/**
+ * Llm integration logics of the 1.1.57 family.
+ * Every provider call concern lives in this file: the request shaping for the four protocol styles the user picks (the openai compatible chat completions shape, the openai responses shape, the anthropic messages shape and the google gemini shape — wire shapes for interoperability, never provider names), the response parsing per style, the completion call through the established fetch machinery with its reviewed retries and backoff, the local model calls that never leave the machine, the streaming token parse per style, the natural language command parsing with intent classification, the goal to plan drafting with the grammar lint, the replan of failed runs, the per step reflection with its running lessons, the openapi style tool briefs for model consumption, the parse guardrails that strip code fences and chatter, validate model text against the expected schema, retry malformed output and refuse after exhaustion, and the usage records with cost budget halts.
+ * Nothing is hardcoded: no endpoint, no model name, no key, no temperature and no token ceiling ever leaves the user configuration, page content never joins a call the user has not granted and every model drafted plan still passes the same human review.
+ */
+/** The refusal markers reviewed by default; user configured markers always win and an empty configured list disables the marker scan. */
+export declare const defaultrefusalmarkers: string[];
+/** One shaped model request: the url, the method, the headers and the body text per protocol style. */
+export interface shapedrequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}
+/** The usage a completion answer reports: prompt, completion and total token counts. */
+export interface modelusage {
+    prompttokens: number;
+    completiontokens: number;
+    totaltokens: number;
+}
+/** Builds the completion request of one protocol style: the endpoint url, the headers with the key placed where the style expects it and the body envelope the style speaks. The user configured headers merge over the shape headers so any gateway works. */
+export declare function buildrequest(input: {
+    provider: {
+        endpoint: string;
+        style: protocolstyle;
+        headers?: Record<string, string>;
+    };
+    model: string;
+    messages: modelmessage[];
+    apikey?: string;
+    temperature?: number;
+    maxtokens?: number;
+    stream?: boolean;
+}): shapedrequest;
+/** Parses one completion answer of the protocol style: the answer text and the usage counts; a malformed answer reports why nothing parsed. */
+export declare function parsecompletion(style: protocolstyle, body: string): {
+    text?: string;
+    usage?: modelusage;
+    reason?: string;
+};
+/** Returns true when the url points at a local machine endpoint: a loopback host keeps the model call inside the machine. */
+export declare function islocalorigin(url: string): boolean;
+/** Sends one completion request to a user configured provider: the request shapes per protocol style, the page content stays stripped unless the user granted it, a configured auth reference without a resolved key refuses the call and the answer parses per style with its usage counts; retries and backoff ride the reviewed fetch options. */
+export declare function callmodel(input: {
+    provider: providerconfig;
+    model: string;
+    messages: modelmessage[];
+    apikey?: string;
+    temperature?: number;
+    maxtokens?: number;
+    pagecontent?: string;
+    pagegrant?: boolean;
+    stream?: boolean;
+    options?: {
+        timeout?: number;
+        retries?: number;
+        backoff?: number;
+        follow?: number;
+    };
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    text: string;
+    usage?: modelusage;
+    request: shapedrequest;
+}>;
+/** Sends one completion request to the local model endpoint: the endpoint must stay local so the call never leaves the machine, the key stays optional because local runtimes need none and the answer parses per the configured style. */
+export declare function calllocal(input: {
+    local: localmodelconfig;
+    messages: modelmessage[];
+    apikey?: string;
+    temperature?: number;
+    maxtokens?: number;
+    options?: {
+        timeout?: number;
+        retries?: number;
+        backoff?: number;
+        follow?: number;
+    };
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    text: string;
+    usage?: modelusage;
+    request: shapedrequest;
+}>;
+/** Parses one streaming event payload of the protocol style into its token text: the chat completions delta content, the responses output text delta, the messages content block text delta and the gemini candidate part text. */
+export declare function streamdelta(style: protocolstyle, event: string): string;
+/** Parses one server sent event body of the protocol style into the ordered token stream it carries; the done marker rides the last token of a finished stream. */
+export declare function parsestream(style: protocolstyle, body: string): tokenstream[];
+/** Streams one completion request when the provider supports it: the request carries the stream flag of its style, the transport seam returns the server sent event body and the ordered tokens assemble into the answer text with its token count. */
+export declare function streammodel(input: {
+    provider: providerconfig;
+    model: string;
+    messages: modelmessage[];
+    apikey?: string;
+    temperature?: number;
+    maxtokens?: number;
+    pagecontent?: string;
+    pagegrant?: boolean;
+    options?: {
+        timeout?: number;
+        retries?: number;
+        backoff?: number;
+        follow?: number;
+    };
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    text: string;
+    tokens: number;
+    request: shapedrequest;
+}>;
+/** The command parse guard schema: the intent kind, the entities array and the confidence number the parsed command answer carries. */
+export declare const commandguard: parseguard;
+/** Classifies one natural language request into its intent kind with a confidence score: the deterministic keyword scan works without any provider, the confidence rides the matched keyword density and an unmatched request classifies as ask with a low score. */
+export declare function classifyintent(text: string): {
+    intent: intentkind;
+    confidence: number;
+};
+/** Parses one natural language command into its structured result: the model call rides the routed provider, the answer passes the command guard with its retries and the parsed intent, entities and confidence land in the commandparse record; a model refusal reports why nothing parsed. */
+export declare function parsecommand(input: {
+    provider: providerconfig;
+    model: string;
+    text: string;
+    apikey?: string;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+    guard?: parseguard;
+}): Promise<{
+    parse?: commandparse;
+    output?: modeloutput;
+    reason?: string;
+}>;
+/** Builds one model drafted plan from a goal: the model call drafts the steps and open questions, the grammar lint checks every drafted step against the action grammar before review and the draft records its provider and model provenance; the draft never executes until the human review approves it. */
+export declare function draftplan(input: {
+    provider: providerconfig;
+    model: string;
+    goal: string;
+    origin?: string;
+    lessons?: string[];
+    apikey?: string;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    draft?: plandraft;
+    output?: modeloutput;
+    reason?: string;
+}>;
+/** Regenerates the tail of a failed plan: the completed steps stay untouched, the failed steps fall away and the model drafted tail steps carry the fresh review marker so the human review approves every revised step again; the replan record keeps the failure reason and the model provenance. */
+export declare function replannonfail(input: {
+    provider: providerconfig;
+    model: string;
+    draft: plandraft;
+    completedstepids: string[];
+    failedstepids: string[];
+    reason: string;
+    lessons?: string[];
+    apikey?: string;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    replan?: replanrecord;
+    output?: modeloutput;
+    reason?: string;
+}>;
+/** Reflects one executed step: the model call reads the step outcome with the running lessons of the earlier steps and answers the lesson learned plus the advice for the next step; the note records its run, step and model provenance. */
+export declare function reflectstep(input: {
+    provider: providerconfig;
+    model: string;
+    runid: string;
+    stepid: string;
+    outcome: string;
+    lessons?: string[];
+    apikey?: string;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<{
+    note?: reflectnote;
+    output?: modeloutput;
+    reason?: string;
+}>;
+/** Summarizes the running lessons of the reflection notes so the next prompt carries them; the newest lesson of every step rides the summary in step order. */
+export declare function reflectionsummary(notes: reflectnote[]): string;
+/** Strips the guardrail noise of one model answer before parsing: code fences open the payload, chatter lines around a json object fall away and a fenced block without a language tag keeps its inner text. The fence runs through plain index scans, because a regex over the fence prefix would backtrack polynomially on adversarial answers built from repeated fence markers. */
+export declare function stripguardrails(text: string): string;
+/** Validates one stripped model answer against the guard schema: every required field must be present with its declared type while optional fields pass through; the verdict reports invalid with the reason otherwise. */
+export declare function parseoutput(input: {
+    guard: parseguard;
+    text: string;
+}): modeloutput;
+/** Runs the parse guard over the model answer attempts: a valid attempt wins, a refusal marker refuses without retries, malformed answers retry up to the configured count and the exhaustion of every attempt refuses the output so nothing invalid ever executes. */
+export declare function guardoutput(input: {
+    guard: parseguard;
+    attempts: string[];
+}): modeloutput;
+/** Builds the openapi style tool brief of one catalog tool: the name, the summary line, the description, the risk class and the typed parameter list with their required markers. */
+export declare function toolbriefof(tool: tooldef): toolbrief;
+/** Renders the tool briefs in openapi style for model consumption: every tool lists its name, summary, risk class and typed parameters so the model knows the surface it may propose; the consent notice states that side effects need the named approved step. */
+export declare function rendertoolbriefs(tools: tooldef[]): string;
+/** Records one usage entry of a model call: the run and step ids ride the record together with the provider, the endpoint, the model, the token counts and the cost; newer records prepend so the newest call reads first. */
+export declare function addusage(records: usagerecord[], record: usagerecord): usagerecord[];
+/** Aggregates the usage records per run, per step, per session and per period: the prompt, completion and total token counts, the cost total and the call count of every record the filter keeps; the session filter of the 1.1.83 gateway family reports the per session totals beside the per run totals. */
+export declare function usagetotals(records: usagerecord[], filter?: {
+    runid?: string;
+    stepid?: string;
+    sessionid?: string;
+    since?: number;
+    until?: number;
+}): {
+    prompttokens: number;
+    completiontokens: number;
+    totaltokens: number;
+    cost: number;
+    calls: number;
+};
+/** Checks the cost budget of a run: a reached token or currency ceiling halts the run and asks the user before anything else runs, while an absent ceiling stays unbounded because every ceiling is a user choice. */
+export declare function budgetcheck(input: {
+    budget: costbudget | undefined;
+    totals: {
+        totaltokens: number;
+        cost: number;
+    };
+}): {
+    allowed: boolean;
+    halted: boolean;
+    asksuser: boolean;
+    reason?: string;
+};
+/**
+ * Model routing of the 1.1.57 llm integration family.
+ * Every routing concern lives in this file: the task kind resolution that maps a task kind onto its preferred provider and model, the availability marking of providers that failed their last call, the fallback resolution on refusal or outage with the user configured fallback pair and the route validation that keeps every entry a user configured choice.
+ * No default route, no default model and no default provider ever applies: an unrouted task kind reports why nothing routed and the user picks the pair.
+ */
+/** Validates one model route entry: the task kind, the provider and the model stay user configured values and the fallback pair needs both halves or none. */
+export declare function routevalid(route: modelroute): policyevaluation;
+/** Returns every route of one task kind in revision order, newest revision first. */
+export declare function routesfor(routes: modelroute[], kind: string): modelroute[];
+/** Resolves the provider and model for one task kind: the newest route of the kind whose provider exists and stays available wins; an unrouted kind, a missing provider or an unavailable provider reports why nothing routed. */
+export declare function resolveroute(input: {
+    routes: modelroute[];
+    providers: providerconfig[];
+    kind: string;
+}): {
+    route?: modelroute;
+    provider?: providerconfig;
+    model?: string;
+    reason?: string;
+};
+/** Marks one provider unavailable after a failed call or available after a successful test; every other provider stays untouched. */
+export declare function markprovider(input: {
+    providers: providerconfig[];
+    providerid: string;
+    available: boolean;
+    now: number;
+}): providerconfig[];
+/** Resolves the fallback pair of one task kind on refusal or outage: the user configured fallback provider and model win when they exist and stay available; a missing fallback reports why nothing fell back so the caller asks the user. */
+export declare function fallbackroute(input: {
+    routes: modelroute[];
+    providers: providerconfig[];
+    kind: string;
+}): {
+    route?: modelroute;
+    provider?: providerconfig;
+    model?: string;
+    reason?: string;
+};
+/** Bumps the revision of one route entry so the revision history of the routing table stays queryable; the newest revision of a kind wins the resolution. */
+export declare function bumprevision(route: modelroute, now: number): modelroute;
+/**
+ * Prompt template library of the 1.1.57 llm integration family.
+ * Every template concern lives in this file: the variable extraction from double braced placeholders, the template render that fills the variables, the consent notice requirement of sensitive flows, the versioning of every saved template with its change notes and the library search.
+ * The library holds user templates only: no built-in template ever ships, so every prompt body stays a user reviewed choice.
+ */
+/** Extracts the double braced variable names of one template body in order of appearance, deduplicated. */
+export declare function templatevariables(body: string): string[];
+/** Renders one template with its variables: every declared variable substitutes its value while a sensitive flow needs its consent notice before the render leaves; the notice rides the rendered text so the reviewer sees the consent line. */
+export declare function rendertemplate(input: {
+    template: prompttemplate;
+    variables?: Record<string, unknown>;
+    sensitive?: boolean;
+    consentnotice?: string;
+}): {
+    text?: string;
+    reason?: string;
+};
+/** Saves one template version: a new name creates the first version while a known name bumps the version with its change notes; every earlier version stays stored so the history never rewrites. */
+export declare function savetemplate(input: {
+    templates: prompttemplate[];
+    name: string;
+    body: string;
+    notes?: string;
+    now: number;
+}): prompttemplate[];
+/** Returns the newest stored version of one template name; an unknown name reports undefined. */
+export declare function latesttemplate(templates: prompttemplate[], name: string): prompttemplate | undefined;
+/** Searches the library: the query matches the template name, the body text, the change notes or one of the declared variables, newest version first. */
+export declare function searchtemplates(templates: prompttemplate[], query: string): prompttemplate[];
+/** Removes every version of one template name from the library; the change history leaves with the name. */
+export declare function removetemplate(templates: prompttemplate[], name: string): prompttemplate[];
+/**
+ * Provider gateway logics of the 1.1.83 family.
+ * Every provider adapter concern lives in this file: the adapter interface one request, stream and cancel contract shares, the four adapters (the openaicompat chat completions shape with its streamed deltas, the anthropicgateway messages shape with its streamed content blocks and its system prompt mapping, the geminigateway generate content shape with its streamed candidate parts and its tool schema mapping, and the ollamalocal localhost runtime with its local model listing), the baseurlconfig one endpoint url per provider with its scheme, host and path shape validation, the per provider key vault behind the secretvault seam, the modellist discovery with its configurable cache window, the capabilityad tool catalog advertisement, the routing of task kinds onto providers with the local fallback, the token budget accounting with its warning threshold, the guardrails over every parsed model answer with the structured retry prompt and the capped retries, and the prompt template library of the per task templates with their variable slots.
+ * The module composes with the llm provider model instead of duplicating it: the three remote adapters speak through the same request shaping, answer parsing and stream parsing the llm module owns, while the ollamalocal adapter speaks its own localhost wire format. Nothing is hardcoded: no remote endpoint, no model name and no key ever leaves the user configuration, the ollamalocal adapter alone defaults to the localhost machine and never to a cloud url, every timeout, retry, backoff and cache window stays a user choice, all http rides the injected fetch transport seam and every key resolves through the vault seam at the last possible moment.
+ */
+/** The local machine base url the ollamalocal adapter alone defaults to: a loopback address of the machine itself, never a cloud url — the explicit contract exception, while every remote provider ships an empty base url until the user configures one. */
+export declare const ollamalocaldefault = "http://localhost:11434";
+/** The provider kinds of the gateway family in their stable order; every surface that lists the adapters reads this one list. */
+export declare const gatewaykinds: gatewaykind[];
+/** Reads the default base url of one provider kind: the ollamalocal runtime alone carries the localhost machine default and every remote kind carries none, so no provider endpoint is contacted unless the user configured one. */
+export declare function defaultbaseurl(kind: gatewaykind): string;
+/** Joins the user configured base url, the optional per provider path prefix and the wire path of the adapter into the request url; the base keeps its trailing shape and the prefix sits between the base and the wire path. The slash trims run through plain character walks, because a leading or trailing slash regex would itself read as polynomial on adversarial bases. */
+export declare function gatewayurl(config: Pick<baseurlconfig, "baseurl" | "pathprefix">, path: string): string;
+/** The input every adapter shapes into one wire request: the provider config, the model, the conversation, the resolved key material, the sampling choices, the stream flag, the tool catalog the capabilityad advertises and the extra headers the user reviewed. */
+export interface gatewayrequestinput {
+    config: baseurlconfig;
+    model: string;
+    messages: modelmessage[];
+    /** Resolved key material; the value reaches the wire headers only and never a log, an audit entry or an export. */
+    apikey?: string;
+    temperature?: number;
+    maxtokens?: number;
+    stream?: boolean;
+    /** The tool catalog the request advertises through the capabilityad serialization of the adapter. */
+    tools?: tooldef[];
+    headers?: Record<string, string>;
+}
+/** The provider adapter contract: every adapter builds its wire request, parses one answer body, parses one streamed body into ordered tokens, lists its models and serializes the tool catalog in its own wire format — one request, stream and cancel contract shared by all four. */
+export interface gatewayadapter {
+    readonly kind: gatewaykind;
+    /** The protocol style of the llm provider model this adapter extends, when it speaks one of them; the ollamalocal runtime speaks its own localhost wire format and carries none. */
+    readonly style?: "chatcompletions" | "messages" | "gemini";
+    /** The wire path of the chat endpoint relative to the base url; the gemini shape rides its model in the path. */
+    chatpath(model: string): string;
+    /** The wire path of the model list endpoint relative to the base url. */
+    modelspath(): string;
+    /** Builds one wire request: the url, the method, the headers with the key placed where the shape expects it and the body envelope the shape speaks, with the tool catalog embedded in the provider format when the request carries one. */
+    build(input: gatewayrequestinput): ReturnType<typeof buildrequest>;
+    /** Parses one answer body of the adapter wire format: the answer text and its usage counts, or the reason nothing parsed. */
+    parseanswer(body: string): {
+        text?: string;
+        usage?: modelusage;
+        reason?: string;
+    };
+    /** Parses one streamed body of the adapter wire format into its ordered token stream: the chat completions deltas, the messages content blocks, the gemini candidate parts or the ollama message lines. */
+    parsestream(body: string): tokenstream[];
+    /** Parses one model list body of the adapter wire format into the discovered models with their context and modality hints when offered. */
+    parsemodellist(body: string): gatewaymodelinfo[];
+    /** Serializes the tool catalog into the tool schema format of the provider for the capabilityad advertisement. */
+    toolcatalog(tools: tooldef[]): unknown[];
+}
+/** The openai compatible chat completions adapter: any endpoint the user configures that speaks the chat completions shape works, the bearer header carries the resolved key, the streamed answer rides server sent event deltas and the tool catalog serializes into the function tool schema. */
+export declare const openaicompatadapter: gatewayadapter;
+/** The anthropic messages adapter: the messages wire shape with its system prompt mapping to the top level system field, the streamed answer rides content block deltas and the tool catalog serializes into the input schema format. */
+export declare const anthropicgatewayadapter: gatewayadapter;
+/** The gemini generate content adapter: the generate content wire shape with the model riding the path, the streamed answer rides candidate parts and the tool schema maps into the function declarations format. */
+export declare const geminigatewayadapter: gatewayadapter;
+/** The ollama local runtime adapter: it speaks its own localhost wire format (the chat endpoint with the message envelope, the tag list of the locally installed models and the newline delimited stream lines), the base url defaults to the local machine alone and never to a cloud url, and a call never leaves the machine. */
+export declare const ollamalocaladapter: gatewayadapter;
+/** Every adapter of the gateway family in its stable order; the surfaces and the tests read this one record. */
+export declare const gatewayadapters: Record<gatewaykind, gatewayadapter>;
+/** Reads the adapter of one provider kind; an unknown kind refuses because the four adapters are the contract. */
+export declare function adapterof(kind: gatewaykind): gatewayadapter;
+/** The cancel contract of the gateway family: one cancel state the caller creates, passes into the request and stream calls and cancels from any surface; the calls check the flag before the dispatch, between the attempts and after every streamed token. */
+export interface gatewaycancelstate {
+    cancelled(): boolean;
+    cancel(reason?: string): void;
+    reason(): string;
+}
+/** Creates one cancel state of the gateway stream contract; the state stays silent until the caller cancels it. */
+export declare function gatewaycancel(): gatewaycancelstate;
+/** Builds one structured gateway error with its code, message, retry hint and request id; every failure surface of the family answers this one shape. */
+export declare function gatewayerrorof(code: gatewayerror["code"], message: string, requestid: string, retryhint?: string, retryafter?: number): gatewayerror;
+/** Normalizes one thrown error into the structured gateway error surface: a thrown gateway error passes through, a timeout keeps its code and every other failure grades as a transport error with its retry hint. */
+export declare function gatewayerrorfrom(error: unknown, requestid: string): gatewayerror;
+/** Reads the retry after milliseconds a rate limited answer announced: the retry-after header carries seconds or milliseconds, the request epoch dates pass through and an absent or malformed header answers undefined. */
+export declare function gatewayretryafterof(headers: Record<string, string>): number | undefined;
+/** Masks one provider key for every log, audit entry and error message: the mask answers the key length alone, so no key material — no prefix, no suffix, no fragment — ever reaches a printed line. */
+export declare function maskkey(key: string): string;
+/** Builds the log safe view of one shaped request: the authorization, api key and proxy header values answer their masked form and a gemini url key parameter strips, so the audit trail and the surfaces never record key material. */
+export declare function maskrequest(request: {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}): {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+};
+/** Stores one provider api key behind the vault seam under the explicit consent of the user: the key material enters the seam at the store moment and the metadata record alone answers, scoped to the origin of the provider base url so a key of one gateway never rides another. */
+export declare function storeproviderkey(input: {
+    seam: {
+        put(vaultid: string, value: string): Promise<void>;
+    };
+    config: Pick<baseurlconfig, "providerid" | "kind" | "baseurl">;
+    profileid: string;
+    value: string;
+    consent: boolean;
+    now: number;
+}): Promise<secretvaultentry>;
+/** Resolves one provider key from the vault seam at the last possible moment before the wire header: the value answers to the dispatching caller only, never to a log writer, and the record stamps its use. */
+export declare function resolveproviderkey(input: {
+    seam: {
+        fetch(vaultid: string): Promise<string | undefined>;
+    };
+    entry: secretvaultentry;
+}): Promise<{
+    ok: boolean;
+    value?: string;
+    reason: string;
+}>;
+/** Revokes one provider key with one click: the value drops from the seam and the metadata record leaves with it, because a deleted key leaves no trace a surface could read. */
+export declare function revokeproviderkey(input: {
+    seam: {
+        drop(vaultid: string): Promise<void>;
+    };
+    entry: secretvaultentry;
+}): Promise<{
+    dropped: boolean;
+    label: string;
+    reason: string;
+}>;
+/** Checks one export candidate list for leaked provider keys: a candidate whose sha-256 digest matches a stored vault record is a leak the export refuses, because key material never rides an export path. */
+export declare function keyexportcheck(input: {
+    candidates: string[];
+    entries: secretvaultentry[];
+}): Promise<{
+    leaks: string[];
+    reason: string;
+}>;
+/** The call options of the one request contract: the timeout, the retry count, the backoff base, the jitter window and the extra headers the user reviewed — every bound a user choice with no code default. */
+export interface gatewayoptions {
+    timeout?: number;
+    retries?: number;
+    backoff?: number;
+    /** Jitter window in milliseconds the backoff waits add; a zero window keeps the deterministic backoff. */
+    jitter?: number;
+    headers?: Record<string, string>;
+}
+/** The result of one gateway request: the answer text, the usage counts, the request id, the shaped request and the transport facts. */
+export interface gatewayresult {
+    text: string;
+    usage?: modelusage;
+    requestid: string;
+    request: ReturnType<typeof buildrequest>;
+    status: number;
+    duration: number;
+    retries: number;
+}
+/** Sends one gateway request through the shared contract: the dispatch loop runs the gates, the retries, the rate limit honoring, the timeout race and the cancellation, and the adapter parses the answer body with its usage counts — every failure answers the structured gateway error. */
+export declare function gatewaycall(input: {
+    config: baseurlconfig;
+    model: string;
+    messages: modelmessage[];
+    apikey?: string;
+    tools?: tooldef[];
+    temperature?: number;
+    maxtokens?: number;
+    options?: gatewayoptions;
+    requestid?: string;
+    cancel?: gatewaycancelstate;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    jitter?: () => number;
+    now?: () => number;
+}): Promise<gatewayresult>;
+/** Streams one gateway request through the shared contract: the request carries the stream flag of its wire format, the adapter parses the streamed body into its ordered tokens (the chat completions deltas, the messages content blocks, the gemini candidate parts or the ollama message lines), the onevent seam fires for every token as it parses so the surfaces append the answer incrementally, and the cancel state stops the parse loop at the token position it reached. */
+export declare function gatewaystream(input: {
+    config: baseurlconfig;
+    model: string;
+    messages: modelmessage[];
+    apikey?: string;
+    tools?: tooldef[];
+    temperature?: number;
+    maxtokens?: number;
+    options?: gatewayoptions;
+    requestid?: string;
+    cancel?: gatewaycancelstate;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    jitter?: () => number;
+    now?: () => number;
+    onevent?: (token: tokenstream) => void;
+}): Promise<{
+    tokens: tokenstream[];
+    text: string;
+    requestid: string;
+    request: ReturnType<typeof buildrequest>;
+    status: number;
+    retries: number;
+}>;
+/** Fetches the model list of one provider through the adapter: the cache window the user configured decides whether the cached list still serves, a fresh fetch rides the model list endpoint of the wire format, the discovered models annotate with their context and modality hints when the provider offers them and a failed fetch keeps the cache untouched. */
+export declare function fetchmodellist(input: {
+    config: baseurlconfig;
+    apikey?: string;
+    cachewindow?: number;
+    cache?: modelcacherecord;
+    transport: fetchtransport;
+    options?: gatewayoptions;
+    now?: () => number;
+}): Promise<{
+    models: gatewaymodelinfo[];
+    cached: boolean;
+    fetchedat: number;
+    reason?: string;
+}>;
+/** Builds the capabilityad advertisement of the tool catalog: the tools serialize into the wire format of the provider (the function schema of the chat completions shape, the input schema of the messages shape, the function declarations of the generate content shape or the function schema of the local runtime), every tool declares its consent requirement from its metadata and the plan review gate rides the required capabilities because a model answer never executes a step the human review did not approve. */
+export declare function capabilityadvertisement(input: {
+    kind: gatewaykind;
+    tools: tooldef[];
+}): {
+    kind: gatewaykind;
+    tools: unknown[];
+    consent: Array<{
+        tool: string;
+        review: string;
+        riskclass?: string;
+        approvalrequired?: boolean;
+    }>;
+    requiredcapabilities: string[];
+};
+/** Resolves the gateway route of one task kind: the user rules of the model routing table map the kind onto its provider and model, a remote provider the consent or enable gates refuse falls back to the user configured fallback pair, and when remote calls are not allowed at all the resolution falls back to the local provider so the task stays on the machine. */
+export declare function resolvegatewayroute(input: {
+    kind: string;
+    routes: modelroute[];
+    providers: providerconfig[];
+    configs: baseurlconfig[];
+    local?: localmodelconfig;
+    remoteallowed?: boolean;
+    sessionorigin?: string;
+}): {
+    source: "route" | "fallback" | "local";
+    provider?: providerconfig;
+    model?: string;
+    config?: baseurlconfig;
+    local?: localmodelconfig;
+    reason?: string;
+};
+/** Builds one usage record of a gateway call: the request id rides the record for the correlation across the run, the session id reports the per session totals beside the per run totals, the cost answers the user configured price per million tokens and the local marker stamps the calls that never left the machine. */
+export declare function gatewayusagerecord(input: {
+    providerid: string;
+    endpoint: string;
+    model: string;
+    usage?: modelusage;
+    costpermilliontokens?: number;
+    sessionid?: string;
+    runid?: string;
+    stepid?: string;
+    requestid: string;
+    local?: boolean;
+    now: number;
+}): usagerecord;
+/** Checks the warning threshold of the cost budget: the budget tracking warns once the recorded tokens or cost cross the user configured share of their ceiling, while the halt of the reviewed budget check stays separate — a warning never blocks a call, the halt does. */
+export declare function gatewaybudgetwarning(input: {
+    budget?: costbudget;
+    totals: {
+        totaltokens: number;
+        cost: number;
+    };
+}): {
+    warned: boolean;
+    tokenratio?: number;
+    costratio?: number;
+    reason?: string;
+};
+/** Builds the cost estimate view of the configured providers: the projected cost per million tokens answers the user configured price of every provider and model pair beside the recorded tokens and cost of the usage records, so the surfaces show what a call costs before it runs — a pair without configured pricing answers zero instead of an invented number. */
+export declare function costestimates(input: {
+    configs: baseurlconfig[];
+    providers: providerconfig[];
+    records: usagerecord[];
+}): costestimate[];
+/** The reviewed default guard of the gateway plan answers: the goal, the steps array and the open questions the plan schema asks, with one retry before the refusal. */
+export declare const gatewayplanguard: parseguard;
+/** Builds the structured retry prompt of one refused model answer: the prompt names the schema the answer failed, quotes the failure reason of the guard and asks the model to answer with the corrected json object alone, so a retry teaches the shape instead of repeating the failure. */
+export declare function guardretryprompt(output: modeloutput): string;
+/** Runs the gateway guardrails over the model answer attempts: every attempt validates against the plan schema through the shared parse guard, the attempts cap at the user configured retry count, a valid attempt wins, a refusal marker refuses without retries and the exhaustion of every capped attempt refuses the output so nothing invalid ever reaches a plan — the structured retry prompt answers whenever a retry is left. */
+export declare function gatewayguard(input: {
+    guard?: parseguard;
+    attempts: string[];
+}): {
+    output: modeloutput;
+    retryprompt?: string;
+    cappedat: number;
+};
+/** The per task prompt templates of the gateway family: every template ships with its double braced variable slots and its version, the memory store keeps the versions and a template renders through the shared prompt library with its variables. */
+export declare function gatewaytemplates(now: number): prompttemplate[];
+/** Composes one gateway prompt from a stored template and its variable values through the shared prompt library; a missing template name answers the reason so the caller refuses instead of sending a hollow prompt. */
+export declare function composegatewayprompt(input: {
+    templates: prompttemplate[];
+    name: string;
+    variables: Record<string, unknown>;
+}): {
+    text?: string;
+    reason?: string;
+};
+/** Assembles the streamed tokens of a gateway chat for incremental rendering: every poll reads the tokens past its cursor, the assembled text carries only the fresh batch and the done marker answers whether a finished stream delivered its last token — the sidepanel chat appends every batch as it arrives instead of waiting for the whole answer. */
+export declare function streamrender(tokens: gatewaychattoken[], cursor: number, finished: boolean): {
+    text: string;
+    nextcursor: number;
+    done: boolean;
+};
+/** Builds one gateway chat state of a streamed exchange: the request id, the provider, the model, the prompt and the token list the panel polls through its cursor; the state never carries key material. */
+export declare function gatewaychatstateof(input: {
+    requestid: string;
+    config: baseurlconfig;
+    model: string;
+    prompt: string;
+    tokens?: gatewaychattoken[];
+    done?: boolean;
+    error?: gatewayerror;
+    now: number;
+}): gatewaychatstate;
+/** Reads whether one base url points at the local machine, shared with the llm provider model so the local marker of the usage records answers one rule. */
+export declare function gatewayislocal(config: Pick<baseurlconfig, "baseurl">): boolean;
+/** Runs the reviewed budget check over the usage totals: the token and currency ceilings halt the run and ask the user, exactly as every model call of the llm family already does — the gateway calls pass the same budget gate. */
+export declare function gatewaybudgetcheck(input: {
+    budget: costbudget | undefined;
+    totals: {
+        totaltokens: number;
+        cost: number;
+    };
+}): {
+    allowed: boolean;
+    halted: boolean;
+    asksuser: boolean;
+    reason?: string;
+};
+/** Validates one gateway config before it saves: the base url passes its scheme, host and path shape gate, the path prefix passes its namespace gate, the ollamalocal base url defaults to the local machine when the user left it empty and every remote kind refuses an empty base url. */
+export declare function validategatewayconfig(config: baseurlconfig): {
+    ok: boolean;
+    config: baseurlconfig;
+    reason?: string;
+};
+/** The key reference the gateway config carries: the name the surfaces show, the origin scope of the provider base url and the storage id of the vault entry — never the key material. */
+export declare function gatewaykeyref(name: string, baseurl: string, storageid: string, configuredat: number): apikeyref;
+//# sourceMappingURL=llm.d.ts.map