@blogic-cz/agent-tools 0.14.41 → 0.14.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.41",
+  "version": "0.14.43",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/audit-tool/index.ts

@@ -3,7 +3,13 @@ import { Command, Flag } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Console, Effect, Layer, Option } from "effect";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#shared";
+import {
+  makeSchemaCommand,
+  formatOption,
+  formatOutput,
+  renderCauseToStderr,
+  VERSION,
+} from "#shared";
 import { AuditService, AuditServiceLayer, withAudit } from "#shared/audit";
 
 type AuditToolResult<T> = {
@@ -81,9 +87,11 @@ const purgeCommand = Command.make(
     }),
 ).pipe(Command.withDescription("Delete old audit log entries"));
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("audit-tool", {}).pipe(
   Command.withDescription("Audit log inspection and maintenance for agent-tools"),
-  Command.withSubcommands([listCommand, purgeCommand]),
+  Command.withSubcommands([listCommand, purgeCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/az-tool/index.ts

@@ -3,7 +3,14 @@ import { Command, Flag } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Console, Effect, Layer, Option } from "effect";
 
-import { formatAny, formatOption, formatOutput, renderCauseToStderr, VERSION } from "#shared";
+import {
+  makeSchemaCommand,
+  formatAny,
+  formatOption,
+  formatOutput,
+  renderCauseToStderr,
+  VERSION,
+} from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import {
   findFailedJobs,
@@ -173,6 +180,8 @@ EXAMPLES:
 // Main command with subcommands
 // ---------------------------------------------------------------------------
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("az-tool", {}).pipe(
   Command.withDescription(
     `Azure CLI Tool for Coding Agents (READ-ONLY)
@@ -187,7 +196,7 @@ Typed build subcommands:
 Raw az wrapper:
   az-tool cmd --cmd "pipelines list"`,
   ),
-  Command.withSubcommands([buildCommand, cmdCommand]),
+  Command.withSubcommands([buildCommand, cmdCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/db-tool/index.ts

@@ -5,7 +5,13 @@ import { Console, Effect, Layer, Option } from "effect";
 
 import type { SchemaMode } from "./types";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#shared";
+import {
+  makeSchemaCommand,
+  formatOption,
+  formatOutput,
+  renderCauseToStderr,
+  VERSION,
+} from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment } from "#config";
 import { DbConfigService, makeDbConfigLayer } from "./config-service";
@@ -133,9 +139,11 @@ const envsCommand = Command.make(
   Command.withDescription("List configured database environments and the default (no network)"),
 );
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("db-tool", {}).pipe(
   Command.withDescription("Database Query Tool for Coding Agents"),
-  Command.withSubcommands([sqlCommand, schemaCommand, envsCommand]),
+  Command.withSubcommands([sqlCommand, schemaCommand, envsCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, {
@@ -145,7 +153,9 @@ const cli = Command.run(mainCommand, {
 const dbConfigLayer = makeDbConfigLayer(profileArg);
 
 const MainLayer = DbService.layer.pipe(
-  Layer.provide(dbConfigLayer),
+  // provideMerge (not provide) so DbConfigService stays in the program context for the `envs` command,
+  // which reads it directly rather than going through DbService.
+  Layer.provideMerge(dbConfigLayer),
   Layer.provideMerge(ConfigServiceLayer),
   Layer.provideMerge(BunServices.layer),
   Layer.provideMerge(AuditServiceLayer),

package/src/db-tool/service.ts

@@ -9,7 +9,7 @@ import { resolveEnvTemplate } from "#shared/env-template";
 import { resolveEnvironmentScopedPrerequisites } from "#shared/prerequisites/config";
 import { runWithProfilePrerequisites } from "#shared/prerequisites/runtime";
 import { buildApiProbeArgs } from "#shared/k8s-probe";
-import { DbConfigService, DbConfigServiceLayer, TUNNEL_CHECK_INTERVAL_MS } from "./config-service";
+import { DbConfigService, TUNNEL_CHECK_INTERVAL_MS } from "./config-service";
 import {
   DbConnectionError,
   DbMutationBlockedError,
@@ -829,5 +829,3 @@ export class DbService extends Context.Service<
     ),
   );
 }
-
-export const DbServiceLayer = DbService.layer.pipe(Layer.provide(DbConfigServiceLayer));

package/src/gh-tool/index.ts

@@ -3,7 +3,7 @@ import { Command } from "effect/unstable/cli";
 import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Effect, Layer } from "effect";
 
-import { renderCauseToStderr, VERSION } from "#shared";
+import { makeSchemaCommand, renderCauseToStderr, VERSION } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { ConfigServiceLayer } from "#config";
 import {
@@ -40,6 +40,7 @@ import {
   prReplyAndResolveCommand,
   prReviewTriageBatchCommand,
   prReviewTriageCommand,
+  prWaitMergeableCommand,
 } from "./pr/index";
 import { branchRenameCommand } from "./branch";
 import {
@@ -74,6 +75,7 @@ const prCommand = Command.make("pr", {}).pipe(
     prCloseCommand,
     prEditCommand,
     prMergeCommand,
+    prWaitMergeableCommand,
     prThreadsCommand,
     prCommentsCommand,
     prIssueCommentsCommand,
@@ -148,6 +150,8 @@ const releaseCommand = Command.make("release", {}).pipe(
   ]),
 );
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("gh-tool", {}).pipe(
   Command.withDescription(
     `GitHub CLI Tool for Coding Agents
@@ -186,6 +190,7 @@ WORKFLOW FOR AI AGENTS:
     branchCommand,
     workflowCommand,
     releaseCommand,
+    commandsCommand,
   ]),
 );
 

package/src/gh-tool/pr/commands.ts

@@ -1,10 +1,20 @@
 import { Command, Flag } from "effect/unstable/cli";
-import { Effect, Option } from "effect";
+import { Console, Effect, Option } from "effect";
 
 import type { CheckResult, PRStatusResult } from "#gh/types";
 
 import { formatOption, logFormatted } from "#shared";
 import { GitHubService } from "#gh/service";
+import { GitHubCommandError } from "#gh/errors";
+
+const emptyBatchError = (batch: string) =>
+  new GitHubCommandError({
+    message: `--prs received no valid PR numbers: ${JSON.stringify(batch)}`,
+    command: "gh pr --prs",
+    exitCode: 1,
+    stderr: "",
+    hint: "Pass comma-separated positive integers, e.g. --prs 1,2,3.",
+  });
 import {
   resolveDefaultTextInput,
   resolveOptionalTextInput,
@@ -29,6 +39,7 @@ import {
   mergePR,
   rerunChecks,
   viewPR,
+  waitForMergeable,
 } from "./core";
 import {
   fetchComments,
@@ -127,18 +138,34 @@ export const prViewCommand = Command.make(
       Flag.withDescription("PR number (default: current branch PR)"),
       Flag.optional,
     ),
+    prs: Flag.string("prs").pipe(
+      Flag.withDescription("Comma-separated PR numbers to view in one call (overrides --pr)"),
+      Flag.optional,
+    ),
     repo: repoOption,
   },
-  ({ format, pr, repo }) =>
+  ({ format, pr, prs, repo }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
-        const prNumber = Option.getOrNull(pr);
-        const info = yield* viewPR(prNumber);
+        const batch = Option.getOrNull(prs);
+        if (batch !== null) {
+          const numbers = parsePrNumbers(batch);
+          if (numbers.length === 0) return yield* emptyBatchError(batch);
+          const results = yield* Effect.all(
+            numbers.map((n) => viewPR(n).pipe(Effect.map((info) => ({ pr: n, info })))),
+            { concurrency: 5 },
+          );
+          yield* logFormatted({ count: results.length, prs: results }, format);
+          return;
+        }
+        const info = yield* viewPR(Option.getOrNull(pr));
         yield* logFormatted(info, format);
       }),
     ),
-).pipe(Command.withDescription("View PR information"));
+).pipe(
+  Command.withDescription("View PR information (use --prs 1,2,3 to view several in one call)"),
+);
 
 export const prStatusCommand = Command.make(
   "status",
@@ -200,6 +227,36 @@ export const prListCommand = Command.make(
   ),
 );
 
+export const prWaitMergeableCommand = Command.make(
+  "wait-mergeable",
+  {
+    format: formatOption,
+    pr: Flag.integer("pr").pipe(
+      Flag.withDescription("PR number (default: current branch PR)"),
+      Flag.optional,
+    ),
+    timeout: Flag.integer("timeout").pipe(
+      Flag.withDescription(
+        "Max seconds to wait for a definitive mergeable verdict (capped at 180)",
+      ),
+      Flag.withDefault(60),
+    ),
+    repo: repoOption,
+  },
+  ({ format, pr, timeout, repo }) =>
+    withRepo(
+      repo,
+      Effect.gen(function* () {
+        const info = yield* waitForMergeable(Option.getOrNull(pr), timeout);
+        yield* logFormatted(info, format);
+      }),
+    ),
+).pipe(
+  Command.withDescription(
+    "Poll until GitHub reports a definitive mergeable verdict (MERGEABLE/CONFLICTING) or timeout",
+  ),
+);
+
 export const prCreateCommand = Command.make(
   "create",
   {
@@ -388,6 +445,10 @@ export const prChecksCommand = Command.make(
       Flag.withDescription("PR number (default: current branch PR)"),
       Flag.optional,
     ),
+    prs: Flag.string("prs").pipe(
+      Flag.withDescription("Comma-separated PR numbers for a one-shot batch snapshot (no --watch)"),
+      Flag.optional,
+    ),
     repo: repoOption,
     timeout: Flag.integer("timeout").pipe(
       Flag.withDefault(CI_CHECK_WATCH_TIMEOUT_MS / 1000),
@@ -398,16 +459,39 @@ export const prChecksCommand = Command.make(
       Flag.withDescription("Watch until checks complete or timeout"),
     ),
   },
-  ({ failFast, format, pr, repo, timeout, watch }) =>
+  ({ failFast, format, pr, prs, repo, timeout, watch }) =>
     withRepo(
       repo,
       Effect.gen(function* () {
-        const prNumber = Option.getOrNull(pr);
-        const checks = yield* fetchChecksForCommand(prNumber, watch, failFast, timeout);
+        const batch = Option.getOrNull(prs);
+        if (batch !== null) {
+          if (watch) {
+            yield* Console.warn(
+              "ℹ️  --watch is ignored with --prs; batch mode returns a one-shot snapshot per PR.",
+            );
+          }
+          const numbers = parsePrNumbers(batch);
+          if (numbers.length === 0) return yield* emptyBatchError(batch);
+          const results = yield* Effect.all(
+            numbers.map((n) =>
+              fetchChecks(n, false, failFast, timeout).pipe(
+                Effect.map((checks) => ({ pr: n, checks })),
+              ),
+            ),
+            { concurrency: 5 },
+          );
+          yield* logFormatted({ count: results.length, prs: results }, format);
+          return;
+        }
+        const checks = yield* fetchChecksForCommand(Option.getOrNull(pr), watch, failFast, timeout);
         yield* logFormatted(checks, format);
       }),
     ),
-).pipe(Command.withDescription("Fetch CI check status for a PR (optionally watch with timeout)"));
+).pipe(
+  Command.withDescription(
+    "Fetch CI check status for a PR (--watch to block; --prs 1,2,3 for a batch snapshot)",
+  ),
+);
 
 export const prChecksFailedCommand = Command.make(
   "checks-failed",
@@ -792,8 +876,10 @@ export const prReviewTriageBatchCommand = Command.make(
     withRepo(
       repo,
       Effect.gen(function* () {
+        const numbers = parsePrNumbers(prs);
+        if (numbers.length === 0) return yield* emptyBatchError(prs);
         const results = yield* Effect.all(
-          parsePrNumbers(prs).map((prNumber) => fetchReviewTriage(prNumber)),
+          numbers.map((prNumber) => fetchReviewTriage(prNumber)),
           { concurrency: "unbounded" },
         );
         yield* logFormatted(results, format);

package/src/gh-tool/pr/core.ts

@@ -1,4 +1,4 @@
-import { Console, Effect, Option, Result } from "effect";
+import { Clock, Console, Duration, Effect, Option, Result } from "effect";
 
 import type {
   BranchPRDetail,
@@ -482,6 +482,41 @@ export const listPRs = Effect.fn("pr.listPRs")(function* (opts: {
   return yield* gh.runGhJson<PRInfo[]>(args);
 });
 
+// GitHub recomputes mergeability asynchronously after CI; poll until it settles out of "UNKNOWN".
+const MAX_MERGEABLE_WAIT_SECONDS = 180;
+const MERGEABLE_POLL_INTERVAL_MS = 3000;
+
+export const waitForMergeable = Effect.fn("pr.waitForMergeable")(function* (
+  pr: number | null,
+  timeoutSeconds: number,
+) {
+  const cappedSeconds = Math.min(timeoutSeconds, MAX_MERGEABLE_WAIT_SECONDS);
+  const start = yield* Clock.currentTimeMillis;
+  const deadlineMs = Number(start) + cappedSeconds * 1000;
+
+  // Effect.whileLoop (not recursion) so TestClock.adjust can advance Effect.sleep without real waits.
+  let latest = yield* viewPR(pr);
+  let timedOut = false;
+  yield* Effect.whileLoop({
+    while: () => latest.mergeable === "UNKNOWN" && !timedOut,
+    body: () =>
+      Effect.gen(function* () {
+        const now = yield* Clock.currentTimeMillis;
+        if (Number(now) >= deadlineMs) {
+          timedOut = true;
+          return;
+        }
+        // Cap the sleep to the remaining budget so the total wait doesn't overshoot the deadline.
+        const remaining = deadlineMs - Number(now);
+        yield* Effect.sleep(Duration.millis(Math.min(MERGEABLE_POLL_INTERVAL_MS, remaining)));
+        latest = yield* viewPR(pr);
+      }),
+    step: () => undefined,
+  });
+
+  return latest;
+});
+
 export const createPR = Effect.fn("pr.createPR")(function* (opts: {
   base: string | null;
   title: string;

package/src/gh-tool/pr/index.ts

@@ -18,6 +18,7 @@ export {
   prStatusCommand,
   prSubmitReviewCommand,
   prThreadsCommand,
+  prWaitMergeableCommand,
   prReviewTriageCommand,
   prReviewTriageBatchCommand,
   prViewCommand,

package/src/k8s-tool/index.ts

@@ -5,7 +5,13 @@ import { Console, Effect, Layer, Option } from "effect";
 
 import type { CommandResult } from "./types";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#shared";
+import {
+  makeSchemaCommand,
+  formatOption,
+  formatOutput,
+  renderCauseToStderr,
+  VERSION,
+} from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { K8sService, K8sServiceLayer } from "./service";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment, getToolConfig } from "#config";
@@ -415,6 +421,8 @@ const topCommand = Command.make(
     }),
 ).pipe(Command.withDescription("Show pod CPU/memory usage (kubectl top pod)"));
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("k8s-tool", {}).pipe(
   Command.withDescription("Kubernetes CLI Tool for Coding Agents"),
   Command.withSubcommands([
@@ -424,6 +432,7 @@ const mainCommand = Command.make("k8s-tool", {}).pipe(
     describeCommand,
     execCommand,
     topCommand,
+    commandsCommand,
   ]),
 );
 

package/src/logs-tool/index.ts

@@ -20,7 +20,13 @@ import { Console, Effect, Layer, Option, Result } from "effect";
 
 import type { Environment, LogResult, ReadOptions } from "./types";
 
-import { formatOption, formatOutput, renderCauseToStderr, VERSION } from "#shared";
+import {
+  makeSchemaCommand,
+  formatOption,
+  formatOutput,
+  renderCauseToStderr,
+  VERSION,
+} from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { ConfigService, ConfigServiceLayer, getDefaultEnvironment } from "#config";
 import { LogsConfigError, LogsNotFoundError, LogsReadError, LogsTimeoutError } from "./errors";
@@ -214,9 +220,11 @@ const readCommand = Command.make(
     }),
 ).pipe(Command.withDescription("Read application logs"));
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("logs-tool", {}).pipe(
   Command.withDescription("Application Logs Tool for Coding Agents"),
-  Command.withSubcommands([listCommand, readCommand]),
+  Command.withSubcommands([listCommand, readCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/observability-tool/index.ts

@@ -7,7 +7,7 @@ import { Command } from "effect/unstable/cli";
 
 import { ConfigServiceLayer } from "#config";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
-import { VERSION } from "#shared";
+import { makeSchemaCommand, VERSION } from "#shared";
 
 import { metricsCommand } from "./metrics";
 import { logsCommand } from "./logs";
@@ -15,11 +15,13 @@ import { traceCommand } from "./trace";
 
 const renderCauseToStderr = (cause: Cause.Cause<unknown>) => Console.error(cause.toString());
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("observability-tool", {}).pipe(
   Command.withDescription(
     "LGTM observability queries — Tempo traces, Loki logs, Prometheus metrics",
   ),
-  Command.withSubcommands([traceCommand, metricsCommand, logsCommand]),
+  Command.withSubcommands([traceCommand, metricsCommand, logsCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, { version: VERSION });

package/src/session-tool/index.ts

@@ -13,7 +13,7 @@ import { Console, Effect, Layer, Result } from "effect";
 
 import type { MessageSummary, SessionResult, SessionSource } from "./types";
 
-import { formatOption, formatOutput, VERSION } from "#shared";
+import { makeSchemaCommand, formatOption, formatOutput, VERSION } from "#shared";
 import { AuditServiceLayer, withAudit } from "#shared/audit";
 import { ResolvedPaths, ResolvedPathsLayer } from "./config";
 import { SessionStorageNotFoundError } from "./errors";
@@ -289,9 +289,11 @@ const readCommand = Command.make(
     }),
 ).pipe(Command.withDescription("Read all messages from a session"));
 
+const commandsCommand = makeSchemaCommand(() => mainCommand);
+
 const mainCommand = Command.make("session-tool", {}).pipe(
   Command.withDescription("OpenCode session history tool"),
-  Command.withSubcommands([listCommand, readCommand, searchCommand]),
+  Command.withSubcommands([listCommand, readCommand, searchCommand, commandsCommand]),
 );
 
 const cli = Command.run(mainCommand, {

package/src/shared/index.ts

@@ -8,6 +8,8 @@ export { commonArgOptions, parseCommonArgs } from "./cli";
 
 export { renderCauseToStderr } from "./error-renderer";
 
+export { dumpCommandSchema, makeSchemaCommand, type CommandSchema } from "./schema-dump";
+
 // eslint-disable-next-line import/no-relative-parent-imports -- package.json lives at project root, outside src/
 import pkg from "../../package.json" with { type: "json" };
 export const VERSION = pkg.version;

package/src/shared/schema-dump.ts

@@ -0,0 +1,94 @@
+import { Command } from "effect/unstable/cli";
+import { Option } from "effect";
+
+import { formatOption, logFormatted } from "./format";
+
+/**
+ * Machine-readable command-tree dump so an agent can discover the whole CLI surface in ONE call
+ * instead of repeated `--help` round-trips (the top remaining discovery friction in the usage audit).
+ */
+export type FlagSchema = {
+  readonly name: string;
+  readonly type?: string;
+  readonly choices?: readonly string[];
+  readonly description?: string;
+  readonly aliases?: readonly string[];
+};
+
+export type CommandSchema = {
+  readonly name: string;
+  readonly description?: string;
+  readonly flags: readonly FlagSchema[];
+  readonly subcommands: readonly CommandSchema[];
+};
+
+// Leaf parameter from effect/unstable/cli; carries the user-facing flag name/description/type.
+type SingleParam = {
+  readonly _tag: "Single";
+  readonly name: string;
+  readonly description: Option.Option<string>;
+  readonly aliases?: readonly string[];
+  readonly primitiveType?: { readonly _tag?: string; readonly choiceKeys?: readonly string[] };
+};
+
+// Minimal view of the (partly internal) Command runtime shape we walk. Public fields: name,
+// description, subcommands; `config.flags` is internal but stable, read defensively.
+type CommandNode = {
+  readonly name: string;
+  readonly description?: string;
+  readonly subcommands?: ReadonlyArray<{ readonly commands?: ReadonlyArray<unknown> }>;
+  readonly config?: { readonly flags?: ReadonlyArray<unknown> };
+};
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null;
+
+// Flags wrap as Optional/Map/Transform/Variadic around a leaf Single; descend via `.param`.
+const unwrapToSingle = (param: unknown): SingleParam | undefined => {
+  let current: unknown = param;
+  for (let depth = 0; depth < 16 && isObject(current); depth++) {
+    if (current._tag === "Single" && typeof current.name === "string") {
+      return current as unknown as SingleParam;
+    }
+    current = current.param;
+  }
+  return undefined;
+};
+
+const flagToSchema = (param: unknown): FlagSchema | undefined => {
+  const single = unwrapToSingle(param);
+  if (!single) return undefined;
+  const primitive = single.primitiveType;
+  const choices = primitive?.choiceKeys;
+  return {
+    name: single.name,
+    type: primitive?._tag,
+    choices: choices && choices.length > 0 ? choices : undefined,
+    description: Option.getOrUndefined(single.description),
+    aliases: single.aliases && single.aliases.length > 0 ? single.aliases : undefined,
+  };
+};
+
+export const dumpCommandSchema = (command: unknown): CommandSchema => {
+  const node = command as CommandNode;
+  const flags = (node.config?.flags ?? [])
+    .map(flagToSchema)
+    .filter((flag): flag is FlagSchema => flag !== undefined);
+  const subcommands = (node.subcommands ?? [])
+    .flatMap((group) => group.commands ?? [])
+    .map(dumpCommandSchema);
+  return { name: node.name, description: node.description, flags, subcommands };
+};
+
+/**
+ * Builds the `commands` subcommand for a tool. Pass a thunk returning the tool's root command so the
+ * dump reflects the fully-assembled tree (the root is defined after its subcommands, incl. this one).
+ */
+export const makeSchemaCommand = (getRoot: () => unknown) =>
+  Command.make("commands", { format: formatOption }, ({ format }) =>
+    logFormatted(dumpCommandSchema(getRoot()), format),
+  ).pipe(
+    Command.withDescription(
+      "Dump the full command tree (names, descriptions, flags, types) as structured output — fetch once instead of repeated --help.",
+    ),
+  );