akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/workflows/ir/schema.js

@@ -1,30 +1,11 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import path from "node:path";
 import { isContainedRelativePath } from "../../core/common.js";
 import { UsageError } from "../../core/errors.js";
-import { formatExtraParamsIssue, validateExtraParams } from "../../core/extra-params.js";
-import { HARNESS_BY_ID } from "../../integrations/harnesses/index.js";
 import { parseReference } from "../program/expressions.js";
 import { PROGRAM_PARAM_NAME_PATTERN, PROGRAM_RETRY_REASONS, PROGRAM_STEP_ID_PATTERN } from "../program/schema.js";
-import { jsonBytes, utf8Bytes, WORKFLOW_ENGINE_NAME_PATTERN, WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_ENGINE_NAME_LENGTH, WORKFLOW_MAX_ENGINES, WORKFLOW_MAX_EXEC_ARG_BYTES, WORKFLOW_MAX_EXEC_ARGV, WORKFLOW_MAX_EXEC_CWD_LENGTH, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_EXTRA_PARAMS_BYTES, WORKFLOW_MAX_GATE_LOOPS, WORKFLOW_MAX_INPUTS, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_JSON_DEPTH, WORKFLOW_MAX_MAP_EXPANSION, WORKFLOW_MAX_PARAMS, WORKFLOW_MAX_PLAN_BYTES, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_ROUTE_BRANCHES, WORKFLOW_MAX_SCHEMA_BYTES, WORKFLOW_MAX_STEPS, WORKFLOW_MAX_TIMEOUT_MS, } from "../resource-limits.js";
-/** The only executable persisted workflow plan format. */
-export const WORKFLOW_IR_VERSION = 3;
-/**
- * The {@link IrRuntimeKind} a frozen engine dispatches as — the value journaled
- * in `workflow_run_units.runner` and read back by `status --units`.
- *
- * Lives here, beside the union, because the mapping is a property OF the union:
- * spelled at each call site instead, a kind added to `FrozenEngineSnapshot`
- * would type-check against whichever site happens to end with a default and be
- * silently mis-journaled. Callers supply their own answer for the ABSENCE of an
- * engine, which genuinely differs — a unit without one is an `exec` unit, while
- * a gate without one is an llm judge.
- */
-export function engineRuntimeKind(engine) {
-    return engine.kind === "llm" ? "llm" : engine.runnerKind;
-}
+import { jsonBytes, utf8Bytes, WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_EXEC_ARG_BYTES, WORKFLOW_MAX_EXEC_ARGV, WORKFLOW_MAX_EXEC_CWD_LENGTH, WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_GATE_LOOPS, WORKFLOW_MAX_INPUTS, WORKFLOW_MAX_INSTRUCTION_BYTES, WORKFLOW_MAX_JSON_DEPTH, WORKFLOW_MAX_MAP_EXPANSION, WORKFLOW_MAX_PARAMS, WORKFLOW_MAX_PLAN_BYTES, WORKFLOW_MAX_RETRIES, WORKFLOW_MAX_ROUTE_BRANCHES, WORKFLOW_MAX_SCHEMA_BYTES, WORKFLOW_MAX_STEPS, WORKFLOW_MAX_TIMEOUT_MS, } from "../resource-limits.js";
 // Shared dispatch-significant bounds now live in `../resource-limits` so the
 // parser, the published JSON Schema, and this decoder enforce identical
 // values. Re-exported here for existing importers (e.g. `commands/workflow-cli.ts`).
