feat(duckduckgo-web): add tool-call translation via webTools prompt injection

[oyi77]

Description

DuckDuckGo AI Chat has no native function calling support. This PR adds tool-call translation using the same pattern as deepseek-web (#2820) and qwen-web (#3252).

How it works

1. Request side: Serialize OpenAI tools[] into a system prompt instruction via serializeToolsToPrompt() from webTools.ts. Prepends tool instructions to messages array.

2. Response side: Parse <tool>{...}</tool> blocks from model text response via parseToolCallsFromText(). Returns proper OpenAI tool_calls format.

When tools are requested, buffers full response for tool-call parsing. When no tools are requested, standard streaming passthrough is used (no behavior change).

Files Changed

• open-sse/executors/duckduckgo-web.ts — +34 lines (tool injection + parsing)

Tests

All 15 existing tests pass.

[gemini-code-assist]

Code Review

This pull request introduces tool-calling support to the DuckDuckGo web executor by serializing requested tools into a system prompt and parsing tool calls from the response. Feedback on these changes highlights a critical issue where returning a standard JSON response when streaming is enabled with tools will break clients expecting an SSE stream; a code suggestion was provided to format the tool calls as SSE chunks. Additionally, the changes violate the repository style guide as no tests were added for the new production code under open-sse/.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

When streaming is true and hasTools is true, returning a standard JSON response with Content-Type: application/json will break clients that expect an SSE stream (text/event-stream). Instead, if streaming is true, we should format the tool calls (or plain text) as SSE chunks and return a text/event-stream response.

      if (hasTools) {
        const { content: cleanedContent, toolCalls } = parseToolCallsFromText(
          fullContent,
          "call-" + Date.now(),
          requestedTools
        );
        if (streaming) {
          const chunks: string[] = [];
          if (toolCalls) {
            chunks.push(JSON.stringify({
              choices: [{
                index: 0,
                delta: { role: "assistant", content: null, tool_calls: toolCalls },
                finish_reason: null
              }]
            }));
            chunks.push(JSON.stringify({
              choices: [{
                index: 0,
                delta: {},
                finish_reason: "tool_calls"
              }]
            }));
          } else {
            if (cleanedContent) {
              chunks.push(JSON.stringify({
                choices: [{
                  index: 0,
                  delta: { role: "assistant", content: cleanedContent },
                  finish_reason: null
                }]
              }));
            }
            chunks.push(JSON.stringify({
              choices: [{
                index: 0,
                delta: {},
                finish_reason: "stop"
              }]
            }));
          }
          const sseData = chunks.map(function(c) { return "data: " + c + "\n\n"; }).join("") + "data: [DONE]\n\n";
          return new Response(sseData, {
            headers: { "Content-Type": "text/event-stream" },
          });
        } else {
          const choice: Record<string, unknown> = {
            index: 0,
            message: { role: "assistant", content: cleanedContent },
            finish_reason: toolCalls ? "tool_calls" : "stop",
          };
          if (toolCalls) {
            (choice.message as Record<string, unknown>).tool_calls = toolCalls;
            (choice.message as Record<string, unknown>).content = null;
          }
          return new Response(JSON.stringify({ choices: [choice] }), {
            headers: { "Content-Type": "application/json" },
          });
        }
      }

[gemini-code-assist]

According to the Repository Style Guide (Rule 9), you must always include tests when changing production code under open-sse/. Please add unit/integration tests for the new tool-call translation logic in the tests/ directory.

References

1. Always include tests when changing production code (src/, open-sse/, electron/, bin/). ^(link)

[kilo-code-bot]

WARNING: Unconditionally prepending a system message can collide with an existing system message in the user's messages array. If messages[0].role === "system", the tool instructions will precede the user's intended system prompt, potentially causing the upstream model to process them in an unintended order or ignore the user's system message entirely. Consider merging tool instructions into the existing system message if one is present, or appending after any existing system message.

[kilo-code-bot]

WARNING: When stream !== false and tools are present, this condition bypasses the SSE streaming path entirely and returns a buffered non-streaming JSON response. The client's stream=true request is silently downgraded to a single JSON payload, breaking the streaming contract for clients that always expect SSE chunks. Tool calls should either be streamed as SSE delta events or the executor should reject stream=true with tools rather than silently changing the response format.

[kilo-code-bot]

Code Review Summary

Status: 2 Issues Found | Recommendation: Address before merge

Overview

Severity	Count
WARNING	2
SUGGESTION	0
CRITICAL	0

Issue Details (click to expand)

WARNING

File	Line	Issue
open-sse/executors/duckduckgo-web.ts	81	Unconditionally prepending a system message can collide with an existing user-provided system message. If messages[0].role === "system", tool instructions will precede or replace the user's intended system prompt. Consider merging into the existing system message instead of blindly prepending.
open-sse/executors/duckduckgo-web.ts	243	When stream !== false and tools are present, the streaming path is bypassed and a non-streaming JSON response is returned. This silently downgrades the client's streaming request, breaking the SSE contract. Tool calls should be streamed as SSE delta events, or the executor should reject stream=true with an explicit error rather than changing the response format.

Other Observations (not in diff)

File	Line	Issue
open-sse/executors/duckduckgo-web.ts	332	Existing review comment on tool-call parsing logic.
open-sse/executors/duckduckgo-web.ts	3	Existing review comment on import statement.

Files Reviewed (1 file)

• open-sse/executors/duckduckgo-web.ts - 2 issues

Fix these issues in Kilo Cloud

---

_{Reviewed by step-3.7-flash-20260528 · 290,000 tokens}

[oyi77]

Superseded by #3259 (consolidated PR with shared helpers)