thoth-agents 0.2.6 → 0.2.8

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import {
   getOpenCodeVersion,
   isOpenCodeInstalled,
   opencodeAdapter
-} from "../chunk-5DHG5II4.js";
+} from "../chunk-75JOF37E.js";
 import {
   CODEX_ROLE_NAMES,
   RECOMMENDED_SKILLS,
@@ -30,13 +30,18 @@ import {
   defaultClaudeCodeModelRoles,
   formatClaudeCodeSetupPlan,
   formatCodexSetupPlan,
+  getClaudeCodeModelRoles,
   getClaudeCodeStatus,
+  getCodexModelRoles,
   getCodexStatus,
+  getModelOptions,
+  getOpenCodeModelRoles,
   getOpenCodeStatus,
   getOperationHarness,
   installRecommendedSkill,
-  listOperationHarnesses
-} from "../chunk-DAZFSPN4.js";
+  listOperationHarnesses,
+  normalizeEffortSelection
+} from "../chunk-FM7HCZSW.js";
 import {
   ALL_AGENT_NAMES,
   CUSTOM_SKILLS,
@@ -48,7 +53,7 @@ import {
   getExistingLiteConfigPath,
   installCustomSkills,
   writeLiteConfig
-} from "../chunk-76DARQOT.js";
+} from "../chunk-YLRPDTU7.js";
 
 // src/cli/index.ts
 import { pathToFileURL } from "url";
@@ -505,6 +510,8 @@ Options:
   --agent=opencode|codex|claude
                          Select OpenCode plugin install (default), Codex agent-pack, or Claude Code plugin setup
   --harness=...          Select harness for status/update/sync/model (opencode|codex|claude)
+  --role-effort=role=effort
+                         Set a repeatable role effort; use inherit or default for no override
   -h, --help             Show this help message
 
 Generate options:
@@ -584,9 +591,37 @@ function defaultModelRoles(harness) {
     model: DEFAULT_MODELS[role] ?? "openai/gpt-5.4"
   }));
 }
