fix(worker): normalize model alias before preset lookup, wire DefaultMaxTurns as fallback

A full model id like claude-sonnet-4-6 in list_config.model never matched any
ModelPresets row (only bare aliases did), so every run under it landed on the
hardcoded 30-turn/DefaultLevel fallback instead of the sonnet preset row -
this is what killed two autonomous tasks at the 30-turn limit.

ModelRegistry.TryNormalizeAlias (non-throwing: exact match, then substring
match against a full model id) lets ModelPresets.For resolve a full model id
to its alias's preset row. For a model that still doesn't resolve, the
hardcoded 30 is replaced by a caller-supplied fallbackMaxTurns, and TaskRunner
now passes AppSettings.DefaultMaxTurns there - so that setting has a real
effect instead of being dead, matching the direction already noted in
docs/open.md.
This commit is contained in:
mika kuns
2026-08-05 08:56:23 +02:00
parent 63d8b5c28d
commit 7d636c60dd
9 changed files with 207 additions and 9 deletions
@@ -65,6 +65,44 @@ public class ModelPresetsTests
Assert.True(row.MaxTurns > 0);
}
[Fact]
public void For_unknown_model_uses_the_supplied_fallback_max_turns_instead_of_a_hardcoded_number()
{
var row = ModelPresets.For(ModelPresets.Defaults, "some-future-model", fallbackMaxTurns: 100);
Assert.Equal(100, row.MaxTurns);
}
[Fact]
public void For_a_full_model_id_resolves_to_its_alias_preset_row_not_the_unknown_fallback()
{
var sonnetPreset = ModelPresets.For(ModelPresets.Defaults, "sonnet");
var row = ModelPresets.For(ModelPresets.Defaults, "claude-sonnet-4-6");
Assert.Equal(sonnetPreset.Effort, row.Effort);
Assert.Equal(sonnetPreset.MaxTurns, row.MaxTurns);
}
[Fact]
public void For_a_full_model_id_honors_a_customized_preset_row_for_its_alias()
{
var parsed = ModelPresets.Parse(ModelPresets.Serialize(new[] { new ModelPreset("sonnet", "xhigh", 77) }));
var row = ModelPresets.For(parsed, "claude-sonnet-4-6");
Assert.Equal("xhigh", row.Effort);
Assert.Equal(77, row.MaxTurns);
}
[Fact]
public void For_unknown_model_never_throws_and_still_starts_a_run()
{
var exception = Record.Exception(() => ModelPresets.For(ModelPresets.Defaults, "totally-unrecognized-model"));
Assert.Null(exception);
}
[Fact]
public void For_null_model_uses_the_default_alias()
{
@@ -33,4 +33,28 @@ public class ModelRegistryTests
{
Assert.Equal(new[] { "haiku", "sonnet", "opus" }, ModelRegistry.ByCostAscending);
}
[Theory]
[InlineData("sonnet", "sonnet")]
[InlineData("OPUS", "opus")]
[InlineData(" haiku ", "haiku")]
[InlineData("claude-sonnet-4-6", "sonnet")]
[InlineData("claude-opus-4-6", "opus")]
[InlineData("claude-haiku-4-5-20251001", "haiku")]
[InlineData("us.anthropic.claude-sonnet-4-6-v1:0", "sonnet")]
public void TryNormalizeAlias_matches_aliases_and_full_model_ids(string input, string expected)
{
Assert.Equal(expected, ModelRegistry.TryNormalizeAlias(input));
}
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData(" ")]
[InlineData("gpt-4")]
[InlineData("some-future-model")]
public void TryNormalizeAlias_never_throws_and_returns_null_when_unrecognized(string? input)
{
Assert.Null(ModelRegistry.TryNormalizeAlias(input));
}
}
@@ -0,0 +1,111 @@
using ClaudeDo.Data;
using ClaudeDo.Data.Git;
using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Config;
using ClaudeDo.Worker.Hub;
using ClaudeDo.Worker.Runner;
using ClaudeDo.Worker.Tests.Infrastructure;
using Microsoft.Extensions.Logging.Abstractions;
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
using Xunit;
namespace ClaudeDo.Worker.Tests.Runner;
/// Verifies ResolveConfigAsync's model → preset resolution reaches the CLI args: a full
/// model id must hit its alias's preset row (not the hardcoded unknown-model fallback), and
/// an unknown model must still start a run, falling back no harder than AppSettings.DefaultMaxTurns.
public sealed class ModelResolutionWireTests : IDisposable
{
private readonly DbFixture _db = new();
private readonly string _tempDir;
private readonly WorkerConfig _cfg;
public ModelResolutionWireTests()
{
_tempDir = Path.Combine(Path.GetTempPath(), $"cd_modelwire_{Guid.NewGuid():N}");
Directory.CreateDirectory(_tempDir);
_cfg = new WorkerConfig { SandboxRoot = _tempDir, LogRoot = _tempDir };
}
public void Dispose() { _db.Dispose(); try { Directory.Delete(_tempDir, true); } catch { } }
private (TaskRunner Runner, IReadOnlyList<string> Args) BuildRunnerCapturingArgs(out Func<IReadOnlyList<string>> getArgs)
{
var dbFactory = _db.CreateFactory();
var state = TaskStateServiceBuilder.Build(dbFactory).State;
var wt = new WorktreeManager(new GitService(), dbFactory, _cfg, NullLogger<WorktreeManager>.Instance);
IReadOnlyList<string>? captured = null;
var fake = new FakeClaudeProcess((_, _, args, _, _) =>
{
captured = args;
return Task.FromResult(new RunResult { ExitCode = 0, ResultMarkdown = "ok" });
});
var runner = new TaskRunner(fake, dbFactory, new HubBroadcaster(new CapturingHubContext()), wt,
new ClaudeArgsBuilder(), _cfg, NullLogger<TaskRunner>.Instance, state, new TaskRunTokenRegistry(),
new AttachmentStore(), new FakeSessionSkillSeeder());
getArgs = () => captured!;
return (runner, Array.Empty<string>());
}
private async Task SeedTaskAsync(string listModel)
{
using var ctx = _db.CreateContext();
ctx.Lists.Add(new ListEntity { Id = "l1", Name = "L", WorkingDir = null, CreatedAt = DateTime.UtcNow });
ctx.ListConfigs.Add(new ListConfigEntity { ListId = "l1", Model = listModel });
ctx.Tasks.Add(new TaskEntity
{
Id = "t1", ListId = "l1", Title = "Task", Status = TaskStatus.Idle, CreatedAt = DateTime.UtcNow,
});
await ctx.SaveChangesAsync();
}
[Fact]
public async Task Full_model_id_resolves_to_its_alias_preset_row()
{
await SeedTaskAsync(listModel: "claude-sonnet-4-6");
var (runner, _) = BuildRunnerCapturingArgs(out var getArgs);
using (var ctx = _db.CreateContext())
await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("t1"))!, "slot-1", CancellationToken.None);
var args = getArgs().ToList();
var sonnetPreset = ModelPresets.For(ModelPresets.Defaults, "sonnet");
Assert.Contains("--effort", args);
Assert.Equal(sonnetPreset.Effort, args[args.IndexOf("--effort") + 1]);
Assert.Contains("--max-turns", args);
Assert.Equal(sonnetPreset.MaxTurns.ToString(), args[args.IndexOf("--max-turns") + 1]);
}
[Fact]
public async Task Unknown_model_still_starts_a_run_and_uses_the_global_default_max_turns()
{
await SeedTaskAsync(listModel: "totally-unrecognized-model");
var (runner, _) = BuildRunnerCapturingArgs(out var getArgs);
using (var ctx = _db.CreateContext())
{
var settingsRepo = new AppSettingsRepository(ctx);
var settings = await settingsRepo.GetAsync();
settings.DefaultMaxTurns = 100;
await ctx.SaveChangesAsync();
}
Exception? thrown = null;
try
{
using var ctx = _db.CreateContext();
await runner.RunAsync((await new TaskRepository(ctx).GetByIdAsync("t1"))!, "slot-1", CancellationToken.None);
}
catch (Exception ex)
{
thrown = ex;
}
Assert.Null(thrown);
var args = getArgs().ToList();
Assert.Contains("--max-turns", args);
Assert.Equal("100", args[args.IndexOf("--max-turns") + 1]);
}
}