@giovannijecha/jecode 0.1.5-rc.2

package/dist/providers/anthropic.js

@@ -0,0 +1,77 @@
+// Anthropic Messages API, spoken directly.
+//
+// Wire contract (verified 2026-08-29): POST /v1/messages, auth via the
+// `x-api-key` header plus `anthropic-version`. Thinking is adaptive — the
+// `budget_tokens` form is rejected with a 400 on current models — and depth is
+// steered by `output_config.effort` instead. `display: "summarized"` is set on
+// purpose: the default omits the reasoning text, which on a screen reads as a
+// long silence before anything appears.
+import { postSse } from "./http.js";
+import { listModels } from "./catalog.js";
+import { keyFor } from "../credentials.js";
+import { assembleAnthropic } from "./anthropic-stream.js";
+import { fromWireResponse, stopNotice, toWireMessage, toWireTool } from "./anthropic-wire.js";
+const ENDPOINT = "https://api.anthropic.com/v1/messages";
+const MODELS = "https://api.anthropic.com/v1/models?limit=100";
+const API_VERSION = "2023-06-01";
+const KEY = "ANTHROPIC_API_KEY";
+// Adaptive thinking and `output_config.effort` exist on the 4.6-and-later
+// families only. Older models reject both with a 400, so `/model claude-haiku-4-5`
+// would fail on send if the request shape were fixed. It follows the model.
+const ADAPTIVE = /^claude-(fable-5|opus-(5|4-[678])|sonnet-(5|4-6))/;
+export function supportsAdaptiveThinking(model) {
+    return ADAPTIVE.test(model);
+}
+export const anthropic = {
+    id: "anthropic",
+    // Sonnet is the default because it is the one that can be left running.
+    // Opus via `--model claude-opus-5`, Haiku via `--model claude-haiku-4-5`.
+    defaultModel: "claude-sonnet-5",
+    keyVar: KEY,
+    blocked() {
+        return apiKey() === undefined ? `${KEY} is not set` : undefined;
+    },
+    // Newest first is how the endpoint already answers, so the order is left
+    // exactly as it arrives rather than re-sorted into something less useful.
+    models(signal, onStatus) {
+        return listModels(MODELS, headers(requireKey()), signal, onStatus);
+    },
+    location: () => "cloud",
+    async send(req) {
+        const key = requireKey();
+        const body = {
+            model: req.model,
+            max_tokens: req.maxTokens,
+            system: req.system,
+            messages: req.messages.map(toWireMessage),
+            tools: req.tools.map(toWireTool),
+            stream: true,
+        };
+        if (supportsAdaptiveThinking(req.model)) {
+            body["thinking"] = { type: "adaptive", display: "summarized" };
+            body["output_config"] = { effort: req.effort };
+        }
+        const events = await postSse(ENDPOINT, headers(key), body, req.signal, req.onStatus);
+        const data = await assembleAnthropic(events, req.onStream);
+        // A refusal or a truncation never arrives as streamed text, so it has to
+        // be announced separately or the user watches the turn end in silence.
+        const notice = stopNotice(data);
+        if (notice !== undefined)
+            req.onStream?.({ kind: "text", text: `\n${notice}` });
+        return fromWireResponse(data);
+    },
+};
+// Read at the moment it is used, never captured at import: a key typed into
+// the running window has to count, and so does one exported after startup.
+function apiKey() {
+    return keyFor(KEY);
+}
+function requireKey() {
+    const key = apiKey();
+    if (key === undefined)
+        throw new Error(`${KEY} is not set`);
+    return key;
+}
+function headers(key) {
+    return { "x-api-key": key, "anthropic-version": API_VERSION };
+}

package/dist/providers/catalog.js