-function modelRoles(harness, roles) {
-  return roles.length > 0 ? [...roles] : defaultModelRoles(harness);
+function resolveCliModelRoles(harness, roles, resolution) {
+  const defaults = resolution?.currentRoles ?? defaultModelRoles(harness);
+  if (roles.length === 0) return defaults.map((role) => ({ ...role }));
+  const defaultsByRole = new Map(defaults.map((role) => [role.role, role]));
+  return roles.map((role) => {
+    const fallback = defaultsByRole.get(role.role);
+    const model = role.model ?? fallback?.model ?? "";
+    const catalogId = harness === "codex" && !model.includes("/") ? `openai/${model}` : model;
+    const option = resolution?.modelOptions.find(
+      (candidate) => candidate.id === model || candidate.catalogId === model || candidate.catalogId === catalogId
+    );
+    const provider = role.provider ?? option?.provider ?? fallback?.provider;
+    return {
+      role: role.role,
+      model,
+      ...provider !== void 0 ? { provider } : {},
+      ...option?.catalogId !== void 0 ? { catalogId: option.catalogId } : fallback?.catalogId ? { catalogId: fallback.catalogId } : {},
+      ...option?.efforts !== void 0 ? { availableEfforts: option.efforts } : fallback?.availableEfforts ? { availableEfforts: fallback.availableEfforts } : {},
+      ...role.effort !== void 0 ? { effort: role.effort } : {}
+    };
+  });
 }
+var defaultModelCommandServices = {
+  operationContext,
+  modelRoles(harness) {
+    if (harness === "opencode") return getOpenCodeModelRoles();
+    if (harness === "claude") return getClaudeCodeModelRoles();
+    return getCodexModelRoles();
+  },
+  modelOptions: getModelOptions
+};
 function printModelGuidance() {
   console.log(
     [
@@ -599,14 +634,19 @@ function printModelGuidance() {
   );
   return 1;
 }
-function buildModelPlan(args) {
+async function buildModelPlan(args, services) {
   if (args.roles.length === 0) return void 0;
   const harness = selectedHarness(args);
-  const context = operationContext();
+  const context = services.operationContext();
+  const currentRoles = services.modelRoles(harness);
+  const modelOptions = await services.modelOptions(harness);
   const input = {
     harness,
     dryRun: true,
-    roles: modelRoles(harness, args.roles)
+    roles: resolveCliModelRoles(harness, args.roles, {
+      currentRoles,
+      modelOptions
+    })
   };
   if (harness === "opencode") return buildOpenCodeModelPlan(input, context);
   if (harness === "claude") return buildClaudeCodeModelPlan(input, context);
@@ -629,7 +669,7 @@ function printPlanOrApply(plan, args) {
   console.log(formatOperationApplyResult(applyOperationPlan(plan)));
   return 0;
 }
-function runOperationCommand(command, args) {
+async function runOperationCommand(command, args, services) {
   if (command === "status") {
     console.log(formatHarnessStatusReport(statusReports(args)));
     return 0;
@@ -641,7 +681,7 @@ function runOperationCommand(command, args) {
   if (command === "update" || command === "sync") {
     return printPlanOrApply(buildOperationPlan(command, args), args);
   }
-  const plan = buildModelPlan(args);
+  const plan = await buildModelPlan(args, services);
   if (!plan) return printModelGuidance();
   return printPlanOrApply(plan, args);
 }
@@ -662,7 +702,7 @@ function printHarnessGeneration(args) {
   console.log(JSON.stringify(result, null, 2));
   return 0;
 }
-async function runCliCommand(parsed) {
+async function runCliCommand(parsed, modelServices = defaultModelCommandServices) {
   if (parsed.command === "install") {
     return install(parsed.installArgs);
   }
@@ -682,7 +722,11 @@ async function runCliCommand(parsed) {
     console.error("Run with --help for usage information");
     return 1;
   }
-  return runOperationCommand(parsed.command, parsed.operationArgs);
+  return runOperationCommand(
+    parsed.command,
+    parsed.operationArgs,
+    modelServices
+  );
 }
 
 // src/cli/runtime.ts
@@ -754,17 +798,39 @@ function parseRoleModel(value) {
   }
   return { role, model };
 }
+function parseRoleEffort(value) {
+  const separator = value.includes("=") ? "=" : ":";
+  const [role, ...effortParts] = value.split(separator);
+  const effort = effortParts.join(separator);
+  if (!role || !effort) {
+    throw new Error(
+      "--role-effort must use role=effort or role:effort, for example --role-effort=deep=high."
+    );
+  }
+  return { role, effort: normalizeEffortSelection(effort) };
+}
 function parseOperationArgs(args) {
   const result = { roles: [] };
   let pendingRole;
   let pendingProvider;
+  function upsertRole(input) {
+    const existing = result.roles.find((role) => role.role === input.role);
+    if (!existing) {
+      result.roles.push(input);
+      return;
+    }
+    if (existing.effort && input.effort && JSON.stringify(existing.effort) !== JSON.stringify(input.effort)) {
+      throw new Error(`Conflicting --role-effort values for ${input.role}.`);
+    }
+    Object.assign(existing, input);
+  }
   function pushPendingRole(model) {
     if (!pendingRole) {
       throw new Error(
         "--model requires --role, or pass --role-model=role=model."
       );
     }
-    result.roles.push({
+    upsertRole({
       role: pendingRole,
       model,
       provider: pendingProvider
@@ -793,11 +859,13 @@ function parseOperationArgs(args) {
       pushPendingRole(arg.split("=")[1] ?? "");
     } else if (arg.startsWith("--role-model=")) {
       const parsed = parseRoleModel(arg.slice("--role-model=".length));
-      result.roles.push({
+      upsertRole({
         ...parsed,
         provider: pendingProvider
       });
       pendingProvider = void 0;
+    } else if (arg.startsWith("--role-effort=")) {
+      upsertRole(parseRoleEffort(arg.slice("--role-effort=".length)));
     } else if (arg === "-h" || arg === "--help") {
       throw new Error("help");
     } else {

package/dist/cli/managed-state-io.d.ts

@@ -10,6 +10,7 @@ export interface ManagedModelState {
     version: number;
     models: Record<string, string>;
     configuredModels?: Record<string, string>;
+    configuredEfforts?: Record<string, string>;
 }
 export declare function emptyManagedModelState(version: number): ManagedModelState;
 export declare function parseManagedModelStateJson(text: string | undefined, version: number): ManagedModelState;

package/dist/cli/model-catalog/cache.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const modelsDevCacheSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    etag: z.ZodOptional<z.ZodString>;
+    fetchedAt: z.ZodString;
+    catalog: z.ZodObject<{
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            catalogId: z.ZodOptional<z.ZodString>;
+            label: z.ZodString;
+            provider: z.ZodString;
+            efforts: z.ZodArray<z.ZodString>;
+            source: z.ZodEnum<{
+                manual: "manual";
+                remote: "remote";
+                lkg: "lkg";
+            }>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ModelsDevCacheV1 = z.infer<typeof modelsDevCacheSchema>;
+export interface ModelsDevCachePathOptions {
+    platform?: NodeJS.Platform;
+    env?: Readonly<Record<string, string | undefined>>;
+    homeDir?: string;
+}
+export declare function resolveModelsDevCachePath(options?: ModelsDevCachePathOptions): string;
+export declare function readModelsDevCache(cachePath: string): ModelsDevCacheV1 | undefined;
+export declare function writeModelsDevCacheAtomic(cachePath: string, cache: ModelsDevCacheV1): void;

package/dist/cli/model-catalog/index.d.ts

@@ -0,0 +1,18 @@
+import type { ModelOption } from './types';
+export interface LoadModelsDevCatalogOptions {
+    cachePath?: string;
+    manual?: readonly ModelOption[];
+    fetcher?: typeof fetch;
+    now?: () => Date;
+}
+export interface LoadedModelCatalog {
+    models: ModelOption[];
+    source: 'remote' | 'lkg' | 'manual';
+    stale: boolean;
+    checkedAt: string;
+    warnings: string[];
+}
+export declare function mergeModelCatalog(dynamic: readonly ModelOption[], manual: readonly ModelOption[]): ModelOption[];
+export declare function loadModelsDevCatalog(options?: LoadModelsDevCatalogOptions): Promise<LoadedModelCatalog>;
+export { readModelsDevCache, resolveModelsDevCachePath, writeModelsDevCacheAtomic, } from './cache';
+export type { ModelCatalogSource, ModelOption, ModelsDevCatalogResult, NormalizedModelsDevCatalog, } from './types';

package/dist/cli/model-catalog/models-dev.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import type { ModelsDevCatalogResult } from './types';
+export declare const modelsDevCatalogSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    models: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        reasoning_options: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>>;
+export type ModelsDevCatalog = z.infer<typeof modelsDevCatalogSchema>;
+export declare function normalizeModelsDevCatalog(input: unknown): ModelsDevCatalogResult;

package/dist/cli/model-catalog/types.d.ts

@@ -0,0 +1,19 @@
+export type ModelCatalogSource = 'remote' | 'lkg' | 'manual';
+export interface ModelOption {
+    id: string;
+    catalogId?: string;
+    label: string;
+    provider: string;
+    efforts: readonly string[];
+    source: ModelCatalogSource;
+}
+export interface NormalizedModelsDevCatalog {
+    models: readonly ModelOption[];
+}
+export type ModelsDevCatalogResult = {
+    ok: true;
+    catalog: NormalizedModelsDevCatalog;
+} | {
+    ok: false;
+    issues: readonly string[];
+};

package/dist/cli/model-effort.d.ts

@@ -0,0 +1,11 @@
+export type EffortSelection = {
+    kind: 'inherit';
+} | {
+    kind: 'effort';
+    value: string;
+};
+export declare function normalizeEffortSelection(value: string | null | undefined): EffortSelection;
+export declare function isExplicitEffort(selection: EffortSelection): selection is {
+    kind: 'effort';
+    value: string;
+};

package/dist/cli/opencode-effort.d.ts

@@ -0,0 +1,10 @@
+import type { ModelRoleInput } from './operations/types';
+export type OpenCodeEffortResolution = {
+    ok: true;
+    variant: string | undefined;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+export declare function resolveOpenCodeEffort(input: Pick<ModelRoleInput, 'catalogId' | 'availableEfforts' | 'effort' | 'model'>): OpenCodeEffortResolution;

package/dist/cli/operations/claude-code.d.ts

@@ -5,6 +5,15 @@ export interface ClaudeCodeOperationContext extends OperationContext {
     homeDir?: string;
     packageRoot?: string;
 }
+export type ClaudeCodeEffortResolution = {
+    ok: true;
+    effort: string | undefined;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+export declare function resolveClaudeCodeEffort(input: Pick<ModelRoleInput, 'availableEfforts' | 'catalogId' | 'effort' | 'model'>): ClaudeCodeEffortResolution;
 export declare const claudeCodeOperationAdapter: {
     readonly id: "claude";
     readonly displayName: "Claude Code";

package/dist/cli/operations/codex.d.ts

@@ -1,5 +1,5 @@
 import type { CodexInstallScope } from '../codex-paths';
-import type { HarnessAction, HarnessStatusReport, ModelConfigInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
+import type { HarnessAction, HarnessStatusReport, ModelConfigInput, ModelRoleInput, OperationApplyResult, OperationContext, OperationPlan } from './types';
 export interface CodexOperationContext extends OperationContext {
     scope?: CodexInstallScope;
     homeDir?: string;
@@ -18,5 +18,13 @@ export declare function getCodexStatus(context?: CodexOperationContext): Harness
 export declare function buildCodexUpdatePlan(context?: CodexOperationContext): OperationPlan;
 export declare function buildCodexSyncPlan(context?: CodexOperationContext): OperationPlan;
 export declare function buildCodexInstallPlan(context?: CodexOperationContext): OperationPlan;
+export declare function resolveCodexEffort(input: ModelRoleInput): {
+    ok: true;
+    value: string | undefined;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
 export declare function buildCodexModelPlan(input: ModelConfigInput, context?: CodexOperationContext): OperationPlan;
 export declare function applyCodexPlan(plan: OperationPlan): OperationApplyResult;

package/dist/cli/operations/types.d.ts

@@ -1,4 +1,5 @@
 import type { HarnessId } from '../../harness/types';
+import type { EffortSelection } from '../model-effort';
 export type ManagedState = 'installed' | 'missing' | 'drift' | 'outdated' | 'unknown';
 export type OperationActionKind = 'status' | 'list' | 'install' | 'update' | 'sync' | 'repair' | 'model-config';
 export type ManagedTargetKind = 'file' | 'directory' | 'config' | 'skill' | 'hook' | 'memory-state' | 'generated-artifact' | 'package' | 'surface' | 'unknown';
@@ -89,6 +90,9 @@ export interface ModelRoleInput {
     role: string;
     model: string;
     provider?: string;
+    effort?: EffortSelection;
+    catalogId?: string;
+    availableEfforts?: readonly string[];
 }
 export interface ModelConfigInput {
     harness: HarnessId;

package/dist/cli/paths.d.ts

@@ -12,6 +12,7 @@ export declare function getConfigJson(): string;
 export declare function getConfigJsonc(): string;
 export declare function getLiteConfig(): string;
 export declare function getLiteConfigJsonc(): string;
+export declare function getOpenCodeManagedModelStatePath(): string;
 export declare function getExistingLiteConfigPath(): string;
 export declare function getExistingConfigPath(): string;
 export declare function ensureConfigDir(): void;

package/dist/cli/providers.d.ts

@@ -6,28 +6,28 @@ export declare const MODEL_MAPPINGS: {
             readonly model: "openai/gpt-5.4";
         };
         readonly oracle: {
-            readonly model: "openai/gpt-5.4";
+            readonly model: "openai/gpt-5.6-sol";
             readonly variant: "high";
         };
         readonly librarian: {
-            readonly model: "openai/gpt-5.4-mini";
+            readonly model: "openai/gpt-5.6-luna";
             readonly variant: "low";
         };
         readonly explorer: {
-            readonly model: "openai/gpt-5.4-mini";
+            readonly model: "openai/gpt-5.6-luna";
             readonly variant: "low";
         };
         readonly designer: {
-            readonly model: "openai/gpt-5.4-mini";
-            readonly variant: "medium";
+            readonly model: "openai/gpt-5.6-terra";
+            readonly variant: "high";
         };
         readonly quick: {
-            readonly model: "openai/gpt-5.4-mini";
-            readonly variant: "low";
+            readonly model: "openai/gpt-5.6-luna";
+            readonly variant: "medium";
         };
         readonly deep: {
-            readonly model: "openai/gpt-5.4";
-            readonly variant: "high";
+            readonly model: "openai/gpt-5.6-terra";
+            readonly variant: "xhigh";
         };
     };
     readonly kimi: {

package/dist/cli/tui/components/ModelChoiceScreen.d.ts

@@ -6,4 +6,12 @@ interface ModelChoiceScreenProps {
     selected: number;
 }
 export declare function ModelChoiceScreen({ currentModel, draftModel, options, selected, }: ModelChoiceScreenProps): import("react/jsx-runtime").JSX.Element;
+interface EffortChoiceScreenProps {
+    model: string;
+    currentEffort: string;
+    draftEffort: string;
+    choices: readonly string[];
+    selected: number;
+}
+export declare function EffortChoiceScreen({ model, currentEffort, draftEffort, choices, selected, }: EffortChoiceScreenProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/cli/tui/components/ModelScreen.d.ts

@@ -2,6 +2,7 @@ import type { HarnessId } from '../../../harness/types';
 import type { ModelRoleInput } from '../../operations';
 export interface ModelRoleView extends ModelRoleInput {
     currentModel: string;
+    currentEffort: NonNullable<ModelRoleInput['effort']>;
     dirty: boolean;
 }
 interface ModelScreenProps {