Isolate parsed provider parameters

integrations/ckprompt/request_flags.go

@@ -85,6 +85,7 @@ func (f ExecutionFlags[I]) bindings() []requestBinding[I] {
 }
 
 // NewExecutionFlags binds execution controls to a field of the caller's input.
+// Parsed provider parameters are copied when the binding is applied.
 func NewExecutionFlags[I any](destination func(*I) *ExecutionInput) ExecutionFlags[I] {
 	target := func(input *I) *promptkit.ExecutionTargetOverride {
 		value := destination(input)
@@ -104,7 +105,36 @@ func NewExecutionFlags[I any](destination func(*I) *ExecutionInput) ExecutionFla
 		ReasoningEffort:  executionFlag(requestFlags.ReasoningEffort.meta, parseDefinitionString, func(i *I, v string) { target(i).ReasoningEffort = &v }),
 		APIKeyEnv:        executionFlag(requestFlags.APIKeyEnv.meta, parseDefinitionString, func(i *I, v string) { target(i).APIKeyEnv = v }),
 		TransientRetries: executionFlag(requestFlags.TransientRetries.meta, strconv.Atoi, func(i *I, v int) { destination(i).TransientRetries = &v }),
-		ExtraParams:      executionFlag(requestFlags.ExtraParams.meta, parseExtraParams, func(i *I, v map[string]any) { target(i).ExtraParams = v }),
+		ExtraParams:      executionFlag(requestFlags.ExtraParams.meta, parseExtraParams, func(i *I, v map[string]any) { target(i).ExtraParams = copyProviderParams(v) }),
+	}
+}
+
+func copyProviderParams(params map[string]any) map[string]any {
+	if params == nil {
+		return nil
+	}
+	result := make(map[string]any, len(params))
+	for key, value := range params {
+		result[key] = copyProviderValue(value)
+	}
+	return result
+}
+
+func copyProviderValue(value any) any {
+	switch value := value.(type) {
+	case map[string]any:
+		return copyProviderParams(value)
+	case []any:
+		if value == nil {
+			return []any(nil)
+		}
+		result := make([]any, len(value))
+		for i, element := range value {
+			result[i] = copyProviderValue(element)
+		}
+		return result
+	default:
+		return value
 	}
 }
 

integrations/ckprompt/request_flags_test.go

@@ -76,3 +76,33 @@ func TestValidationForwardsExecutionControls(t *testing.T) {
 		t.Fatalf("result/request = %#v %#v", result, received)
 	}
 }
+
+func TestExecutionExtraParamsCapturedApplicationsAreIndependent(t *testing.T) {
+	type target struct{ execution ckprompt.ExecutionInput }
+	type outer struct{ captured commandkit.FlagValues[target] }
+	flag := ckprompt.NewExecutionFlags(func(i *target) *ckprompt.ExecutionInput { return &i.execution }).ExtraParams
+	captured := commandkit.CaptureFlags([]commandkit.Flag[target]{flag}, func(i *outer) *commandkit.FlagValues[target] { return &i.captured })
+	command := commandkit.NewCommand(commandkit.CommandSpec[outer]{Name: "run", Flags: captured, Run: func(_ commandkit.Invocation, input outer) commandkit.Outcome {
+		var first, second target
+		if err := input.captured.ApplyTo(&first, flag); err != nil {
+			t.Fatal(err)
+		}
+		first.execution.Execution.ExtraParams["nested"].(map[string]any)["array"].([]any)[0].(map[string]any)["number"] = int64(9)
+		if err := input.captured.ApplySuppliedTo(&second, flag); err != nil {
+			t.Fatal(err)
+		}
+		value := second.execution.Execution.ExtraParams["nested"].(map[string]any)["array"].([]any)[0].(map[string]any)["number"]
+		if value != int64(1) {
+			t.Errorf("second value = %#v", value)
+		}
+		return commandkit.Success()
+	}})
+	app, err := commandkit.New(commandkit.Identity{Name: "app"}, command)
+	if err != nil {
+		t.Fatal(err)
+	}
+	result := app.Execute(context.Background(), []string{"run", `--llm-extra-params={"nested":{"array":[{"number":1}]}}`}, commandkit.Streams{Out: io.Discard, Err: io.Discard})
+	if result.Kind != commandkit.OutcomeSuccess {
+		t.Fatal(result)
+	}
+}

integrations/ckprompt/smoke_aggregate_test.go

@@ -219,3 +219,33 @@ func TestSmokeAggregateCancellationRetainsPartialResults(t *testing.T) {
 		t.Fatalf("partial aggregate entries = %#v", document.Tests)
 	}
 }
+
+func TestSmokeAggregateIsolatesProviderParameters(t *testing.T) {
+	calls := 0
+	app := newPromptTestApp(t, Command(Suite[struct{}, struct{}]{
+		SmokeTest: func(_ context.Context, request SmokeRequest, _, _ struct{}) (commandkit.Acquired[*promptkit.SmokeTestReport], error) {
+			calls++
+			params := request.Request.Execution.ExtraParams
+			value := params["nested"].(map[string]any)["array"].([]any)[0].(map[string]any)
+			if value["number"] != int64(1) {
+				t.Errorf("call %d: %#v", calls, value)
+			}
+			value["number"] = int64(9)
+			return commandkit.Acquired[*promptkit.SmokeTestReport]{Value: &promptkit.SmokeTestReport{Kind: request.Request.Kind}}, nil
+		},
+	}))
+	outcome := app.Execute(context.Background(), []string{"promptkit", "test", "all", `--llm-extra-params={"nested":{"array":[{"number":1}]}}`}, commandkit.Streams{Out: io.Discard, Err: io.Discard})
+	if outcome.Kind != commandkit.OutcomeSuccess || calls != 4 {
+		t.Fatalf("outcome=%#v calls=%d", outcome, calls)
+	}
+}
+
+func TestCopyProviderParamsPreservesEmptyAndNilValues(t *testing.T) {
+	if copyProviderParams(nil) != nil {
+		t.Fatal("nil object became non-nil")
+	}
+	copied := copyProviderParams(map[string]any{"emptyObject": map[string]any{}, "nilObject": map[string]any(nil), "emptyArray": []any{}, "nilArray": []any(nil), "null": nil, "decimal": float64(1.5)})
+	if copied["emptyObject"].(map[string]any) == nil || copied["nilObject"].(map[string]any) != nil || copied["emptyArray"].([]any) == nil || copied["nilArray"].([]any) != nil || copied["null"] != nil || copied["decimal"] != float64(1.5) {
+		t.Fatalf("copied = %#v", copied)
+	}
+}

integrations/ckprompt/smoke_command.go

@@ -232,6 +232,7 @@ func smokeRequestForKind(seed promptkit.SmokeTestRequest, kind promptkit.SmokeTe
 	request.Kind = kind
 	if seed.Execution != nil {
 		execution := *seed.Execution
+		execution.ExtraParams = copyProviderParams(seed.Execution.ExtraParams)
 		execution.Temperature = copyFloat64(seed.Execution.Temperature)
 		execution.MaxTokens = copyInt(seed.Execution.MaxTokens)
 		execution.TopP = copyFloat64(seed.Execution.TopP)