@@ -0,0 +1,37 @@
+// Asking a provider what it will answer to.
+//
+// Nothing here is a list of models. A catalogue written into this repo is
+// wrong the week after it is written, and wrong in the worst way — it names
+// models that no longer exist and hides the ones that do. So the question goes
+// to the provider, every time the user opens the menu.
+//
+// All three happen to answer the same GET at `/v1/models` with the same shape,
+// `{ data: [{ id }] }`, so the asking is written once and a provider supplies
+// only its URL and its headers.
+import { getJson } from "./http.js";
+export const MAX_MODEL_CATALOG_ENTRIES = 1_000;
+export const MAX_MODEL_CATALOG_ITEMS = 4_000;
+export const MAX_MODEL_ID_CHARS = 256;
+export async function listModels(url, headers, signal, onStatus) {
+    const body = await getJson(url, headers, signal, onStatus);
+    const data = body.data;
+    if (!Array.isArray(data))
+        throw new Error(`${url} did not return a model list`);
+    const models = [];
+    const unique = new Set();
+    const inspected = Math.min(data.length, MAX_MODEL_CATALOG_ITEMS);
+    for (let index = 0; index < inspected && models.length < MAX_MODEL_CATALOG_ENTRIES; index++) {
+        const entry = data[index];
+        const id = typeof entry === "object" && entry !== null
+            ? entry.id
+            : undefined;
+        if (typeof id !== "string" ||
+            id === "" ||
+            id.length > MAX_MODEL_ID_CHARS ||
+            unique.has(id))
+            continue;
+        unique.add(id);
+        models.push(id);
+    }
+    return models;
+}

package/dist/providers/http.js

