fix: prevent panic from openai-go

gollm/openai.go

@@ -328,8 +328,19 @@ func (cs *openAIChatSession) SendStreaming(ctx context.Context, contents ...any)
 		for stream.Next() {
 			chunk := stream.Current()
 
-			// Update the accumulator with the new chunk
-			acc.AddChunk(chunk)
+			// Update the accumulator with the new chunk, guarding against
+			// panics from the upstream client when tool call indices are
+			// missing. See https://github.com/openai/openai-go/issues/464 for more details.
+			if ok, err := addChunkSafely(&acc, chunk); err != nil {
+				klog.ErrorS(err, "Recovered from OpenAI accumulator panic while processing chunk")
+				yield(nil, fmt.Errorf("OpenAI streaming error while accumulating chunk: %w", err))
+				return
+			} else if !ok {
+				err := errors.New("OpenAI accumulator rejected stream chunk")
+				klog.Error(err)
+				yield(nil, fmt.Errorf("OpenAI streaming error while accumulating chunk: %w", err))
+				return
+			}
 
 			// Handle content completion
 			if _, ok := acc.JustFinishedContent(); ok {
@@ -415,6 +426,23 @@ func (cs *openAIChatSession) SendStreaming(ctx context.Context, contents ...any)
 	}, nil
 }
 
+// addChunkSafely wraps the accumulator's AddChunk method to protect against
+// panics triggered by malformed tool call indices returned by the upstream
+// openai-go client. Returning an error allows the caller to surface a regular
+// failure instead of crashing the entire process while the upstream fix is in
+// flight.
+func addChunkSafely(acc *openai.ChatCompletionAccumulator, chunk openai.ChatCompletionChunk) (added bool, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = fmt.Errorf("openai accumulator panic: %v", r)
+			added = false
+		}
+	}()
+
+	added = acc.AddChunk(chunk)
+	return
+}
+
 // IsRetryableError determines if an error from the OpenAI API should be retried.
 func (cs *openAIChatSession) IsRetryableError(err error) bool {
 	if err == nil {

gollm/openai_test.go

@@ -604,3 +604,73 @@ func TestConvertToolCallsToFunctionCalls(t *testing.T) {
 		})
 	}
 }
+
+func TestAddChunkSafely(t *testing.T) {
+	tests := []struct {
+		name             string
+		chunk            openai.ChatCompletionChunk
+		expectError      bool
+		expectAdded      bool
+		setupAccumulator func() *openai.ChatCompletionAccumulator
+		unmarshalJSON    bool
+		jsonString       string
+	}{
+		{
+			name: "valid chunk with valid accumulator",
+			chunk: openai.ChatCompletionChunk{
+				Choices: []openai.ChatCompletionChunkChoice{
+					{
+						Delta: openai.ChatCompletionChunkChoiceDelta{
+							Content: "hello",
+						},
+					},
+				},
+			},
+			expectError: false,
+			expectAdded: true,
+			setupAccumulator: func() *openai.ChatCompletionAccumulator {
+				return &openai.ChatCompletionAccumulator{}
+			},
+		},
+		{
+			name:        "chunk with negative tool call index should panic and be recovered",
+			expectError: true,
+			expectAdded: false,
+			setupAccumulator: func() *openai.ChatCompletionAccumulator {
+				return &openai.ChatCompletionAccumulator{}
+			},
+			unmarshalJSON: true,
+			jsonString:    "{\"id\":\"gen-1753952129163910909\",\"object\":\"chat.completion.chunk\",\"created\":1753952129,\"model\":\"model\",\"choices\":[{\"index\":0,\"delta\":{\"role\":null,\"content\":null,\"reasoning_content\":null,\"tool_calls\":[{\"id\":\"call_goVJu3KUQtuahQuqW6wgzQ\",\"index\":-1,\"type\":\"function\",\"function\":{\"name\":\"doc_search\",\"arguments\":\"\"}}]},\"logprobs\":null,\"finish_reason\":null,\"matched_stop\":null}],\"usage\":null}",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			acc := tt.setupAccumulator()
+			chunk := tt.chunk
+
+			if tt.unmarshalJSON {
+				err := json.Unmarshal([]byte(tt.jsonString), &chunk)
+				if err != nil {
+					t.Fatalf("Failed to unmarshal test JSON: %v", err)
+				}
+			}
+
+			added, err := addChunkSafely(acc, chunk)
+
+			if tt.expectError {
+				if err == nil {
+					t.Error("expected an error, but got none")
+				}
+			} else {
+				if err != nil {
+					t.Errorf("unexpected error: %v", err)
+				}
+			}
+
+			if added != tt.expectAdded {
+				t.Errorf("expected added to be %v, but got %v", tt.expectAdded, added)
+			}
+		})
+	}
+}