nuabase 2.3.11 → 3.0.0

package/dist/chunks/local-agent-Bj-QKikS.d.cts

@@ -0,0 +1,270 @@
+type NormalizedUsage = {
+    /** All prompt tokens, including any the provider read from or wrote to its prompt cache. */
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /** Prompt tokens the provider read from its prompt cache, billed at a discount. Undefined when not reported. */
+    promptCacheReadTokens?: number;
+    /** Prompt tokens the provider wrote to its prompt cache (Claude bills these at a premium). Undefined when not reported. */
+    promptCacheWriteTokens?: number;
+};
+
+interface Logger {
+    debug(message: string, context?: object): void;
+    info(message: string, context?: object): void;
+    warn(message: string, context?: object): void;
+    error(message: string, context?: object): void;
+}
+
+type JsonSchema = Record<string, unknown>;
+
+declare const LLM_PROVIDER_IDS: readonly ["groq", "cerebras", "gemini", "openrouter", "deepseek"];
+type LlmProviderId = (typeof LLM_PROVIDER_IDS)[number];
+
+/** Supported coding-agent CLIs, in the order findLocalAgent() tries them. */
+declare const LOCAL_AGENT_IDS: readonly ["claude-code", "codex", "pi"];
+type LocalAgentId = (typeof LOCAL_AGENT_IDS)[number];
+declare function isLocalAgentId(value: unknown): value is LocalAgentId;
+
+/**
+ * How one attempt makes the model produce the output shape.
+ * - in-prompt: the prompt describes the schema; the reply is free text that should contain the JSON.
+ * - native: the engine enforces `schema` itself. It is the output schema wrapped in an
+ *   envelope (see cast/envelope), already converted to the engine's own dialect.
+ */
+type SchemaEnforcement = {
+    kind: "in-prompt";
+} | {
+    kind: "native";
+    schema: JsonSchema;
+};
+type SchemaEnforcementKind = SchemaEnforcement["kind"];
+/** One prompt for an engine to answer once, on the model the engine was created for. */
+type AttemptRequest = {
+    prompt: string;
+    /** The start of `prompt` that repeats across calls of the same cast. Engines may cache it. */
+    reusablePrefix: string;
+    maxTokens: number;
+    enforcement: SchemaEnforcement;
+};
+type Answer = 
+/** A free-text reply that should contain the JSON result. */
+{
+    kind: "text";
+    text: string;
+}
+/** The envelope object the engine enforced natively. */
+ | {
+    kind: "structured";
+    envelope: unknown;
+};
+/** Which engine produced an answer. */
+type AnswerOrigin = {
+    engine: "http";
+    provider: LlmProviderId;
+    model: string;
+} | {
+    engine: "local-agent";
+    agent: LocalAgentId;
+    /** The model the agent reports using, else the one requested; undefined when neither is known. */
+    model: string | undefined;
+    /** The agent's own estimate. On a subscription this is not what the user pays. */
+    costUsdEstimate: number | undefined;
+};
+type AttemptFailure = {
+    /**
+     * - transient: another attempt may succeed.
+     * - fatal: every attempt will fail the same way (bad API key, not logged in, out of quota, timed out).
+     * - schema-rejected: the engine refused the native schema; the in-prompt prompt may still work.
+     */
+    kind: "transient" | "fatal" | "schema-rejected";
+    message: string;
+};
+type AttemptOutcome = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    origin: AnswerOrigin;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+/**
+ * Answers prompts on one model: an LLM provider's HTTP API, or a coding-agent
+ * CLI on this machine. Expected failures come back as outcomes, not exceptions.
+ */
+interface LlmEngine {
+    /** The envelope schema in the form this engine enforces natively, or null if it cannot. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    attempt(request: AttemptRequest): Promise<AttemptOutcome>;
+}
+
+type ProviderModel = {
+    provider: LlmProviderId;
+    model: string;
+};
+type ModelAliasName = "fast" | "gemini" | "qwen" | "sonnet" | "opus" | "haiku" | "kimi" | "deepseek" | "gpt";
+type ModelInput = ProviderModel | {
+    alias: ModelAliasName;
+};
+
+/** The engine that runs a model choice, or why none can. */
+type Route = {
+    kind: "routed";
+    engine: LlmEngine;
+} | {
+    kind: "unroutable";
+    message: string;
+};
+/**
+ * Where a client's calls run. Every setup answers the same question: for this
+ * model choice, which engine runs it? Created by providerEngines() for LLM
+ * providers' APIs, or by localAgent() / findLocalAgent() in the Node-only
+ * "nua-llm-core/local-agent" entry point for a coding-agent CLI.
+ */
+interface EngineRouter {
+    /** Where the engines log their calls. Casts log their retries here too. */
+    readonly logger: Logger;
+    /** `model` undefined means this router's default model. */
+    route(model: ModelInput | undefined): Route;
+}
+
+/** A process to run inside a fresh, empty working directory. */
+type AgentInvocation = {
+    args: string[];
+    stdin: string;
+    /** Files written into the working directory before the process starts. */
+    files?: {
+        name: string;
+        content: string;
+    }[];
+    /** Files read back from the working directory after the process exits. */
+    outputFiles?: string[];
+};
+type AgentProcessResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    /** Contents of the requested output files; undefined when a file was not written. */
+    outputFiles: Record<string, string | undefined>;
+};
+/** What an agent's output says about one attempt. */
+type AgentReply = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    /** The model the agent reports having used, when it says. */
+    model: string | undefined;
+    costUsdEstimate: number | undefined;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+/**
+ * How hard the agent's model thinks before it answers: the CLI's own reasoning
+ * or effort setting, at one of the levels every supported CLI has.
+ */
+type AgentEffort = "low" | "medium" | "high";
+/** How one cast runs on an agent. An undefined field leaves it to the CLI's default. */
+type AgentCallOptions = {
+    /** The CLI's own model name. */
+    model?: string;
+    effort?: AgentEffort;
+};
+/**
+ * Who approves an interactive session's edits and commands:
+ * - ask: the user, step by step, as the CLI does by default.
+ * - auto: the CLI's own auto mode. Its reviewer approves routine steps and stops risky ones.
+ */
+type SessionApproval = "ask" | "auto";
+type AgentLoginStatus = {
+    loggedIn: boolean;
+    detail?: string;
+};
+/**
+ * Knows one coding-agent CLI: which models it offers, how to invoke it headless,
+ * and how to read its output. Adapters do no I/O; the process runner does the spawning.
+ */
+interface AgentAdapter {
+    id: LocalAgentId;
+    /** Executable name looked up on PATH. */
+    binaryName: string;
+    /** Env vars that would make the CLI bill an API key instead of the user's subscription. */
+    apiKeyEnvVars: string[];
+    /** The CLI's own model name for each model alias it has an equivalent for. */
+    modelAliases: Partial<Record<ModelAliasName, string>>;
+    /** The envelope schema in the form this CLI accepts, or null if it can't enforce it. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    buildInvocation(request: AttemptRequest, options: AgentCallOptions): AgentInvocation;
+    readResult(result: AgentProcessResult, request: AttemptRequest): AgentReply;
+    loginStatusArgs: string[];
+    readLoginStatus(result: AgentProcessResult): AgentLoginStatus;
+    /**
+     * Options for an interactive session in the user's own project, which go
+     * before its first message. `model` is the CLI's own model name; undefined
+     * uses the CLI's default.
+     */
+    sessionArgs(model: string | undefined, approval: SessionApproval): string[];
+}
+
+/** Runs at most `limit` tasks at once; the rest wait in order. */
+declare class Semaphore {
+    private readonly limit;
+    private active;
+    private readonly waiting;
+    constructor(limit: number);
+    run<T>(task: () => Promise<T>): Promise<T>;
+}
+
+/** How to run one installed agent's processes. Set up once and shared by all its engines. */
+type AgentRunner = {
+    adapter: AgentAdapter;
+    binaryPath: string;
+    /** Env vars removed from the agent's environment. */
+    unsetEnv: string[];
+    /** Bounds how many agent processes run at once, across all models. */
+    limiter: Semaphore;
+    logger: Logger;
+};
+/** How one engine's attempts run: the CLI's options and how long each may take. */
+type AgentCall = AgentCallOptions & {
+    /** Per-attempt limit. */
+    timeoutMs: number;
+};
+
+/** What `LocalAgent.with()` changes: how its casts run, not which processes run them. */
+type LocalAgentCallOptions = AgentCallOptions & {
+    /** Per-call limit in milliseconds. */
+    timeoutMs?: number;
+};
+/**
+ * A coding-agent CLI on this machine, set up once and ready to run casts.
+ * Created by localAgent() or findLocalAgent().
+ */
+declare class LocalAgent implements EngineRouter {
+    private readonly runner;
+    /** How calls that name no model run. */
+    private readonly call;
+    readonly agent: LocalAgentId;
+    readonly logger: Logger;
+    constructor(runner: AgentRunner, 
+    /** How calls that name no model run. */
+    call: AgentCall);
+    /**
+     * The same agent with other call options, sharing this one's executable,
+     * environment, logger and limit on processes running at once. Options left
+     * out keep this agent's; a model or effort given as undefined is the CLI's
+     * default.
+     */
+    with(options: LocalAgentCallOptions): LocalAgent;
+    /**
+     * No model choice runs the default model. An alias runs the CLI's equivalent
+     * model, if it has one. Provider models cannot run on a local agent.
+     */
+    route(model: ModelInput | undefined): Route;
+    private routeTo;
+}
+
+export { LocalAgent as a, LOCAL_AGENT_IDS as f, isLocalAgentId as i };
+export type { AnswerOrigin as A, LlmProviderId as L, ModelInput as M, NormalizedUsage as N, SchemaEnforcementKind as S, LocalAgentId as b, AgentEffort as c, Logger as d, SessionApproval as e, LocalAgentCallOptions as g };

