1package agent
2
3import (
4 "context"
5 "fmt"
6 "os"
7 "path/filepath"
8 "runtime"
9 "sort"
10 "strings"
11
12 zutdocs "github.com/bnema/zut"
13 "github.com/bnema/zut/packages/agent/lsp"
14 "github.com/bnema/zut/packages/agent/skills"
15 "github.com/bnema/zut/packages/agent/subagents"
16 "github.com/bnema/zut/packages/agent/tools"
17 "github.com/bnema/zut/packages/core"
18 "github.com/bnema/zut/packages/provider"
19)
20
21// ContextFile is an instruction file loaded into the system prompt.
22type ContextFile struct {
23 Path string
24 Content string
25}
26
27// Resolved is the effective configuration after merging CLI, config, defaults.
28type Resolved struct {
29 Provider string
30 Model string
31 Credential string // api key or oauth access token
32 AuthMethod string // "apikey" | "oauth" | "" (no credential yet)
33 AccountID string // ChatGPT account id (for openai oauth), "" otherwise
34 BaseURL string
35 InsecureTLS bool
36 CWD string
37 Reasoning string
38 Temperature *float32
39 FastMode bool
40 WebSearchPolicy subagents.WebSearchPolicy
41
42 ToolRegistry core.Registry
43 ToolSummary []ToolSummary
44 SystemPrompt string
45 MaxSteps int
46 Sandbox *tools.Sandbox
47
48 // ContextWindow and MaxOutput retain the effective model metadata,
49 // including metadata synthesized for valid open-catalog local and routed
50 // models that provider.FindModel cannot rediscover later.
51 ContextWindow int
52
53 // MaxOutput is the resolved model's maximum output-token budget
54 // (from the catalog). Passed to the agent so each turn requests
55 // the model's full output capacity instead of the provider's
56 // conservative default (e.g. Bedrock's 4096, which truncates
57 // long writes/edits with stopReason=length).
58 MaxOutput int
59
60 // SkillTool is the on-demand skill loader registered with the
61 // agent's tool registry, or nil if no SKILL.md files were
62 // discovered. Exposed so the tui can list / preview skills.
63 SkillTool *skills.Tool
64
65 // ContextFiles records the AGENTS.md files appended to SystemPrompt,
66 // in effective load order. Interactive mode uses this metadata to make
67 // otherwise invisible startup context inspectable without adding fake
68 // messages to the provider transcript.
69 ContextFiles []ContextFile
70
71 // skillsEnabled is true when discovery ran, even when it found no
72 // skills. It is false only for an explicit clean-room disable.
73 skillsEnabled bool
74
75 // Bookkeeping for MergeExtensionTools. Captured at Resolve time
76 // so the system prompt can be rebuilt later without re-running
77 // resolve.
78 systemAppend []string
79 systemCustom string
80 skillAddendum string
81 toolDescriptions map[string]string
82}
83
84// HasCredential reports whether a credential was resolved.
85func (r Resolved) HasCredential() bool { return r.Credential != "" }
86
87// MergeExtensionTools folds every tool registered by an extension
88// into r's ToolRegistry and re-renders the system prompt's tool
89// summary so the model sees both built-in and extension tools.
90//
91// Idempotent: calling twice with the same manager state has no
92// effect on the second pass (existing names are preserved). Built-in
93// tools always win on conflict.
94func (r *Resolved) MergeExtensionTools(mgr ExtensionToolSource) {
95 if mgr == nil {
96 return
97 }
98 changed := false
99 for _, info := range mgr.Tools() {
100 // web_search remains a reserved native-tool name even when its
101 // capability policy excludes the current session. An extension must
102 // not turn a normal CLI opt-out into a differently implemented search
103 // capability with the same model-visible name.
104 if info.Name == "web_search" {
105 continue
106 }
107 if _, exists := r.ToolRegistry[info.Name]; exists {
108 continue
109 }
110 r.ToolRegistry[info.Name] = mgr.NewExtensionTool(info)
111 changed = true
112 }
113
114 // A nil SkillTool can mean discovery ran and found nothing, so use the
115 // explicit disable flag rather than the discovery result as the gate.
116 if source, ok := mgr.(ExtensionSkillSource); ok && r.skillsEnabled {
117 if bundled := source.Skills(); len(bundled) > 0 {
118 merged := mergeExtensionSkills(r.SkillTool, bundled)
119 if r.SkillTool == nil {
120 r.SkillTool = skills.NewTool(merged)
121 r.ToolRegistry[r.SkillTool.Name()] = r.SkillTool
122 } else {
123 r.SkillTool.SetSkills(merged)
124 }
125 append_ := append([]string(nil), r.systemAppend...)
126 if r.skillAddendum != "" {
127 filtered := append_[:0]
128 for _, item := range append_ {
129 if item != r.skillAddendum {
130 filtered = append(filtered, item)
131 }
132 }
133 append_ = filtered
134 }
135 r.skillAddendum = skills.SystemPromptAddendum(merged)
136 if r.skillAddendum != "" {
137 append_ = append(append_, r.skillAddendum)
138 }
139 r.systemAppend = append_
140 changed = true
141 }
142 }
143 if !changed {
144 return
145 }
146 // Re-render the system prompt with the merged tool and skill lists.
147 r.ToolSummary = toolSummariesFromRegistry(r.ToolRegistry, r.toolDescriptions)
148 r.SystemPrompt = BuildSystemPrompt(SystemPromptOpts{
149 CWD: r.CWD,
150 Tools: r.ToolSummary,
151 Custom: r.systemCustom,
152 Append: r.systemAppend,
153 ZutDocsDir: filepath.Join(ZutHome(), "docs"),
154 })
155}
156
157func mergeExtensionSkills(tool *skills.Tool, bundled []*skills.Skill) []*skills.Skill {
158 var existing []*skills.Skill
159 if tool != nil {
160 existing = tool.Skills()
161 }
162 merged := make([]*skills.Skill, 0, len(existing)+len(bundled))
163 seen := map[string]bool{}
164 add := func(list []*skills.Skill) {
165 for _, skill := range list {
166 if skill == nil || skill.Name == "" || seen[skill.Name] {
167 continue
168 }
169 seen[skill.Name] = true
170 merged = append(merged, skill)
171 }
172 }
173 var user, builtins []*skills.Skill
174 for _, skill := range existing {
175 if skill == nil || strings.HasPrefix(skill.Source, "extension ") {
176 continue
177 }
178 if skill.Builtin {
179 builtins = append(builtins, skill)
180 } else {
181 user = append(user, skill)
182 }
183 }
184 add(user)
185 add(bundled)
186 add(builtins)
187 return merged
188}
189
190// ExtensionToolSource is the slice of the extension manager that
191// MergeExtensionTools needs. Lives here as an interface so the
192// build package doesn't import packages/agent/extensions (which
193// imports core, which imports... avoid the cycle).
194type ExtensionToolSource interface {
195 Tools() []ExtensionToolInfo
196 NewExtensionTool(info ExtensionToolInfo) core.Tool
197}
198
199// ExtensionSkillSource exposes the optional bundled-skill surface without
200// forcing older ExtensionToolSource implementations to add it.
201type ExtensionSkillSource interface {
202 Skills() []*skills.Skill
203}
204
205// ExtensionToolInfo mirrors extensions.ToolInfo so we can declare
206// ExtensionToolSource here without importing the extensions
207// package. The cli wires a tiny adapter to bridge them.
208type ExtensionToolInfo struct {
209 Extension string
210 Name string
211 Description string
212 Schema []byte
213 Deferred bool
214}
215
216// toolSummariesFromRegistry rebuilds the system-prompt tool list
217// from a (possibly extended) registry, using cached descriptions for
218// the human-readable summary text.
219func toolSummariesFromRegistry(reg core.Registry, cached map[string]string) []ToolSummary {
220 out := make([]ToolSummary, 0, len(reg))
221 seen := make(map[string]bool, len(nativeToolSummaryOrder))
222 appendSummary := func(name string) {
223 t, ok := reg[name]
224 if !ok {
225 return
226 }
227 seen[name] = true
228 if d, ok := t.(interface{ Deferred() bool }); ok && d.Deferred() {
229 return
230 }
231 desc := t.Description()
232 if d, ok := cached[name]; ok && d != "" {
233 desc = d
234 }
235 out = append(out, ToolSummary{Name: name, Description: desc})
236 }
237 for _, name := range nativeToolSummaryOrder {
238 appendSummary(name)
239 }
240 remaining := make([]string, 0, len(reg)-len(seen))
241 for name := range reg {
242 if !seen[name] {
243 remaining = append(remaining, name)
244 }
245 }
246 sort.Strings(remaining)
247 for _, name := range remaining {
248 appendSummary(name)
249 }
250 return out
251}
252
253// defaultModelForProvider returns the model id zut prefers when the
254// caller didn't pick one. Mirrors the per-provider switch used at
255// multiple points in Resolve; centralised so the unknown-model
256// recovery path and the no-model-configured path can't drift.
257//
258// Returns the empty string for "ollama", which has no built-in
259// default — the caller is expected to special-case ollama and
260// error or use whatever the user passed.
261func defaultModelForProvider(prov string) string {
262 switch prov {
263 case "openai":
264 return "gpt-5"
265 case "openai-codex":
266 return "gpt-5.5"
267 case "openai-responses":
268 return "gpt-5"
269 case "kimi":
270 return "kimi-for-coding"
271 case "deepseek":
272 return "deepseek-v4-pro"
273 case "google":
274 return "gemini-2.5-pro"
275 case "ollama", provider.LlamaCPPProviderID:
276 return ""
277 case "moonshotai", "moonshotai-cn":
278 return "kimi-k2.6"
279 case "cerebras":
280 return "qwen-3-235b-a22b-instruct-2507"
281 case "groq":
282 return "llama-3.3-70b-versatile"
283 case "xai":
284 return "grok-4.5"
285 case "together":
286 return "Qwen/Qwen3-Coder-480B-A35B-Instruct"
287 case "huggingface":
288 return "moonshotai/Kimi-K2-Instruct"
289 case "openrouter":
290 return "anthropic/claude-sonnet-4.5"
291 case "mistral":
292 return "mistral-large-latest"
293 case "zai":
294 return "glm-4.7"
295 case "xiaomi", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "xiaomi-token-plan-sgp":
296 return "mimo-v2.5"
297 case "minimax", "minimax-cn":
298 return "MiniMax-M2.7"
299 case "fireworks":
300 return "accounts/fireworks/models/kimi-k2p6"
301 case "vercel-ai-gateway":
302 return "anthropic/claude-sonnet-4.5"
303 case "opencode":
304 return "claude-sonnet-4-5"
305 case "opencode-go":
306 return "kimi-k2.6"
307 case "amazon-bedrock":
308 return "anthropic.claude-sonnet-4-5-20250929-v1:0"
309 case "google-vertex":
310 return "gemini-2.5-pro"
311 case "azure-openai-responses":
312 return "gpt-5"
313 case "github-copilot":
314 return "claude-sonnet-4.5"
315 default:
316 // Custom providers: pick the first model from the catalog for
317 // that provider, or fall back to the global default.
318 if models := provider.ModelsForProvider(prov); len(models) > 0 {
319 return models[0].ID
320 }
321 return provider.DefaultModel.ID
322 }
323}
324
325// knownProviders is the set of provider ids zut recognises. Used by
326// Resolve to validate args.Provider, by extension-callers, and by the
327// auto-fallback logic that picks any logged-in provider when the user's
328// preferred one has no credentials.
329var knownProviders = []string{
330 "anthropic", "openai", "openai-codex", "openai-responses", "kimi", "deepseek", "google", "ollama", provider.LlamaCPPProviderID,
331 "moonshotai", "moonshotai-cn",
332 "cerebras", "groq", "xai", "together", "huggingface", "openrouter",
333 "mistral", "zai",
334 "xiaomi", "xiaomi-token-plan-ams", "xiaomi-token-plan-cn", "xiaomi-token-plan-sgp",
335 "minimax", "minimax-cn",
336 "fireworks", "vercel-ai-gateway",
337 "opencode", "opencode-go",
338 "amazon-bedrock", "google-vertex", "azure-openai-responses",
339 "github-copilot", "cloudflare-workers-ai", "cloudflare-ai-gateway",
340}
341
342func isKnownProvider(name string) bool {
343 for _, p := range knownProviders {
344 if p == name {
345 return true
346 }
347 }
348 _, ok := provider.CustomProviders()[name]
349 return ok
350}
351
352// isBuiltinProvider reports whether name is in the hardcoded
353// knownProviders list (not a user-defined custom provider).
354func isBuiltinProvider(name string) bool {
355 for _, p := range knownProviders {
356 if p == name {
357 return true
358 }
359 }
360 return false
361}
362
363// providerAliases maps common short / alternate provider names to the
364// canonical id in knownProviders. Users (and other agents) reach for
365// "bedrock" or "vertex" far more naturally than the fully-qualified
366// "amazon-bedrock" / "google-vertex"; without this mapping an alias is
367// treated as an unknown provider and Resolve silently falls back to
368// anthropic, producing a misleading "no credential for anthropic" error
369// after the user explicitly picked, say, bedrock.
370var providerAliases = map[string]string{
371 "bedrock": "amazon-bedrock",
372 "aws-bedrock": "amazon-bedrock",
373 "amazon": "amazon-bedrock",
374 "vertex": "google-vertex",
375 "gcp-vertex": "google-vertex",
376 "gemini": "google",
377 "googleai": "google",
378 "google-ai": "google",
379 "azure": "azure-openai-responses",
380 "azure-openai": "azure-openai-responses",
381 "copilot": "github-copilot",
382 "github": "github-copilot",
383 "codex": "openai-codex",
384 "moonshot": "moonshotai",
385 "kimi-code": "kimi",
386 "ai-gateway": "vercel-ai-gateway",
387 "vercel": "vercel-ai-gateway",
388 "cloudflare": "cloudflare-workers-ai",
389 "workers-ai": "cloudflare-workers-ai",
390 "hf": "huggingface",
391 "llama": provider.LlamaCPPProviderID,
392 "llamacpp": provider.LlamaCPPProviderID,
393}
394
395// canonicalProvider normalises a user-supplied provider name: trims
396// surrounding whitespace, lower-cases it, and resolves any known alias
397// to its canonical id. Unknown names are returned trimmed/lower-cased
398// and unchanged so the existing unknown-provider handling still runs.
399func canonicalProvider(name string) string {
400 n := strings.ToLower(strings.TrimSpace(name))
401 if n == "" {
402 return n
403 }
404 if canon, ok := providerAliases[n]; ok {
405 return canon
406 }
407 return n
408}
409
410func findSubagentProfile(cwd, name string) (*subagents.Profile, error) {
411 name = strings.TrimSpace(name)
412 if name == "" {
413 return nil, nil
414 }
415 home, _ := os.UserHomeDir()
416 profiles, discoveryErrors := subagents.Discover(cwd, home)
417 if len(discoveryErrors) > 0 {
418 return nil, fmt.Errorf("discover subagent profiles: %d profile discovery error(s)", len(discoveryErrors))
419 }
420 profile := subagents.Find(profiles, name)
421 if profile == nil {
422 return nil, fmt.Errorf("subagent profile %q not found (looked in ~/.agents/agents and compatibility locations)", name)
423 }
424 return profile, nil
425}
426
427func applySubagentProfile(args *Args, profile *subagents.Profile) {
428 if args == nil || profile == nil {
429 return
430 }
431 profileProvider, profileModel := profile.ModelSelection()
432 if args.Provider == "" && profileProvider != "" {
433 args.Provider = profileProvider
434 }
435 if args.Model == "" && profileModel != "" {
436 args.Model = profileModel
437 }
438 if args.Reasoning == "" && profile.Thinking != "" {
439 // Keep an explicit "off" value non-empty so it overrides a
440 // persisted global reasoning setting when the child resolves.
441 args.Reasoning = strings.TrimSpace(profile.Thinking)
442 }
443 if !args.NoTools && !args.ToolsSet && len(args.Tools) == 0 && len(profile.Tools) > 0 {
444 args.Tools = append([]string(nil), profile.Tools...)
445 }
446 if profile.InheritSkills != nil && !*profile.InheritSkills {
447 args.NoSkill = true
448 }
449}
450
451// resolveWebSearchPolicy applies capability precedence at the owning resolver
452// boundary. Permission, tool-list, and named-profile restrictions are ceilings
453// on every caller-provided policy. Workers additionally require an explicit,
454// valid propagated decision rather than falling back to their local config.
455func resolveWebSearchPolicy(args Args, cfg Config, cfgErr error, profile *subagents.Profile) subagents.WebSearchPolicy {
456 if args.NoTools || args.PermissionSet != nil {
457 return subagents.WebSearchDeny
458 }
459 if args.ToolsSet && !toolListContains(args.Tools, "web_search") {
460 return subagents.WebSearchDeny
461 }
462 if profile != nil && subagents.NamedWebSearchPolicy(profile.Tools) != subagents.WebSearchAllow {
463 return subagents.WebSearchDeny
464 }
465
466 switch args.WebSearchPolicy {
467 case subagents.WebSearchDeny:
468 return subagents.WebSearchDeny
469 case subagents.WebSearchAllow:
470 return subagents.WebSearchAllow
471 case subagents.WebSearchInherit:
472 // Continue through normal-mode defaults below. Inherit is not a valid
473 // propagated worker decision.
474 default:
475 return subagents.WebSearchDeny
476 }
477 if args.Mode == ModeSubagentWorker {
478 return subagents.WebSearchDeny
479 }
480 if args.ToolsSet {
481 return subagents.WebSearchAllow
482 }
483 if cfgErr != nil {
484 return subagents.WebSearchDeny
485 }
486 if profile != nil {
487 return subagents.WebSearchAllow
488 }
489 if cfg.WebSearchEnabledForCLI() {
490 return subagents.WebSearchAllow
491 }
492 return subagents.WebSearchDeny
493}
494
495func toolListContains(names []string, target string) bool {
496 for _, name := range names {
497 if name == target {
498 return true
499 }
500 }
501 return false
502}
503
504// webSearchAllowedForRegistry is kept separate from the resolver so direct
505// registry tests and callers that build a registry without persisted config
506// still get the normal default-on behavior. Worker registries fail closed if
507// they have not first received a resolved allow decision.
508func webSearchAllowedForRegistry(args Args) bool {
509 if args.NoTools || args.PermissionSet != nil {
510 return false
511 }
512 if args.ToolsSet && !toolListContains(args.Tools, "web_search") {
513 return false
514 }
515 switch args.WebSearchPolicy {
516 case subagents.WebSearchAllow:
517 return true
518 case subagents.WebSearchDeny:
519 return false
520 default:
521 return args.Mode != ModeSubagentWorker
522 }
523}
524
525// Resolve merges args, config, and env into a Resolved set.
526//
527// Unlike the earlier version, Resolve NEVER returns an error for
528// missing credentials: the TUI can start without them and launch a
529// login flow. requireCred controls whether missing credentials are a
530// hard error (used by print/json modes).
531func Resolve(args Args, requireCred bool) (Resolved, error) {
532 cfg, cfgErr := LoadConfig()
533 // Programmatic callers historically supplied Tools without the parser's
534 // provenance bit. Treat a non-empty list as explicit before a named profile
535 // can contribute its defaults.
536 if len(args.Tools) > 0 {
537 args.ToolsSet = true
538 }
539 var selectedProfile *subagents.Profile
540 if strings.TrimSpace(args.Subagent) != "" {
541 var err error
542 selectedProfile, err = findSubagentProfile(args.CWD, args.Subagent)
543 if err != nil {
544 return Resolved{}, err
545 }
546 applySubagentProfile(&args, selectedProfile)
547 }
548 webSearchPolicy := resolveWebSearchPolicy(args, cfg, cfgErr, selectedProfile)
549 args.WebSearchPolicy = webSearchPolicy
550
551 // User-requested provider (explicit > config > default).
552 // Normalise common aliases (e.g. "bedrock" -> "amazon-bedrock")
553 // before validation so an alias is never mistaken for an unknown
554 // provider and silently downgraded to anthropic.
555 argProvider := canonicalProvider(args.Provider)
556 provName := firstNonEmpty(argProvider, canonicalProvider(cfg.Provider), "anthropic")
557 if !isKnownProvider(provName) {
558 // Unknown provider (maybe removed or renamed). Fall back to
559 // the first provider that has credentials, or anthropic.
560 // Custom providers (from models.json) are already accepted
561 // by isKnownProvider, so we only reach here for truly unknown
562 // names.
563 provName = "anthropic"
564 if CredentialAvailable("openai") {
565 provName = "openai"
566 }
567 if CredentialAvailable("openai-codex") {
568 provName = "openai-codex"
569 }
570 if CredentialAvailable("kimi") {
571 provName = "kimi"
572 }
573 if CredentialAvailable("deepseek") {
574 provName = "deepseek"
575 }
576 if CredentialAvailable("anthropic") {
577 provName = "anthropic"
578 }
579 // Reset the saved config so this doesn't keep happening.
580 cfg.Provider = provName
581 cfg.Model = ""
582 _ = SaveConfig(cfg)
583 }
584
585 var (
586 cred string
587 method string
588 accountID string
589 credErr error
590 )
591 if args.inheritedCredential != "" {
592 cred = args.inheritedCredential
593 method = args.inheritedAuthMethod
594 accountID = args.inheritedAccountID
595 } else if provName == "ollama" {
596 cred = firstNonEmpty(args.APIKey, "ollama")
597 method = "apikey"
598 } else {
599 cred, method, accountID, credErr = ResolveCredentialFull(provName, args.APIKey)
600 }
601
602 // Persist --api-key for custom providers so subsequent runs don't
603 // need to pass it again.
604 if !isBuiltinProvider(provName) && args.APIKey != "" {
605 if store := AuthStoreFor(); store != nil {
606 _ = store.SetAPIKey(provName, args.APIKey)
607 }
608 }
609
610 // If the user did NOT explicitly pick a provider (neither via --provider
611 // nor by saving one in config.json) and the default one has no
612 // credentials, auto-fall-back to whichever provider is actually logged
613 // in. That way running plain `zut` after `/login` (any provider) never
614 // shows a "not logged in" banner.
615 //
616 // Critical: when the user HAS saved a provider in config.json (e.g.
617 // "deepseek" with "deepseek-v4-flash"), that choice is respected even
618 // if no credential is found — the tui will show the login dialog or
619 // surface a clear credential error rather than silently switching to
620 // a completely different provider and model.
621 // autoFellBack tracks whether the provider was changed by the
622 // auto-fallback loop (no explicit provider from CLI or config,
623 // and the default had no credentials). When false, the provider
624 // came from the user's explicit choice (--provider or config.json)
625 // and must be respected, including any model id that may belong
626 // to a different provider in the catalog — for example when using
627 // a gateway/router like OpenRouter with "deepseek/deepseek-v4-flash".
628 var autoFellBack bool
629 userPickedProvider := args.Provider != "" || cfg.Provider != ""
630 if credErr != nil && !userPickedProvider && provName != "ollama" {
631 autoFellBack = true
632 // Scan every known provider (not a hardcoded subset) so any
633 // env-based credential is discovered, e.g. an env-only
634 // amazon-bedrock setup (AWS_BEARER_TOKEN_BEDROCK / AWS_PROFILE /
635 // IAM keys) when no config.json pins the provider, such as after
636 // pointing ZUT_HOME at a fresh home dir. Iteration order of
637 // knownProviders defines fallback priority. Local providers without a
638 // default model are skipped because selecting either one here would
639 // fail before the user can choose a model.
640 for _, other := range knownProviders {
641 if other == provName || other == "ollama" || other == provider.LlamaCPPProviderID {
642 continue
643 }
644 if !CredentialAvailable(other) {
645 continue
646 }
647 c, m, a, err := ResolveCredentialFull(other, args.APIKey)
648 provName = other
649 cred, method, accountID, credErr = c, m, a, err
650 break
651 }
652 }
653
654 model := firstNonEmpty(args.Model, cfg.Model)
655 if model == "" {
656 if provName == "ollama" || provName == provider.LlamaCPPProviderID {
657 return Resolved{}, fmt.Errorf("%s requires --model or a model selected from its manager", provName)
658 }
659 model = defaultModelForProvider(provName)
660 }
661 // If the resolved model belongs to a different provider (e.g. config
662 // says gpt-5 but we auto-fell back to anthropic), pick that provider's
663 // default. This override only fires when the provider was auto-fallback-
664 // changed, NOT when the user explicitly configured the pair — gateway/
665 // router providers (openrouter, vercel-ai-gateway, etc.) can serve
666 // models from any provider in the catalog.
667 if autoFellBack && provName != "ollama" {
668 if m, err := provider.FindModel("", model); err == nil && m.Provider != provName {
669 model = defaultModelForProvider(provName)
670 }
671 }
672 resolvedModel, err := provider.FindModel(provName, model)
673 if err != nil && (provName == "ollama" || provName == provider.LlamaCPPProviderID) {
674 // Local providers are intentionally open-catalogue: any model id the
675 // configured server understands is valid, even if it is not cached.
676 resolvedModel = provider.Model{
677 Provider: provName,
678 ID: model,
679 DisplayName: model,
680 ContextWindow: 128000,
681 MaxOutput: 16384,
682 BaseURL: args.BaseURL,
683 Source: provName,
684 }
685 err = nil
686 }
687 // Custom providers are open-catalogue like ollama: any model id the
688 // endpoint understands is valid. Use the provider-level base URL.
689 if err != nil {
690 if cfg, ok := provider.CustomProviders()[provName]; ok {
691 resolvedModel = provider.Model{
692 Provider: provName,
693 ID: model,
694 DisplayName: model,
695 ContextWindow: 128000,
696 MaxOutput: 16384,
697 BaseURL: cfg.BaseURL,
698 Source: "user",
699 }
700 err = nil
701 }
702 }
703 if cfg, ok := provider.CustomProviders()[provName]; ok && err == nil && resolvedModel.BaseURL == "" && cfg.BaseURL != "" {
704 // Fall back to the provider-level base URL when the model does
705 // not define its own endpoint.
706 resolvedModel.BaseURL = cfg.BaseURL
707 }
708 if err != nil {
709 // The model the user (or persisted config) asked for is no
710 // longer in the active catalogue — they probably removed it
711 // from their models.json or upgraded zut and the id changed.
712 // Refusing to launch is the wrong move: it strands the user
713 // with no way to even open the TUI and pick a new model.
714 // Fall back to the provider's default, warn on stderr, and,
715 // when the stale id came from the persisted config (not an
716 // explicit --model flag), repair the config so the warning
717 // doesn't repeat on every launch.
718
719 // Gateway providers can accept route-qualified ids that are not in
720 // zut's local catalog yet, for example OpenRouter's
721 // "deepseek/deepseek-v4-flash". Preserve only route-qualified ids;
722 // plain unknown values are likely typos and should still fall back.
723 if isGatewayProvider(provName) && isGatewayRoutedModelID(model) {
724 resolvedModel = provider.Model{
725 Provider: provName,
726 ID: model,
727 DisplayName: model,
728 ContextWindow: 1000000,
729 MaxOutput: 64000,
730 BaseURL: "",
731 Source: "gateway",
732 }
733 // Don't repair config — the routed model id may be valid upstream.
734 } else {
735 fallback := defaultModelForProvider(provName)
736 fm, ferr := provider.FindModel(provName, fallback)
737 if ferr != nil {
738 // Even the provider default is gone (catastrophic
739 // catalogue trim). Last resort: any model on this
740 // provider, then the global DefaultModel.
741 if candidates := provider.ModelsForProvider(provName); len(candidates) > 0 {
742 fm = candidates[0]
743 } else {
744 fm = provider.DefaultModel
745 }
746 }
747 fmt.Fprintf(os.Stderr,
748 "zut: model %q is not in the active catalogue; using %q instead. Pick a different model with --model or /model.\n",
749 model, fm.ID)
750 if args.Model == "" && cfg.Model == model {
751 cfg.Model = fm.ID
752 _ = SaveConfig(cfg)
753 }
754 resolvedModel = fm
755 model = fm.ID
756 }
757 }
758
759 explicitBaseURL := args.BaseURL != "" || (resolvedModel.Source == "user" && resolvedModel.BaseURL != "")
760
761 // If the model defines a base URL (e.g. local ollama) and the
762 // user didn't pass --base-url, use the model's URL. For ollama,
763 // keep http://localhost:11434 as a fallback only after the model
764 // metadata has had a chance to provide a custom baseUrl.
765 if args.BaseURL == "" && resolvedModel.BaseURL != "" {
766 args.BaseURL = resolvedModel.BaseURL
767 }
768 if args.BaseURL == "" && provName == "ollama" {
769 args.BaseURL = "http://localhost:11434"
770 }
771 if args.BaseURL == "" && provName == provider.LlamaCPPProviderID {
772 managementURL, _, configErr := ResolveLlamaCPPConfig()
773 if configErr != nil {
774 return Resolved{}, configErr
775 }
776 var baseErr error
777 args.BaseURL, baseErr = provider.LlamaCPPInferenceURL(managementURL)
778 if baseErr != nil {
779 return Resolved{}, baseErr
780 }
781 }
782
783 // Insecure TLS is intentionally scoped to explicit custom endpoints.
784 // Built-in provider base URLs, auth calls, and model discovery keep normal
785 // certificate verification even when --insecure is present.
786 insecureTLS := (args.InsecureTLS || cfg.Insecure) && explicitBaseURL
787
788 // If the model has a base URL, credentials are optional (local
789 // models like ollama don't need real API keys).
790 if resolvedModel.BaseURL != "" && credErr != nil {
791 cred = "ollama"
792 credErr = nil
793 requireCred = false
794 }
795
796 if credErr != nil && requireCred {
797 return Resolved{}, fmt.Errorf("%w; set %s_API_KEY, pass --api-key, or run `zut` and /login",
798 credErr, envVarName(provName))
799 }
800
801 sandbox := tools.NewSandbox(args.CWD)
802 if cfg.JailByDefault != nil && *cfg.JailByDefault {
803 sandbox.Lock()
804 }
805 if args.PermissionSet != nil {
806 sandbox.SetPermissions(args.PermissionSet)
807 }
808 subagentSession := args.Mode == ModeSubagentWorker || strings.TrimSpace(args.Subagent) != ""
809 lspEnabled := !args.NoLSP && cfg.LSPEnabledFor(subagentSession)
810 reg := buildToolRegistry(args, args.CWD, sandbox, lspEnabled, cfg.LSPDiagnosticsOnWriteEnabled(subagentSession), cfg.LSPDiagnosticsOnEditEnabled(subagentSession))
811
812 docsDir, _ := zutdocs.EnsureInstalled(ZutHome())
813
814 // Skill discovery: scan project + global locations + built-in
815 // skills shipped with the binary. If any are found, register
816 // the on-demand `skill` loader tool plus a system-prompt
817 // manifest so the model knows what's available.
818 //
819 // --no-skill bypasses the entire mechanism: no manifest in the
820 // system prompt, no `skill` tool in the registry. Useful for a
821 // clean-room run with zero extra context biasing the model.
822 var (
823 discovered []*skills.Skill
824 skillTool *skills.Tool
825 skillAddendum string
826 skillsEnabled bool
827 )
828 if !args.NoSkill && (selectedProfile == nil || selectedProfile.InheritSkills == nil || *selectedProfile.InheritSkills) {
829 skillsEnabled = true
830 homeDir, _ := os.UserHomeDir()
831 discovered, _ = skills.Discover(ZutHome(), args.CWD, homeDir, args.WithSkills)
832 if len(discovered) > 0 {
833 skillTool = skills.NewTool(discovered)
834 reg[skillTool.Name()] = skillTool
835 skillAddendum = skills.SystemPromptAddendum(discovered)
836 }
837 }
838 _ = skillTool
839
840 summaries := toolSummaries(reg, args)
841
842 contextFiles := []ContextFile(nil)
843 if selectedProfile == nil || selectedProfile.InheritProjectContext == nil || *selectedProfile.InheritProjectContext {
844 contextFiles = loadAgentsContext(args.CWD, ZutHome())
845 }
846 append_ := []string(nil)
847 if cfg.PonytailModeEnabled() {
848 if ponytailAddendum := PonytailSystemAddendum(); ponytailAddendum != "" {
849 append_ = append(append_, ponytailAddendum)
850 }
851 }
852 append_ = append(append_, args.AppendSystemPrompt...)
853 if agentsAddendum := formatAgentsContext(contextFiles); agentsAddendum != "" {
854 append_ = append(append_, agentsAddendum)
855 }
856 if skillAddendum != "" {
857 append_ = append(append_, skillAddendum)
858 }
859 interactiveMode := args.Mode == "" || args.Mode == ModeInteractive
860 primaryInteractive := selectedProfile == nil && interactiveMode
861 if primaryInteractive && autoSubagentsToolAllowed(args) {
862 homeDir, _ := os.UserHomeDir()
863 profiles, _ := subagents.Discover(args.CWD, homeDir)
864 if subagentsAddendum := subagents.SystemPromptAddendum(profiles); subagentsAddendum != "" {
865 append_ = append(append_, subagentsAddendum)
866 }
867 }
868 if primaryInteractive && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
869 append_ = append(append_, AutoSubagentsSystemAddendumFor(
870 autoSubagentsToolAllowed(args),
871 autoSubagentsStopToolAllowed(args),
872 autoSubagentsResumeToolAllowed(args),
873 ))
874 } else if primaryInteractive && autoSubagentsAnyToolAllowed(args) {
875 append_ = append(append_, OnDemandSubagentsSystemAddendum)
876 }
877 if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {
878 append_ = append(append_, selectedProfile.SystemPrompt)
879 }
880
881 // Custom system prompt resolution order:
882 // 1. --system-prompt flag (highest priority; ad-hoc per run)
883 // 2. $ZUT_HOME/SYSTEM.md (persistent user override)
884 // 3. built-in default (defaultIdentity + defaultGuidelines)
885 custom := args.SystemPrompt
886 if selectedProfile != nil && selectedProfile.SystemPromptMode == "replace" {
887 custom = selectedProfile.SystemPrompt
888 } else if custom == "" {
889 custom = readUserSystemPrompt(ZutHome())
890 }
891
892 sys := BuildSystemPrompt(SystemPromptOpts{
893 CWD: args.CWD,
894 Tools: summaries,
895 Custom: custom,
896 Append: append_,
897 ZutDocsDir: docsDir,
898 })
899
900 reasoning := provider.NormalizeReasoning(firstNonEmpty(args.Reasoning, cfg.Reasoning))
901 temperature := args.Temperature
902 if temperature == nil {
903 temperature = cfg.Temperature
904 }
905 fastMode := cfg.FastMode != nil && *cfg.FastMode
906 if args.FastModeSet {
907 fastMode = args.FastMode
908 }
909 // A profile's explicit fastMode setting overrides the global setting
910 // for this child. This preserves fastMode: false as an opt-out while
911 // allowing fastMode: true to request the fast tier for a focused worker.
912 if selectedProfile != nil && selectedProfile.FastMode != nil {
913 fastMode = *selectedProfile.FastMode
914 }
915
916 max := args.MaxSteps // 0 = unlimited
917
918 return Resolved{
919 Provider: provName,
920 Model: model,
921 Credential: cred,
922 AuthMethod: method,
923 AccountID: accountID,
924 BaseURL: args.BaseURL,
925 InsecureTLS: insecureTLS,
926 CWD: args.CWD,
927 Reasoning: reasoning,
928 Temperature: temperature,
929 FastMode: fastMode,
930 WebSearchPolicy: webSearchPolicy,
931 ToolRegistry: reg,
932 ToolSummary: summaries,
933 SystemPrompt: sys,
934 MaxSteps: max,
935 ContextWindow: resolvedModel.ContextWindow,
936 MaxOutput: resolvedModel.MaxOutput,
937 Sandbox: sandbox,
938 SkillTool: skillTool,
939 skillsEnabled: skillsEnabled,
940 ContextFiles: contextFiles,
941 systemAppend: append_,
942 systemCustom: custom,
943 skillAddendum: skillAddendum,
944 toolDescriptions: descMapFromSummaries(summaries),
945 }, nil
946}
947
948// readUserSystemPrompt looks for $ZUT_HOME/SYSTEM.md and returns its
949// trimmed contents, or "" when the file is missing / unreadable /
950// empty. Errors are intentionally swallowed: the file is optional,
951// and any failure to read it should fall back to the built-in
952// default system prompt rather than crash the run.
953func readUserSystemPrompt(zutHome string) string {
954 if zutHome == "" {
955 return ""
956 }
957 path := filepath.Join(zutHome, "SYSTEM.md")
958 raw, err := os.ReadFile(path)
959 if err != nil {
960 return ""
961 }
962 return strings.TrimSpace(string(raw))
963}
964
965// loadAgentsContext loads optional AGENTS.md instruction files. No
966// default file is created or required: zut only includes files that
967// already exist. Global instructions ($ZUT_HOME/AGENTS.md) come first,
968// followed by project instructions from the filesystem root down to cwd.
969func loadAgentsContext(cwd, zutHome string) []ContextFile {
970 var files []ContextFile
971 seen := map[string]bool{}
972 add := func(path string) {
973 if path == "" {
974 return
975 }
976 abs, err := filepath.Abs(path)
977 if err == nil {
978 path = abs
979 }
980 if seen[path] {
981 return
982 }
983 raw, err := os.ReadFile(path)
984 if err != nil {
985 return
986 }
987 content := strings.TrimSpace(string(raw))
988 if content == "" {
989 return
990 }
991 seen[path] = true
992 files = append(files, ContextFile{Path: path, Content: content})
993 }
994 addFirstFromDir := func(dir string) {
995 if dir == "" {
996 return
997 }
998 for _, name := range []string{"AGENTS.md", "AGENTS.MD"} {
999 path := filepath.Join(dir, name)
1000 if _, err := os.Stat(path); err == nil {
1001 add(path)
1002 return
1003 }
1004 }
1005 }
1006
1007 addFirstFromDir(zutHome)
1008
1009 if cwd != "" {
1010 abs, err := filepath.Abs(cwd)
1011 if err == nil {
1012 cwd = abs
1013 }
1014 var dirs []string
1015 for dir := filepath.Clean(cwd); ; dir = filepath.Dir(dir) {
1016 dirs = append(dirs, dir)
1017 parent := filepath.Dir(dir)
1018 if parent == dir {
1019 break
1020 }
1021 }
1022 for i := len(dirs) - 1; i >= 0; i-- {
1023 addFirstFromDir(dirs[i])
1024 }
1025 }
1026
1027 return files
1028}
1029
1030func formatAgentsContext(files []ContextFile) string {
1031 if len(files) == 0 {
1032 return ""
1033 }
1034 var sb strings.Builder
1035 sb.WriteString("Project context instructions loaded from AGENTS.md files. Follow them when working in this repository. Later files are more specific and may override earlier ones.\n")
1036 for _, f := range files {
1037 fmt.Fprintf(&sb, "\n## %s\n\n%s\n", f.Path, f.Content)
1038 }
1039 return strings.TrimSpace(sb.String())
1040}
1041
1042// descMapFromSummaries indexes the human-readable descriptions for
1043// the renderToolsSection rebuild path.
1044func descMapFromSummaries(summaries []ToolSummary) map[string]string {
1045 out := make(map[string]string, len(summaries))
1046 for _, s := range summaries {
1047 out[s.Name] = s.Description
1048 }
1049 return out
1050}
1051
1052// NewClient returns a provider.Client for r, choosing the auth mode
1053// based on r.AuthMethod. Panics if no credential is present; callers
1054// must check HasCredential() first.
1055func (r Resolved) NewClient() provider.Client {
1056 if !r.HasCredential() {
1057 panic("NewClient called without credential; check HasCredential first")
1058 }
1059 wrap := r.withHTTPClient
1060 switch r.Provider {
1061 case "ollama":
1062 return wrap(provider.NewOpenAICompat("ollama", r.Credential, r.BaseURL, ""))
1063 case provider.LlamaCPPProviderID:
1064 credential := r.Credential
1065 if credential == "local" {
1066 credential = ""
1067 }
1068 return wrap(provider.NewOpenAICompat(provider.LlamaCPPProviderID, credential, r.BaseURL, ""))
1069 case "kimi":
1070 // kimi-coding speaks anthropic-messages on api.kimi.com/coding.
1071 // Subscription OAuth (refreshed) wraps the same Anthropic-shaped client.
1072 inner := wrap(provider.NewKimiCodingWithHeaders(r.Credential, r.BaseURL, kimiCodeHeaders()))
1073 if r.AuthMethod == "oauth" {
1074 return r.wrapWithRefresh(inner)
1075 }
1076 return inner
1077 case "moonshotai":
1078 return wrap(provider.NewMoonshot(r.Credential, r.BaseURL))
1079 case "moonshotai-cn":
1080 return wrap(provider.NewMoonshotCN(r.Credential, r.BaseURL))
1081 case "deepseek":
1082 return wrap(provider.NewDeepSeek(r.Credential, r.BaseURL))
1083 case "openai":
1084 return provider.NewModelRouter("openai",
1085 wrap(provider.NewOpenAI(r.Credential, r.BaseURL)),
1086 map[string]provider.Client{
1087 provider.APIResponses: wrap(provider.NewOpenAIResponsesNamed(r.Credential, r.BaseURL, "openai")),
1088 })
1089 case "openai-codex":
1090 inner := wrap(provider.NewOpenAICodex(r.Credential, r.AccountID, r.BaseURL))
1091 return r.wrapWithRefresh(inner)
1092 case "openai-responses":
1093 // Public OpenAI Responses API (api.openai.com/v1/responses) via
1094 // API key. Separate provider from `openai` (Chat Completions) and
1095 // from `openai-codex` (ChatGPT subscription OAuth).
1096 return wrap(provider.NewOpenAIResponses(r.Credential, r.BaseURL))
1097 case "google":
1098 return wrap(provider.NewGemini(r.Credential, r.BaseURL))
1099 case "cerebras":
1100 return wrap(provider.NewCerebras(r.Credential, r.BaseURL))
1101 case "groq":
1102 return wrap(provider.NewGroq(r.Credential, r.BaseURL))
1103 case "xai":
1104 inner := r.newXAIClient(r.Credential)
1105 if r.AuthMethod == "oauth" {
1106 return r.wrapWithRefresh(inner)
1107 }
1108 return inner
1109 case "together":
1110 return wrap(provider.NewTogether(r.Credential, r.BaseURL))
1111 case "huggingface":
1112 return wrap(provider.NewHuggingFace(r.Credential, r.BaseURL))
1113 case "openrouter":
1114 return wrap(provider.NewOpenRouter(r.Credential, r.BaseURL))
1115 case "zai":
1116 return wrap(provider.NewZAI(r.Credential, r.BaseURL))
1117 case "xiaomi":
1118 return wrap(provider.NewXiaomi(r.Credential, r.BaseURL))
1119 case "xiaomi-token-plan-ams":
1120 return wrap(provider.NewXiaomiTokenPlan("ams", r.Credential, r.BaseURL))
1121 case "xiaomi-token-plan-cn":
1122 return wrap(provider.NewXiaomiTokenPlan("cn", r.Credential, r.BaseURL))
1123 case "xiaomi-token-plan-sgp":
1124 return wrap(provider.NewXiaomiTokenPlan("sgp", r.Credential, r.BaseURL))
1125 case "opencode":
1126 return wrap(provider.NewOpenCode(r.Credential, r.BaseURL))
1127 case "opencode-go":
1128 return wrap(provider.NewOpenCodeGo(r.Credential, r.BaseURL))
1129 case "minimax":
1130 return wrap(provider.NewMinimaxAnthropic(r.Credential, r.BaseURL))
1131 case "minimax-cn":
1132 return wrap(provider.NewMinimaxCNAnthropic(r.Credential, r.BaseURL))
1133 case "fireworks":
1134 return wrap(provider.NewFireworksAnthropic(r.Credential, r.BaseURL))
1135 case "vercel-ai-gateway":
1136 return wrap(provider.NewVercelGatewayAnthropic(r.Credential, r.BaseURL))
1137 case "mistral":
1138 return wrap(provider.NewMistral(r.Credential, r.BaseURL))
1139 case "amazon-bedrock":
1140 return wrap(provider.NewBedrock(r.Credential, r.BaseURL))
1141 case "google-vertex":
1142 return wrap(provider.NewGoogleVertex(r.Credential, r.BaseURL))
1143 case "azure-openai-responses":
1144 return wrap(provider.NewAzureOpenAIResponses(r.Credential, r.BaseURL))
1145 case "github-copilot":
1146 return wrap(provider.NewGithubCopilot(r.Credential, r.BaseURL))
1147 case "cloudflare-workers-ai":
1148 return wrap(provider.NewCloudflareWorkersAI(r.Credential, r.BaseURL))
1149 case "cloudflare-ai-gateway":
1150 return wrap(provider.NewCloudflareAIGateway(r.Credential, r.BaseURL))
1151 default:
1152 // Custom providers: choose wire format from the models.json api field.
1153 if cfg, ok := provider.CustomProviders()[r.Provider]; ok {
1154 switch cfg.API {
1155 case provider.APIResponses:
1156 return wrap(provider.NewOpenAIResponsesNamed(r.Credential, r.BaseURL, r.Provider))
1157 case "anthropic":
1158 return wrap(provider.NewAnthropicCompat(r.Provider, r.Credential, r.BaseURL))
1159 default: // "openai"
1160 return wrap(provider.NewOpenAICompat(r.Provider, r.Credential, r.BaseURL, ""))
1161 }
1162 }
1163 if r.AuthMethod == "oauth" {
1164 inner := wrap(provider.NewAnthropicOAuth(r.Credential, r.BaseURL))
1165 return r.wrapWithRefresh(inner)
1166 }
1167 return wrap(provider.NewAnthropic(r.Credential, r.BaseURL))
1168 }
1169}
1170
1171func (r Resolved) withHTTPClient(c provider.Client) provider.Client {
1172 if !r.InsecureTLS {
1173 return c
1174 }
1175 return provider.WithHTTPClient(c, provider.NewHTTPClient(true))
1176}
1177
1178func (r Resolved) newXAIClient(token string) provider.Client {
1179 return provider.NewModelRouter("xai",
1180 r.withHTTPClient(provider.NewXAI(token, r.BaseURL)),
1181 map[string]provider.Client{
1182 provider.APIResponses: r.withHTTPClient(provider.NewOpenAIResponsesNamed(token, r.BaseURL, "xai")),
1183 })
1184}
1185
1186// wrapWithRefresh wraps an OAuth client so the access token is
1187// refreshed automatically before each API call. Without this, long
1188// sessions (hours) silently fail when the 1-hour token expires.
1189func (r Resolved) wrapWithRefresh(inner provider.Client) provider.Client {
1190 provName := r.Provider
1191 tokenProvider := provName
1192 if provName == "openai-codex" {
1193 tokenProvider = "openai"
1194 }
1195 baseURL := r.BaseURL
1196 accountID := r.AccountID
1197
1198 refreshFn := func(ctx context.Context) (string, error) {
1199 tok, err := refreshIfExpired(tokenProvider, loadOAuthToken(tokenProvider))
1200 if err != nil {
1201 return "", err
1202 }
1203 return tok.AccessToken, nil
1204 }
1205
1206 factory := func(token string) provider.Client {
1207 switch provName {
1208 case "openai-codex":
1209 return r.withHTTPClient(provider.NewOpenAICodex(token, accountID, baseURL))
1210 case "kimi":
1211 // anthropic-messages on api.kimi.com/coding.
1212 return r.withHTTPClient(provider.NewKimiCodingWithHeaders(token, baseURL, kimiCodeHeaders()))
1213 case "xai":
1214 return r.newXAIClient(token)
1215 default:
1216 return r.withHTTPClient(provider.NewAnthropicOAuth(token, baseURL))
1217 }
1218 }
1219
1220 return provider.NewRefreshingClient(inner, refreshFn, factory)
1221}
1222
1223// UseSandbox replaces the sandbox pointer that every tool in r's
1224// registry references. Used to keep the /jail state stable across
1225// agent rebuilds (e.g. /login, /model switching providers).
1226func (r *Resolved) UseSandbox(s *tools.Sandbox) {
1227 if s == nil || r == nil {
1228 return
1229 }
1230 if r.Sandbox != nil && r.Sandbox.Permissions != nil {
1231 s.Permissions = r.Sandbox.Permissions
1232 }
1233 r.Sandbox = s
1234 for name, t := range r.ToolRegistry {
1235 switch v := t.(type) {
1236 case *tools.ReadTool:
1237 v.Sandbox = s
1238 case *tools.WriteTool:
1239 v.Sandbox = s
1240 case *tools.EditTool:
1241 v.Sandbox = s
1242 case *tools.BashTool:
1243 v.Sandbox = s
1244 case *tools.CreateWorktreeTool:
1245 v.Sandbox = s
1246 case *tools.LSPTool:
1247 v.Sandbox = s
1248 }
1249 _ = name
1250 }
1251}
1252
1253// NewAgent constructs a core.Agent from r. Requires a credential.
1254func (r Resolved) NewAgent() *core.Agent {
1255 a := core.NewAgent(r.NewClient(), r.Model, r.SystemPrompt, r.ToolRegistry)
1256 a.MaxSteps = r.MaxSteps
1257 a.ContextWindow = r.ContextWindow
1258 a.MaxTokens = r.MaxOutput
1259 a.Reasoning = r.Reasoning
1260 a.Temperature = r.Temperature
1261 a.FastMode = r.FastMode
1262 return a
1263}
1264
1265func buildToolRegistry(args Args, cwd string, sandbox *tools.Sandbox, lspEnabled, diagnosticsOnWrite, diagnosticsOnEdit bool) core.Registry {
1266 if args.NoTools {
1267 return core.Registry{}
1268 }
1269 var manager *lsp.Manager
1270 if lspEnabled && lspManagerNeeded(args, diagnosticsOnWrite, diagnosticsOnEdit) {
1271 options := lsp.ManagerOptions{}
1272 if sandbox != nil {
1273 options.CheckWritePath = sandbox.CheckWritePath
1274 }
1275 manager = lsp.NewManagerWithOptions(options)
1276 }
1277 all := map[string]core.Tool{
1278 "read": &tools.ReadTool{CWD: cwd, Sandbox: sandbox},
1279 "write": &tools.WriteTool{CWD: cwd, Sandbox: sandbox, LSP: manager, LSPDiagnostics: diagnosticsOnWrite},
1280 "edit": &tools.EditTool{CWD: cwd, Sandbox: sandbox, LSP: manager, LSPDiagnostics: diagnosticsOnEdit},
1281 "bash": &tools.BashTool{CWD: cwd, Sandbox: sandbox},
1282 "create_worktree": &tools.CreateWorktreeTool{CWD: cwd, Sandbox: sandbox},
1283 }
1284 if webSearchAllowedForRegistry(args) {
1285 all["web_search"] = tools.NewWebSearchTool()
1286 }
1287 if manager != nil {
1288 lspTool := tools.NewLSPTool(cwd, manager)
1289 lspTool.Sandbox = sandbox
1290 all["lsp"] = lspTool
1291 }
1292 reg := core.Registry{}
1293 if len(args.Tools) == 0 {
1294 for _, t := range all {
1295 reg[t.Name()] = t
1296 }
1297 return reg
1298 }
1299 for _, name := range args.Tools {
1300 if t, ok := all[name]; ok {
1301 reg[name] = t
1302 }
1303 }
1304 return reg
1305}
1306
1307func lspManagerNeeded(args Args, diagnosticsOnWrite, diagnosticsOnEdit bool) bool {
1308 if len(args.Tools) == 0 {
1309 return true
1310 }
1311 for _, name := range args.Tools {
1312 switch name {
1313 case "lsp":
1314 return true
1315 case "write":
1316 if diagnosticsOnWrite {
1317 return true
1318 }
1319 case "edit":
1320 if diagnosticsOnEdit {
1321 return true
1322 }
1323 }
1324 }
1325 return false
1326}
1327
1328func autoSubagentsToolAllowed(args Args) bool {
1329 return autoSubagentsToolAllowedFor(args, "subagent_spawn")
1330}
1331
1332func autoSubagentsStatusToolAllowed(args Args) bool {
1333 return autoSubagentsToolAllowedFor(args, "subagent_status")
1334}
1335
1336func autoSubagentsStopToolAllowed(args Args) bool {
1337 return autoSubagentsToolAllowedFor(args, "subagent_stop")
1338}
1339
1340func autoSubagentsResumeToolAllowed(args Args) bool {
1341 return autoSubagentsToolAllowedFor(args, "subagent_resume")
1342}
1343
1344func autoSubagentsAnyToolAllowed(args Args) bool {
1345 return autoSubagentsToolAllowed(args) ||
1346 autoSubagentsStatusToolAllowed(args) ||
1347 autoSubagentsStopToolAllowed(args) ||
1348 autoSubagentsResumeToolAllowed(args)
1349}
1350
1351func autoSubagentsToolAllowedFor(args Args, toolName string) bool {
1352 if args.NoTools || args.PermissionSet != nil {
1353 return false
1354 }
1355 if args.ToolsSet && len(args.Tools) == 0 {
1356 return false
1357 }
1358 if len(args.Tools) == 0 {
1359 return true
1360 }
1361 for _, name := range args.Tools {
1362 if name == toolName {
1363 return true
1364 }
1365 }
1366 return false
1367}
1368
1369var nativeToolSummaryOrder = []string{"read", "write", "edit", "bash", "create_worktree", "lsp", "web_search"}
1370
1371func toolSummaries(reg core.Registry, args Args) []ToolSummary {
1372 var out []ToolSummary
1373 for _, name := range nativeToolSummaryOrder {
1374 if t, ok := reg[name]; ok {
1375 out = append(out, ToolSummary{Name: t.Name(), Description: t.Description()})
1376 }
1377 }
1378 return out
1379}
1380
1381func firstNonEmpty(vals ...string) string {
1382 for _, v := range vals {
1383 if v != "" {
1384 return v
1385 }
1386 }
1387 return ""
1388}
1389
1390func kimiCodeHeaders() map[string]string {
1391 host, _ := os.Hostname()
1392 if host == "" {
1393 host = "unknown"
1394 }
1395 deviceID := ""
1396 if home, err := os.UserHomeDir(); err == nil {
1397 if b, err := os.ReadFile(filepath.Join(home, ".kimi", "device_id")); err == nil {
1398 deviceID = strings.TrimSpace(string(b))
1399 }
1400 }
1401 if deviceID == "" {
1402 deviceID = "zut"
1403 }
1404 return map[string]string{
1405 "User-Agent": "KimiCLI/1.41.0",
1406 "X-Msh-Platform": "kimi_cli",
1407 "X-Msh-Version": "1.41.0",
1408 "X-Msh-Device-Name": host,
1409 "X-Msh-Device-Model": runtime.GOOS + "-" + runtime.GOARCH,
1410 "X-Msh-Os-Version": runtime.GOOS,
1411 "X-Msh-Device-Id": deviceID,
1412 }
1413}
1414
1415func envVarName(provider string) string {
1416 switch provider {
1417 case "openai", "openai-codex", "openai-responses":
1418 return "OPENAI"
1419 case "kimi":
1420 return "KIMI"
1421 case "deepseek":
1422 return "DEEPSEEK"
1423 case "google":
1424 return "GEMINI"
1425 case "ollama":
1426 return "OLLAMA"
1427 case "llama.cpp":
1428 return "LLAMA"
1429 case "moonshotai", "moonshotai-cn":
1430 return "MOONSHOT"
1431 case "groq":
1432 return "GROQ"
1433 case "xai":
1434 return "XAI"
1435 case "cerebras":
1436 return "CEREBRAS"
1437 case "together":
1438 return "TOGETHER"
1439 case "huggingface":
1440 return "HF"
1441 case "openrouter":
1442 return "OPENROUTER"
1443 case "mistral":
1444 return "MISTRAL"
1445 case "zai":
1446 return "ZAI"
1447 case "xiaomi":
1448 return "XIAOMI"
1449 case "xiaomi-token-plan-ams":
1450 return "XIAOMI_TOKEN_PLAN_AMS"
1451 case "xiaomi-token-plan-cn":
1452 return "XIAOMI_TOKEN_PLAN_CN"
1453 case "xiaomi-token-plan-sgp":
1454 return "XIAOMI_TOKEN_PLAN_SGP"
1455 case "minimax":
1456 return "MINIMAX"
1457 case "minimax-cn":
1458 return "MINIMAX_CN"
1459 case "fireworks":
1460 return "FIREWORKS"
1461 case "vercel-ai-gateway":
1462 return "AI_GATEWAY"
1463 case "opencode", "opencode-go":
1464 return "OPENCODE"
1465 case "github-copilot":
1466 return "COPILOT_GITHUB_TOKEN"
1467 case "cloudflare-workers-ai", "cloudflare-ai-gateway":
1468 return "CLOUDFLARE"
1469 case "amazon-bedrock":
1470 return "AWS"
1471 case "google-vertex":
1472 return "GOOGLE_CLOUD"
1473 case "azure-openai-responses":
1474 return "AZURE_OPENAI"
1475 default:
1476 return "ANTHROPIC"
1477 }
1478}