@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/chunk-WNACAUDK.js

@@ -0,0 +1,946 @@
+#!/usr/bin/env node
+import {
+  reasoningPayload
+} from "./chunk-BLOYFIAD.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/provider.ts
+import OpenAI from "openai";
+import { ResponsesWS } from "openai/resources/responses/ws";
+import { toResponseInputItems } from "openai/lib/responses/ResponseInputItems";
+
+// src/thinking.ts
+var OPEN = "<think>";
+var CLOSE = "</think>";
+function partialTag(text, tag) {
+  for (let n = Math.min(tag.length - 1, text.length); n > 0; n--) if (tag.startsWith(text.slice(-n))) return n;
+  return 0;
+}
+var ThinkSplitter = class {
+  inside = false;
+  held = "";
+  push(delta) {
+    let rest = this.held + delta;
+    this.held = "";
+    let text = "";
+    let thinking = "";
+    while (rest) {
+      const tag = this.inside ? CLOSE : OPEN;
+      const at = rest.indexOf(tag);
+      if (at >= 0) {
+        if (this.inside) thinking += rest.slice(0, at);
+        else text += rest.slice(0, at);
+        rest = rest.slice(at + tag.length);
+        this.inside = !this.inside;
+        continue;
+      }
+      const keep = partialTag(rest, tag);
+      const out = rest.slice(0, rest.length - keep);
+      if (this.inside) thinking += out;
+      else text += out;
+      this.held = rest.slice(rest.length - keep);
+      break;
+    }
+    return { text, thinking };
+  }
+  /** Whatever was held back as a possible tag start is plain text after all. */
+  flush() {
+    const held = this.held;
+    this.held = "";
+    return this.inside ? { text: "", thinking: held } : { text: held, thinking: "" };
+  }
+};
+function splitThinking(text) {
+  const s = new ThinkSplitter();
+  const a = s.push(text);
+  const b = s.flush();
+  return { text: a.text + b.text, thinking: a.thinking + b.thinking };
+}
+
+// src/provider.ts
+var LUNA_AUTO_COMPACT_THRESHOLD = 24e4;
+var ProviderError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function outputReasoningSummary(items) {
+  return (items ?? []).flatMap((item) => {
+    if (!item || typeof item !== "object" || !("type" in item) || item.type !== "reasoning") return [];
+    if (!("summary" in item) || !Array.isArray(item.summary)) return [];
+    return item.summary;
+  }).map((part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+}
+var retryable = (status) => status === 429 || status >= 500;
+function detectRepetition(text) {
+  const tail = text.slice(-600);
+  for (let len = 1; len <= 12; len++) {
+    const unit = tail.slice(-len);
+    if (unit.length < len || !unit.trim()) continue;
+    let i = tail.length;
+    let count = 0;
+    while (i >= len && tail.slice(i - len, i) === unit) {
+      count++;
+      i -= len;
+    }
+    if (count >= 20 && count * len >= 300) return text.length - count * len;
+  }
+  return -1;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function errorMessage(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return parsed?.error?.message ?? parsed?.message ?? body.slice(0, 300);
+  } catch {
+    return body.slice(0, 300);
+  }
+}
+var toUsage = (u) => u ? {
+  inputTokens: u.prompt_tokens ?? 0,
+  outputTokens: u.completion_tokens ?? 0,
+  ...u.prompt_tokens_details?.cached_tokens != null ? { cachedInputTokens: u.prompt_tokens_details.cached_tokens } : {},
+  ...u.prompt_tokens_details?.cache_write_tokens != null ? { cacheWriteTokens: u.prompt_tokens_details.cache_write_tokens } : {}
+} : void 0;
+async function readStream(res, onText, onThinking) {
+  let text = "";
+  let thinking = "";
+  const splitter = new ThinkSplitter();
+  const emit = (part) => {
+    if (part.thinking) {
+      thinking += part.thinking;
+      onThinking?.(part.thinking);
+    }
+    if (part.text) {
+      text += part.text;
+      onText?.(part.text);
+      if (loopAt < 0) loopAt = detectRepetition(text);
+    }
+  };
+  let usage;
+  let finishReason;
+  const calls = [];
+  const byIndex = /* @__PURE__ */ new Map();
+  let current;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let loopAt = -1;
+  const handle = (line) => {
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (event.error) throw new ProviderError(t("Error from the provider: {message}", { message: event.error.message ?? JSON.stringify(event.error) }));
+    if (event.usage) usage = toUsage(event.usage);
+    const choice = event.choices?.[0];
+    if (!choice) return;
+    if (choice.finish_reason) finishReason = choice.finish_reason;
+    const delta = choice.delta ?? {};
+    const reasoning = delta.reasoning_content || delta.reasoning;
+    if (reasoning) emit({ text: "", thinking: reasoning });
+    if (delta.content) emit(splitter.push(delta.content));
+    for (const tc of delta.tool_calls ?? []) {
+      let target = tc.index !== void 0 ? byIndex.get(tc.index) : current;
+      if (!target || tc.index === void 0 && tc.id && target.id && target.id !== tc.id) {
+        target = { id: "", name: "", arguments: "" };
+        calls.push(target);
+        if (tc.index !== void 0) byIndex.set(tc.index, target);
+      }
+      current = target;
+      if (tc.id) target.id = tc.id;
+      if (tc.function?.name && !target.name) target.name = tc.function.name;
+      if (tc.function?.arguments) target.arguments += tc.function.arguments;
+    }
+  };
+  for await (const chunk of res.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0 && loopAt < 0) {
+      handle(buffer.slice(0, newline).trim());
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+    }
+    if (loopAt >= 0) return { text: text.slice(0, loopAt), toolCalls: [], thinking: thinking || void 0, usage, finishReason: "repetition" };
+  }
+  handle(buffer.trim());
+  emit(splitter.flush());
+  const toolCalls = calls.map((call, index) => ({ ...call, id: call.id || `call_${index}` }));
+  return { text, toolCalls, thinking: thinking || void 0, usage, finishReason };
+}
+async function readJson(res) {
+  const body = await res.json();
+  const choice = body.choices?.[0];
+  const toolCalls = (choice?.message?.tool_calls ?? []).map((tc, i) => ({
+    id: tc.id || `call_${i}`,
+    name: tc.function?.name ?? "",
+    arguments: tc.function?.arguments ?? ""
+  }));
+  const split = splitThinking(choice?.message?.content ?? "");
+  const thinking = (choice?.message?.reasoning_content || choice?.message?.reasoning || "") + split.thinking;
+  return { text: split.text, toolCalls, thinking: thinking || void 0, usage: toUsage(body.usage), finishReason: choice?.finish_reason };
+}
+function contentText(content) {
+  if (typeof content === "string") return content;
+  const text = content.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
+  const hasImage = content.some((part) => part.type === "image_url");
+  if (!hasImage) return text;
+  return text ? `${text} [image]` : "[image]";
+}
+function imageUserMessage(images) {
+  const paths = images.map((image) => image.path);
+  const caption = paths.length === 1 ? `Image read from ${paths[0]}.` : `Images read from ${paths.join(", ")}.`;
+  return {
+    role: "user",
+    content: [
+      { type: "text", text: caption },
+      ...images.map((image) => ({ type: "image_url", image_url: { url: `data:${image.mediaType};base64,${image.data}` } }))
+    ]
+  };
+}
+function responseInputFromMessages(messages) {
+  const input = [];
+  for (const message of messages) {
+    if (message.role === "system" || message.role === "user") {
+      if (Array.isArray(message.content)) {
+        input.push({
+          role: message.role,
+          content: message.content.map(
+            (part) => part.type === "image_url" ? { type: "input_image", image_url: part.image_url.url } : { type: "input_text", text: part.text }
+          )
+        });
+      } else {
+        input.push({ role: message.role, content: message.content });
+      }
+      continue;
+    }
+    if (message.role === "assistant") {
+      if (message.responses_output_items?.length) {
+        input.push(...toResponseInputItems(message.responses_output_items));
+        continue;
+      }
+      if (message.content) input.push({ role: "assistant", content: message.content });
+      for (const call of message.tool_calls ?? []) {
+        input.push({
+          type: "function_call",
+          call_id: call.id,
+          name: call.function.name,
+          arguments: call.function.arguments || "{}",
+          ...call.caller ? { caller: call.caller } : {}
+        });
+      }
+      continue;
+    }
+    input.push({
+      type: "function_call_output",
+      call_id: message.tool_call_id,
+      output: message.content,
+      ...message.responses_caller ? { caller: message.responses_caller } : {}
+    });
+  }
+  return input;
+}
+var LUNA_TOOL_SEARCH_MIN_MCP_TOOLS = 20;
+var LUNA_TOOL_SEARCH_MIN_MCP_SCHEMA_CHARS = 32e3;
+var LUNA_PTC_SAFE_FUNCTIONS = /* @__PURE__ */ new Set(["read", "grep", "glob"]);
+var LUNA_PTC_TOOL_OUTPUT_TRIGGER_CHARS = 8e3;
+var LUNA_PTC_MULTI_WORK_CUE = /\b(both|all|multiple|several|compare|comparison|aggregate|aggregation|total|count|sum|average|filter|join|merge|dedupe|deduplicate|rank|scan|across|every|semua|keduanya|beberapa|bandingkan|perbandingan|agregasi|hitung|jumlah|rata[- ]?rata|gabung|deduplikasi|urutkan|pindai|seluruh)\b|\b(many|banyak)\s+(files?|file|records?|rows?|items?|dokumen|berkas)\b/i;
+var LUNA_PTC_FORCE_CUE = /\b(count|sum|total|average|aggregate|aggregation|filter|join|merge|dedupe|deduplicate|hitung|jumlah|rata[- ]?rata|agregasi|gabung|deduplikasi)\b/i;
+function shouldForceLunaPtc(messages, enabled) {
+  if (!enabled) return false;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "assistant" && message.responses_output_items?.some((item) => item.type === "program")) return true;
+    if (message.role === "user") return LUNA_PTC_FORCE_CUE.test(contentText(message.content));
+  }
+  return false;
+}
+function shouldEnableLunaPtc(messages, enabled, programmaticToolNames = []) {
+  if (!enabled) return false;
+  let lastUser = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  const turn = messages.slice(Math.max(0, lastUser));
+  const latestUser = lastUser >= 0 ? messages[lastUser] : void 0;
+  const prompt = latestUser?.role === "user" ? contentText(latestUser.content) : "";
+  if (LUNA_PTC_MULTI_WORK_CUE.test(prompt)) return true;
+  const safeToolNames = /* @__PURE__ */ new Set([...LUNA_PTC_SAFE_FUNCTIONS, ...programmaticToolNames]);
+  const safeCalls = /* @__PURE__ */ new Set();
+  let safeOutputChars = 0;
+  for (const message of turn) {
+    if (message.role === "assistant") {
+      if (message.responses_output_items?.some((item) => item.type === "program")) return true;
+      for (const call of message.tool_calls ?? []) {
+        if (safeToolNames.has(call.function.name)) safeCalls.add(call.id);
+      }
+      continue;
+    }
+    if (message.role === "tool" && safeCalls.has(message.tool_call_id)) {
+      safeOutputChars += message.content.length;
+      if (safeOutputChars >= LUNA_PTC_TOOL_OUTPUT_TRIGGER_CHARS) return true;
+    }
+  }
+  return false;
+}
+function lunaToolPlan(tools, enableProgrammaticToolCalling = false, programmaticToolNames = [], forceProgrammaticOnly = false) {
+  const native = (tools ?? []).map((tool) => ({
+    type: "function",
+    name: tool.function.name,
+    description: tool.function.description,
+    parameters: tool.function.parameters,
+    ...tool.function.output_schema ? { output_schema: tool.function.output_schema } : {},
+    strict: false
+  }));
+  const mcpIndexes = native.map((tool, index) => String(tool.name).startsWith("mcp__") ? index : -1).filter((index) => index >= 0);
+  const deferredSchemaChars = mcpIndexes.reduce((sum, index) => sum + JSON.stringify(native[index]).length, 0);
+  const useToolSearch = mcpIndexes.length >= LUNA_TOOL_SEARCH_MIN_MCP_TOOLS || deferredSchemaChars >= LUNA_TOOL_SEARCH_MIN_MCP_SCHEMA_CHARS;
+  let programmaticToolCount = 0;
+  const safeToolNames = /* @__PURE__ */ new Set([...LUNA_PTC_SAFE_FUNCTIONS, ...programmaticToolNames]);
+  if (enableProgrammaticToolCalling) {
+    for (let index = 0; index < native.length; index++) {
+      if (safeToolNames.has(String(native[index].name))) {
+        native[index] = { ...native[index], allowed_callers: forceProgrammaticOnly ? ["programmatic"] : ["direct", "programmatic"] };
+        programmaticToolCount++;
+      }
+    }
+    if (programmaticToolCount > 0) native.push({ type: "programmatic_tool_calling" });
+  }
+  const useProgrammaticToolCalling = programmaticToolCount > 0;
+  if (!useToolSearch) {
+    return {
+      tools: native,
+      useToolSearch: false,
+      useProgrammaticToolCalling,
+      deferredToolCount: 0,
+      deferredSchemaChars
+    };
+  }
+  for (const index of mcpIndexes) native[index] = { ...native[index], defer_loading: true };
+  native.push({
+    type: "tool_search",
+    execution: "server"
+  });
+  return {
+    tools: native,
+    useToolSearch: true,
+    useProgrammaticToolCalling,
+    deferredToolCount: mcpIndexes.length,
+    deferredSchemaChars
+  };
+}
+function responseTools(tools, enableProgrammaticToolCalling = false, programmaticToolNames = [], forceProgrammaticOnly = false) {
+  return lunaToolPlan(tools, enableProgrammaticToolCalling, programmaticToolNames, forceProgrammaticOnly).tools;
+}
+function responseReasoning(level) {
+  if (level === "off") return { reasoning: { effort: "none" } };
+  return { reasoning: { ...level === "auto" ? {} : { effort: level }, summary: "auto" } };
+}
+function toResponsesUsage(usage) {
+  return usage ? { inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0 } : void 0;
+}
+function programCaller(item) {
+  const caller = item?.caller;
+  return caller?.type === "program" && typeof caller.caller_id === "string" ? { type: "program", caller_id: caller.caller_id } : void 0;
+}
+function responsesFinishReason(items, toolCallCount, incompleteReason) {
+  if (incompleteReason) return incompleteReason;
+  if (toolCallCount) return "tool_calls";
+  const hasMessage = items?.some((item) => item.type === "message") ?? false;
+  const hasProgramState = items?.some((item) => item.type === "program" || item.type === "program_output") ?? false;
+  return !hasMessage && hasProgramState ? "continue" : "stop";
+}
+function hasPendingProgrammaticReplay(messages) {
+  let pending = false;
+  for (const message of messages) {
+    if (message.role !== "assistant") continue;
+    for (const item of message.responses_output_items ?? []) {
+      if (item.type === "program") pending = true;
+      else if (item.type === "message" && pending) pending = false;
+    }
+  }
+  return pending;
+}
+async function readResponsesStream(res, onText, onThinking) {
+  let text = "";
+  let thinking = "";
+  let usage;
+  let finishReason;
+  let loopAt = -1;
+  const calls = /* @__PURE__ */ new Map();
+  const outputItems = /* @__PURE__ */ new Map();
+  let responsesOutputItems;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const emitText = (delta) => {
+    if (!delta) return;
+    text += delta;
+    onText?.(delta);
+    if (loopAt < 0) loopAt = detectRepetition(text);
+  };
+  const handle = (line) => {
+    if (!line.startsWith("data:")) return;
+    const data = line.slice(5).trim();
+    if (!data || data === "[DONE]") return;
+    let event;
+    try {
+      event = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (event.type === "error") {
+      throw new ProviderError(t("Error from the provider: {message}", { message: event.message ?? event.error?.message ?? JSON.stringify(event) }));
+    }
+    if (event.type === "response.failed") {
+      throw new ProviderError(t("Error from the provider: {message}", { message: event.response?.error?.message ?? "Response failed" }));
+    }
+    if (event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_summary.delta") {
+      const summary = String(event.delta ?? "");
+      thinking += summary;
+      if (summary) onThinking?.(summary);
+      return;
+    }
+    if (event.type === "response.output_text.delta" || event.type === "response.refusal.delta") {
+      emitText(String(event.delta ?? ""));
+      return;
+    }
+    if (event.type === "response.output_item.added" && event.item?.type === "function_call") {
+      calls.set(Number(event.output_index ?? calls.size), {
+        id: String(event.item.call_id || event.item.id || `call_${calls.size}`),
+        name: String(event.item.name || ""),
+        arguments: String(event.item.arguments || ""),
+        ...programCaller(event.item) ? { caller: programCaller(event.item) } : {}
+      });
+      return;
+    }
+    if (event.type === "response.function_call_arguments.delta") {
+      const index = Number(event.output_index ?? 0);
+      const call = calls.get(index);
+      if (call) call.arguments += String(event.delta || "");
+      return;
+    }
+    if (event.type === "response.output_item.done" && event.item) {
+      const index = Number(event.output_index ?? outputItems.size);
+      outputItems.set(index, event.item);
+      if (event.item.type === "function_call") {
+        const current = calls.get(index);
+        calls.set(index, {
+          id: String(event.item.call_id || current?.id || event.item.id || `call_${index}`),
+          name: String(event.item.name || current?.name || ""),
+          arguments: String(event.item.arguments ?? current?.arguments ?? ""),
+          ...programCaller(event.item) ?? current?.caller ? { caller: programCaller(event.item) ?? current?.caller } : {}
+        });
+      }
+      return;
+    }
+    if (event.type === "response.completed") {
+      usage = toResponsesUsage(event.response?.usage);
+      responsesOutputItems = event.response?.output ?? [...outputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+      if (!thinking) {
+        const summary = outputReasoningSummary(responsesOutputItems);
+        if (summary) {
+          thinking = summary;
+          onThinking?.(summary);
+        }
+      }
+      finishReason = responsesFinishReason(responsesOutputItems, calls.size);
+      return;
+    }
+    if (event.type === "response.incomplete") {
+      usage = toResponsesUsage(event.response?.usage);
+      responsesOutputItems = event.response?.output ?? [...outputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+      if (!thinking) {
+        const summary = outputReasoningSummary(responsesOutputItems);
+        if (summary) {
+          thinking = summary;
+          onThinking?.(summary);
+        }
+      }
+      finishReason = responsesFinishReason(
+        responsesOutputItems,
+        calls.size,
+        String(event.response?.incomplete_details?.reason || "incomplete")
+      );
+    }
+  };
+  for await (const chunk of res.body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0 && loopAt < 0) {
+      handle(buffer.slice(0, newline).trim());
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+    }
+    if (loopAt >= 0) {
+      return { text: text.slice(0, loopAt), toolCalls: [], usage, finishReason: "repetition" };
+    }
+  }
+  handle(buffer.trim());
+  return {
+    text,
+    toolCalls: [...calls.entries()].sort(([a], [b]) => a - b).map(([, call]) => call),
+    thinking: thinking || void 0,
+    usage,
+    finishReason,
+    responsesOutputItems
+  };
+}
+async function readResponsesJson(res, onThinking) {
+  const body = await res.json();
+  let text = "";
+  let thinking = "";
+  const toolCalls = [];
+  for (const item of body.output ?? []) {
+    if (item?.type === "message") {
+      for (const part of item.content ?? []) {
+        if (part?.type === "output_text" && typeof part.text === "string") text += part.text;
+        else if (part?.type === "refusal" && typeof part.refusal === "string") text += part.refusal;
+      }
+    } else if (item?.type === "reasoning" && Array.isArray(item.summary)) {
+      const summary = item.summary.filter((part) => typeof part === "object" && part !== null && typeof part.text === "string").map((part) => part.text).join("");
+      if (summary) {
+        thinking += summary;
+        onThinking?.(summary);
+      }
+    } else if (item?.type === "function_call") {
+      toolCalls.push({
+        id: String(item.call_id || item.id || `call_${toolCalls.length}`),
+        name: String(item.name || ""),
+        arguments: String(item.arguments || "{}"),
+        ...programCaller(item) ? { caller: programCaller(item) } : {}
+      });
+    }
+  }
+  return {
+    text,
+    toolCalls,
+    thinking: thinking || void 0,
+    usage: toResponsesUsage(body.usage),
+    responsesOutputItems: body.output,
+    finishReason: responsesFinishReason(
+      body.output,
+      toolCalls.length,
+      body.status === "incomplete" ? String(body.incomplete_details?.reason || "incomplete") : void 0
+    )
+  };
+}
+function cloneMessages(messages) {
+  return structuredClone(messages);
+}
+function sameMessage(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function completionAssistantMessage(completion) {
+  return {
+    role: "assistant",
+    content: completion.text || null,
+    ...completion.toolCalls.length ? {
+      tool_calls: completion.toolCalls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: { name: call.name, arguments: call.arguments },
+        ...call.caller ? { caller: call.caller } : {}
+      }))
+    } : {},
+    ...completion.responsesOutputItems?.length ? { responses_output_items: completion.responsesOutputItems } : {}
+  };
+}
+function responseContinuationInput(messages, continuation) {
+  if (!continuation || messages.length <= continuation.requestMessages.length) {
+    return { input: responseInputFromMessages(messages), incremental: false };
+  }
+  for (let i = 0; i < continuation.requestMessages.length; i++) {
+    if (!sameMessage(messages[i], continuation.requestMessages[i])) {
+      return { input: responseInputFromMessages(messages), incremental: false };
+    }
+  }
+  const expectedAssistant = completionAssistantMessage(continuation.completion);
+  const assistant = messages[continuation.requestMessages.length];
+  if (!assistant || !sameMessage(assistant, expectedAssistant)) {
+    return { input: responseInputFromMessages(messages), incremental: false };
+  }
+  const delta = messages.slice(continuation.requestMessages.length + 1);
+  if (!delta.length) {
+    if (continuation.completion.finishReason === "continue") {
+      return { input: [], previousResponseId: continuation.responseId, incremental: true };
+    }
+    return { input: responseInputFromMessages(messages), incremental: false };
+  }
+  return {
+    input: responseInputFromMessages(delta),
+    previousResponseId: continuation.responseId,
+    incremental: true
+  };
+}
+async function readResponsesWebSocketTurn(events, ws, onText, onThinking, signal) {
+  let responseId = "";
+  let text = "";
+  let thinking = "";
+  let usage;
+  let finishReason;
+  let loopAt = -1;
+  const calls = /* @__PURE__ */ new Map();
+  const outputItems = /* @__PURE__ */ new Map();
+  const emitText = (delta) => {
+    if (!delta) return;
+    text += delta;
+    onText?.(delta);
+    if (loopAt < 0) loopAt = detectRepetition(text);
+  };
+  const abort = () => {
+    try {
+      ws.close({ code: 1e3, reason: "BCCLI request cancelled" });
+    } catch {
+    }
+  };
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    while (true) {
+      if (signal?.aborted) throw signal.reason ?? new Error("Request aborted");
+      const next = await events.next();
+      if (next.done) throw new ProviderError(t("Connection closed before the response finished."));
+      const envelope = next.value;
+      if (envelope.type === "error") {
+        throw new ProviderError(envelope.error.message || t("WebSocket connection failed."));
+      }
+      if (envelope.type === "close") {
+        throw new ProviderError(
+          t("WebSocket connection closed: {reason}", { reason: envelope.reason || String(envelope.code) })
+        );
+      }
+      if (envelope.type !== "message") continue;
+      const event = envelope.message;
+      if (event.type === "error") {
+        const code = "code" in (event.error ?? {}) ? String(event.error.code || "") : void 0;
+        throw new ProviderError(
+          t("Error from the provider: {message}", { message: event.error?.message ?? event.message ?? JSON.stringify(event) }),
+          event.status,
+          code
+        );
+      }
+      if (event.type === "response.created") {
+        responseId = String(event.response?.id || responseId);
+        continue;
+      }
+      if (event.type === "response.reasoning_summary_text.delta") {
+        const summary = String(event.delta ?? "");
+        thinking += summary;
+        if (summary) onThinking?.(summary);
+        continue;
+      }
+      if (event.type === "response.output_text.delta" || event.type === "response.refusal.delta") {
+        emitText(String(event.delta ?? ""));
+        if (loopAt >= 0) {
+          abort();
+          return {
+            responseId,
+            completion: { text: text.slice(0, loopAt), toolCalls: [], usage, finishReason: "repetition" }
+          };
+        }
+        continue;
+      }
+      if (event.type === "response.output_item.added" && event.item?.type === "function_call") {
+        const index = Number(event.output_index ?? calls.size);
+        calls.set(index, {
+          id: String(event.item.call_id || event.item.id || `call_${index}`),
+          name: String(event.item.name || ""),
+          arguments: String(event.item.arguments || ""),
+          ...programCaller(event.item) ? { caller: programCaller(event.item) } : {}
+        });
+        continue;
+      }
+      if (event.type === "response.function_call_arguments.delta") {
+        const index = Number(event.output_index ?? 0);
+        const call = calls.get(index);
+        if (call) call.arguments += String(event.delta || "");
+        continue;
+      }
+      if (event.type === "response.output_item.done" && event.item) {
+        const index = Number(event.output_index ?? outputItems.size);
+        outputItems.set(index, event.item);
+        if (event.item.type === "function_call") {
+          const current = calls.get(index);
+          calls.set(index, {
+            id: String(event.item.call_id || current?.id || event.item.id || `call_${index}`),
+            name: String(event.item.name || current?.name || ""),
+            arguments: String(event.item.arguments ?? current?.arguments ?? ""),
+            ...programCaller(event.item) ?? current?.caller ? { caller: programCaller(event.item) ?? current?.caller } : {}
+          });
+        }
+        continue;
+      }
+      if (event.type === "response.failed") {
+        throw new ProviderError(
+          t("Error from the provider: {message}", { message: event.response?.error?.message ?? "Response failed" })
+        );
+      }
+      if (event.type === "response.completed" || event.type === "response.incomplete") {
+        responseId = String(event.response?.id || responseId);
+        usage = toResponsesUsage(event.response?.usage);
+        const responsesOutputItems = event.response?.output ?? [...outputItems.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+        if (!thinking) {
+          const summary = outputReasoningSummary(responsesOutputItems);
+          if (summary) {
+            thinking = summary;
+            onThinking?.(summary);
+          }
+        }
+        finishReason = responsesFinishReason(
+          responsesOutputItems,
+          calls.size,
+          event.type === "response.incomplete" ? String(event.response?.incomplete_details?.reason || "incomplete") : void 0
+        );
+        return {
+          responseId,
+          completion: {
+            text,
+            toolCalls: [...calls.entries()].sort(([a], [b]) => a - b).map(([, call]) => call),
+            thinking: thinking || void 0,
+            usage,
+            finishReason,
+            responsesOutputItems
+          }
+        };
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", abort);
+  }
+}
+function createProvider(options) {
+  const {
+    baseURL,
+    apiKey,
+    model,
+    providerId,
+    fetch: fetchOverride,
+    retryDelayMs = 1e3,
+    responsesWebSocketFactory,
+    enableProgrammaticToolCalling = false
+  } = options;
+  const doFetch = fetchOverride ?? fetch;
+  const headers = { "content-type": "application/json" };
+  if (apiKey) headers.authorization = `Bearer ${apiKey}`;
+  const isBotConnectorCloud = /^https:\/\/api\.botconnector\.id\/v1\/?$/.test(baseURL) && apiKey?.startsWith("bc_live_");
+  if (isBotConnectorCloud) {
+    headers["x-botconnector-client"] = "bccli";
+    headers["x-botconnector-client-version"] = "0.4.1";
+  }
+  const useNativeResponses = isBotConnectorCloud && providerId === "bc-cloud" && model === "gpt-6-luna";
+  const useResponsesWebSocket = useNativeResponses && Boolean(apiKey) && (fetchOverride === void 0 || responsesWebSocketFactory !== void 0);
+  let lunaWs;
+  let lunaWsEvents;
+  let lunaContinuation;
+  let lunaWsIdleTimer;
+  const resetLunaWebSocket = () => {
+    if (lunaWsIdleTimer) clearTimeout(lunaWsIdleTimer);
+    lunaWsIdleTimer = void 0;
+    const current = lunaWs;
+    lunaWs = void 0;
+    lunaWsEvents = void 0;
+    lunaContinuation = void 0;
+    if (current) {
+      try {
+        current.close({ code: 1e3, reason: "BCCLI reset" });
+      } catch {
+      }
+    }
+  };
+  const ensureLunaWebSocket = () => {
+    if (lunaWsIdleTimer) clearTimeout(lunaWsIdleTimer);
+    lunaWsIdleTimer = void 0;
+    if (!lunaWs || !lunaWsEvents) {
+      const client = new OpenAI({
+        apiKey,
+        baseURL: baseURL.replace(/\/+$/, ""),
+        defaultHeaders: {
+          "x-botconnector-client": "bccli",
+          "x-botconnector-client-version": "0.4.1"
+        }
+      });
+      lunaWs = responsesWebSocketFactory ? responsesWebSocketFactory(client) : new ResponsesWS(client, { reconnect: null });
+      lunaWsEvents = lunaWs.stream({ maxBufferedEvents: 4096 });
+    }
+    return { ws: lunaWs, events: lunaWsEvents };
+  };
+  const scheduleLunaWebSocketIdleReset = () => {
+    if (lunaWsIdleTimer) clearTimeout(lunaWsIdleTimer);
+    lunaWsIdleTimer = setTimeout(() => resetLunaWebSocket(), 10 * 6e4);
+    lunaWsIdleTimer.unref?.();
+  };
+  async function chatLunaWebSocket(messages, tools, programmaticToolNames, reasoning, signal, onText, onThinking) {
+    const ptcEnabled = shouldEnableLunaPtc(messages, enableProgrammaticToolCalling, programmaticToolNames);
+    const forcePtc = shouldForceLunaPtc(messages, ptcEnabled);
+    const nativeTools = responseTools(tools, ptcEnabled, programmaticToolNames, forcePtc);
+    const initialPlan = responseContinuationInput(messages, lunaContinuation);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (signal?.aborted) throw signal.reason ?? new Error("Request aborted");
+      const plan = attempt === 0 ? initialPlan : { input: responseInputFromMessages(messages), incremental: false, previousResponseId: void 0 };
+      const { ws, events } = ensureLunaWebSocket();
+      const createEvent = {
+        type: "response.create",
+        stream_id: "main",
+        model,
+        store: false,
+        input: plan.input,
+        ...plan.previousResponseId ? { previous_response_id: plan.previousResponseId } : {},
+        ...nativeTools.length ? { tools: nativeTools } : {},
+        context_management: [{ type: "compaction", compact_threshold: LUNA_AUTO_COMPACT_THRESHOLD }],
+        ...responseReasoning(reasoning)
+      };
+      let emittedText = false;
+      const trackText = (delta) => {
+        if (delta) emittedText = true;
+        onText?.(delta);
+      };
+      const trackSummary = (delta) => {
+        if (delta) emittedText = true;
+        onThinking?.(delta);
+      };
+      try {
+        ws.send(createEvent);
+        const result = await readResponsesWebSocketTurn(events, ws, trackText, trackSummary, signal);
+        if (result.completion.finishReason === "repetition") {
+          resetLunaWebSocket();
+          return result.completion;
+        }
+        if (!result.responseId) {
+          resetLunaWebSocket();
+          return result.completion;
+        }
+        lunaContinuation = {
+          responseId: result.responseId,
+          requestMessages: cloneMessages(messages),
+          completion: structuredClone(result.completion)
+        };
+        scheduleLunaWebSocketIdleReset();
+        return result.completion;
+      } catch (error) {
+        const err = error instanceof ProviderError ? error : new ProviderError(error.message);
+        const lostPrevious = err.code === "previous_response_not_found";
+        const handshakeStatus = /unexpected server response:\s*(\d{3})\b/i.exec(err.message);
+        const handshakeRejected = Boolean(handshakeStatus && Number(handshakeStatus[1]) >= 400);
+        const connectionLost = /websocket|connection closed|socket|network/i.test(err.message) || err.code === "websocket_connection_limit_reached";
+        resetLunaWebSocket();
+        if (!emittedText && !signal?.aborted && handshakeRejected) {
+          throw new ProviderError(err.message, Number(handshakeStatus?.[1]), "bc_ws_http_fallback");
+        }
+        if (attempt === 0 && !emittedText && !signal?.aborted && (plan.incremental || lostPrevious || connectionLost)) {
+          continue;
+        }
+        if (!emittedText && !signal?.aborted && connectionLost) {
+          throw new ProviderError(err.message, err.status, "bc_ws_http_fallback");
+        }
+        throw err;
+      }
+    }
+    throw new ProviderError(t("Request failed"));
+  }
+  async function post(path, body, signal) {
+    let lastError;
+    for (let attempt = 0; attempt < 4; attempt++) {
+      if (attempt > 0) await sleep(retryDelayMs * 2 ** (attempt - 1), signal);
+      let res;
+      try {
+        res = await doFetch(`${baseURL}${path}`, { method: "POST", headers, body: JSON.stringify(body), signal });
+      } catch (error) {
+        if (signal?.aborted) throw error;
+        lastError = new ProviderError(t("Cannot connect to {url}: {error}", { url: baseURL, error: error.message }));
+        continue;
+      }
+      if (res.ok) return res;
+      const text = await res.text().catch(() => "");
+      lastError = new ProviderError(t("{status} from {url}: {message}", { status: res.status, url: baseURL, message: errorMessage(text) }), res.status);
+      const deterministicQuota429 = res.status === 429 && /"code"\s*:\s*"(?:luna_monthly_quota_exhausted|plan_allowance_exhausted)"/i.test(text);
+      if (!retryable(res.status) || deterministicQuota429) throw lastError;
+    }
+    throw lastError ?? new ProviderError(t("Request failed"));
+  }
+  return {
+    async chat({ messages, tools, programmaticToolNames = [], signal, onText, onThinking, reasoning = "auto" }) {
+      let reasoningOverride;
+      try {
+        reasoningOverride = reasoningPayload(providerId, reasoning);
+      } catch (error) {
+        throw new ProviderError(error.message);
+      }
+      if (useResponsesWebSocket) {
+        try {
+          return await chatLunaWebSocket(messages, tools, programmaticToolNames, reasoning, signal, onText, onThinking);
+        } catch (error) {
+          const err = error instanceof ProviderError ? error : new ProviderError(error.message);
+          if (err.code !== "bc_ws_http_fallback") throw err;
+        }
+      }
+      if (useNativeResponses) {
+        const ptcEnabled = shouldEnableLunaPtc(messages, enableProgrammaticToolCalling, programmaticToolNames);
+        const forcePtc = shouldForceLunaPtc(messages, ptcEnabled);
+        const nativeTools = responseTools(tools, ptcEnabled, programmaticToolNames, forcePtc);
+        const res2 = await post(
+          "/responses",
+          {
+            model,
+            input: responseInputFromMessages(messages),
+            stream: true,
+            store: false,
+            ...nativeTools.length ? { tools: nativeTools } : {},
+            context_management: [{ type: "compaction", compact_threshold: LUNA_AUTO_COMPACT_THRESHOLD }],
+            ...responseReasoning(reasoning)
+          },
+          signal
+        );
+        if ((res2.headers.get("content-type") ?? "").includes("application/json")) return readResponsesJson(res2, onThinking);
+        if (!res2.body) throw new ProviderError(t("Empty response from the provider"));
+        return readResponsesStream(res2, onText, onThinking);
+      }
+      const res = await post(
+        "/chat/completions",
+        { model, messages, stream: true, stream_options: { include_usage: true }, ...tools?.length ? { tools } : {}, ...reasoningOverride },
+        signal
+      );
+      if ((res.headers.get("content-type") ?? "").includes("application/json")) return readJson(res);
+      if (!res.body) throw new ProviderError(t("Empty response from the provider"));
+      return readStream(res, onText, onThinking);
+    },
+    async listModels() {
+      const res = await doFetch(`${baseURL}/models`, { headers });
+      if (!res.ok) throw new ProviderError(t("{status} while fetching the model list", { status: res.status }), res.status);
+      const body = await res.json();
+      const ids = (body.data ?? []).map((m) => m?.id).filter((id) => typeof id === "string" && id.length > 0);
+      return [...new Set(ids)].sort();
+    }
+  };
+}
+
+export {
+  contentText,
+  imageUserMessage,
+  hasPendingProgrammaticReplay,
+  completionAssistantMessage,
+  createProvider
+};