package/dist/chunks/local-agent-Bj-QKikS.d.mts

@@ -0,0 +1,270 @@
+type NormalizedUsage = {
+    /** All prompt tokens, including any the provider read from or wrote to its prompt cache. */
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /** Prompt tokens the provider read from its prompt cache, billed at a discount. Undefined when not reported. */
+    promptCacheReadTokens?: number;
+    /** Prompt tokens the provider wrote to its prompt cache (Claude bills these at a premium). Undefined when not reported. */
+    promptCacheWriteTokens?: number;
+};
+
+interface Logger {
+    debug(message: string, context?: object): void;
+    info(message: string, context?: object): void;
+    warn(message: string, context?: object): void;
+    error(message: string, context?: object): void;
+}
+
+type JsonSchema = Record<string, unknown>;
+
+declare const LLM_PROVIDER_IDS: readonly ["groq", "cerebras", "gemini", "openrouter", "deepseek"];
+type LlmProviderId = (typeof LLM_PROVIDER_IDS)[number];
+
+/** Supported coding-agent CLIs, in the order findLocalAgent() tries them. */
+declare const LOCAL_AGENT_IDS: readonly ["claude-code", "codex", "pi"];
+type LocalAgentId = (typeof LOCAL_AGENT_IDS)[number];
+declare function isLocalAgentId(value: unknown): value is LocalAgentId;
+
+/**
+ * How one attempt makes the model produce the output shape.
+ * - in-prompt: the prompt describes the schema; the reply is free text that should contain the JSON.
+ * - native: the engine enforces `schema` itself. It is the output schema wrapped in an
+ *   envelope (see cast/envelope), already converted to the engine's own dialect.
+ */
+type SchemaEnforcement = {
+    kind: "in-prompt";
+} | {
+    kind: "native";
+    schema: JsonSchema;
+};
+type SchemaEnforcementKind = SchemaEnforcement["kind"];
+/** One prompt for an engine to answer once, on the model the engine was created for. */
+type AttemptRequest = {
+    prompt: string;
+    /** The start of `prompt` that repeats across calls of the same cast. Engines may cache it. */
+    reusablePrefix: string;
+    maxTokens: number;
+    enforcement: SchemaEnforcement;
+};
+type Answer = 
+/** A free-text reply that should contain the JSON result. */
+{
+    kind: "text";
+    text: string;
+}
+/** The envelope object the engine enforced natively. */
+ | {
+    kind: "structured";
+    envelope: unknown;
+};
+/** Which engine produced an answer. */
+type AnswerOrigin = {
+    engine: "http";
+    provider: LlmProviderId;
+    model: string;
+} | {
+    engine: "local-agent";
+    agent: LocalAgentId;
+    /** The model the agent reports using, else the one requested; undefined when neither is known. */
+    model: string | undefined;
+    /** The agent's own estimate. On a subscription this is not what the user pays. */
+    costUsdEstimate: number | undefined;
+};
+type AttemptFailure = {
+    /**
+     * - transient: another attempt may succeed.
+     * - fatal: every attempt will fail the same way (bad API key, not logged in, out of quota, timed out).
+     * - schema-rejected: the engine refused the native schema; the in-prompt prompt may still work.
+     */
+    kind: "transient" | "fatal" | "schema-rejected";
+    message: string;
+};
+type AttemptOutcome = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    origin: AnswerOrigin;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+/**
+ * Answers prompts on one model: an LLM provider's HTTP API, or a coding-agent
+ * CLI on this machine. Expected failures come back as outcomes, not exceptions.
+ */
+interface LlmEngine {
+    /** The envelope schema in the form this engine enforces natively, or null if it cannot. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    attempt(request: AttemptRequest): Promise<AttemptOutcome>;
+}
+
+type ProviderModel = {
+    provider: LlmProviderId;
+    model: string;
+};
+type ModelAliasName = "fast" | "gemini" | "qwen" | "sonnet" | "opus" | "haiku" | "kimi" | "deepseek" | "gpt";
+type ModelInput = ProviderModel | {
+    alias: ModelAliasName;
+};
+
+/** The engine that runs a model choice, or why none can. */
+type Route = {
+    kind: "routed";
+    engine: LlmEngine;
+} | {
+    kind: "unroutable";
+    message: string;
+};
+/**
+ * Where a client's calls run. Every setup answers the same question: for this
+ * model choice, which engine runs it? Created by providerEngines() for LLM
+ * providers' APIs, or by localAgent() / findLocalAgent() in the Node-only
+ * "nua-llm-core/local-agent" entry point for a coding-agent CLI.
+ */
+interface EngineRouter {
+    /** Where the engines log their calls. Casts log their retries here too. */
+    readonly logger: Logger;
+    /** `model` undefined means this router's default model. */
+    route(model: ModelInput | undefined): Route;
+}
+
+/** A process to run inside a fresh, empty working directory. */
+type AgentInvocation = {
+    args: string[];
+    stdin: string;
+    /** Files written into the working directory before the process starts. */
+    files?: {
+        name: string;
+        content: string;
+    }[];
+    /** Files read back from the working directory after the process exits. */
+    outputFiles?: string[];
+};
+type AgentProcessResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    /** Contents of the requested output files; undefined when a file was not written. */
+    outputFiles: Record<string, string | undefined>;
+};
+/** What an agent's output says about one attempt. */
+type AgentReply = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    /** The model the agent reports having used, when it says. */
+    model: string | undefined;
+    costUsdEstimate: number | undefined;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+/**
+ * How hard the agent's model thinks before it answers: the CLI's own reasoning
+ * or effort setting, at one of the levels every supported CLI has.
+ */
+type AgentEffort = "low" | "medium" | "high";
+/** How one cast runs on an agent. An undefined field leaves it to the CLI's default. */
+type AgentCallOptions = {
+    /** The CLI's own model name. */
+    model?: string;
+    effort?: AgentEffort;
+};
+/**
+ * Who approves an interactive session's edits and commands:
+ * - ask: the user, step by step, as the CLI does by default.
+ * - auto: the CLI's own auto mode. Its reviewer approves routine steps and stops risky ones.
+ */
+type SessionApproval = "ask" | "auto";
+type AgentLoginStatus = {
+    loggedIn: boolean;
+    detail?: string;
+};
+/**
+ * Knows one coding-agent CLI: which models it offers, how to invoke it headless,
+ * and how to read its output. Adapters do no I/O; the process runner does the spawning.
+ */
+interface AgentAdapter {
+    id: LocalAgentId;
+    /** Executable name looked up on PATH. */
+    binaryName: string;
+    /** Env vars that would make the CLI bill an API key instead of the user's subscription. */
+    apiKeyEnvVars: string[];
+    /** The CLI's own model name for each model alias it has an equivalent for. */
+    modelAliases: Partial<Record<ModelAliasName, string>>;
+    /** The envelope schema in the form this CLI accepts, or null if it can't enforce it. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    buildInvocation(request: AttemptRequest, options: AgentCallOptions): AgentInvocation;
+    readResult(result: AgentProcessResult, request: AttemptRequest): AgentReply;
+    loginStatusArgs: string[];
+    readLoginStatus(result: AgentProcessResult): AgentLoginStatus;
+    /**
+     * Options for an interactive session in the user's own project, which go
+     * before its first message. `model` is the CLI's own model name; undefined
+     * uses the CLI's default.
+     */
+    sessionArgs(model: string | undefined, approval: SessionApproval): string[];
+}
+
+/** Runs at most `limit` tasks at once; the rest wait in order. */
+declare class Semaphore {
+    private readonly limit;
+    private active;
+    private readonly waiting;
+    constructor(limit: number);
+    run<T>(task: () => Promise<T>): Promise<T>;
+}
+
+/** How to run one installed agent's processes. Set up once and shared by all its engines. */
+type AgentRunner = {
+    adapter: AgentAdapter;
+    binaryPath: string;
+    /** Env vars removed from the agent's environment. */
+    unsetEnv: string[];
+    /** Bounds how many agent processes run at once, across all models. */
+    limiter: Semaphore;
+    logger: Logger;
+};
+/** How one engine's attempts run: the CLI's options and how long each may take. */
+type AgentCall = AgentCallOptions & {
+    /** Per-attempt limit. */
+    timeoutMs: number;
+};
+
+/** What `LocalAgent.with()` changes: how its casts run, not which processes run them. */
+type LocalAgentCallOptions = AgentCallOptions & {
+    /** Per-call limit in milliseconds. */
+    timeoutMs?: number;
+};
+/**
+ * A coding-agent CLI on this machine, set up once and ready to run casts.
+ * Created by localAgent() or findLocalAgent().
+ */
+declare class LocalAgent implements EngineRouter {
+    private readonly runner;
+    /** How calls that name no model run. */
+    private readonly call;
+    readonly agent: LocalAgentId;
+    readonly logger: Logger;
+    constructor(runner: AgentRunner, 
+    /** How calls that name no model run. */
+    call: AgentCall);
+    /**
+     * The same agent with other call options, sharing this one's executable,
+     * environment, logger and limit on processes running at once. Options left
+     * out keep this agent's; a model or effort given as undefined is the CLI's
+     * default.
+     */
+    with(options: LocalAgentCallOptions): LocalAgent;
+    /**
+     * No model choice runs the default model. An alias runs the CLI's equivalent
+     * model, if it has one. Provider models cannot run on a local agent.
+     */
+    route(model: ModelInput | undefined): Route;
+    private routeTo;
+}
+
+export { LocalAgent as a, LOCAL_AGENT_IDS as f, isLocalAgentId as i };
+export type { AnswerOrigin as A, LlmProviderId as L, ModelInput as M, NormalizedUsage as N, SchemaEnforcementKind as S, LocalAgentId as b, AgentEffort as c, Logger as d, SessionApproval as e, LocalAgentCallOptions as g };

