@botconnector/bccli 0.4.0-beta.9 → 0.4.1

package/dist/chunk-75BECX4F.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  hasKey,
+  providerName
+} from "./chunk-JHPGOAXU.js";
+import {
+  createProvider
+} from "./chunk-WNACAUDK.js";
+import {
+  PRESETS,
+  readCredentials
+} from "./chunk-FLQPE4S5.js";
+import {
+  t
+} from "./chunk-UZWJQF67.js";
+
+// src/models.ts
+function order(ids) {
+  const presetIds = PRESETS.map((p) => p.id);
+  const presets = presetIds.filter((id) => ids.includes(id));
+  const custom = ids.filter((id) => !presetIds.includes(id)).sort();
+  return [...presets, ...custom];
+}
+async function listAllModels(config, env = process.env, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const baseFetch = opts.fetch ?? fetch;
+  const untrusted = new Set(config.projectProviders ?? []);
+  const ids = order(Object.keys(config.providers)).filter((id) => opts.only ? id === opts.only : !untrusted.has(id) && hasKey(config, id, env));
+  const results = await Promise.all(
+    ids.map(async (id) => {
+      const provider = config.providers[id];
+      const apiKey = (opts.keyOverride && id === opts.only ? opts.keyOverride : void 0) || readCredentials(env)[id] || (provider.apiKeyEnv ? env[provider.apiKeyEnv] : void 0) || void 0;
+      const local = !provider.apiKeyEnv;
+      const timedFetch = ((input, init) => baseFetch(input, { ...init, signal: AbortSignal.timeout(timeoutMs) }));
+      const list = createProvider({ baseURL: provider.baseURL.replace(/\/+$/, ""), apiKey, model: "", fetch: timedFetch }).listModels();
+      let timer;
+      const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timeout")), timeoutMs);
+      });
+      try {
+        const models = await Promise.race([list, timeout]);
+        return { providerId: id, providerName: providerName(config, id), models };
+      } catch {
+        if (local && !opts.only) return void 0;
+        return { providerId: id, providerName: providerName(config, id), models: [], error: t("could not be reached") };
+      } finally {
+        clearTimeout(timer);
+      }
+    })
+  );
+  return results.filter((g) => !!g);
+}
+
+export {
+  listAllModels
+};

package/dist/{chunk-SJH3YLW4.js → chunk-BC7UXFE4.js}

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  contentText
+} from "./chunk-WNACAUDK.js";
 
 // src/session.ts
 import { randomBytes } from "crypto";
@@ -36,7 +39,7 @@ var Session = class _Session {
     return readdirSync(dir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       const session = new _Session(join(dir, f));
       const first = session.load().find((m) => m.role === "user");
-      return { session, mtime: statSync(session.file).mtime, preview: first ? String(first.content).slice(0, 80) : "" };
+      return { session, mtime: statSync(session.file).mtime, preview: first ? contentText(first.content).slice(0, 80) : "" };
     }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || b.session.file.localeCompare(a.session.file));
   }
   static latest(home, cwd) {
@@ -49,26 +52,86 @@ var Session = class _Session {
   append(message) {
     this.write({ t: "msg", m: message });
   }
+  appendUsage(usage) {
+    this.write({ t: "usage", ...usage });
+  }
   reset() {
     this.write({ t: "reset" });
   }
-  load() {
+  records() {
     if (!existsSync(this.file)) return [];
-    let messages = [];
+    const out = [];
     for (const line of readFileSync(this.file, "utf8").split("\n")) {
       if (!line.trim()) continue;
-      let record;
       try {
-        record = JSON.parse(line);
+        out.push(JSON.parse(line));
       } catch {
-        continue;
       }
+    }
+    return out;
+  }
+  /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+  load() {
+    let messages = [];
+    for (const record of this.records()) {
       if (record.t === "reset") messages = [];
       else if (record.t === "msg") messages.push(record.m);
     }
     return repairTail(messages);
   }
+  /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+  lastModel() {
+    const records = this.records();
+    for (let i = records.length - 1; i >= 0; i--) {
+      const record = records[i];
+      if (record.t === "usage" && record.model) return record.model;
+    }
+    return void 0;
+  }
+  /**
+   * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+   * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+   * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+   */
+  loadHistory() {
+    const segments = [[]];
+    for (const record of this.records()) {
+      if (record.t === "reset") segments.push([]);
+      else if (record.t === "msg") segments[segments.length - 1].push(record.m);
+    }
+    let shown = segments[0];
+    for (const segment of segments.slice(1)) {
+      if (!isCompactionSummary(segment[0])) {
+        shown = segment;
+        continue;
+      }
+      const kept = segment.slice(2);
+      let at = 0;
+      while (at <= shown.length && !endsWithPrefixOf(shown, at, kept)) at++;
+      shown = [...shown, ...kept.slice(shown.length - at)];
+    }
+    return repairTail(shown.filter((m) => !isCompactionSummary(m) && !isCompactionAck(m)));
+  }
 };
+var SUMMARY_PREFIX = "Summary of the previous conversation:";
+var SUMMARY_ACK = "OK, I will continue from this summary.";
+function isCompactionSummary(m) {
+  return m?.role === "user" && typeof m.content === "string" && m.content.startsWith(SUMMARY_PREFIX);
+}
+function isCompactionAck(m) {
+  return m.role === "assistant" && m.content === SUMMARY_ACK;
+}
+function sameMessage(a, b) {
+  if (a.role !== b.role) return false;
+  if (a.role === "tool" && b.role === "tool") return a.tool_call_id === b.tool_call_id;
+  return JSON.stringify(a.content) === JSON.stringify(b.content) && JSON.stringify("tool_calls" in a && a.tool_calls) === JSON.stringify("tool_calls" in b && b.tool_calls);
+}
+function endsWithPrefixOf(shown, at, kept) {
+  const n = shown.length - at;
+  if (n > kept.length) return false;
+  for (let j = 0; j < n; j++) if (!sameMessage(shown[at + j], kept[j])) return false;
+  return true;
+}
 function pruneSessions(home, now = Date.now(), maxAgeDays = 30) {
   const root = join(home, "sessions");
   if (!existsSync(root)) return 0;