chore: sync upstream fantasy v0.40.0 into coder_2_33

.github/workflows/lint.yml

@@ -1,6 +1,7 @@
 name: lint
 on:
   push:
+    branches: [main]
   pull_request:
 
 jobs:
@@ -10,3 +11,4 @@ jobs:
       golangci_path: .golangci.yml
       golangci_version: v2.9
       timeout: 10m
+      os: '["ubuntu-latest"]'

agent.go

@@ -8,7 +8,9 @@ import (
 	"errors"
 	"fmt"
 	"maps"
+	"runtime/debug"
 	"slices"
+	"strings"
 	"sync"
 
 	"charm.land/fantasy/jsonrepair"
@@ -171,10 +173,18 @@ type AgentCall struct {
 	FrequencyPenalty *float64    `json:"frequency_penalty"`
 	ActiveTools      []string    `json:"active_tools"`
 	ToolChoice       *ToolChoice `json:"tool_choice"`
+	Headers          map[string]string
 	ProviderOptions  ProviderOptions
 	OnRetry          OnRetryCallback
+	OnAuthRefresh    OnAuthRefreshFunc
 	MaxRetries       *int
 
+	// ModelProvider, when non-nil, is called on each retry attempt to
+	// obtain the language model. This allows callers to swap in a
+	// refreshed model after OnAuthRefresh rebuilds credentials. When
+	// nil, the model captured at step preparation time is used.
+	ModelProvider func() LanguageModel
+
 	StopWhen       []StopCondition
 	PrepareStep    PrepareStepFunction
 	RepairToolCall RepairToolCallFunction
@@ -199,6 +209,16 @@ type (
 
 	// OnErrorFunc is called when an error occurs.
 	OnErrorFunc func(error)
+
+	// OnAuthRefreshFunc is called when a stream fails with an authentication
+	// error that the caller may be able to resolve (e.g. an expired SSO
+	// session or OAuth token). The function should perform whatever credential
+	// refresh is needed and return nil on success, in which case fantasy
+	// retries the operation transparently. Returning an error surfaces the
+	// original auth error to the caller without retry. Pair this with
+	// ModelProvider to supply a rebuilt model carrying the refreshed
+	// credentials on the retry attempt.
+	OnAuthRefreshFunc func(ctx context.Context, err *ProviderError) error
 )
 
 // Stream part callbacks - called for each corresponding stream part type.
@@ -265,8 +285,15 @@ type AgentStreamCall struct {
 	Headers          map[string]string
 	ProviderOptions  ProviderOptions
 	OnRetry          OnRetryCallback
+	OnAuthRefresh    OnAuthRefreshFunc
 	MaxRetries       *int
 
+	// ModelProvider, when non-nil, is called on each retry attempt to
+	// obtain the language model. This allows callers to swap in a
+	// refreshed model after OnAuthRefresh rebuilds credentials. When
+	// nil, the model captured at step preparation time is used.
+	ModelProvider func() LanguageModel
+
 	StopWhen       []StopCondition
 	PrepareStep    PrepareStepFunction
 	RepairToolCall RepairToolCallFunction
@@ -300,11 +327,44 @@ type AgentStreamCall struct {
 // AgentResult represents the result of an agent execution.
 type AgentResult struct {
 	Steps []StepResult
-	// Final response
+	// Final response. When the last step is tool-only (no text content),
+	// this is the response from the most recent step that contained text,
+	// so callers always see meaningful output without walking Steps manually.
 	Response   Response
 	TotalUsage Usage
 }
 
+// finalResponse picks the best Response from a slice of steps. It walks
+// backwards to find the most recent step with non-blank text content. If no
+// step has text content (e.g. all steps were tool calls), the last step's
+// response is returned as-is.
+func finalResponse(steps []StepResult) Response {
+	for i := len(steps) - 1; i >= 0; i-- {
+		if hasNonBlankText(steps[i].Content) {
+			return steps[i].Response
+		}
+	}
+	if len(steps) > 0 {
+		return steps[len(steps)-1].Response
+	}
+	return Response{}
+}
+
+// hasNonBlankText reports whether content contains at least one text block
+// with non-whitespace characters.
+func hasNonBlankText(content ResponseContent) bool {
+	for _, c := range content {
+		if c.GetType() == ContentTypeText {
+			if tc, ok := AsContentType[TextContent](c); ok {
+				if strings.TrimSpace(tc.Text) != "" {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
 // Agent represents an AI agent that can generate responses and stream responses.
 type Agent interface {
 	Generate(context.Context, AgentCall) (*AgentResult, error)
@@ -368,6 +428,10 @@ func (a *agent) prepareCall(call AgentCall) AgentCall {
 	if a.settings.headers != nil {
 		maps.Copy(headers, a.settings.headers)
 	}
+	if call.Headers != nil {
+		maps.Copy(headers, call.Headers)
+	}
+	call.Headers = headers
 
 	return call
 }
@@ -452,9 +516,17 @@ func (a *agent) Generate(ctx context.Context, opts AgentCall) (*AgentResult, err
 			retryOptions.MaxRetries = *opts.MaxRetries
 		}
 		retryOptions.OnRetry = opts.OnRetry
+		retryOptions.OnAuthRefresh = opts.OnAuthRefresh
 		retry := RetryWithExponentialBackoffRespectingRetryHeaders[*Response](retryOptions)
 		result, err := retry(ctx, func() (*Response, error) {
-			return stepModel.Generate(ctx, Call{
+			// Re-read the model on each retry attempt so that
+			// OnAuthRefresh can swap in a model with fresh credentials.
+			retryModel := stepModel
+			if opts.ModelProvider != nil {
+				retryModel = opts.ModelProvider()
+			}
+
+			return retryModel.Generate(ctx, Call{
 				Prompt:           stepInputMessages,
 				MaxOutputTokens:  opts.MaxOutputTokens,
 				Temperature:      opts.Temperature,
@@ -465,6 +537,7 @@ func (a *agent) Generate(ctx context.Context, opts AgentCall) (*AgentResult, err
 				Tools:            preparedTools,
 				ToolChoice:       &stepToolChoice,
 				UserAgent:        a.settings.userAgent,
+				Headers:          opts.Headers,
 				ProviderOptions:  opts.ProviderOptions,
 			})
 		})
@@ -555,7 +628,7 @@ func (a *agent) Generate(ctx context.Context, opts AgentCall) (*AgentResult, err
 
 	agentResult := &AgentResult{
 		Steps:      steps,
-		Response:   steps[len(steps)-1].Response,
+		Response:   finalResponse(steps),
 		TotalUsage: totalUsage,
 	}
 	return agentResult, nil
@@ -643,6 +716,7 @@ func toResponseMessages(content []Content) []Message {
 				Output:           result.Result,
 				ProviderExecuted: result.ProviderExecuted,
 				ProviderOptions:  ProviderOptions(result.ProviderMetadata),
+				ClientMetadata:   result.ClientMetadata,
 			}
 			if result.ProviderExecuted {
 				// Provider-executed tool results (e.g. web search)
@@ -740,8 +814,11 @@ func (a *agent) executeSingleTool(ctx context.Context, toolMap map[string]AgentT
 		return result, false
 	}
 
-	// Execute the tool
-	toolResult, err := runTool(ctx, ToolCall{
+	// Execute the tool, converting a panic into a failed tool result so a
+	// single misbehaving tool cannot take down the whole process. The panic
+	// value and stack are included so they survive in the transcript even
+	// when stderr is lost.
+	toolResult, err := runToolSafely(ctx, runTool, ToolCall{
 		ID:    toolCall.ToolCallID,
 		Name:  toolCall.ToolName,
 		Input: toolCall.Input,
@@ -781,6 +858,25 @@ func (a *agent) executeSingleTool(ctx context.Context, toolMap map[string]AgentT
 	return result, false
 }
 
+// runToolSafely invokes a tool's run function and converts any panic into a
+// failed tool result. Tool implementations run on goroutines spawned by the
+// agent's step processor where an unrecovered panic would crash the entire
+// host process, so this boundary is the last line of defense. The panic
+// value and stack trace are captured in the returned error so they are
+// preserved in the conversation transcript and any persisted logs.
+func runToolSafely(ctx context.Context, runTool func(ctx context.Context, call ToolCall) (ToolResponse, error), call ToolCall) (toolResult ToolResponse, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			stack := debug.Stack()
+			toolResult = NewTextErrorResponse(fmt.Sprintf(
+				"tool %q panicked: %v\n\n%s", call.Name, r, stack,
+			))
+			err = nil
+		}
+	}()
+	return runTool(ctx, call)
+}
+
 // Stream implements Agent.
 func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult, error) {
 	// Convert AgentStreamCall to AgentCall for preparation
@@ -796,9 +892,12 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 		FrequencyPenalty: opts.FrequencyPenalty,
 		ActiveTools:      opts.ActiveTools,
 		ToolChoice:       opts.ToolChoice,
+		Headers:          opts.Headers,
 		ProviderOptions:  opts.ProviderOptions,
 		MaxRetries:       opts.MaxRetries,
 		OnRetry:          opts.OnRetry,
+		OnAuthRefresh:    opts.OnAuthRefresh,
+		ModelProvider:    opts.ModelProvider,
 		StopWhen:         opts.StopWhen,
 		PrepareStep:      opts.PrepareStep,
 		RepairToolCall:   opts.RepairToolCall,
@@ -900,6 +999,7 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 			Tools:            preparedTools,
 			ToolChoice:       &stepToolChoice,
 			UserAgent:        a.settings.userAgent,
+			Headers:          call.Headers,
 			ProviderOptions:  call.ProviderOptions,
 		}
 
@@ -909,11 +1009,19 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 			retryOptions.MaxRetries = *call.MaxRetries
 		}
 		retryOptions.OnRetry = call.OnRetry
+		retryOptions.OnAuthRefresh = call.OnAuthRefresh
 		retry := RetryWithExponentialBackoffRespectingRetryHeaders[stepExecutionResult](retryOptions)
 
 		result, err := retry(ctx, func() (stepExecutionResult, error) {
+			// Re-read the model on each retry attempt so that
+			// OnAuthRefresh can swap in a model with fresh credentials.
+			retryModel := stepModel
+			if call.ModelProvider != nil {
+				retryModel = call.ModelProvider()
+			}
+
 			// Create the stream
-			stream, err := stepModel.Stream(ctx, streamCall)
+			stream, err := retryModel.Stream(ctx, streamCall)
 			if err != nil {
 				return stepExecutionResult{}, err
 			}
@@ -954,7 +1062,7 @@ func (a *agent) Stream(ctx context.Context, opts AgentStreamCall) (*AgentResult,
 	// Finish agent stream
 	agentResult := &AgentResult{
 		Steps:      steps,
-		Response:   steps[len(steps)-1].Response,
+		Response:   finalResponse(steps),
 		TotalUsage: totalUsage,
 	}
 
@@ -1088,7 +1196,14 @@ func (a *agent) validateToolCall(toolCall ToolCallContent, availableTools []Agen
 				return nil
 			}
 		}
-		return fmt.Errorf("tool not found: %s", toolCall.ToolName)
+		names := make([]string, 0, len(availableTools)+len(execProviderTools))
+		for _, t := range availableTools {
+			names = append(names, t.Info().Name)
+		}
+		for _, ept := range execProviderTools {
+			names = append(names, ept.GetName())
+		}
+		return fmt.Errorf("tool not found: %s. Available tools: %s", toolCall.ToolName, strings.Join(names, ", "))
 	}
 
 	// Validate JSON parsing