package/dist/cjs/chunks/strict-json-schema-bKwaMWm1.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+class ConsoleLogger {
+  debug(message, context) {
+    console.debug(`[DEBUG] ${message}`, context || "");
+  }
+  info(message, context) {
+    console.info(`[INFO] ${message}`, context || "");
+  }
+  warn(message, context) {
+    console.warn(`[WARN] ${message}`, context || "");
+  }
+  error(message, context) {
+    console.error(`[ERROR] ${message}`, context || "");
+  }
+}
+const generateSpanId = () => crypto.randomUUID();
+function pickHeaders(headers, allowlist, redactSet) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const lowerKey = key.toLowerCase();
+    if (allowlist.has(lowerKey)) {
+      result[key] = Array.isArray(value) ? value.join(", ") : value ?? "";
+    }
+  }
+  return result;
+}
+function normalizeError(error) {
+  return error instanceof Error ? { message: error.message, stack: error.stack } : String(error);
+}
+const LLM_RESPONSE_HEADER_ALLOWLIST = /* @__PURE__ */ new Set([
+  "x-request-id",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-remaining-tokens",
+  "x-groq-region"
+]);
+const logLlmCallStart = (logger, spanId, service, method, request) => {
+  logger.info("LLM call started", {
+    type: "llm_call_start",
+    span_id: spanId,
+    service,
+    method,
+    ...request
+  });
+};
+const logLlmCallComplete = (logger, spanId, service, method, response, duration) => {
+  const { headers, ...rest } = response;
+  logger.info("LLM call completed", {
+    type: "llm_call_complete",
+    span_id: spanId,
+    service,
+    method,
+    ...rest,
+    ...pickHeaders(headers, LLM_RESPONSE_HEADER_ALLOWLIST),
+    duration_ms: duration
+  });
+};
+const logLlmCallError = (logger, spanId, service, method, error, duration) => {
+  logger.error("LLM call failed", {
+    type: "llm_call_error",
+    span_id: spanId,
+    service,
+    method,
+    error: normalizeError(error),
+    duration_ms: duration
+  });
+};
+
+const STRICT_UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+  "patternProperties",
+  "propertyNames",
+  "unevaluatedProperties",
+  "dependentRequired",
+  "dependentSchemas",
+  "if",
+  "then",
+  "else",
+  "not",
+  "allOf",
+  "oneOf"
+]);
+function toStrictSchema(schema) {
+  return strictNode(schema);
+}
+function strictNode(node) {
+  if (typeof node !== "object" || node === null || Array.isArray(node)) {
+    return null;
+  }
+  const schema = node;
+  for (const key of Object.keys(schema)) {
+    if (STRICT_UNSUPPORTED_KEYWORDS.has(key)) return null;
+  }
+  const result = { ...schema };
+  delete result.$schema;
+  const isObject = schema.type === "object" || Array.isArray(schema.type) && schema.type.includes("object") || schema.properties !== void 0;
+  if (isObject) {
+    const properties = schema.properties ?? {};
+    if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+      return null;
+    }
+    const required = new Set(schema.required ?? []);
+    const shapedProperties = {};
+    for (const [name, child] of Object.entries(properties)) {
+      if (!required.has(name)) return null;
+      const shaped = strictNode(child);
+      if (!shaped) return null;
+      shapedProperties[name] = shaped;
+    }
+    result.properties = shapedProperties;
+    result.required = Object.keys(shapedProperties);
+    result.additionalProperties = false;
+  }
+  if (schema.items !== void 0) {
+    const shaped = strictNode(schema.items);
+    if (!shaped) return null;
+    result.items = shaped;
+  }
+  if (schema.prefixItems !== void 0) return null;
+  if (schema.anyOf !== void 0) {
+    const variants = schema.anyOf.map(strictNode);
+    if (variants.some((v) => v === null)) return null;
+    result.anyOf = variants;
+  }
+  for (const defsKey of ["$defs", "definitions"]) {
+    if (schema[defsKey] !== void 0) {
+      const defs = {};
+      for (const [name, child] of Object.entries(schema[defsKey])) {
+        const shaped = strictNode(child);
+        if (!shaped) return null;
+        defs[name] = shaped;
+      }
+      result[defsKey] = defs;
+    }
+  }
+  return result;
+}
+
+exports.ConsoleLogger = ConsoleLogger;
+exports.generateSpanId = generateSpanId;
+exports.logLlmCallComplete = logLlmCallComplete;
+exports.logLlmCallError = logLlmCallError;
+exports.logLlmCallStart = logLlmCallStart;
+exports.toStrictSchema = toStrictSchema;