@diologue/local-agent 0.1.0 → 0.1.1

package/dist/cli.mjs

@@ -1351,6 +1351,366 @@ var translateResponse = (response, id, modelEcho) => {
   };
 };
 
+// src/shim/responses-translator.ts
+var flattenContent = (content) => {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "input_text" || part.type === "output_text") {
+      return part.text ?? "";
+    }
+    return "";
+  }).join("");
+};
+var responsesToChatCompletions = (req) => {
+  const messages = [];
+  for (const item of req.input) {
+    if ("type" in item && item.type === "function_call") {
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: [
+          {
+            id: item.call_id,
+            type: "function",
+            function: { name: item.name, arguments: item.arguments }
+          }
+        ]
+      });
+      continue;
+    }
+    if ("type" in item && item.type === "function_call_output") {
+      messages.push({
+        role: "tool",
+        content: item.output,
+        tool_call_id: item.call_id
+      });
+      continue;
+    }
+    const role = item.role;
+    const content = flattenContent(item.content);
+    messages.push({ role, content });
+  }
+  const tools = req.tools?.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+  let toolChoice;
+  if (typeof req.tool_choice === "string") {
+    toolChoice = req.tool_choice;
+  } else if (req.tool_choice && typeof req.tool_choice === "object") {
+    toolChoice = {
+      type: "function",
+      function: { name: req.tool_choice.name }
+    };
+  }
+  return {
+    model: req.model,
+    messages,
+    tools,
+    tool_choice: toolChoice,
+    temperature: req.temperature,
+    stream: req.stream,
+    // Pass max_output_tokens through as max_tokens for downstream
+    // providers that honour it. Chat Completions naming.
+    max_tokens: req.max_output_tokens
+  };
+};
+var randomId = (prefix) => `${prefix}_${Math.random().toString(36).slice(2, 12)}`;
+var ResponsesStreamState = class {
+  responseId;
+  model;
+  createdAt;
+  outputIndex = 0;
+  /** Open message item carrying assistant text, if any. */
+  text = null;
+  /** Open function_call items, keyed by the broker's tool_call index
+   *  (the model's call position, not our output_index). */
+  tools = /* @__PURE__ */ new Map();
+  finished = false;
+  /** Set when broker emits `complete`. We carry usage + finish_reason
+   *  into the final response.completed payload. */
+  finalUsage;
+  finalStatus = "completed";
+  constructor(model, id) {
+    this.responseId = id ?? randomId("resp");
+    this.model = model;
+    this.createdAt = Math.floor(Date.now() / 1e3);
+  }
+  /** Emit the response.created + response.in_progress pair. Call once
+   *  before any chunks. */
+  start() {
+    const responseObj = {
+      id: this.responseId,
+      object: "response",
+      created_at: this.createdAt,
+      status: "in_progress",
+      model: this.model,
+      output: [],
+      usage: null
+    };
+    return [
+      { event: "response.created", data: { type: "response.created", response: responseObj } },
+      { event: "response.in_progress", data: { type: "response.in_progress", response: responseObj } }
+    ];
+  }
+  /** Translate a single broker chunk. Some chunks emit multiple events
+   *  (opening a new item requires output_item.added + content_part.added
+   *  before the delta itself). */
+  chunk(c) {
+    if (this.finished) return [];
+    switch (c.type) {
+      case "text_delta":
+        return this.handleTextDelta(c.text);
+      case "tool_call_delta":
+        return this.handleToolCallDelta(c);
+      case "complete":
+        {
+          const tu = c.payload?.tokenUsage;
+          if (tu) {
+            const input = tu.input ?? 0;
+            const output = tu.output ?? 0;
+            this.finalUsage = {
+              input_tokens: input,
+              output_tokens: output,
+              total_tokens: input + output
+            };
+          }
+        }
+        return [];
+      case "error":
+        this.finalStatus = "failed";
+        return [];
+    }
+  }
+  /** Close any open items + emit the terminal response.completed event. */
+  finish() {
+    if (this.finished) return [];
+    this.finished = true;
+    const out = [];
+    out.push(...this.closeTextItem());
+    out.push(...this.closeAllToolItems());
+    const responseObj = {
+      id: this.responseId,
+      object: "response",
+      created_at: this.createdAt,
+      status: this.finalStatus,
+      model: this.model,
+      output: [],
+      // For brevity — the AI SDK only needs status + usage at completion.
+      usage: this.finalUsage ?? null
+    };
+    out.push({
+      event: "response.completed",
+      data: { type: "response.completed", response: responseObj }
+    });
+    return out;
+  }
+  // ---- internals ----
+  handleTextDelta(text) {
+    if (!this.text) {
+      const itemId = randomId("msg");
+      const outputIndex = this.outputIndex++;
+      const contentIndex = 0;
+      this.text = { itemId, outputIndex, contentIndex, buffer: text };
+      return [
+        {
+          event: "response.output_item.added",
+          data: {
+            type: "response.output_item.added",
+            output_index: outputIndex,
+            item: {
+              id: itemId,
+              type: "message",
+              status: "in_progress",
+              role: "assistant",
+              content: []
+            }
+          }
+        },
+        {
+          event: "response.content_part.added",
+          data: {
+            type: "response.content_part.added",
+            item_id: itemId,
+            output_index: outputIndex,
+            content_index: contentIndex,
+            part: { type: "output_text", text: "" }
+          }
+        },
+        {
+          event: "response.output_text.delta",
+          data: {
+            type: "response.output_text.delta",
+            item_id: itemId,
+            output_index: outputIndex,
+            content_index: contentIndex,
+            delta: text
+          }
+        }
+      ];
+    }
+    this.text.buffer += text;
+    return [
+      {
+        event: "response.output_text.delta",
+        data: {
+          type: "response.output_text.delta",
+          item_id: this.text.itemId,
+          output_index: this.text.outputIndex,
+          content_index: this.text.contentIndex,
+          delta: text
+        }
+      }
+    ];
+  }
+  handleToolCallDelta(c) {
+    const events = [];
+    events.push(...this.closeTextItem());
+    let entry = this.tools.get(c.index);
+    if (!entry) {
+      entry = {
+        itemId: randomId("fc"),
+        outputIndex: this.outputIndex++,
+        callId: c.id ?? randomId("call"),
+        name: c.name ?? "",
+        arguments: "",
+        emittedAdded: false
+      };
+      this.tools.set(c.index, entry);
+    } else {
+      if (c.id) entry.callId = c.id;
+      if (c.name) entry.name = c.name;
+    }
+    if (!entry.emittedAdded && entry.name) {
+      entry.emittedAdded = true;
+      events.push({
+        event: "response.output_item.added",
+        data: {
+          type: "response.output_item.added",
+          output_index: entry.outputIndex,
+          item: {
+            id: entry.itemId,
+            type: "function_call",
+            status: "in_progress",
+            name: entry.name,
+            call_id: entry.callId,
+            arguments: ""
+          }
+        }
+      });
+    }
+    if (c.argumentsDelta !== void 0 && c.argumentsDelta.length > 0) {
+      entry.arguments += c.argumentsDelta;
+      if (entry.emittedAdded) {
+        events.push({
+          event: "response.function_call_arguments.delta",
+          data: {
+            type: "response.function_call_arguments.delta",
+            item_id: entry.itemId,
+            output_index: entry.outputIndex,
+            delta: c.argumentsDelta
+          }
+        });
+      }
+    }
+    return events;
+  }
+  closeTextItem() {
+    if (!this.text) return [];
+    const { itemId, outputIndex, contentIndex, buffer } = this.text;
+    this.text = null;
+    return [
+      {
+        event: "response.output_text.done",
+        data: {
+          type: "response.output_text.done",
+          item_id: itemId,
+          output_index: outputIndex,
+          content_index: contentIndex,
+          text: buffer
+        }
+      },
+      {
+        event: "response.content_part.done",
+        data: {
+          type: "response.content_part.done",
+          item_id: itemId,
+          output_index: outputIndex,
+          content_index: contentIndex,
+          part: { type: "output_text", text: buffer }
+        }
+      },
+      {
+        event: "response.output_item.done",
+        data: {
+          type: "response.output_item.done",
+          output_index: outputIndex,
+          item: {
+            id: itemId,
+            type: "message",
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: buffer }]
+          }
+        }
+      }
+    ];
+  }
+  closeAllToolItems() {
+    const out = [];
+    for (const entry of this.tools.values()) {
+      if (!entry.emittedAdded) {
+        entry.emittedAdded = true;
+        out.push({
+          event: "response.output_item.added",
+          data: {
+            type: "response.output_item.added",
+            output_index: entry.outputIndex,
+            item: {
+              id: entry.itemId,
+              type: "function_call",
+              status: "in_progress",
+              name: entry.name || "unknown",
+              call_id: entry.callId,
+              arguments: ""
+            }
+          }
+        });
+      }
+      out.push({
+        event: "response.function_call_arguments.done",
+        data: {
+          type: "response.function_call_arguments.done",
+          item_id: entry.itemId,
+          output_index: entry.outputIndex,
+          arguments: entry.arguments
+        }
+      });
+      out.push({
+        event: "response.output_item.done",
+        data: {
+          type: "response.output_item.done",
+          output_index: entry.outputIndex,
+          item: {
+            id: entry.itemId,
+            type: "function_call",
+            status: "completed",
+            name: entry.name || "unknown",
+            call_id: entry.callId,
+            arguments: entry.arguments
+          }
+        }
+      });
+    }
+    this.tools.clear();
+    return out;
+  }
+};
+
 // src/shim/active-broker.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 var byToken = /* @__PURE__ */ new Map();
