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 if selectedProfile == nil && interactiveMode && cfg.AutoSubagentsEnabled != nil && *cfg.AutoSubagentsEnabled {
861 if 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 append_ = append(append_, AutoSubagentsSystemAddendumFor(
869 autoSubagentsToolAllowed(args),
870 autoSubagentsStopToolAllowed(args),
871 autoSubagentsResumeToolAllowed(args),
872 ))
873 } else if selectedProfile == nil && interactiveMode && autoSubagentsAnyToolAllowed(args) {
874 append_ = append(append_, OnDemandSubagentsSystemAddendum)
875 }
876 if selectedProfile != nil && selectedProfile.SystemPromptMode != "replace" && selectedProfile.SystemPrompt != "" {
877 append_ = append(append_, selectedProfile.SystemPrompt)
878 }
879
880 // Custom system prompt resolution order:
881 // 1. --system-prompt flag (highest priority; ad-hoc per run)
882 // 2. $ZUT_HOME/SYSTEM.md (persistent user override)
883 // 3. built-in default (defaultIdentity + defaultGuidelines)
884 custom := args.SystemPrompt
885 if selectedProfile != nil && selectedProfile.SystemPromptMode == "replace" {
886 custom = selectedProfile.SystemPrompt
887 } else if custom == "" {
888 custom = readUserSystemPrompt(ZutHome())
889 }
890
891 sys := BuildSystemPrompt(SystemPromptOpts{
892 CWD: args.CWD,
893 Tools: summaries,
894 Custom: custom,
895 Append: append_,
896 ZutDocsDir: docsDir,
897 })
898
899 reasoning := provider.NormalizeReasoning(firstNonEmpty(args.Reasoning, cfg.Reasoning))
900 temperature := args.Temperature
901 if temperature == nil {
902 temperature = cfg.Temperature
903 }
904 fastMode := cfg.FastMode != nil && *cfg.FastMode
905 if args.FastModeSet {
906 fastMode = args.FastMode
907 }
908 // A profile's explicit fastMode setting overrides the global setting
909 // for this child. This preserves fastMode: false as an opt-out while
910 // allowing fastMode: true to request the fast tier for a focused worker.
911 if selectedProfile != nil && selectedProfile.FastMode != nil {
912 fastMode = *selectedProfile.FastMode
913 }
914
915 max := args.MaxSteps // 0 = unlimited
916
917 return Resolved{
918 Provider: provName,
919 Model: model,
920 Credential: cred,
921 AuthMethod: method,
922 AccountID: accountID,
923 BaseURL: args.BaseURL,
924 InsecureTLS: insecureTLS,
925 CWD: args.CWD,
926 Reasoning: reasoning,
927 Temperature: temperature,
928 FastMode: fastMode,
929 WebSearchPolicy: webSearchPolicy,
930 ToolRegistry: reg,
931 ToolSummary: summaries,
932 SystemPrompt: sys,
933 MaxSteps: max,
934 ContextWindow: resolvedModel.ContextWindow,
935 MaxOutput: resolvedModel.MaxOutput,
936 Sandbox: sandbox,
937 SkillTool: skillTool,
938 skillsEnabled: skillsEnabled,
939 ContextFiles: contextFiles,
940 systemAppend: append_,
941 systemCustom: custom,
942 skillAddendum: skillAddendum,
943 toolDescriptions: descMapFromSummaries(summaries),
944 }, nil
945}
946
947// readUserSystemPrompt looks for $ZUT_HOME/SYSTEM.md and returns its
948// trimmed contents, or "" when the file is missing / unreadable /
949// empty. Errors are intentionally swallowed: the file is optional,
950// and any failure to read it should fall back to the built-in
951// default system prompt rather than crash the run.
952func readUserSystemPrompt(zutHome string) string {
953 if zutHome == "" {
954 return ""
955 }
956 path := filepath.Join(zutHome, "SYSTEM.md")
957 raw, err := os.ReadFile(path)
958 if err != nil {
959 return ""
960 }
961 return strings.TrimSpace(string(raw))
962}
963
964// loadAgentsContext loads optional AGENTS.md instruction files. No
965// default file is created or required: zut only includes files that
966// already exist. Global instructions ($ZUT_HOME/AGENTS.md) come first,
967// followed by project instructions from the filesystem root down to cwd.
968func loadAgentsContext(cwd, zutHome string) []ContextFile {
969 var files []ContextFile
970 seen := map[string]bool{}
971 add := func(path string) {
972 if path == "" {
973 return
974 }
975 abs, err := filepath.Abs(path)
976 if err == nil {
977 path = abs
978 }
979 if seen[path] {
980 return
981 }
982 raw, err := os.ReadFile(path)
983 if err != nil {
984 return
985 }
986 content := strings.TrimSpace(string(raw))
987 if content == "" {
988 return
989 }
990 seen[path] = true
991 files = append(files, ContextFile{Path: path, Content: content})
992 }
993 addFirstFromDir := func(dir string) {
994 if dir == "" {
995 return
996 }
997 for _, name := range []string{"AGENTS.md", "AGENTS.MD"} {
998 path := filepath.Join(dir, name)
999 if _, err := os.Stat(path); err == nil {
1000 add(path)
1001 return
1002 }
1003 }
1004 }
1005
1006 addFirstFromDir(zutHome)
1007
1008 if cwd != "" {
1009 abs, err := filepath.Abs(cwd)
1010 if err == nil {
1011 cwd = abs
1012 }
1013 var dirs []string
1014 for dir := filepath.Clean(cwd); ; dir = filepath.Dir(dir) {
1015 dirs = append(dirs, dir)
1016 parent := filepath.Dir(dir)
1017 if parent == dir {
1018 break
1019 }
1020 }
1021 for i := len(dirs) - 1; i >= 0; i-- {
1022 addFirstFromDir(dirs[i])
1023 }
1024 }
1025
1026 return files
1027}
1028
1029func formatAgentsContext(files []ContextFile) string {
1030 if len(files) == 0 {
1031 return ""
1032 }
1033 var sb strings.Builder
1034 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")
1035 for _, f := range files {
1036 fmt.Fprintf(&sb, "\n## %s\n\n%s\n", f.Path, f.Content)
1037 }
1038 return strings.TrimSpace(sb.String())
1039}
1040
1041// descMapFromSummaries indexes the human-readable descriptions for
1042// the renderToolsSection rebuild path.
1043func descMapFromSummaries(summaries []ToolSummary) map[string]string {
1044 out := make(map[string]string, len(summaries))
1045 for _, s := range summaries {
1046 out[s.Name] = s.Description
1047 }
1048 return out
1049}
1050
1051// NewClient returns a provider.Client for r, choosing the auth mode
1052// based on r.AuthMethod. Panics if no credential is present; callers
1053// must check HasCredential() first.
1054func (r Resolved) NewClient() provider.Client {
1055 if !r.HasCredential() {
1056 panic("NewClient called without credential; check HasCredential first")
1057 }
1058 wrap := r.withHTTPClient
1059 switch r.Provider {
1060 case "ollama":
1061 return wrap(provider.NewOpenAICompat("ollama", r.Credential, r.BaseURL, ""))
1062 case provider.LlamaCPPProviderID:
1063 credential := r.Credential
1064 if credential == "local" {
1065 credential = ""
1066 }
1067 return wrap(provider.NewOpenAICompat(provider.LlamaCPPProviderID, credential, r.BaseURL, ""))
1068 case "kimi":
1069 // kimi-coding speaks anthropic-messages on api.kimi.com/coding.
1070 // Subscription OAuth (refreshed) wraps the same Anthropic-shaped client.
1071 inner := wrap(provider.NewKimiCodingWithHeaders(r.Credential, r.BaseURL, kimiCodeHeaders()))
1072 if r.AuthMethod == "oauth" {
1073 return r.wrapWithRefresh(inner)
1074 }
1075 return inner
1076 case "moonshotai":
1077 return wrap(provider.NewMoonshot(r.Credential, r.BaseURL))
1078 case "moonshotai-cn":
1079 return wrap(provider.NewMoonshotCN(r.Credential, r.BaseURL))
1080 case "deepseek":
1081 return wrap(provider.NewDeepSeek(r.Credential, r.BaseURL))
1082 case "openai":
1083 return provider.NewModelRouter("openai",
1084 wrap(provider.NewOpenAI(r.Credential, r.BaseURL)),
1085 map[string]provider.Client{
1086 provider.APIResponses: wrap(provider.NewOpenAIResponsesNamed(r.Credential, r.BaseURL, "openai")),
1087 })
1088 case "openai-codex":
1089 inner := wrap(provider.NewOpenAICodex(r.Credential, r.AccountID, r.BaseURL))
1090 return r.wrapWithRefresh(inner)
1091 case "openai-responses":
1092 // Public OpenAI Responses API (api.openai.com/v1/responses) via
1093 // API key. Separate provider from `openai` (Chat Completions) and
1094 // from `openai-codex` (ChatGPT subscription OAuth).
1095 return wrap(provider.NewOpenAIResponses(r.Credential, r.BaseURL))
1096 case "google":
1097 return wrap(provider.NewGemini(r.Credential, r.BaseURL))
1098 case "cerebras":
1099 return wrap(provider.NewCerebras(r.Credential, r.BaseURL))
1100 case "groq":
1101 return wrap(provider.NewGroq(r.Credential, r.BaseURL))
1102 case "xai":
1103 inner := r.newXAIClient(r.Credential)
1104 if r.AuthMethod == "oauth" {
1105 return r.wrapWithRefresh(inner)
1106 }
1107 return inner
1108 case "together":
1109 return wrap(provider.NewTogether(r.Credential, r.BaseURL))
1110 case "huggingface":
1111 return wrap(provider.NewHuggingFace(r.Credential, r.BaseURL))
1112 case "openrouter":
1113 return wrap(provider.NewOpenRouter(r.Credential, r.BaseURL))
1114 case "zai":
1115 return wrap(provider.NewZAI(r.Credential, r.BaseURL))
1116 case "xiaomi":
1117 return wrap(provider.NewXiaomi(r.Credential, r.BaseURL))
1118 case "xiaomi-token-plan-ams":
1119 return wrap(provider.NewXiaomiTokenPlan("ams", r.Credential, r.BaseURL))
1120 case "xiaomi-token-plan-cn":
1121 return wrap(provider.NewXiaomiTokenPlan("cn", r.Credential, r.BaseURL))
1122 case "xiaomi-token-plan-sgp":
1123 return wrap(provider.NewXiaomiTokenPlan("sgp", r.Credential, r.BaseURL))
1124 case "opencode":
1125 return wrap(provider.NewOpenCode(r.Credential, r.BaseURL))
1126 case "opencode-go":
1127 return wrap(provider.NewOpenCodeGo(r.Credential, r.BaseURL))
1128 case "minimax":
1129 return wrap(provider.NewMinimaxAnthropic(r.Credential, r.BaseURL))
1130 case "minimax-cn":
1131 return wrap(provider.NewMinimaxCNAnthropic(r.Credential, r.BaseURL))
1132 case "fireworks":
1133 return wrap(provider.NewFireworksAnthropic(r.Credential, r.BaseURL))
1134 case "vercel-ai-gateway":
1135 return wrap(provider.NewVercelGatewayAnthropic(r.Credential, r.BaseURL))
1136 case "mistral":
1137 return wrap(provider.NewMistral(r.Credential, r.BaseURL))
1138 case "amazon-bedrock":
1139 return wrap(provider.NewBedrock(r.Credential, r.BaseURL))
1140 case "google-vertex":
1141 return wrap(provider.NewGoogleVertex(r.Credential, r.BaseURL))
1142 case "azure-openai-responses":
1143 return wrap(provider.NewAzureOpenAIResponses(r.Credential, r.BaseURL))
1144 case "github-copilot":
1145 return wrap(provider.NewGithubCopilot(r.Credential, r.BaseURL))
1146 case "cloudflare-workers-ai":
1147 return wrap(provider.NewCloudflareWorkersAI(r.Credential, r.BaseURL))
1148 case "cloudflare-ai-gateway":
1149 return wrap(provider.NewCloudflareAIGateway(r.Credential, r.BaseURL))
1150 default:
1151 // Custom providers: choose wire format from the models.json api field.
1152 if cfg, ok := provider.CustomProviders()[r.Provider]; ok {
1153 switch cfg.API {
1154 case provider.APIResponses:
1155 return wrap(provider.NewOpenAIResponsesNamed(r.Credential, r.BaseURL, r.Provider))
1156 case "anthropic":
1157 return wrap(provider.NewAnthropicCompat(r.Provider, r.Credential, r.BaseURL))
1158 default: // "openai"
1159 return wrap(provider.NewOpenAICompat(r.Provider, r.Credential, r.BaseURL, ""))
1160 }
1161 }
1162 if r.AuthMethod == "oauth" {
1163 inner := wrap(provider.NewAnthropicOAuth(r.Credential, r.BaseURL))
1164 return r.wrapWithRefresh(inner)
1165 }
1166 return wrap(provider.NewAnthropic(r.Credential, r.BaseURL))
1167 }
1168}
1169
1170func (r Resolved) withHTTPClient(c provider.Client) provider.Client {
1171 if !r.InsecureTLS {
1172 return c
1173 }
1174 return provider.WithHTTPClient(c, provider.NewHTTPClient(true))
1175}
1176
1177func (r Resolved) newXAIClient(token string) provider.Client {
1178 return provider.NewModelRouter("xai",
1179 r.withHTTPClient(provider.NewXAI(token, r.BaseURL)),
1180 map[string]provider.Client{
1181 provider.APIResponses: r.withHTTPClient(provider.NewOpenAIResponsesNamed(token, r.BaseURL, "xai")),
1182 })
1183}
1184
1185// wrapWithRefresh wraps an OAuth client so the access token is
1186// refreshed automatically before each API call. Without this, long
1187// sessions (hours) silently fail when the 1-hour token expires.
1188func (r Resolved) wrapWithRefresh(inner provider.Client) provider.Client {
1189 provName := r.Provider
1190 tokenProvider := provName
1191 if provName == "openai-codex" {
1192 tokenProvider = "openai"
1193 }
1194 baseURL := r.BaseURL
1195 accountID := r.AccountID
1196
1197 refreshFn := func(ctx context.Context) (string, error) {
1198 tok, err := refreshIfExpired(tokenProvider, loadOAuthToken(tokenProvider))
1199 if err != nil {
1200 return "", err
1201 }
1202 return tok.AccessToken, nil
1203 }
1204
1205 factory := func(token string) provider.Client {
1206 switch provName {
1207 case "openai-codex":
1208 return r.withHTTPClient(provider.NewOpenAICodex(token, accountID, baseURL))
1209 case "kimi":
1210 // anthropic-messages on api.kimi.com/coding.
1211 return r.withHTTPClient(provider.NewKimiCodingWithHeaders(token, baseURL, kimiCodeHeaders()))
1212 case "xai":
1213 return r.newXAIClient(token)
1214 default:
1215 return r.withHTTPClient(provider.NewAnthropicOAuth(token, baseURL))
1216 }
1217 }
1218
1219 return provider.NewRefreshingClient(inner, refreshFn, factory)
1220}
1221
1222// UseSandbox replaces the sandbox pointer that every tool in r's
1223// registry references. Used to keep the /jail state stable across
1224// agent rebuilds (e.g. /login, /model switching providers).
1225func (r *Resolved) UseSandbox(s *tools.Sandbox) {
1226 if s == nil || r == nil {
1227 return
1228 }
1229 if r.Sandbox != nil && r.Sandbox.Permissions != nil {
1230 s.Permissions = r.Sandbox.Permissions
1231 }
1232 r.Sandbox = s
1233 for name, t := range r.ToolRegistry {
1234 switch v := t.(type) {
1235 case *tools.ReadTool:
1236 v.Sandbox = s
1237 case *tools.WriteTool:
1238 v.Sandbox = s
1239 case *tools.EditTool:
1240 v.Sandbox = s
1241 case *tools.BashTool:
1242 v.Sandbox = s
1243 case *tools.CreateWorktreeTool:
1244 v.Sandbox = s
1245 case *tools.LSPTool:
1246 v.Sandbox = s
1247 }
1248 _ = name
1249 }
1250}
1251
1252// NewAgent constructs a core.Agent from r. Requires a credential.
1253func (r Resolved) NewAgent() *core.Agent {
1254 a := core.NewAgent(r.NewClient(), r.Model, r.SystemPrompt, r.ToolRegistry)
1255 a.MaxSteps = r.MaxSteps
1256 a.ContextWindow = r.ContextWindow
1257 a.MaxTokens = r.MaxOutput
1258 a.Reasoning = r.Reasoning
1259 a.Temperature = r.Temperature
1260 a.FastMode = r.FastMode
1261 return a
1262}
1263
1264func buildToolRegistry(args Args, cwd string, sandbox *tools.Sandbox, lspEnabled, diagnosticsOnWrite, diagnosticsOnEdit bool) core.Registry {
1265 if args.NoTools {
1266 return core.Registry{}
1267 }
1268 var manager *lsp.Manager
1269 if lspEnabled && lspManagerNeeded(args, diagnosticsOnWrite, diagnosticsOnEdit) {
1270 options := lsp.ManagerOptions{}
1271 if sandbox != nil {
1272 options.CheckWritePath = sandbox.CheckWritePath
1273 }
1274 manager = lsp.NewManagerWithOptions(options)
1275 }
1276 all := map[string]core.Tool{
1277 "read": &tools.ReadTool{CWD: cwd, Sandbox: sandbox},
1278 "write": &tools.WriteTool{CWD: cwd, Sandbox: sandbox, LSP: manager, LSPDiagnostics: diagnosticsOnWrite},
1279 "edit": &tools.EditTool{CWD: cwd, Sandbox: sandbox, LSP: manager, LSPDiagnostics: diagnosticsOnEdit},
1280 "bash": &tools.BashTool{CWD: cwd, Sandbox: sandbox},
1281 "create_worktree": &tools.CreateWorktreeTool{CWD: cwd, Sandbox: sandbox},
1282 }
1283 if webSearchAllowedForRegistry(args) {
1284 all["web_search"] = tools.NewWebSearchTool()
1285 }
1286 if manager != nil {
1287 lspTool := tools.NewLSPTool(cwd, manager)
1288 lspTool.Sandbox = sandbox
1289 all["lsp"] = lspTool
1290 }
1291 reg := core.Registry{}
1292 if len(args.Tools) == 0 {
1293 for _, t := range all {
1294 reg[t.Name()] = t
1295 }
1296 return reg
1297 }
1298 for _, name := range args.Tools {
1299 if t, ok := all[name]; ok {
1300 reg[name] = t
1301 }
1302 }
1303 return reg
1304}
1305
1306func lspManagerNeeded(args Args, diagnosticsOnWrite, diagnosticsOnEdit bool) bool {
1307 if len(args.Tools) == 0 {
1308 return true
1309 }
1310 for _, name := range args.Tools {
1311 switch name {
1312 case "lsp":
1313 return true
1314 case "write":
1315 if diagnosticsOnWrite {
1316 return true
1317 }
1318 case "edit":
1319 if diagnosticsOnEdit {
1320 return true
1321 }
1322 }
1323 }
1324 return false
1325}
1326
1327func autoSubagentsToolAllowed(args Args) bool {
1328 return autoSubagentsToolAllowedFor(args, "subagent_spawn")
1329}
1330
1331func autoSubagentsStatusToolAllowed(args Args) bool {
1332 return autoSubagentsToolAllowedFor(args, "subagent_status")
1333}
1334
1335func autoSubagentsStopToolAllowed(args Args) bool {
1336 return autoSubagentsToolAllowedFor(args, "subagent_stop")
1337}
1338
1339func autoSubagentsResumeToolAllowed(args Args) bool {
1340 return autoSubagentsToolAllowedFor(args, "subagent_resume")
1341}
1342
1343func autoSubagentsAnyToolAllowed(args Args) bool {
1344 return autoSubagentsToolAllowed(args) ||
1345 autoSubagentsStatusToolAllowed(args) ||
1346 autoSubagentsStopToolAllowed(args) ||
1347 autoSubagentsResumeToolAllowed(args)
1348}
1349
1350func autoSubagentsToolAllowedFor(args Args, toolName string) bool {
1351 if args.NoTools || args.PermissionSet != nil {
1352 return false
1353 }
1354 if args.ToolsSet && len(args.Tools) == 0 {
1355 return false
1356 }
1357 if len(args.Tools) == 0 {
1358 return true
1359 }
1360 for _, name := range args.Tools {
1361 if name == toolName {
1362 return true
1363 }
1364 }
1365 return false
1366}
1367
1368var nativeToolSummaryOrder = []string{"read", "write", "edit", "bash", "create_worktree", "lsp", "web_search"}
1369
1370func toolSummaries(reg core.Registry, args Args) []ToolSummary {
1371 var out []ToolSummary
1372 for _, name := range nativeToolSummaryOrder {
1373 if t, ok := reg[name]; ok {
1374 out = append(out, ToolSummary{Name: t.Name(), Description: t.Description()})
1375 }
1376 }
1377 return out
1378}
1379
1380func firstNonEmpty(vals ...string) string {
1381 for _, v := range vals {
1382 if v != "" {
1383 return v
1384 }
1385 }
1386 return ""
1387}
1388
1389func kimiCodeHeaders() map[string]string {
1390 host, _ := os.Hostname()
1391 if host == "" {
1392 host = "unknown"
1393 }
1394 deviceID := ""
1395 if home, err := os.UserHomeDir(); err == nil {
1396 if b, err := os.ReadFile(filepath.Join(home, ".kimi", "device_id")); err == nil {
1397 deviceID = strings.TrimSpace(string(b))
1398 }
1399 }
1400 if deviceID == "" {
1401 deviceID = "zut"
1402 }
1403 return map[string]string{
1404 "User-Agent": "KimiCLI/1.41.0",
1405 "X-Msh-Platform": "kimi_cli",
1406 "X-Msh-Version": "1.41.0",
1407 "X-Msh-Device-Name": host,
1408 "X-Msh-Device-Model": runtime.GOOS + "-" + runtime.GOARCH,
1409 "X-Msh-Os-Version": runtime.GOOS,
1410 "X-Msh-Device-Id": deviceID,
1411 }
1412}
1413
1414func envVarName(provider string) string {
1415 switch provider {
1416 case "openai", "openai-codex", "openai-responses":
1417 return "OPENAI"
1418 case "kimi":
1419 return "KIMI"
1420 case "deepseek":
1421 return "DEEPSEEK"
1422 case "google":
1423 return "GEMINI"
1424 case "ollama":
1425 return "OLLAMA"
1426 case "llama.cpp":
1427 return "LLAMA"
1428 case "moonshotai", "moonshotai-cn":
1429 return "MOONSHOT"
1430 case "groq":
1431 return "GROQ"
1432 case "xai":
1433 return "XAI"
1434 case "cerebras":
1435 return "CEREBRAS"
1436 case "together":
1437 return "TOGETHER"
1438 case "huggingface":
1439 return "HF"
1440 case "openrouter":
1441 return "OPENROUTER"
1442 case "mistral":
1443 return "MISTRAL"
1444 case "zai":
1445 return "ZAI"
1446 case "xiaomi":
1447 return "XIAOMI"
1448 case "xiaomi-token-plan-ams":
1449 return "XIAOMI_TOKEN_PLAN_AMS"
1450 case "xiaomi-token-plan-cn":
1451 return "XIAOMI_TOKEN_PLAN_CN"
1452 case "xiaomi-token-plan-sgp":
1453 return "XIAOMI_TOKEN_PLAN_SGP"
1454 case "minimax":
1455 return "MINIMAX"
1456 case "minimax-cn":
1457 return "MINIMAX_CN"
1458 case "fireworks":
1459 return "FIREWORKS"
1460 case "vercel-ai-gateway":
1461 return "AI_GATEWAY"
1462 case "opencode", "opencode-go":
1463 return "OPENCODE"
1464 case "github-copilot":
1465 return "COPILOT_GITHUB_TOKEN"
1466 case "cloudflare-workers-ai", "cloudflare-ai-gateway":
1467 return "CLOUDFLARE"
1468 case "amazon-bedrock":
1469 return "AWS"
1470 case "google-vertex":
1471 return "GOOGLE_CLOUD"
1472 case "azure-openai-responses":
1473 return "AZURE_OPENAI"
1474 default:
1475 return "ANTHROPIC"
1476 }
1477}