fix(provider): align openaicompat identity and responses semantics

Generated with [codeagent](https://github.com/qbox/codeagent)
Co-authored-by: phantom5099 <245659304+phantom5099@users.noreply.github.com>

Author: xgopilot

internal/provider/identity.go

@@ -175,9 +175,6 @@ func NormalizeProviderIdentity(identity ProviderIdentity) (ProviderIdentity, err
 		if err != nil {
 			return ProviderIdentity{}, err
 		}
-		if chatEndpointPath == "/chat/completions" {
-			chatEndpointPath = ""
-		}
 		return ProviderIdentity{
 			Driver:                normalizedDriver,
 			BaseURL:               normalizedBaseURL,

internal/provider/identity_test.go

@@ -36,13 +36,43 @@ func TestNormalizeProviderIdentityUsesDriverSpecificNormalization(t *testing.T)
 		t.Fatalf("expected normalized base url %q, got %q", "https://api.example.com/v1", identity.BaseURL)
 	}
 	if identity.ChatEndpointPath != "" {
-		t.Fatalf("expected default chat/completions path to be omitted from identity, got %q", identity.ChatEndpointPath)
+		t.Fatalf("expected empty chat endpoint path to stay empty in identity, got %q", identity.ChatEndpointPath)
 	}
 	if identity.DiscoveryEndpointPath != "/models" {
 		t.Fatalf("expected normalized discovery endpoint path %q, got %q", "/models", identity.DiscoveryEndpointPath)
 	}
 }
 
+func TestNormalizeProviderIdentityOpenAICompatPreservesChatEndpointSemanticDifference(t *testing.T) {
+	t.Parallel()
+
+	directIdentity, err := NormalizeProviderIdentity(ProviderIdentity{
+		Driver:                DriverOpenAICompat,
+		BaseURL:               "https://api.example.com/v1",
+		ChatEndpointPath:      "",
+		DiscoveryEndpointPath: "/models",
+	})
+	if err != nil {
+		t.Fatalf("NormalizeProviderIdentity() direct error = %v", err)
+	}
+	chatIdentity, err := NormalizeProviderIdentity(ProviderIdentity{
+		Driver:                DriverOpenAICompat,
+		BaseURL:               "https://api.example.com/v1",
+		ChatEndpointPath:      "/chat/completions",
+		DiscoveryEndpointPath: "/models",
+	})
+	if err != nil {
+		t.Fatalf("NormalizeProviderIdentity() chat error = %v", err)
+	}
+
+	if directIdentity.Key() == chatIdentity.Key() {
+		t.Fatalf("expected distinct identity keys for direct mode and /chat/completions, got %q", directIdentity.Key())
+	}
+	if chatIdentity.ChatEndpointPath != "/chat/completions" {
+		t.Fatalf("expected /chat/completions to be preserved, got %q", chatIdentity.ChatEndpointPath)
+	}
+}
+
 func TestNormalizeProviderIdentityShrinksSDKDriverFields(t *testing.T) {
 	t.Parallel()
 

internal/provider/openaicompat/chatcompletions/request.go

@@ -94,6 +94,17 @@ func ToOpenAIMessage(ctx context.Context, message providertypes.Message, assetRe
 	return msg, err
 }
 
+// ToOpenAIMessageWithBudget 将通用 Message 转换为 OpenAI 协议消息格式，并应用会话附件预算限制。
+func ToOpenAIMessageWithBudget(
+	ctx context.Context,
+	message providertypes.Message,
+	assetReader providertypes.SessionAssetReader,
+	remainingAssetBudget int64,
+	assetLimits providertypes.SessionAssetLimits,
+) (Message, int64, error) {
+	return toOpenAIMessageWithBudget(ctx, message, assetReader, remainingAssetBudget, assetLimits)
+}
+
 // toOpenAIMessageWithBudget 将通用 Message 转换为 OpenAI 协议消息格式，并记录 session_asset 消耗字节数。
 func toOpenAIMessageWithBudget(
 	ctx context.Context,

internal/provider/openaicompat/responses/request.go

@@ -33,11 +33,21 @@ func BuildRequest(ctx context.Context, cfg provider.RuntimeConfig, req providert
 		payload.Instructions = req.SystemPrompt
 	}
 
+	assetLimits := providertypes.NormalizeSessionAssetLimits(cfg.SessionAssetLimits)
+	var usedSessionAssetBytes int64
 	for _, message := range req.Messages {
-		items, err := toResponsesInputItems(ctx, message, req.SessionAssetReader)
+		remainingSessionAssetBytes := assetLimits.MaxSessionAssetsTotalBytes - usedSessionAssetBytes
+		items, consumedBytes, err := toResponsesInputItems(
+			ctx,
+			message,
+			req.SessionAssetReader,
+			remainingSessionAssetBytes,
+			assetLimits,
+		)
 		if err != nil {
 			return Request{}, err
 		}
+		usedSessionAssetBytes += consumedBytes
 		payload.Input = append(payload.Input, items...)
 	}
 
@@ -62,20 +72,28 @@ func toResponsesInputItems(
 	ctx context.Context,
 	message providertypes.Message,
 	assetReader providertypes.SessionAssetReader,
-) ([]InputItem, error) {
-	openaiMessage, err := chatcompletions.ToOpenAIMessage(ctx, message, assetReader)
+	remainingAssetBudget int64,
+	assetLimits providertypes.SessionAssetLimits,
+) ([]InputItem, int64, error) {
+	openaiMessage, consumedBytes, err := chatcompletions.ToOpenAIMessageWithBudget(
+		ctx,
+		message,
+		assetReader,
+		remainingAssetBudget,
+		assetLimits,
+	)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
 	switch strings.TrimSpace(openaiMessage.Role) {
 	case providertypes.RoleSystem:
-		return nil, nil
+		return nil, consumedBytes, nil
 	case providertypes.RoleUser, providertypes.RoleAssistant:
 		items := make([]InputItem, 0, 1+len(openaiMessage.ToolCalls))
 		contentParts, err := toResponsesContentParts(openaiMessage.Content)
 		if err != nil {
-			return nil, err
+			return nil, 0, err
 		}
 		if len(contentParts) > 0 {
 			items = append(items, InputItem{
@@ -96,23 +114,23 @@ func toResponsesInputItems(
 				})
 			}
 		}
-		return items, nil
+		return items, consumedBytes, nil
 	case providertypes.RoleTool:
 		callID := strings.TrimSpace(openaiMessage.ToolCallID)
 		if callID == "" {
-			return nil, errors.New(errorPrefix + "tool result message requires tool_call_id")
+			return nil, 0, errors.New(errorPrefix + "tool result message requires tool_call_id")
 		}
 		output, err := renderToolOutput(openaiMessage.Content)
 		if err != nil {
-			return nil, err
+			return nil, 0, err
 		}
 		return []InputItem{{
 			Type:   "function_call_output",
 			CallID: callID,
 			Output: output,
-		}}, nil
+		}}, consumedBytes, nil
 	default:
-		return nil, fmt.Errorf("%sunsupported message role %q", errorPrefix, openaiMessage.Role)
+		return nil, 0, fmt.Errorf("%sunsupported message role %q", errorPrefix, openaiMessage.Role)
 	}
 }
 

internal/provider/openaicompat/responses/request_test.go

@@ -2,13 +2,27 @@ package responses
 
 import (
 	"context"
+	"io"
 	"strings"
 	"testing"
 
 	"neo-code/internal/provider"
 	providertypes "neo-code/internal/provider/types"
 )
 
+type stubAssetReader struct {
+	data map[string][]byte
+	mime map[string]string
+}
+
+func (s *stubAssetReader) Open(_ context.Context, assetID string) (io.ReadCloser, string, error) {
+	content, ok := s.data[assetID]
+	if !ok {
+		return nil, "", io.EOF
+	}
+	return io.NopCloser(strings.NewReader(string(content))), s.mime[assetID], nil
+}
+
 func TestBuildRequestUsesDefaultModelAndMapsMessages(t *testing.T) {
 	t.Parallel()
 
@@ -114,6 +128,44 @@ func TestBuildRequestValidationErrors(t *testing.T) {
 			t.Fatalf("expected tool_call_id error, got %v", err)
 		}
 	})
