codictator 0.0.0-stage → 0.1.2

package/dist/features/integrity/self-protection.js

@@ -0,0 +1,144 @@
+// SPEC §4.14.3: self-protection (L1, core/no-bypass). Commands are matched
+// by the kernel shell analyser, so wrappers (bash -c, env assignments,
+// $(…) nesting) do not hide them; a raw token scan backstops unparseable
+// input fail-closed. There is no flag or file that turns Codictator off.
+import { analyseShell, isProtectedPath, matchBypassCommand, parseJson, scanBypassRawText, } from "../../kernel/index.js";
+export { isProtectedPath };
+const NO_BYPASS = "core/no-bypass";
+function noBypass(message, remediation) {
+    return { ruleId: NO_BYPASS, message, remediation };
+}
+const TOOL_WRITE_VERBS = new Set([
+    "write",
+    "edit",
+    "create",
+    "delete",
+    "remove",
+    "move",
+    "rename",
+    "rm",
+    "unlink",
+]);
+const SHELLS = new Set(["bash", "sh", "dash", "zsh", "env", "sudo", "doas"]);
+function candidatesFor(command) {
+    const out = [command.join(" ")];
+    for (let i = 0; i + 1 < command.length; i += 1) {
+        const flag = command[i];
+        const next = command[i + 1];
+        if ((flag === "-c" || flag === "--command") && next !== undefined) {
+            out.push(next);
+        }
+    }
+    if (command.length > 1 &&
+        SHELLS.has(command[0] ?? "") &&
+        !command.includes("-c")) {
+        out.push(command.slice(1).join(" "));
+    }
+    return out;
+}
+function codictatorDep(text) {
+    const parsed = parseJson(text);
+    if (!parsed.ok) {
+        return undefined;
+    }
+    const root = parsed.value;
+    if (typeof root !== "object" ||
+        root === null ||
+        !("devDependencies" in root)) {
+        return undefined;
+    }
+    const deps = root.devDependencies;
+    if (typeof deps !== "object" || deps === null || !("codictator" in deps)) {
+        return undefined;
+    }
+    const pinned = deps.codictator;
+    return typeof pinned === "string" ? pinned : undefined;
+}
+// SPEC §4.14.3 manifests row: a package.json write that removes or changes
+// the codictator dev dependency is self-protection, not drift.
+export function checkPackageManifestEdit(beforeText, afterText) {
+    const before = codictatorDep(beforeText);
+    const after = codictatorDep(afterText);
+    if (before !== undefined && after !== before) {
+        return [
+            noBypass("package.json removes or changes the codictator dev dependency", "Restore the exact pinned codictator devDependency; upgrades go through the upgrade bot (§4.8.6)."),
+        ];
+    }
+    return [];
+}
+// SPEC §4.14.2 core/no-bypass at L4: a non-merge commit in range needs the
+// Codictator-L3 trailer that commit-msg adds (value: short config hash),
+// unless its author is exempt (bot accounts). Web-editor commits (EC-4) and
+// --no-verify commits (EC-3) lack it and block the PR here.
+export function checkCommitTrailers(commits, trailerExempt) {
+    const findings = [];
+    for (const commit of commits) {
+        if (commit.isMerge || trailerExempt.includes(commit.author)) {
+            continue;
+        }
+        if (!commit.message
+            .split("\n")
+            .some((line) => line.startsWith("Codictator-L3: "))) {
+            findings.push(noBypass(`commit ${commit.sha} lacks the Codictator-L3 trailer`, "Make the change locally so commit-msg adds the trailer; web-editor commits must be redone locally (EC-4)."));
+        }
+    }
+    return findings;
+}
+function toolFormHit(command) {
+    const verb = (command[0] ?? "").toLowerCase();
+    if (!TOOL_WRITE_VERBS.has(verb)) {
+        return undefined;
+    }
+    const target = command.find((part) => isProtectedPath(part));
+    if (target === undefined) {
+        return undefined;
+    }
+    return noBypass(`agent ${verb} of protected guardrail path ${target}`, "All guardrail state changes go through `codictator` commands (§4.14.5); run `codictator regen` instead.");
+}
+function unparseableFinding() {
+    return {
+        ruleId: "core/dangerous-shell",
+        code: "CDX-E306",
+        message: "shell command is unparseable; blocking fail-closed",
+        remediation: "Rewrite the command with balanced quotes and retry (§4.7.2).",
+    };
+}
+// SPEC §4.14.2 + §4.14.3: L1 blocks the bypass; L4 blocks the PR via the
+// missing Codictator-L3 trailer. Every hit names the blocked construct.
+export function checkSelfProtection(_ctx, command) {
+    const toolHit = toolFormHit(command);
+    if (toolHit !== undefined) {
+        return [toolHit];
+    }
+    const candidates = candidatesFor(command);
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const parsed = analyseShell(candidate);
+        if (!parsed.ok) {
+            continue;
+        }
+        for (const pipeline of parsed.value.pipelines) {
+            for (const cmd of pipeline.commands) {
+                const hit = matchBypassCommand(cmd);
+                if (hit !== undefined && !seen.has(hit)) {
+                    seen.add(hit);
+                    return [
+                        noBypass(hit, "Run the command without the bypass; hooks and required checks cannot be skipped (§4.14.3)."),
+                    ];
+                }
+            }
+        }
+    }
+    const raw = scanBypassRawText(candidates[0] ?? "");
+    if (raw !== undefined) {
+        return [
+            noBypass(raw, "Wrappers do not hide bypasses from the shell analyser; run the command without the bypass (§4.14.3)."),
+        ];
+    }
+    const failed = candidates.some((candidate) => !analyseShell(candidate).ok);
+    const looksShell = SHELLS.has(command[0] ?? "") || /[;|&$`()]/.test(candidates[0] ?? "");
+    if (failed && looksShell) {
+        return [unparseableFinding()];
+    }
+    return [];
+}

package/dist/features/llm/attempt.d.ts

@@ -0,0 +1,17 @@
+import { type Env, type Result } from "../../kernel/index.ts";
+import type { CompletionRequest, CompletionResponse, LlmPorts } from "./index.ts";
+import type { LlmConfig } from "./presets.ts";
+export declare const LLM_MAX_ATTEMPTS = 3;
+export declare const LLM_RETRY_DELAYS_MS: ReadonlyArray<number>;
+export declare function isRetryableStatus(status: number): boolean;
+export declare function resolveKey(env: Env, keyName: string | undefined): Result<string | undefined>;
+export type Advance = {
+    readonly kind: "return";
+    readonly result: Result<CompletionResponse>;
+} | {
+    readonly kind: "strip-format";
+} | {
+    readonly kind: "backoff";
+    readonly delayMs: number;
+};
+export declare function runAttempt(ports: LlmPorts, config: LlmConfig, req: CompletionRequest, key: string | undefined, withResponseFormat: boolean, attempt: number, started: string): Promise<Advance>;

package/dist/features/llm/attempt.js

@@ -0,0 +1,99 @@
+// SPEC §4.17.4: one answered attempt and its classification. Kept apart so
+// the factory and the retry loop stay under the size and complexity guards.
+import { err, ok, } from "../../kernel/index.js";
+import { invalidDraftError, keyMissingError, keyRejectedError, unavailableError, } from "./errors.js";
+import { buildWireRequest, readWireText } from "./wire.js";
+export const LLM_MAX_ATTEMPTS = 3;
+// SPEC §4.17.4 EC-3: retry twice with 2 s and 8 s backoff.
+export const LLM_RETRY_DELAYS_MS = [2000, 8000];
+const AUTH_STATUSES = new Set([401, 403]);
+// SPEC §4.17.4 EC-3: 429 and 5xx are retryable; every other status fails at
+// once (401/403 become CDX-E852, the rest CDX-E854).
+export function isRetryableStatus(status) {
+    return status === 429 || (status >= 500 && status <= 599);
+}
+// SPEC §4.17.4 EC-6: a 400 that names response_format means the provider
+// rejected the json_object hint, so the one retry goes without it.
+function rejectsResponseFormat(body) {
+    return body.toLowerCase().includes("response_format");
+}
+// Read the key at call time; an empty value counts as unset (EC-1).
+export function resolveKey(env, keyName) {
+    if (keyName === undefined) {
+        return ok(undefined);
+    }
+    const raw = env.get(keyName);
+    const key = raw === undefined || raw === "" ? undefined : raw;
+    if (key === undefined) {
+        return err(keyMissingError(keyName));
+    }
+    return ok(key);
+}
+function readBody(config, response) {
+    const read = readWireText(config.format, response.body);
+    if (read === undefined) {
+        return err(invalidDraftError(`provider answer is not ${config.format} JSON`));
+    }
+    // SPEC §4.17.4 EC-7: a draft cut at maxOutputTokens is invalid JSON for
+    // the generator repair round.
+    if (read.truncated) {
+        return err(invalidDraftError(`response truncated at maxOutputTokens (stop: ${read.stopReason})`));
+    }
+    return ok({ text: read.text, stopReason: read.stopReason });
+}
+// Classify one answered attempt: finish now, strip the format hint once, or
+// back off and retry.
+function advance(ports, config, response, withResponseFormat, attempt, started) {
+    if (AUTH_STATUSES.has(response.status)) {
+        return {
+            kind: "return",
+            result: err(keyRejectedError(response.status, config.apiKeyEnv)),
+        };
+    }
+    if (withResponseFormat &&
+        response.status === 400 &&
+        rejectsResponseFormat(response.body)) {
+        return { kind: "strip-format" };
+    }
+    if (isRetryableStatus(response.status)) {
+        if (attempt + 1 < LLM_MAX_ATTEMPTS) {
+            const delays = LLM_RETRY_DELAYS_MS;
+            return {
+                kind: "backoff",
+                delayMs: delays[Math.min(attempt, delays.length - 1)] ?? 8000,
+            };
+        }
+        const elapsed = Date.parse(ports.clock.now()) - Date.parse(started);
+        return {
+            kind: "return",
+            result: err(unavailableError(`status ${String(response.status)} after ${String(LLM_MAX_ATTEMPTS)} attempts over ${String(elapsed)} ms`)),
+        };
+    }
+    if (response.status !== 200) {
+        return {
+            kind: "return",
+            result: err(unavailableError(`status ${String(response.status)}`)),
+        };
+    }
+    return { kind: "return", result: readBody(config, response) };
+}
+// One attempt: send the wire request and classify the answer.
+export async function runAttempt(ports, config, req, key, withResponseFormat, attempt, started) {
+    const wire = buildWireRequest(config, req.model, req.prompt, req.maxOutputTokens, key, withResponseFormat);
+    const sent = await ports.net.request({
+        method: wire.method,
+        url: wire.url,
+        headers: wire.headers,
+        body: wire.body,
+        timeoutMs: config.timeoutMs,
+    });
+    // SPEC §4.17.4 EC-4: a transport failure (including a timeout at the Net
+    // port) is CDX-E854 at once, never a retry.
+    if (!sent.ok) {
+        return {
+            kind: "return",
+            result: err(unavailableError(`request failed: ${sent.error.message}`)),
+        };
+    }
+    return advance(ports, config, sent.value, withResponseFormat, attempt, started);
+}

package/dist/features/llm/errors.d.ts

@@ -0,0 +1,5 @@
+import { type CdxError } from "../../kernel/index.ts";
+export declare function keyMissingError(name: string): CdxError;
+export declare function keyRejectedError(status: number, keyName: string | undefined): CdxError;
+export declare function unavailableError(detail: string): CdxError;
+export declare function invalidDraftError(detail: string): CdxError;

package/dist/features/llm/errors.js

@@ -0,0 +1,18 @@
+// SPEC §4.17.4: the client-side error constructors. Every failure is a
+// CdxError with a SPEC §8 code; the key itself never appears in a message,
+// a detail or an event (SPEC §4.17.3, §9.2).
+import { makeError } from "../../kernel/index.js";
+export function keyMissingError(name) {
+    return makeError("CDX-E852", `LLM API key is not set: environment variable ${name} is unset`, `Export ${name} with the provider key, then retry. The key is read at call time and never stored.`);
+}
+export function keyRejectedError(status, keyName) {
+    return makeError("CDX-E852", `LLM provider rejected the API key (status ${String(status)})`, keyName === undefined
+        ? "Check the provider key the local runtime expects, then retry."
+        : `Check the value of ${keyName} (the value itself is never logged), then retry.`);
+}
+export function unavailableError(detail) {
+    return makeError("CDX-E854", `LLM provider is unavailable: ${detail}`, "Retry the request; after repeated failures check the provider status and the generator falls back to --template.", detail);
+}
+export function invalidDraftError(detail) {
+    return makeError("CDX-E853", `LLM draft is not valid JSON: ${detail}`, "Retry the request; the generator runs one repair round on invalid drafts.");
+}

package/dist/features/llm/index.d.ts

@@ -0,0 +1,23 @@
+import { type Clock, type Env, type Net, type Result } from "../../kernel/index.ts";
+export { isRetryableStatus, LLM_MAX_ATTEMPTS, LLM_RETRY_DELAYS_MS, } from "./attempt.ts";
+export type { LlmFormat, LlmPresetId } from "./presets.ts";
+export { DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_PRESET_ID, DEFAULT_TIMEOUT_MS, LLM_PRESETS, narrowLlmConfig, } from "./presets.ts";
+export interface CompletionRequest {
+    readonly model: string;
+    readonly prompt: string;
+    readonly maxOutputTokens: number;
+}
+export interface CompletionResponse {
+    readonly text: string;
+    readonly stopReason: string;
+}
+export interface LlmClient {
+    readonly complete: (req: CompletionRequest) => Promise<Result<CompletionResponse>>;
+}
+export interface LlmPorts {
+    readonly net: Net;
+    readonly env: Env;
+    readonly clock: Clock;
+    readonly sleep?: (ms: number) => Promise<void>;
+}
+export declare function createClient(config: unknown, ports: LlmPorts): LlmClient;

package/dist/features/llm/index.js

@@ -0,0 +1,46 @@
+// SPEC §4.17: provider-agnostic completion client. Only generator and cli
+// may import this module (§3.3 hard boundary); no enforcement path does.
+import { err, } from "../../kernel/index.js";
+import { resolveKey, runAttempt } from "./attempt.js";
+import { narrowLlmConfig } from "./presets.js";
+export { isRetryableStatus, LLM_MAX_ATTEMPTS, LLM_RETRY_DELAYS_MS, } from "./attempt.js";
+export { DEFAULT_MAX_OUTPUT_TOKENS, DEFAULT_PRESET_ID, DEFAULT_TIMEOUT_MS, LLM_PRESETS, narrowLlmConfig, } from "./presets.js";
+// The retry loop lives outside the factory so neither function trips the
+// size guard; narrowing still happens once at construction.
+async function runComplete(narrowed, ports, req) {
+    if (!narrowed.ok) {
+        return err(narrowed.error);
+    }
+    const active = narrowed.value;
+    // SPEC §4.17.3: the key is read from the environment at call time,
+    // never logged, cached or written.
+    const keyed = resolveKey(ports.env, active.apiKeyEnv);
+    if (!keyed.ok) {
+        return err(keyed.error);
+    }
+    const started = ports.clock.now();
+    let withResponseFormat = active.format === "openai-chat";
+    for (let attempt = 0;; attempt += 1) {
+        const next = await runAttempt(ports, active, req, keyed.value, withResponseFormat, attempt, started);
+        if (next.kind === "return") {
+            return next.result;
+        }
+        if (next.kind === "strip-format") {
+            withResponseFormat = false;
+            continue;
+        }
+        if (ports.sleep !== undefined) {
+            await ports.sleep(next.delayMs);
+        }
+    }
+}
+// SPEC §4.17.2: the client returns Result<{ text, usage? }>; it never throws.
+export function createClient(config, ports) {
+    // Narrow once at construction; a shape violation fails closed on every
+    // call instead of throwing from the factory.
+    const narrowed = narrowLlmConfig(config);
+    async function complete(req) {
+        return runComplete(narrowed, ports, req);
+    }
+    return { complete };
+}

package/dist/features/llm/presets.d.ts

@@ -0,0 +1,25 @@
+import { type Result } from "../../kernel/index.ts";
+export type LlmFormat = "openai-chat" | "anthropic-messages";
+export type LlmPresetId = "meta" | "meta-messages" | "openai-compatible" | "anthropic" | "openai";
+export interface LlmPreset {
+    readonly baseUrl: string;
+    readonly format: LlmFormat;
+    readonly model: string;
+    readonly apiKeyEnv?: string;
+}
+export declare const LLM_PRESETS: Record<LlmPresetId, LlmPreset>;
+export declare const DEFAULT_PRESET_ID: LlmPresetId;
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_MAX_OUTPUT_TOKENS = 1024;
+export interface LlmConfig {
+    readonly provider: LlmPresetId;
+    readonly baseUrl: string;
+    readonly format: LlmFormat;
+    readonly model: string;
+    readonly apiKeyEnv?: string;
+    readonly timeoutMs: number;
+    readonly maxOutputTokens: number;
+    readonly reasoningEffort?: string;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function narrowLlmConfig(config: unknown): Result<LlmConfig>;

package/dist/features/llm/presets.js

@@ -0,0 +1,159 @@
+// SPEC §4.17.1: the preset table and the §7.2 llm config block narrowing.
+// S24: the meta preset (model muse-spark-1.3) is the default suggestion and
+// no preset selects a -contributor variant.
+import { err, makeError, ok } from "../../kernel/index.js";
+function preset(baseUrl, format, model, apiKeyEnv) {
+    return apiKeyEnv === undefined
+        ? { baseUrl, format, model }
+        : { baseUrl, format, model, apiKeyEnv };
+}
+// SPEC §4.17.1: the preset table. openai-compatible targets a local runtime
+// (127.0.0.1 over http is allowed for it); every other preset needs https.
+export const LLM_PRESETS = {
+    meta: preset("https://api.meta.ai/v1", "openai-chat", "muse-spark-1.3", "MODEL_API_KEY"),
+    "meta-messages": preset("https://api.meta.ai/v1", "anthropic-messages", "muse-spark-1.3", "MODEL_API_KEY"),
+    "openai-compatible": preset("", "openai-chat", ""),
+    anthropic: preset("https://api.anthropic.com/v1", "anthropic-messages", "", "ANTHROPIC_API_KEY"),
+    openai: preset("https://api.openai.com/v1", "openai-chat", "", "OPENAI_API_KEY"),
+};
+export const DEFAULT_PRESET_ID = "meta";
+export const DEFAULT_TIMEOUT_MS = 30_000;
+export const DEFAULT_MAX_OUTPUT_TOKENS = 1024;
+const PRESET_IDS = [
+    "meta",
+    "meta-messages",
+    "openai-compatible",
+    "anthropic",
+    "openai",
+];
+function configError(message) {
+    return err(makeError("CDX-E106", message, "Set config.llm to a preset from SPEC §4.17.1 (provider, baseUrl, format, model, apiKeyEnv) with an https baseUrl, or point it at a 127.0.0.1 runtime."));
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Bracket access through a variable keeps noPropertyAccessFromIndexSignature
+// satisfied without tripping useLiteralKeys (deps/fields narrows the same
+// way over its own records; this module stays dependency-free).
+function configField(config, name) {
+    return config[name];
+}
+// One defaulting helper so the narrow functions below spend their branch
+// budget on validation, not on fallback plumbing.
+function fieldOr(config, name, fallback) {
+    const value = config[name];
+    return value ?? fallback;
+}
+function isPresetId(value) {
+    return typeof value === "string" && PRESET_IDS.includes(value);
+}
+function isFormat(value) {
+    return value === "openai-chat" || value === "anthropic-messages";
+}
+// SPEC §4.17.1: apiKeyEnv names an environment variable; a literal key is
+// rejected with CDX-E106 instead of being sent anywhere.
+function isEnvName(value) {
+    return typeof value === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function isLoopbackHost(host) {
+    const lowered = host.toLowerCase();
+    return (lowered === "localhost" ||
+        lowered === "::1" ||
+        lowered === "127.0.0.1" ||
+        lowered.startsWith("127."));
+}
+// SPEC §4.17.4 EC-5: http is refused on non-loopback hosts (keys over
+// plaintext); a loopback host stays allowed for local runtimes.
+function checkBaseUrl(raw) {
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        return configError(`llm baseUrl is not an absolute url: ${raw}`);
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        return configError(`llm baseUrl must be https or loopback http: ${raw}`);
+    }
+    if (parsed.protocol === "http:" && !isLoopbackHost(parsed.hostname)) {
+        return configError(`llm baseUrl uses plaintext http on a non-loopback host: ${raw}`);
+    }
+    return ok(raw);
+}
+function positiveInt(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+        ? value
+        : undefined;
+}
+function narrowEndpoint(config) {
+    const providerRaw = fieldOr(config, "provider", DEFAULT_PRESET_ID);
+    if (!isPresetId(providerRaw)) {
+        return configError(`unknown llm provider: ${String(fieldOr(config, "provider", ""))}`);
+    }
+    const defaults = LLM_PRESETS[providerRaw];
+    const baseUrlRaw = fieldOr(config, "baseUrl", defaults.baseUrl);
+    if (typeof baseUrlRaw !== "string" || baseUrlRaw === "") {
+        return configError(`llm provider ${providerRaw} needs a baseUrl`);
+    }
+    const checked = checkBaseUrl(baseUrlRaw);
+    if (!checked.ok) {
+        return err(checked.error);
+    }
+    const formatRaw = fieldOr(config, "format", defaults.format);
+    if (!isFormat(formatRaw)) {
+        return configError(`unknown llm format: ${String(formatRaw)}`);
+    }
+    const modelRaw = fieldOr(config, "model", defaults.model);
+    if (typeof modelRaw !== "string" || modelRaw === "") {
+        return configError(`llm provider ${providerRaw} needs a model`);
+    }
+    return ok({
+        provider: providerRaw,
+        baseUrl: baseUrlRaw,
+        format: formatRaw,
+        model: modelRaw,
+    });
+}
+function narrowBudgets(config, endpoint) {
+    const fallbackKey = LLM_PRESETS[endpoint.provider].apiKeyEnv;
+    const apiKeyEnvRaw = fieldOr(config, "apiKeyEnv", fallbackKey);
+    if (apiKeyEnvRaw !== undefined && !isEnvName(apiKeyEnvRaw)) {
+        return configError("llm apiKeyEnv must name an environment variable");
+    }
+    const timeoutRaw = fieldOr(config, "timeoutMs", DEFAULT_TIMEOUT_MS);
+    const timeoutMs = positiveInt(timeoutRaw);
+    if (timeoutMs === undefined) {
+        return configError("llm timeoutMs must be a positive integer");
+    }
+    const tokensRaw = fieldOr(config, "maxOutputTokens", DEFAULT_MAX_OUTPUT_TOKENS);
+    const maxOutputTokens = positiveInt(tokensRaw);
+    if (maxOutputTokens === undefined) {
+        return configError("llm maxOutputTokens must be a positive integer");
+    }
+    const reasoningRaw = configField(config, "reasoningEffort");
+    if (reasoningRaw !== undefined && typeof reasoningRaw !== "string") {
+        return configError("llm reasoningEffort must be a string");
+    }
+    const narrowed = {
+        provider: endpoint.provider,
+        baseUrl: endpoint.baseUrl,
+        format: endpoint.format,
+        model: endpoint.model,
+        timeoutMs,
+        maxOutputTokens,
+        ...(apiKeyEnvRaw === undefined ? {} : { apiKeyEnv: apiKeyEnvRaw }),
+    };
+    return reasoningRaw === undefined
+        ? ok(narrowed)
+        : ok({ ...narrowed, reasoningEffort: reasoningRaw });
+}
+export function narrowLlmConfig(config) {
+    if (!isRecord(config)) {
+        return configError("llm config must be an object");
+    }
+    const endpoint = narrowEndpoint(config);
+    if (!endpoint.ok) {
+        return err(endpoint.error);
+    }
+    return narrowBudgets(config, endpoint.value);
+}

package/dist/features/llm/wire.d.ts

@@ -0,0 +1,17 @@
+import type { LlmConfig } from "./presets.ts";
+export interface WireRequest {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+export interface WireText {
+    readonly text: string;
+    readonly stopReason: string;
+    readonly truncated: boolean;
+}
+export declare const ANTHROPIC_VERSION = "2023-06-01";
+export declare function buildOpenaiChatRequest(config: LlmConfig, model: string, prompt: string, maxTokens: number, key: string | undefined, withResponseFormat: boolean): WireRequest;
+export declare function buildAnthropicRequest(config: LlmConfig, model: string, prompt: string, maxTokens: number, key: string | undefined): WireRequest;
+export declare function buildWireRequest(config: LlmConfig, model: string, prompt: string, maxTokens: number, key: string | undefined, withResponseFormat: boolean): WireRequest;
+export declare function readWireText(format: LlmConfig["format"], body: string): WireText | undefined;