app/agent/openaiCompatBackend.ts

// A generic backend for any provider speaking OpenAI's chat-completions
// wire format (verified directly against both Groq and Cloudflare
// Workers AI, which both implement it) -- one implementation instead of
// a bespoke one per provider, since (unlike Gemini) they genuinely
// share a shape: messages[] with system/user/assistant/tool roles,
// assistant tool_calls as {id, function:{name, arguments: JSON STRING}},
// and a "tool" message matched back by tool_call_id rather than by
// name.
import type { ChatBackend, ChatMessage } from "./chatBackend.js";
import type { ToolDef } from "./tools.js";

interface OpenAiToolCall {
  id: string;
  type: "function";
  function: { name: string; arguments: string };
}

function toOpenAiTools(tools: ToolDef[]) {
  return tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
}

// OpenAI's shape needs a real tool_call_id round-tripped on the
// following "tool" message -- this project's internal ChatMessage only
// carries a tool-call's `name` (Ollama doesn't need more, matching by
// array order). Track the most recent assistant turn's calls and match
// by name to recover the id, the same limitation the Gemini backend
// already accepts for functionResponse matching.
function toOpenAiMessages(messages: ChatMessage[]): Record<string, unknown>[] {
  const out: Record<string, unknown>[] = [];
  let lastAssistantCalls: OpenAiToolCall[] = [];
  for (const m of messages) {
    if (m.role === "tool") {
      const matched = lastAssistantCalls.find((c) => c.function.name === m.name);
      out.push({ role: "tool", tool_call_id: matched?.id ?? m.name ?? "unknown", content: m.content });
      continue;
    }
    if (m.role === "assistant" && m.tool_calls?.length) {
      const calls: OpenAiToolCall[] = m.tool_calls.map((c, i) => (c.raw as OpenAiToolCall | undefined) ?? { id: `call_${i}`, type: "function", function: { name: c.function.name, arguments: JSON.stringify(c.function.arguments) } });
      lastAssistantCalls = calls;
      // OpenAI itself accepts `content: null` here; Cloudflare Workers
      // AI's schema does not (confirmed directly: a real 400 "Type
      // mismatch... 'string' not in 'null'") -- an empty string is
      // accepted by both, so use that instead of leaning on an
      // OpenAI-specific allowance.
      out.push({ role: "assistant", content: m.content ?? "", tool_calls: calls });
      continue;
    }
    out.push({ role: m.role, content: m.content });
  }
  return out;
}

function fromOpenAiResponse(data: { choices?: { message?: { content?: string | null; tool_calls?: OpenAiToolCall[] } }[] }): ChatMessage {
  const msg = data.choices?.[0]?.message;
  const toolCalls: NonNullable<ChatMessage["tool_calls"]> = [];
  for (const c of msg?.tool_calls ?? []) {
    let args: Record<string, unknown>;
    try {
      args = JSON.parse(c.function.arguments);
    } catch {
      args = {};
    }
    toolCalls.push({ function: { name: c.function.name, arguments: args }, raw: c });
  }
  return { role: "assistant", content: msg?.content ?? "", tool_calls: toolCalls.length ? toolCalls : undefined };
}

interface StreamedToolCallDelta {
  index: number;
  id?: string;
  function?: { name?: string; arguments?: string };
}

export function createOpenAiCompatBackend(opts: { name: string; url: string; model: string; apiKey: () => string }): ChatBackend {
  return {
    name: opts.name,
    async chat(messages, tools, onPartial) {
      const res = await fetch(opts.url, {
        method: "POST",
        headers: { "content-type": "application/json", authorization: `Bearer ${opts.apiKey()}` },
        // Several OpenAI-compatible providers (confirmed: Groq) reject an
        // empty `tools` array outright rather than treating it the same
        // as omitting the field -- needed for a plain-text, no-tools
        // generation call (agent/scriptedWork.ts), which intentionally
        // passes [].
        body: JSON.stringify({ model: opts.model, messages: toOpenAiMessages(messages), ...(tools.length ? { tools: toOpenAiTools(tools) } : {}), stream: true }),
      });
      if (!res.ok) throw new Error(`${opts.name} chat failed: ${res.status} ${await res.text()}`);
      if (!res.body) throw new Error(`${opts.name} chat response had no body to stream`);

      // SSE: "data: {...}\n\n" lines, a final "data: [DONE]" sentinel.
      // Prose content arrives incrementally (delta.content, appended
      // straight onto the running total); a tool call arrives as
      // fragments keyed by `index` (one chunk's id/name, several more
      // chunks each appending a few more characters of `arguments`'
      // JSON string) that have to be reassembled before
      // fromOpenAiResponse can parse them -- same two-tier shape
      // ollamaBackend.ts's own streaming loop documents (content
      // token-by-token, tool_calls complete once decided), just SSE
      // instead of NDJSON on the wire.
      let content = "";
      const toolCallsByIndex = new Map<number, { id: string; type: "function"; function: { name: string; arguments: string } }>();
      let buffer = "";
      for await (const rawChunk of res.body as unknown as AsyncIterable<Uint8Array>) {
        buffer += Buffer.from(rawChunk).toString("utf8");
        let newlineAt: number;
        while ((newlineAt = buffer.indexOf("\n")) >= 0) {
          const line = buffer.slice(0, newlineAt).trim();
          buffer = buffer.slice(newlineAt + 1);
          if (!line.startsWith("data:")) continue;
          const data = line.slice(5).trim();
          if (!data || data === "[DONE]") continue;
          let chunk: { choices?: { delta?: { content?: string; tool_calls?: StreamedToolCallDelta[] } }[] };
          try {
            chunk = JSON.parse(data);
          } catch {
            continue; // a stray/partial SSE line -- skip rather than crash the whole stream over it
          }
          const delta = chunk.choices?.[0]?.delta;
          if (delta?.content) {
            content += delta.content;
            onPartial?.(content);
          }
          for (const tc of delta?.tool_calls ?? []) {
            const existing = toolCallsByIndex.get(tc.index) ?? { id: "", type: "function" as const, function: { name: "", arguments: "" } };
            if (tc.id) existing.id = tc.id;
            if (tc.function?.name) existing.function.name += tc.function.name;
            if (tc.function?.arguments) existing.function.arguments += tc.function.arguments;
            toolCallsByIndex.set(tc.index, existing);
          }
        }
      }
      const toolCalls = [...toolCallsByIndex.entries()].sort(([a], [b]) => a - b).map(([, v]) => v);
      return fromOpenAiResponse({ choices: [{ message: { content, tool_calls: toolCalls.length ? toolCalls : undefined } }] });
    },
  };
}