@@ -32,16 +13,16 @@ export { WORKFLOW_MAX_CONCURRENCY, WORKFLOW_MAX_GATE_LOOPS, WORKFLOW_MAX_RETRIES
 export const WORKFLOW_MAX_UNITS = WORKFLOW_MAX_MAP_EXPANSION;
 const MAX_LIST_ITEMS = 1024;
 const MAX_STRING_LENGTH = 1_000_000;
-const ENGINE_NAME_PATTERN = WORKFLOW_ENGINE_NAME_PATTERN;
-/** Strictly decode persisted v3 data before it can drive a workflow. */
-export function decodeWorkflowPlanV3(input, hooks = {}) {
-    if (!isRecord(input) || input.irVersion !== WORKFLOW_IR_VERSION)
-        fail("irVersion must be 3");
+/** Validate the current durable execution graph. */
+export function validateWorkflowPlanStructure(input, options, hooks = {}) {
+    if (!isRecord(input) || input.irVersion !== options.expectedVersion) {
+        fail(`irVersion must be ${options.expectedVersion}`);
+    }
     assertJson(input);
     if (jsonBytes(input) > WORKFLOW_MAX_PLAN_BYTES)
         fail("plan exceeds the 2 MiB resource limit");
     const plan = input;
-    assertKeys(input, ["irVersion", "title", "params", "paramSchemas", "budget", "execution", "steps"], "plan");
+    assertKeys(input, ["irVersion", "title", "params", "paramSchemas", "budget", "execution", "steps", ...(options.planExtraKeys ?? [])], "plan");
     assertString(plan.title, "title");
     validateParams(plan.params, plan.paramSchemas);
     validateBudget(plan.budget);
@@ -51,15 +32,7 @@ export function decodeWorkflowPlanV3(input, hooks = {}) {
         plan.execution.maxConcurrency > WORKFLOW_MAX_CONCURRENCY) {
         fail(`execution.maxConcurrency must be an integer from 1 through ${WORKFLOW_MAX_CONCURRENCY}`);
     }
-    assertKeys(plan.execution, ["maxConcurrency", "engines"], "execution");
-    if (!isRecord(plan.execution.engines))
-        fail("execution.engines must be an object");
-    const engines = plan.execution.engines;
-    if (Object.keys(engines).length > WORKFLOW_MAX_ENGINES)
-        fail(`execution.engines exceeds ${WORKFLOW_MAX_ENGINES} entries`);
-    const references = new Set();
-    for (const [key, engine] of Object.entries(engines))
-        validateEngine(key, engine, references, hooks);
+    assertKeys(plan.execution, ["maxConcurrency"], "execution");
     if (!Array.isArray(plan.steps) || plan.steps.length === 0 || plan.steps.length > WORKFLOW_MAX_STEPS)
         fail("steps must contain 1 through 256 entries");
     const stepIds = new Set();
@@ -81,10 +54,10 @@ export function decodeWorkflowPlanV3(input, hooks = {}) {
         if (step.outputSchema !== undefined)
             validateSchema(step.outputSchema, `step ${step.stepId} outputSchema`);
         if (step.root)
-            validateNode(step.root, step.stepId, references, nodeIds, hooks);
+            validateNode(step.root, step.stepId, nodeIds, options.unitExtraKeys ?? []);
         if (step.route)
             validateRoute(step.route, step.stepId);
-        validateGate(step.gate, step.stepId, references, nodeIds, hooks);
+        validateGate(step.gate, step.stepId, nodeIds, options.gateExtraKeys ?? []);
     }
     const stepIndex = new Map(plan.steps.map((step, index) => [step.stepId, index]));
     for (const [index, step] of plan.steps.entries()) {
@@ -99,136 +72,8 @@ export function decodeWorkflowPlanV3(input, hooks = {}) {
         }
         validateStepExpressions(step, index, stepIndex);
     }
-    for (const name of references) {
-        if (!engines[name])
-            fail(`engine reference ${name} is not in execution.engines`);
-    }
-    for (const name of Object.keys(engines))
-        if (!references.has(name))
-            fail(`engine ${name} is not referenced`);
-    for (const engine of Object.values(engines)) {
-        if (engine.kind !== "agent")
-            continue;
-        if (engine.fallbackLlmEngine !== null && engines[engine.fallbackLlmEngine]?.kind !== "llm")
-            fail(`SDK engine ${engine.name} fallback must name an LLM engine`);
-    }
-    for (const step of plan.steps) {
-        if (step.root)
-            assertUnitEngineCompatibility(step.root, engines);
-        if (step.gate.judge) {
-            const judge = engines[step.gate.judge.engine];
-            if (!judge)
-                fail(`gate ${step.gate.id} references an unavailable engine`);
-            if (judge.kind === "llm" && step.gate.judge.model === null)
-                fail(`LLM gate ${step.gate.id} has no exact model`);
-            if (judge.kind === "agent" && step.gate.judge.llm !== undefined)
-                fail(`agent gate ${step.gate.id} cannot carry LLM invocation settings`);
-        }
-    }
-    return plan;
 }
-function validateEngine(key, engine, references, hooks) {
-    if (!ENGINE_NAME_PATTERN.test(key) ||
-        key.length > WORKFLOW_MAX_ENGINE_NAME_LENGTH ||
-        !isRecord(engine) ||
-        engine.name !== key ||
-        (engine.kind !== "llm" && engine.kind !== "agent"))
-        fail("catalog keys must equal a valid snapshot name");
-    if (engine.kind === "llm") {
-        assertKeys(engine, [
-            "name",
-            "kind",
-            "provider",
-            "endpoint",
-            "model",
-            "credential",
-            "temperature",
-            "maxTokens",
-            "concurrency",
-            "supportsJsonSchema",
-            "extraParams",
-            "contextLength",
-            "enableThinking",
-        ], `LLM engine ${key}`);
-        if (typeof engine.endpoint !== "string" ||
-            !engine.endpoint ||
-            typeof engine.model !== "string" ||
-            !engine.model ||
-            !Number.isInteger(engine.concurrency) ||
-            engine.concurrency < 1 ||
-            engine.concurrency > WORKFLOW_MAX_CONCURRENCY)
-            fail(`LLM engine ${key} is invalid`);
-        if (engine.provider !== undefined)
-            assertString(engine.provider, `LLM engine ${key} provider`);
-        validateEndpoint(engine.endpoint, key);
-        validateOptionalFiniteNumber(engine.temperature, `LLM engine ${key} temperature`);
-        validateOptionalPositiveInteger(engine.maxTokens, `LLM engine ${key} maxTokens`);
-        validateOptionalPositiveInteger(engine.contextLength, `LLM engine ${key} contextLength`);
-        if (engine.supportsJsonSchema !== undefined && typeof engine.supportsJsonSchema !== "boolean")
-            fail(`LLM engine ${key} supportsJsonSchema must be boolean`);
-        if (engine.enableThinking !== undefined && typeof engine.enableThinking !== "boolean")
-            fail(`LLM engine ${key} enableThinking must be boolean`);
-        if (engine.extraParams !== undefined) {
-            const issue = validateExtraParams(engine.extraParams)[0];
-            if (issue)
-                fail(formatExtraParamsIssue(`LLM engine ${key} extraParams`, issue));
-        }
-        validateExtraParamsValue(engine.extraParams, `LLM engine ${key} extraParams`, hooks);
-        if (engine.credential !== undefined) {
-            if (!isRecord(engine.credential) ||
-                !Array.isArray(engine.credential.names) ||
-                engine.credential.names.length === 0 ||
-                engine.credential.names.length > 32 ||
-                !engine.credential.names.every((n) => typeof n === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(n)) ||
-                new Set(engine.credential.names).size !== engine.credential.names.length ||
-                typeof engine.credential.required !== "boolean") {
-                fail(`LLM engine ${key} has an invalid credential descriptor`);
-            }
-            assertKeys(engine.credential, ["names", "required"], `LLM engine ${key} credential`);
-        }
-        return;
-    }
-    assertKeys(engine, [
-        "name",
-        "kind",
-        "runnerKind",
-        "platform",
-        "bin",
-        "args",
-        "workspace",
-        "envPassthrough",
-        "commandBuilder",
-        "fallbackLlmEngine",
-    ], `agent engine ${key}`);
-    if ((engine.runnerKind !== "agent" && engine.runnerKind !== "sdk") ||
-        typeof engine.platform !== "string" ||
-        !engine.platform ||
-        typeof engine.bin !== "string" ||
-        !engine.bin ||
-        !Array.isArray(engine.args) ||
-        engine.args.length > MAX_LIST_ITEMS ||
-        !engine.args.every((arg) => typeof arg === "string" && arg.length <= MAX_STRING_LENGTH) ||
-        !(typeof engine.workspace === "string" || engine.workspace === null) ||
-        !Array.isArray(engine.envPassthrough) ||
-        engine.envPassthrough.length > MAX_LIST_ITEMS ||
-        !engine.envPassthrough.every((name) => typeof name === "string" && WORKFLOW_ENV_VAR_NAME_PATTERN.test(name)) ||
-        new Set(engine.envPassthrough).size !== engine.envPassthrough.length ||
-        typeof engine.commandBuilder !== "string" ||
-        engine.commandBuilder !== engine.platform ||
-        (engine.workspace !== null && !path.isAbsolute(engine.workspace)) ||
-        !HARNESS_BY_ID.get(engine.platform)?.capabilities.agentDispatch)
-        fail(`agent engine ${key} is invalid`);
-    if ((engine.platform === "opencode-sdk") !== (engine.runnerKind === "sdk"))
-        fail(`agent engine ${key} has incompatible platform and runnerKind`);
-    if (engine.runnerKind === "agent" && engine.fallbackLlmEngine !== null)
-        fail(`agent engine ${key} cannot have an SDK fallback`);
-    if (engine.fallbackLlmEngine !== null) {
-        if (typeof engine.fallbackLlmEngine !== "string" || !engine.fallbackLlmEngine)
-            fail(`agent engine ${key} has an invalid fallback`);
-        references.add(engine.fallbackLlmEngine);
-    }
-}
-function validateNode(node, stepId, references, nodeIds, hooks) {
+function validateNode(node, stepId, nodeIds, unitExtraKeys) {
     if (!isRecord(node) ||
         (node.kind !== "unit" && node.kind !== "map") ||
         typeof node.id !== "string" ||
@@ -248,7 +93,7 @@ function validateNode(node, stepId, references, nodeIds, hooks) {
         if (node.id !== `${stepId}.map`)
             fail(`map ${node.id} does not match step ${stepId}`);
         validateSource(node.source, `map ${node.id} source`);
-        validateNode(node.template, stepId, references, nodeIds, hooks);
+        validateNode(node.template, stepId, nodeIds, unitExtraKeys);
         if (!isRecord(node.template) || node.template.kind !== "unit")
             fail(`map ${node.id} template must be a unit`);
         if (node.template.id !== `${stepId}.unit`)
@@ -259,20 +104,17 @@ function validateNode(node, stepId, references, nodeIds, hooks) {
         "kind",
         "id",
         "instructions",
-        "templating",
         "inputs",
-        "invocation",
-        "exec",
         "schema",
         "retry",
         "onError",
         "env",
         "isolation",
         "source",
+        ...unitExtraKeys,
     ], `unit ${node.id}`);
     if (typeof node.instructions !== "string" ||
         !node.instructions ||
-        node.templating !== "verbatim" ||
         (node.onError !== "fail" && node.onError !== "continue") ||
         (node.isolation !== "none" && node.isolation !== "worktree"))
         fail(`unit ${node.id} is invalid`);
@@ -286,17 +128,6 @@ function validateNode(node, stepId, references, nodeIds, hooks) {
     validateStringArray(node.env, `unit ${node.id} env`, MAX_LIST_ITEMS, true);
     validateStringArray(node.inputs, `unit ${node.id} inputs`, WORKFLOW_MAX_INPUTS, true);
     validateSource(node.source, `unit ${node.id} source`);
-    // Exactly one dispatch mechanism per unit. A node carrying both would let a
-    // tampered plan smuggle a shell command past the engine-compatibility checks
-    // (which key off the invocation); one carrying neither has nothing to run.
-    if ((node.invocation === undefined) === (node.exec === undefined)) {
-        fail(`unit ${node.id} must declare exactly one of invocation or exec`);
-    }
-    if (node.exec !== undefined) {
-        validateExecSpec(node.exec, `unit ${node.id} exec`);
-        return;
-    }
-    validateInvocation(node.invocation, references, hooks);
 }
 /**
  * Strictly decode a frozen {@link IrExecSpec}. This is the corruption gate for
@@ -307,7 +138,7 @@ function validateNode(node, stepId, references, nodeIds, hooks) {
 function validateExecSpec(value, label) {
     if (!isRecord(value))
         fail(`${label} must be an object`);
-    assertKeys(value, ["command", "cwd", "passEnv", "inheritEnv", "timeoutMs"], label);
+    assertKeys(value, ["command", "cwd", "passEnv", "timeoutMs"], label);
     validateExecEnvScope(value, label);
     const command = value.command;
     if (!Array.isArray(command) ||
@@ -331,20 +162,22 @@ function validateExecSpec(value, label) {
         fail(`${label}.timeoutMs must be null or an integer from 1 through ${WORKFLOW_MAX_TIMEOUT_MS}`);
     }
 }
+/** Decode one current frozen exec spec. */
+export function decodeWorkflowExecSpec(value, label) {
+    validateExecSpec(value, label);
+    return value;
+}
 /**
  * The child's ENVIRONMENT SCOPE half of a frozen exec spec. Split out so
  * {@link validateExecSpec} keeps its shape (and the src-fn-size ratchet stays
  * shrink-only).
  *
- * Both keys are canonical-form-only: `inheritEnv` may only be `true` and
- * `passEnv` may only be a non-empty deduplicated name list. A persisted `false`
- * or `[]` means exactly what absence means, and admitting a second spelling of
- * the default would give the same unit two different input hashes.
+ * `passEnv` is canonical-form-only and may only be a non-empty deduplicated
+ * name list. A persisted `[]` means exactly what absence means, and admitting a
+ * second spelling of the default would give the same unit two different input
+ * hashes.
  */
 function validateExecEnvScope(value, label) {
-    if (value.inheritEnv !== undefined && value.inheritEnv !== true) {
-        fail(`${label}.inheritEnv must be true when present (the allowlist default is the key's ABSENCE)`);
-    }
     if (value.passEnv === undefined)
         return;
     const passEnv = value.passEnv;
@@ -357,7 +190,7 @@ function validateExecEnvScope(value, label) {
             `matching ${WORKFLOW_ENV_VAR_NAME_PATTERN.source}`);
     }
 }
-function validateGate(gate, stepId, references, nodeIds, hooks) {
+function validateGate(gate, stepId, nodeIds, gateExtraKeys) {
     if (!isRecord(gate) ||
         gate.kind !== "gate" ||
         gate.id !== `${stepId}.gate` ||
@@ -371,26 +204,8 @@ function validateGate(gate, stepId, references, nodeIds, hooks) {
         fail(`gate for step ${stepId} is invalid`);
     if (nodeIds.has(gate.id))
         fail(`gate id ${gate.id} collides with a node`);
-    assertKeys(gate, ["kind", "id", "stepId", "criteria", "maxLoops", "judge"], `gate ${stepId}`);
+    assertKeys(gate, ["kind", "id", "stepId", "criteria", "maxLoops", ...gateExtraKeys], `gate ${stepId}`);
     nodeIds.add(gate.id);
-    if (gate.criteria.length === 0 && gate.judge !== null)
-        fail(`gate ${gate.id} without criteria cannot have a judge`);
-    if (gate.judge !== null)
-        validateInvocation(gate.judge, references, hooks);
-}
-function validateInvocation(invocation, references, hooks) {
-    if (!isRecord(invocation) ||
-        typeof invocation.engine !== "string" ||
-        !invocation.engine ||
-        !((typeof invocation.model === "string" && invocation.model.length > 0) || invocation.model === null) ||
-        !(invocation.timeoutMs === null ||
-            (Number.isSafeInteger(invocation.timeoutMs) &&
-                invocation.timeoutMs >= 1 &&
-                invocation.timeoutMs <= WORKFLOW_MAX_TIMEOUT_MS)))
-        fail("invocation is invalid");
-    references.add(invocation.engine);
-    assertKeys(invocation, ["engine", "model", "timeoutMs", "llm"], "invocation");
-    validateLlmOverrides(invocation.llm, hooks);
 }
 function validateRoute(route, stepId) {
     if (!isRecord(route) ||
@@ -406,27 +221,6 @@ function validateRoute(route, stepId) {
     if (route.defaultStepId !== undefined && (typeof route.defaultStepId !== "string" || !route.defaultStepId))
         fail(`route for step ${stepId} has an invalid default target`);
 }
-function assertUnitEngineCompatibility(node, engines) {
-    const unit = node.kind === "map" ? node.template : node;
-    // An exec unit names no engine at all, so there is no engine pairing to
-    // check. It is the ONE kind that may carry `env` + `isolation: worktree`
-    // without an engine behind it: it spawns a real child process, which is
-    // exactly the precondition those two features require. `validateNode` has
-    // already proven it carries no `invocation`, so nothing here can be bypassed
-    // by declaring both.
-    if (unit.exec !== undefined)
-        return;
-    const engine = unit.invocation ? engines[unit.invocation.engine] : undefined;
-    if (!engine)
-        return;
-    if (engine.kind === "llm" && unit.invocation?.model === null)
-        fail(`LLM unit ${unit.id} has no exact model`);
-    if (engine.kind === "agent" && unit.invocation?.llm !== undefined)
-        fail(`agent unit ${unit.id} cannot carry LLM invocation settings`);
-    if (engine.kind === "llm" && ((unit.env?.length ?? 0) > 0 || unit.isolation === "worktree")) {
-        fail(`LLM unit ${unit.id} cannot use env injection or worktree isolation`);
-    }
-}
 function assertKeys(value, allowed, label) {
     for (const key of Object.keys(value))
         if (!allowed.includes(key))
@@ -508,46 +302,12 @@ function validateRetry(retry, nodeId) {
         retry.on.some((reason) => !PROGRAM_RETRY_REASONS.includes(reason)))
         fail(`unit ${nodeId} retry.on is invalid`);
 }
-function validateLlmOverrides(value, hooks) {
-    if (value === undefined)
-        return;
-    if (!isRecord(value))
-        fail("invocation.llm must be an object");
-    assertKeys(value, ["temperature", "maxTokens", "supportsJsonSchema", "extraParams", "contextLength", "enableThinking"], "invocation.llm");
-    validateOptionalFiniteNumber(value.temperature, "invocation.llm.temperature");
-    validateOptionalPositiveInteger(value.maxTokens, "invocation.llm.maxTokens");
-    validateOptionalPositiveInteger(value.contextLength, "invocation.llm.contextLength");
-    if (value.supportsJsonSchema !== undefined && typeof value.supportsJsonSchema !== "boolean")
-        fail("invocation.llm.supportsJsonSchema must be boolean");
-    if (value.enableThinking !== undefined && typeof value.enableThinking !== "boolean")
-        fail("invocation.llm.enableThinking must be boolean");
-    if (value.extraParams !== undefined) {
-        const issue = validateExtraParams(value.extraParams)[0];
-        if (issue)
-            fail(formatExtraParamsIssue("invocation.llm.extraParams", issue));
-    }
-    validateExtraParamsValue(value.extraParams, "invocation.llm.extraParams", hooks);
-}
 function validateSchema(value, label) {
     if (!isRecord(value))
         fail(`${label} must be an object`);
     if (jsonBytes(value) > WORKFLOW_MAX_SCHEMA_BYTES)
         fail(`${label} exceeds the 256 KiB resource limit`);
 }
-function validateExtraParamsValue(value, label, hooks) {
-    if (value === undefined)
-        return;
-    if (!isRecord(value))
-        fail(`${label} must be an object`);
-    if (jsonBytes(value) > WORKFLOW_MAX_EXTRA_PARAMS_BYTES)
-        fail(`${label} exceeds the 64 KiB resource limit`);
-    const issue = validateExtraParams(value)[0];
-    if (issue)
-        fail(formatExtraParamsIssue(label, issue));
-    const policyError = hooks.validateExtraParams?.(value, label);
-    if (policyError)
-        fail(`${label}: ${policyError}`);
-}
 function validateStepExpressions(step, index, steps) {
     const validateReference = (text, label, paramsAllowed) => {
         const parsed = parseReference(text);
@@ -594,29 +354,10 @@ function validateStringArray(value, label, max, unique) {
         (unique && new Set(value).size !== value.length))
         fail(`${label} is invalid`);
 }
-function validateOptionalFiniteNumber(value, label) {
-    if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value)))
-        fail(`${label} must be finite`);
-}
 function validateOptionalPositiveInteger(value, label) {
     if (value !== undefined && (!Number.isSafeInteger(value) || value < 1))
         fail(`${label} must be a positive safe integer`);
 }
-function validateEndpoint(value, engine) {
-    try {
-        const url = new URL(value);
-        if ((url.protocol !== "http:" && url.protocol !== "https:") ||
-            url.username ||
-            url.password ||
-            url.search ||
-            url.hash ||
-            !url.pathname.endsWith("/chat/completions"))
-            fail(`LLM engine ${engine} endpoint is not canonical`);
-    }
-    catch {
-        fail(`LLM engine ${engine} endpoint is invalid`);
-    }
-}
 function assertString(value, label) {
     if (typeof value !== "string" || value.length === 0 || value.length > MAX_STRING_LENGTH)
         fail(`${label} must be a non-empty bounded string`);