@@ -0,0 +1,219 @@
+// The entire HTTP layer: one bounded request, then either a JSON body or an
+// event stream. Only idempotent reads retry. Once a POST starts or response
+// bytes flow, a failure is surfaced rather than silently replayed.
+import { readSseJson } from "./sse.js";
+const RETRYABLE = new Set([408, 409, 429, 500, 502, 503, 504]);
+const MAX_JSON_CHARS = 5_000_000;
+const MAX_ERROR_CHARS = 2_000;
+const HANDSHAKE_TIMEOUT_MS = 60_000;
+const BODY_IDLE_TIMEOUT_MS = 120_000;
+const GET_RETRIES = 3;
+function httpError(message, status, body) {
+    const error = new Error(message);
+    error.status = status;
+    error.body = body;
+    return error;
+}
+export async function postJson(url, headers, body, signal, onStatus) {
+    return asJson(url, await request(url, headers, body, signal, onStatus));
+}
+/** A plain read. The only thing jecode asks for without sending anything. */
+export async function getJson(url, headers, signal, onStatus) {
+    return asJson(url, await request(url, headers, undefined, signal, onStatus));
+}
+async function asJson(url, res) {
+    const { text, truncated } = await boundedText(url, res, MAX_JSON_CHARS);
+    if (truncated) {
+        throw httpError(`${url} returned JSON over ${MAX_JSON_CHARS} characters`, res.status, text);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw httpError(`${url} returned non-JSON`, res.status, text.slice(0, 500));
+    }
+}
+export async function postSse(url, headers, body, signal, onStatus) {
+    const res = await request(url, { accept: "text/event-stream", ...headers }, body, signal, onStatus);
+    if (res.body === null)
+        throw httpError(`${url} returned no body`, res.status);
+    return readSseJson(withIdleTimeout(url, res.body));
+}
+async function request(url, headers, body, signal, onStatus) {
+    const maxRetries = body === undefined ? GET_RETRIES : 0;
+    let lastError;
+    let waitMs = 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        if (waitMs > 0)
+            await sleep(waitMs, signal);
+        let res;
+        const handshake = handshakeSignal(url, signal);
+        try {
+            // No body, no method: a request with nothing to send is a read, and
+            // saying so is what keeps the retry and error handling in one place.
+            res = await fetch(url, {
+                method: body === undefined ? "GET" : "POST",
+                headers: body === undefined ? headers : { "content-type": "application/json", ...headers },
+                ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+                redirect: "manual",
+                signal: handshake.signal,
+            });
+        }
+        catch (cause) {
+            const timeout = handshake.timeout();
+            if (timeout !== undefined)
+                throw timeout;
+            if (signal?.aborted === true)
+                throw cause;
+            const detail = cause instanceof Error ? cause.message : String(cause);
+            lastError = httpError(`network error calling ${url}: ${detail}`);
+            waitMs = backoff(attempt);
+            if (attempt < maxRetries)
+                onStatus?.(`Network error · retrying in ${waitLabel(waitMs)}`);
+            continue;
+        }
+        finally {
+            handshake.clear();
+        }
+        if (res.status >= 300 && res.status < 400) {
+            await res.body?.cancel().catch(() => undefined);
+            throw httpError(`${url} -> ${res.status} redirect rejected`, res.status);
+        }
+        if (res.ok)
+            return res;
+        const { text } = await boundedText(url, res, MAX_ERROR_CHARS);
+        lastError = httpError(`${url} -> ${res.status} ${res.statusText}`, res.status, text);
+        if (!RETRYABLE.has(res.status))
+            throw lastError;
+        waitMs = retryAfter(res) ?? backoff(attempt);
+        if (attempt < maxRetries) {
+            const reason = res.status === 429 ? "Rate limited" : `HTTP ${res.status}`;
+            onStatus?.(`${reason} · retrying in ${waitLabel(waitMs)}`);
+        }
+    }
+    throw lastError ?? httpError(`${url} failed`);
+}
+async function boundedText(url, res, max) {
+    if (res.body === null)
+        return { text: "", truncated: false };
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    try {
+        while (true) {
+            const { done, value } = await timedRead(url, reader);
+            if (done) {
+                text += decoder.decode();
+                return text.length > max
+                    ? { text: text.slice(0, max), truncated: true }
+                    : { text, truncated: false };
+            }
+            text += decoder.decode(value, { stream: true });
+            if (text.length > max) {
+                await reader.cancel().catch(() => undefined);
+                return { text: text.slice(0, max), truncated: true };
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function handshakeSignal(url, signal) {
+    const controller = new AbortController();
+    let timeout;
+    const timer = setTimeout(() => {
+        timeout = httpError(`${url} timed out waiting for response headers after ${HANDSHAKE_TIMEOUT_MS}ms`);
+        controller.abort(timeout);
+    }, HANDSHAKE_TIMEOUT_MS);
+    return {
+        signal: signal === undefined ? controller.signal : AbortSignal.any([signal, controller.signal]),
+        timeout: () => timeout,
+        clear: () => clearTimeout(timer),
+    };
+}
+async function timedRead(url, reader) {
+    const timeout = httpError(`${url} response body was idle for ${BODY_IDLE_TIMEOUT_MS}ms`);
+    let timer;
+    const expired = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(timeout), BODY_IDLE_TIMEOUT_MS);
+    });
+    try {
+        return await Promise.race([reader.read(), expired]);
+    }
+    catch (error) {
+        if (error === timeout)
+            await reader.cancel(timeout).catch(() => undefined);
+        throw error;
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function withIdleTimeout(url, body) {
+    const reader = body.getReader();
+    let released = false;
+    const release = () => {
+        if (released)
+            return;
+        released = true;
+        reader.releaseLock();
+    };
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await timedRead(url, reader);
+                if (done) {
+                    release();
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                await reader.cancel(error).catch(() => undefined);
+                release();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            await reader.cancel(reason).catch(() => undefined);
+            release();
+        },
+    });
+}
+function waitLabel(ms) {
+    return ms < 1_000 ? `${ms}ms` : `${Math.ceil(ms / 1_000)}s`;
+}
+function backoff(attempt) {
+    return Math.min(30_000, 1_000 * 2 ** attempt);
+}
+function retryAfter(res) {
+    const header = res.headers.get("retry-after");
+    if (header === null)
+        return undefined;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return Math.min(60_000, seconds * 1_000);
+    const at = Date.parse(header);
+    return Number.isNaN(at) ? undefined : Math.max(0, Math.min(60_000, at - Date.now()));
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted === true) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/providers/index.js

@@ -0,0 +1,18 @@
+import { anthropic } from "./anthropic.js";
+import { openai } from "./openai.js";
+import { configureOllama, ollama } from "./ollama.js";
+export const PROVIDERS = [anthropic, openai, ollama];
+export function providerNames() {
+    return PROVIDERS.map((provider) => provider.id);
+}
+export function selectProvider(id) {
+    const found = PROVIDERS.find((provider) => provider.id === id);
+    if (found === undefined) {
+        throw new Error(`unknown provider "${id}" (available: ${providerNames().join(", ")})`);
+    }
+    return found;
+}
+/** Apply provider-specific process state after startup precedence is resolved. */
+export function configureProviders(config) {
+    configureOllama(config.ollamaHost);
+}

package/dist/providers/ollama-endpoint.js

@@ -0,0 +1,40 @@
+// Turning an Ollama host into one safe, normalized endpoint.
+export const OLLAMA_LOCAL_HOST = "http://127.0.0.1:11434";
+export const OLLAMA_CLOUD_HOST = "https://ollama.com";
+export function parseOllamaEndpoint(value) {
+    let url;
+    try {
+        url = new URL(value.trim());
+    }
+    catch {
+        throw new Error("Ollama endpoint must be an absolute HTTP(S) URL");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("Ollama endpoint must use HTTP or HTTPS");
+    }
+    if (url.username !== "" || url.password !== "") {
+        throw new Error("Ollama endpoint must not contain credentials");
+    }
+    if (url.search !== "" || url.hash !== "") {
+        throw new Error("Ollama endpoint must not contain a query or fragment");
+    }
+    const loopback = isExactLoopback(url.hostname);
+    if (url.protocol === "http:" && !loopback) {
+        throw new Error("Ollama endpoint must use HTTPS unless it is an exact loopback address");
+    }
+    const pathname = url.pathname.replace(/\/+$/, "");
+    return {
+        baseUrl: `${url.origin}${pathname === "" ? "" : pathname}`,
+        loopback,
+    };
+}
+export function ollamaConnectionKind(endpoint) {
+    if (endpoint.baseUrl === OLLAMA_CLOUD_HOST)
+        return "cloud";
+    if (endpoint.baseUrl === OLLAMA_LOCAL_HOST)
+        return "local";
+    return "custom";
+}
+function isExactLoopback(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}

package/dist/providers/ollama-stream.js

@@ -0,0 +1,60 @@
+// Reassembling a Chat Completions reply from its event stream.
+//
+// Nothing arrives finished here: text accumulates, and each tool call is
+// spread across chunks keyed by `index` — id and name usually in the first,
+// arguments as JSON fragments after it.
+import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
+export async function assembleOllama(events, onStream) {
+    const calls = new Map();
+    let toolArgumentChars = 0;
+    let content = "";
+    let finishReason;
+    let usage;
+    for await (const raw of events) {
+        const event = raw;
+        if (event.error !== undefined) {
+            const message = typeof event.error === "string" ? event.error : event.error.message;
+            throw new Error(`ollama stream error: ${message ?? "unspecified"}`);
+        }
+        if (event.usage !== undefined)
+            usage = event.usage;
+        const choice = event.choices?.[0];
+        if (choice === undefined)
+            continue;
+        if (typeof choice.finish_reason === "string")
+            finishReason = choice.finish_reason;
+        const delta = choice.delta;
+        if (delta === undefined)
+            continue;
+        // Reasoning has no standardized field name across the models Ollama
+        // serves, so both spellings in circulation are accepted.
+        const reasoning = delta.reasoning ?? delta.reasoning_content;
+        if (typeof reasoning === "string" && reasoning !== "") {
+            onStream?.({ kind: "thinking", text: reasoning });
+        }
+        if (typeof delta.content === "string" && delta.content !== "") {
+            content += delta.content;
+            onStream?.({ kind: "text", text: delta.content });
+        }
+        for (const part of delta.tool_calls ?? []) {
+            const index = typeof part.index === "number" ? part.index : 0;
+            const call = calls.get(index) ?? { id: "", name: "", args: "" };
+            if (typeof part.id === "string" && part.id !== "")
+                call.id = part.id;
+            if (typeof part.function?.name === "string" && part.function.name !== "") {
+                call.name = part.function.name;
+            }
+            if (typeof part.function?.arguments === "string") {
+                toolArgumentChars = addBounded(toolArgumentChars, part.function.arguments.length, MAX_TOOL_ARGUMENT_CHARS, "streamed tool arguments");
+                call.args += part.function.arguments;
+            }
+            calls.set(index, call);
+        }
+    }
+    const toolCalls = [...calls.entries()]
+        .sort(([a], [b]) => a - b)
+        // Not every server sends an id, and the loop needs one to pair the result
+        // back to its call.
+        .map(([index, call]) => (call.id === "" ? { ...call, id: `call_${index}` } : call));
+    return { content, toolCalls, finishReason, usage };
+}

package/dist/providers/ollama-wire.js

@@ -0,0 +1,95 @@
+// Translation between the normalized vocabulary and the OpenAI-compatible
+// Chat Completions shape Ollama serves at /v1/chat/completions.
+//
+// This is a third wire format rather than a reuse of the OpenAI provider, and
+// the reason is worth stating: Ollama does not implement the Responses API.
+// Chat Completions differs on two points that matter here — a tool result is a
+// message of its own with role "tool", not a block inside a user turn, and tool
+// arguments travel as a JSON string rather than an object.
+export function toWireTool(tool) {
+    return {
+        type: "function",
+        function: { name: tool.name, description: tool.description, parameters: tool.input },
+    };
+}
+// Flattens the history: one normalized message can become several wire
+// messages, because every tool result is its own turn.
+export function toWireMessages(system, messages) {
+    const wire = [];
+    if (system !== "")
+        wire.push({ role: "system", content: system });
+    for (const message of messages) {
+        const texts = [];
+        const toolCalls = [];
+        for (const block of message.content) {
+            if (block.kind === "text") {
+                texts.push(block.text);
+            }
+            else if (block.kind === "tool_call") {
+                toolCalls.push({
+                    id: block.id,
+                    type: "function",
+                    function: { name: block.name, arguments: JSON.stringify(block.input) },
+                });
+            }
+            else {
+                wire.push({ role: "tool", tool_call_id: block.id, content: block.output });
+            }
+        }
+        if (message.role === "assistant") {
+            if (texts.length === 0 && toolCalls.length === 0)
+                continue;
+            const turn = { role: "assistant", content: texts.join("\n") };
+            // An empty tool_calls array is not the same as no tool_calls to every
+            // server, so the key is omitted rather than sent empty.
+            if (toolCalls.length > 0)
+                turn["tool_calls"] = toolCalls;
+            wire.push(turn);
+        }
+        else if (texts.length > 0) {
+            wire.push({ role: "user", content: texts.join("\n") });
+        }
+    }
+    return wire;
+}
+export function fromWireReply(reply) {
+    const content = [];
+    if (reply.content !== "")
+        content.push({ kind: "text", text: reply.content });
+    for (const call of reply.toolCalls) {
+        content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+    }
+    // No `raw`: unlike the other two providers, nothing in this shape has to be
+    // echoed back verbatim, so the normalized blocks are the whole message.
+    return { role: "assistant", content, usage: normalizeUsage(reply) };
+}
+function normalizeUsage(reply) {
+    if (reply.usage === undefined)
+        return undefined;
+    return {
+        inputTokens: reply.usage.prompt_tokens ?? 0,
+        outputTokens: reply.usage.completion_tokens ?? 0,
+        cachedInputTokens: 0,
+        cacheWriteInputTokens: 0,
+        reasoningTokens: 0,
+    };
+}
+export function stopNotice(reply) {
+    return reply.finishReason === "length"
+        ? "[truncated: hit the output limit — raise --max-tokens]"
+        : undefined;
+}
+// A model that emits malformed JSON gets the empty object, which fails
+// validation in tools/args.ts with a message written for it to read. That is a
+// recoverable turn; throwing here would end the whole thing instead.
+function parseArgs(args) {
+    if (args.trim() === "")
+        return {};
+    try {
+        const parsed = JSON.parse(args);
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/providers/ollama.js

@@ -0,0 +1,87 @@
+// Ollama, spoken through its OpenAI-compatible Chat Completions endpoint.
+//
+// One provider covers both deployments. An explicit session endpoint wins;
+// otherwise a configured key selects Ollama Cloud and no key selects the local
+// daemon. There is no default model — the catalogue is whatever the host has
+// pulled or the subscription grants — so the model has to be named with
+// --model.
+import { postSse } from "./http.js";
+import { listModels } from "./catalog.js";
+import { keyFor } from "../credentials.js";
+import { assembleOllama } from "./ollama-stream.js";
+import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
+import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
+const KEY = "OLLAMA_API_KEY";
+let configuredHost;
+/** Set the endpoint selected for this process. Undefined restores key-aware inference. */
+export function configureOllama(host) {
+    configuredHost = host === undefined ? undefined : parseOllamaEndpoint(host).baseUrl;
+}
+export function ollamaConnection() {
+    const inferred = configuredHost === undefined;
+    const endpoint = parseOllamaEndpoint(configuredHost ?? (apiKey() === undefined ? OLLAMA_LOCAL_HOST : OLLAMA_CLOUD_HOST));
+    return { ...endpoint, kind: ollamaConnectionKind(endpoint), inferred };
+}
+export const ollama = {
+    id: "ollama",
+    defaultModel: "",
+    keyVar: KEY,
+    // The only provider whose key is conditional: a daemon on this machine is
+    // reached over loopback and asks for nothing, so demanding a key there
+    // would be an invented requirement.
+    blocked() {
+        try {
+            const at = endpoint();
+            if (apiKey() !== undefined || at.loopback)
+                return undefined;
+            return `${KEY} is not set (required by ${at.baseUrl})`;
+        }
+        catch (error) {
+            return error.message;
+        }
+    },
+    // Whatever the daemon has pulled, or whatever the subscription grants.
+    models(signal, onStatus) {
+        const at = endpoint();
+        return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
+    },
+    location: () => {
+        try {
+            return endpoint().loopback ? "local" : "cloud";
+        }
+        catch {
+            return "cloud";
+        }
+    },
+    async send(req) {
+        const at = endpoint();
+        // `effort` has no equivalent in this shape and is dropped rather than
+        // guessed at — depth on these models is a property of the model chosen.
+        const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
+            model: req.model,
+            messages: toWireMessages(req.system, req.messages),
+            tools: req.tools.map(toWireTool),
+            max_tokens: req.maxTokens,
+            stream: true,
+        }, req.signal, req.onStatus);
+        const reply = await assembleOllama(events, req.onStream);
+        const notice = stopNotice(reply);
+        if (notice !== undefined)
+            req.onStream?.({ kind: "text", text: `\n${notice}` });
+        return fromWireReply(reply);
+    },
+};
+function endpoint() {
+    return ollamaConnection();
+}
+function apiKey() {
+    return keyFor(KEY);
+}
+function headers(at) {
+    if (at.loopback)
+        return {};
+    const key = apiKey();
+    if (key !== undefined)
+        return { authorization: `Bearer ${key}` };
+    throw new Error(`${KEY} is not set (required by ${at.baseUrl})`);
+}