@@ -1545,6 +1905,129 @@ var createLlmShimRouter = () => {
       res.json(out);
     }
   );
+  router.post("/v1/responses", async (req, res) => {
+    const token = extractBearer(req);
+    if (!token) {
+      sendOpenAIError(res, 401, "Missing Authorization bearer", "auth_error");
+      return;
+    }
+    const broker = getActiveBrokerByToken(token);
+    if (!broker) {
+      sendOpenAIError(
+        res,
+        401,
+        "No active coding-agent stream is currently authorised on this helper.",
+        "auth_error"
+      );
+      return;
+    }
+    const body = req.body;
+    if (!body || typeof body !== "object" || !Array.isArray(body.input) || body.input.length === 0) {
+      sendOpenAIError(res, 400, "input[] is required and must be non-empty");
+      return;
+    }
+    const chatRequest = responsesToChatCompletions(body);
+    const brokerRequest = translateRequest(chatRequest);
+    const stream = body.stream === true;
+    if (stream) {
+      res.setHeader("Content-Type", "text/event-stream");
+      res.setHeader("Cache-Control", "no-cache, no-transform");
+      res.setHeader("Connection", "keep-alive");
+      res.flushHeaders?.();
+      const state = new ResponsesStreamState(body.model);
+      const writeEvent2 = (ev) => {
+        res.write(`event: ${ev.event}
+`);
+        res.write(`data: ${JSON.stringify(ev.data)}
+
+`);
+      };
+      for (const ev of state.start()) writeEvent2(ev);
+      const observer = (chunk) => {
+        for (const ev of state.chunk(chunk)) writeEvent2(ev);
+      };
+      try {
+        await broker.request(brokerRequest, observer);
+      } catch (err) {
+        writeEvent2({
+          event: "response.failed",
+          data: {
+            type: "response.failed",
+            response: {
+              id: `resp_${Math.random().toString(36).slice(2, 12)}`,
+              object: "response",
+              status: "failed",
+              model: body.model,
+              error: {
+                code: "broker_error",
+                message: err instanceof Error ? err.message : "Broker call failed"
+              }
+            }
+          }
+        });
+        res.write("data: [DONE]\n\n");
+        res.end();
+        return;
+      }
+      for (const ev of state.finish()) writeEvent2(ev);
+      res.write("data: [DONE]\n\n");
+      res.end();
+      return;
+    }
+    let brokerResponse;
+    try {
+      brokerResponse = await broker.request(brokerRequest);
+    } catch (err) {
+      sendOpenAIError(
+        res,
+        502,
+        err instanceof Error ? err.message : "Broker call failed",
+        "api_error"
+      );
+      return;
+    }
+    if (brokerResponse.error) {
+      sendOpenAIError(res, 502, brokerResponse.error, "api_error");
+      return;
+    }
+    const completionId = `resp_${Math.random().toString(36).slice(2, 12)}`;
+    const chatResponse = translateResponse(
+      brokerResponse,
+      completionId,
+      body.model
+    );
+    const text = chatResponse.choices[0]?.message?.content ?? "";
+    const toolCalls = chatResponse.choices[0]?.message?.tool_calls ?? [];
+    const output = [];
+    if (text) {
+      output.push({
+        id: `msg_${Math.random().toString(36).slice(2, 12)}`,
+        type: "message",
+        status: "completed",
+        role: "assistant",
+        content: [{ type: "output_text", text }]
+      });
+    }
+    for (const tc of toolCalls) {
+      output.push({
+        id: `fc_${Math.random().toString(36).slice(2, 12)}`,
+        type: "function_call",
+        status: "completed",
+        name: tc.function.name,
+        call_id: tc.id,
+        arguments: tc.function.arguments
+      });
+    }
+    res.json({
+      id: completionId,
+      object: "response",
+      created_at: Math.floor(Date.now() / 1e3),
+      status: "completed",
+      model: body.model,
+      output,
+      usage: chatResponse.usage
+    });
+  });
   return router;
 };