+
+	t.Run("session asset total budget respects runtime limits", func(t *testing.T) {
+		t.Parallel()
+
+		assetReader := &stubAssetReader{
+			data: map[string][]byte{
+				"asset_1": []byte("PN"),
+				"asset_2": []byte("PN"),
+			},
+			mime: map[string]string{
+				"asset_1": "image/png",
+				"asset_2": "image/png",
+			},
+		}
+
+		_, err := BuildRequest(context.Background(), provider.RuntimeConfig{
+			DefaultModel: "m",
+			SessionAssetLimits: providertypes.SessionAssetLimits{
+				MaxSessionAssetBytes:       2,
+				MaxSessionAssetsTotalBytes: 3,
+			},
+		}, providertypes.GenerateRequest{
+			Messages: []providertypes.Message{
+				{
+					Role:  providertypes.RoleUser,
+					Parts: []providertypes.ContentPart{providertypes.NewSessionAssetImagePart("asset_1", "image/png")},
+				},
+				{
+					Role:  providertypes.RoleUser,
+					Parts: []providertypes.ContentPart{providertypes.NewSessionAssetImagePart("asset_2", "image/png")},
+				},
+			},
+			SessionAssetReader: assetReader,
+		})
+		if err == nil || !strings.Contains(err.Error(), "session_asset total exceeds 3 bytes") {
+			t.Fatalf("expected runtime session asset total budget error, got %v", err)
+		}
+	})
 }
 
 func TestToResponsesContentPartsAndRenderToolOutput(t *testing.T) {

internal/provider/openaicompat/responses/stream.go

@@ -58,6 +58,7 @@ func ConsumeStream(
 				Function: responseFunctionCall{
 					Arguments: event.Delta,
 				},
+				ArgumentsMode: responseToolCallArgumentsMergeAppend,
 			}
 			if err := mergeToolCallDelta(ctx, events, toolCalls, delta); err != nil {
 				return err
@@ -66,6 +67,10 @@ func ConsumeStream(
 			if event.Item == nil || strings.TrimSpace(event.Item.Type) != "function_call" {
 				return nil
 			}
+			argumentsMode := responseToolCallArgumentsMergeAppend
+			if strings.TrimSpace(event.Type) == "response.output_item.done" {
+				argumentsMode = responseToolCallArgumentsMergeReplace
+			}
 			toolIndex := resolveToolCallIndex(event.OutputIndex, event.Item.ID, itemToolCallMap, &nextToolCallSlot)
 			toolCallID := strings.TrimSpace(event.Item.CallID)
 			if toolCallID == "" {
@@ -78,6 +83,7 @@ func ConsumeStream(
 					Name:      strings.TrimSpace(event.Item.Name),
 					Arguments: event.Item.Arguments,
 				},
+				ArgumentsMode: argumentsMode,
 			}
 			if err := mergeToolCallDelta(ctx, events, toolCalls, delta); err != nil {
 				return err
@@ -194,11 +200,19 @@ type responseFunctionCall struct {
 }
 
 type responseToolCallDelta struct {
-	Index    int
-	ID       string
-	Function responseFunctionCall
+	Index         int
+	ID            string
+	Function      responseFunctionCall
+	ArgumentsMode responseToolCallArgumentsMergeMode
 }
 
+type responseToolCallArgumentsMergeMode int
+
+const (
+	responseToolCallArgumentsMergeAppend responseToolCallArgumentsMergeMode = iota
+	responseToolCallArgumentsMergeReplace
+)
+
 // mergeToolCallDelta 将单个 tool call 增量合并到累积状态，并在必要时发出统一事件。
 func mergeToolCallDelta(
 	ctx context.Context,
@@ -227,9 +241,29 @@ func mergeToolCallDelta(
 	}
 
 	if args := delta.Function.Arguments; args != "" {
-		call.Arguments += args
-		if err := provider.EmitToolCallDelta(ctx, events, delta.Index, call.ID, args); err != nil {
-			return err
+		switch delta.ArgumentsMode {
+		case responseToolCallArgumentsMergeReplace:
+			if call.Arguments == args {
+				return nil
+			}
+			emitDelta := args
+			if strings.HasPrefix(args, call.Arguments) {
+				emitDelta = strings.TrimPrefix(args, call.Arguments)
+			}
+			call.Arguments = args
+			if emitDelta != "" {
+				if err := provider.EmitToolCallDelta(ctx, events, delta.Index, call.ID, emitDelta); err != nil {
+					return err
+				}
+			}
+		default:
+			if strings.HasSuffix(call.Arguments, args) {
+				return nil
+			}
+			call.Arguments += args
+			if err := provider.EmitToolCallDelta(ctx, events, delta.Index, call.ID, args); err != nil {
+				return err
+			}
 		}
 	}
 	return nil

internal/provider/openaicompat/responses/stream_test.go

@@ -65,6 +65,49 @@ func TestConsumeStreamCompletedWithToolCalls(t *testing.T) {
 	}
 }
 
+func TestConsumeStreamToolCallArgumentsAddedDeltaDoneNoDuplicate(t *testing.T) {
+	t.Parallel()
+
+	sseBody := strings.Join([]string{
+		`data: {"type":"response.output_item.added","output_index":0,"item":{"type":"function_call","id":"item_1","call_id":"call_1","name":"read_file","arguments":"{\"path\":\"README.md\"}"}}`,
+		"",
+		`data: {"type":"response.function_call_arguments.delta","output_index":0,"item_id":"item_1","delta":"{\"path\":\"README.md\"}"}`,
+		"",
+		`data: {"type":"response.output_item.done","output_index":0,"item":{"type":"function_call","id":"item_1","call_id":"call_1","name":"read_file","arguments":"{\"path\":\"README.md\"}"}}`,
+		"",
+		`data: {"type":"response.completed","response":{"status":"completed"}}`,
+		"",
+		"data: [DONE]",
+		"",
+	}, "\n")
+
+	events := make(chan providertypes.StreamEvent, 16)
+	err := ConsumeStream(context.Background(), strings.NewReader(sseBody), events)
+	if err != nil {
+		t.Fatalf("ConsumeStream() error = %v", err)
+	}
+
+	collected := drainStreamEvents(events)
+	if len(collected) != 3 {
+		t.Fatalf("expected 3 events, got %d", len(collected))
+	}
+
+	start, err := collected[0].ToolCallStartValue()
+	if err != nil || start.Name != "read_file" {
+		t.Fatalf("expected tool start event, got err=%v event=%+v", err, collected[0])
+	}
+	delta, err := collected[1].ToolCallDeltaValue()
+	if err != nil {
+		t.Fatalf("expected tool delta event, got err=%v event=%+v", err, collected[1])
+	}
+	if delta.ArgumentsDelta != `{"path":"README.md"}` {
+		t.Fatalf("expected single non-duplicated arguments delta, got %q", delta.ArgumentsDelta)
+	}
+	if _, err := collected[2].MessageDoneValue(); err != nil {
+		t.Fatalf("expected message done event, got err=%v event=%+v", err, collected[2])
+	}
+}
+
 func TestConsumeStreamIncompleteAndFailures(t *testing.T) {
 	t.Parallel()