fix: improve follow-up prompt timeout and abort handling

[Abhiiishek44]

Summary

This PR improves follow-up prompt reliability for Ollama-based requests by making the request flow abort-aware and ensuring cleanup across retry attempts.

Changes included:

• wrap the Ollama follow-up prompt request in an abort-aware race so configured timeouts and retries are respected consistently
• ensure AbortSignal listeners are always removed after execution to avoid listener accumulation across retries
• add a small runtime validation guard for the parsed follow-up prompt response before returning the result

Notes

• changes are intentionally scoped only to packages/components/src/followUpPrompts.ts
• no behavior changes for unrelated providers
• verified under the repository's Node 20 environment
• local repository-wide TypeScript issues observed during checks appear unrelated to this change

Related: #6421

[gemini-code-assist]

Code Review

This pull request introduces a robust retry mechanism with exponential backoff and timeout handling for generating follow-up prompts across various LLM providers. It adds a new executeWithRetry utility and updates provider-specific logic to utilize this wrapper. Feedback highlights unreachable code at the end of the retry function and redundant timeout logic within the Ollama provider implementation, suggesting a cleaner approach using the existing wrapper's capabilities.

[gemini-code-assist]

This line is unreachable. The retry loop already throws the last encountered error when attempt >= maxRetries is reached (line 92).

[gemini-code-assist]

The manual Promise.race and AbortSignal listener inside the Ollama provider are redundant because executeWithRetry already wraps the execution in a race against a timeout-driven abort signal. Additionally, the check for result.questions is unnecessary as FollowUpPromptType.parse already validates the presence and type of the field, ensuring fail-fast behavior for external data.

                        // Ollama client does not accept AbortSignal directly in this SDK call.
                        // However, executeWithRetry already handles the timeout and abort logic
                        // via Promise.race at the outer level.
                        const response = await ollamaClient.chat({
                            model: providerConfig.modelName,
                            messages: [
                                {
                                    role: 'user',
                                    content: followUpPromptsPrompt
                                }
                            ],
                            format: {
                                type: 'object',
                                properties: {
                                    questions: {
                                        type: 'array',
                                        items: {
                                            type: 'string'
                                        },
                                        minItems: 3,
                                        maxItems: 3,
                                        description: 'Three follow-up questions based on the conversation history'
                                    }
                                },
                                required: ['questions'],
                                additionalProperties: false
                            },
                            options: {
                                temperature: parseFloat(`${providerConfig.temperature}`)
                            }
                        })

                        const result = FollowUpPromptType.parse(JSON.parse((response as any).message.content))
                        return { questions: result.questions }

References

1. Use a default (fallback) implementation unless the specific implementation has meaningfully different behavior or provides better error messages.
2. When handling potentially invalid data from external sources, prefer throwing an error for invalid input types rather than silently returning a default or empty value.