@shogo-ai/core 1.9.13 → 2.4.1

package/dist/chunk-H625AGFN.js

@@ -0,0 +1,466 @@
+// src/stream-compaction.ts
+var TURN_SEQ_EVENT_TYPE = "data-turn-seq";
+var DELTA_PART = {
+  "text-delta": "text",
+  "reasoning-delta": "reasoning"
+};
+var PART_BOUNDARY = {
+  "text-end": "text",
+  "reasoning-end": "reasoning",
+  "text-start": "text",
+  "reasoning-start": "reasoning"
+};
+function compactSseFrames(frames) {
+  if (frames.length === 0) return new Uint8Array(0);
+  const decoder = new TextDecoder();
+  let text = "";
+  for (const frame of frames) text += decoder.decode(frame, { stream: true });
+  text += decoder.decode();
+  const events = text.split("\n\n");
+  const tail = events.pop() ?? "";
+  const out = [];
+  const openParts = /* @__PURE__ */ new Map();
+  const openToolInputs = /* @__PURE__ */ new Map();
+  const preliminaryOutputs = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const chunk = parseEvent(event);
+    if (!chunk) {
+      out.push({ raw: event });
+      continue;
+    }
+    const type = chunk.type;
+    if (type === TURN_SEQ_EVENT_TYPE) continue;
+    if (type in PART_BOUNDARY) {
+      openParts.delete(`${PART_BOUNDARY[type]}:${chunk.id}`);
+      out.push({ chunk });
+      continue;
+    }
+    if (type in DELTA_PART && typeof chunk.delta === "string") {
+      const key = `${DELTA_PART[type]}:${chunk.id}`;
+      const merged = openParts.get(key);
+      if (merged) {
+        merged.delta += chunk.delta;
+        if (chunk.providerMetadata !== void 0) merged.providerMetadata = chunk.providerMetadata;
+        continue;
+      }
+      const copy = { ...chunk };
+      openParts.set(key, copy);
+      out.push({ chunk: copy });
+      continue;
+    }
+    if (type === "tool-input-delta" && typeof chunk.inputTextDelta === "string") {
+      const index = openToolInputs.get(chunk.toolCallId);
+      const existing = index !== void 0 ? out[index] : null;
+      if (existing && "chunk" in existing) {
+        existing.chunk.inputTextDelta += chunk.inputTextDelta;
+        continue;
+      }
+      openToolInputs.set(chunk.toolCallId, out.length);
+      out.push({ chunk: { ...chunk } });
+      continue;
+    }
+    if (type === "tool-input-available" || type === "tool-input-error") {
+      const index = openToolInputs.get(chunk.toolCallId);
+      if (index !== void 0) out[index] = null;
+      openToolInputs.delete(chunk.toolCallId);
+    } else if (type === "tool-input-start") {
+      openToolInputs.delete(chunk.toolCallId);
+    } else if (type === "tool-output-available" || type === "tool-output-error") {
+      const superseded = preliminaryOutputs.get(chunk.toolCallId);
+      if (superseded !== void 0) {
+        out[superseded] = null;
+        preliminaryOutputs.delete(chunk.toolCallId);
+      }
+      if (type === "tool-output-available" && chunk.preliminary === true) {
+        preliminaryOutputs.set(chunk.toolCallId, out.length);
+      }
+    }
+    out.push({ chunk });
+  }
+  let result = "";
+  for (const entry of out) {
+    if (!entry) continue;
+    result += "chunk" in entry ? encodeEvent(entry.chunk) : `${entry.raw}
+
+`;
+  }
+  result += tail;
+  return new TextEncoder().encode(result);
+}
+function encodeTurnSeqFrame(turnId, seq) {
+  return new TextEncoder().encode(
+    encodeEvent({ type: TURN_SEQ_EVENT_TYPE, data: { turnId, seq }, transient: true })
+  );
+}
+function encodeEvent(chunk) {
+  return `data: ${JSON.stringify(chunk)}
+
+`;
+}
+function parseEvent(event) {
+  if (!event.startsWith("data: ") || event.includes("\n")) return null;
+  const payload = event.slice(6);
+  if (!payload.startsWith("{")) return null;
+  try {
+    const chunk = JSON.parse(payload);
+    return chunk && typeof chunk.type === "string" ? chunk : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/stream-buffer.ts
+var CLEANUP_INTERVAL_MS = 6e4;
+var MAX_BUFFER_AGE_MS = 30 * 6e4;
+var COMPLETED_GRACE_MS = 3e4;
+var TURN_REPLY_TTL_MS = 60 * 6e4;
+var StreamBufferStore = class {
+  constructor() {
+    this.buffers = /* @__PURE__ */ new Map();
+    this.replies = /* @__PURE__ */ new Map();
+    this.cleanupTimer = null;
+    this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+    const handle = this.cleanupTimer;
+    if (handle && typeof handle.unref === "function") {
+      handle.unref();
+    }
+  }
+  /**
+   * Create (or replace) a buffer for the given key. Any existing active
+   * buffer is completed and discarded. Returns a writer bound to this
+   * specific buffer instance, including the new `turnId`.
+   */
+  create(key, opts) {
+    const existing = this.buffers.get(key);
+    if (existing && existing.status === "active") {
+      this.completeBuffer(existing, "replaced");
+    }
+    const now = Date.now();
+    const turnId = opts?.turnId || generateTurnId();
+    const buf = {
+      turnId,
+      frames: [],
+      subscribers: /* @__PURE__ */ new Set(),
+      status: "active",
+      terminal: null,
+      createdAt: now,
+      completedAt: null,
+      lastEventAt: now,
+      nextSeq: 1
+    };
+    this.buffers.set(key, buf);
+    return {
+      get turnId() {
+        return buf.turnId;
+      },
+      get lastSeq() {
+        return buf.nextSeq - 1;
+      },
+      append: (chunk) => {
+        if (buf.status !== "active") return -1;
+        const seq = buf.nextSeq++;
+        buf.frames.push({ seq, chunk });
+        buf.lastEventAt = Date.now();
+        for (const ctrl of buf.subscribers) {
+          try {
+            ctrl.enqueue(chunk);
+          } catch {
+            buf.subscribers.delete(ctrl);
+          }
+        }
+        return seq;
+      },
+      complete: (reason) => {
+        this.completeBuffer(buf, reason);
+      },
+      fail: (error) => {
+        this.failBuffer(buf, error);
+      }
+    };
+  }
+  /**
+   * Append a chunk by key (loose, untyped writer). Returns the seq assigned,
+   * or -1 if the buffer is unknown/inactive.
+   */
+  append(key, chunk) {
+    const buf = this.buffers.get(key);
+    if (!buf || buf.status !== "active") return -1;
+    const seq = buf.nextSeq++;
+    buf.frames.push({ seq, chunk });
+    buf.lastEventAt = Date.now();
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.enqueue(chunk);
+      } catch {
+        buf.subscribers.delete(ctrl);
+      }
+    }
+    return seq;
+  }
+  /** Mark a buffer as completed by key. Optional terminal reason. */
+  complete(key, reason) {
+    const buf = this.buffers.get(key);
+    if (!buf) return;
+    this.completeBuffer(buf, reason);
+  }
+  /**
+   * Abort a stream: complete subscribers and remove the buffer entirely.
+   * Future resume/replay requests for this key will return null (→ 204).
+   */
+  abort(key) {
+    const buf = this.buffers.get(key);
+    if (!buf) return;
+    this.completeBuffer(buf, "aborted");
+    buf.status = "aborted";
+    this.buffers.delete(key);
+  }
+  has(key) {
+    return this.buffers.has(key);
+  }
+  /** Read-only metadata about a buffered turn. Useful for resume responses. */
+  snapshot(key) {
+    const buf = this.buffers.get(key);
+    if (!buf) return null;
+    return {
+      turnId: buf.turnId,
+      status: buf.status,
+      lastSeq: buf.nextSeq - 1,
+      terminal: buf.terminal,
+      createdAt: buf.createdAt,
+      completedAt: buf.completedAt,
+      lastEventAt: buf.lastEventAt
+    };
+  }
+  /**
+   * Keep the reply a turn finished with, so it can still be read after the
+   * buffer is evicted (30 s grace) — e.g. by the API's call follower, or by a
+   * reconciliation pass long after the stream is gone. Keyed by the same
+   * session key as the buffer.
+   */
+  recordTurnReply(key, reply) {
+    const trimmed = reply?.trim();
+    if (!trimmed) return;
+    const now = Date.now();
+    this.pruneReplies(now);
+    this.replies.set(key, {
+      turnId: this.buffers.get(key)?.turnId ?? "",
+      reply,
+      completedAt: now
+    });
+  }
+  /**
+   * The terminal reply for a session, or null when none was recorded or it
+   * expired. A reply belonging to an older turn of a session that has since
+   * started a new one is never returned.
+   */
+  turnReply(key) {
+    const entry = this.replies.get(key);
+    if (!entry) return null;
+    if (Date.now() - entry.completedAt > TURN_REPLY_TTL_MS) {
+      this.replies.delete(key);
+      return null;
+    }
+    const current = this.buffers.get(key);
+    if (current && entry.turnId && current.turnId !== entry.turnId) return null;
+    return entry;
+  }
+  pruneReplies(now) {
+    for (const [key, entry] of this.replies) {
+      if (now - entry.completedAt > TURN_REPLY_TTL_MS) this.replies.delete(key);
+    }
+  }
+  /**
+   * Create a ReadableStream that first replays all buffered chunks past
+   * `opts.fromSeq` (default: 0 → replay everything), then subscribes for
+   * any further live chunks until the stream completes.
+   *
+   * Returns null if no buffer exists for the key.
+   */
+  createReplayStream(key, opts = {}) {
+    const buf = this.buffers.get(key);
+    if (!buf) return null;
+    const fromSeq = Math.max(0, opts.fromSeq ?? 0);
+    let subscribedController = null;
+    if (opts.buildReplay) return this.createBuiltReplayStream(buf, fromSeq, opts.buildReplay);
+    return new ReadableStream({
+      start(controller) {
+        if (opts.compact) {
+          const pending = buf.frames.filter((frame) => frame.seq > fromSeq);
+          const compacted = compactSseFrames(pending.map((frame) => frame.chunk));
+          try {
+            if (compacted.byteLength > 0) controller.enqueue(compacted);
+            if (pending.length > 0 && buf.status === "active") {
+              controller.enqueue(encodeTurnSeqFrame(buf.turnId, buf.nextSeq - 1));
+            }
+          } catch {
+            return;
+          }
+        } else {
+          for (const frame of buf.frames) {
+            if (frame.seq <= fromSeq) continue;
+            try {
+              controller.enqueue(frame.chunk);
+            } catch {
+              return;
+            }
+          }
+        }
+        if (buf.status !== "active") {
+          try {
+            controller.close();
+          } catch {
+          }
+          return;
+        }
+        subscribedController = controller;
+        buf.subscribers.add(controller);
+      },
+      cancel() {
+        if (subscribedController) {
+          buf.subscribers.delete(subscribedController);
+          subscribedController = null;
+        }
+      }
+    });
+  }
+  createBuiltReplayStream(buf, fromSeq, buildReplay) {
+    const pending = buf.frames.filter((frame) => frame.seq > fromSeq).map((frame) => frame.chunk);
+    const ctx = { turnId: buf.turnId, lastSeq: buf.nextSeq - 1 };
+    const held = [];
+    let ended = false;
+    let target = null;
+    const proxy = {
+      enqueue(chunk) {
+        if (target) target.enqueue(chunk);
+        else held.push(chunk);
+      },
+      close() {
+        if (target) target.close();
+        else ended = true;
+      },
+      error(reason) {
+        if (target) target.error(reason);
+        else ended = true;
+      }
+    };
+    const active = buf.status === "active";
+    if (active) buf.subscribers.add(proxy);
+    return new ReadableStream({
+      async start(controller) {
+        let replay;
+        try {
+          replay = await buildReplay(pending, ctx);
+        } catch {
+          replay = compactSseFrames(pending);
+        }
+        try {
+          if (replay.byteLength > 0) controller.enqueue(replay);
+          if (pending.length > 0 && active) controller.enqueue(encodeTurnSeqFrame(ctx.turnId, ctx.lastSeq));
+          for (const chunk of held) controller.enqueue(chunk);
+          held.length = 0;
+          if (!active || ended || buf.status !== "active") {
+            controller.close();
+            return;
+          }
+          target = controller;
+        } catch {
+          buf.subscribers.delete(proxy);
+        }
+      },
+      cancel() {
+        buf.subscribers.delete(proxy);
+        target = null;
+      }
+    });
+  }
+  cleanup() {
+    const now = Date.now();
+    this.pruneReplies(now);
+    for (const [key, buf] of this.buffers) {
+      if (buf.status !== "active" && buf.completedAt && now - buf.completedAt > COMPLETED_GRACE_MS) {
+        this.buffers.delete(key);
+      } else if (now - buf.createdAt > MAX_BUFFER_AGE_MS && buf.subscribers.size === 0) {
+        this.completeBuffer(buf, "expired");
+        this.buffers.delete(key);
+      }
+    }
+  }
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    for (const buf of this.buffers.values()) {
+      this.completeBuffer(buf, "disposed");
+    }
+    this.buffers.clear();
+    this.replies.clear();
+  }
+  completeBuffer(buf, reason) {
+    if (buf.status !== "active") return;
+    buf.status = "completed";
+    buf.terminal = { reason };
+    buf.completedAt = Date.now();
+    buf.lastEventAt = buf.completedAt;
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.close();
+      } catch {
+      }
+    }
+    buf.subscribers.clear();
+  }
+  failBuffer(buf, error) {
+    if (buf.status !== "active") return;
+    buf.status = "failed";
+    buf.terminal = { error };
+    buf.completedAt = Date.now();
+    buf.lastEventAt = buf.completedAt;
+    for (const ctrl of buf.subscribers) {
+      try {
+        ctrl.close();
+      } catch {
+      }
+    }
+    buf.subscribers.clear();
+  }
+};
+var TURN_COMPLETE_EVENT_TYPE = "data-turn-complete";
+function encodeTurnCompleteFrame(data) {
+  return new TextEncoder().encode(
+    `data: ${JSON.stringify({ type: TURN_COMPLETE_EVENT_TYPE, data })}
+
+`
+  );
+}
+function generateTurnId() {
+  try {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+  } catch {
+  }
+  return `turn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function createBufferingTransform(store, key) {
+  return new TransformStream({
+    transform(chunk, controller) {
+      store.append(key, chunk);
+      controller.enqueue(chunk);
+    },
+    flush() {
+      store.complete(key);
+    }
+  });
+}
+
+export {
+  TURN_SEQ_EVENT_TYPE,
+  compactSseFrames,
+  encodeTurnSeqFrame,
+  StreamBufferStore,
+  TURN_COMPLETE_EVENT_TYPE,
+  encodeTurnCompleteFrame,
+  createBufferingTransform
+};
+//# sourceMappingURL=chunk-H625AGFN.js.map

package/dist/chunk-MDRCI2CN.js

@@ -0,0 +1,197 @@
+// src/file-types.ts
+var BINARY_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Images
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "bmp",
+  "ico",
+  "avif",
+  "apng",
+  "heic",
+  "heif",
+  "tiff",
+  "tif",
+  "jxl",
+  "cur",
+  // Archives
+  "zip",
+  "gz",
+  "tar",
+  "tgz",
+  "bz2",
+  "xz",
+  "7z",
+  "rar",
+  "zst",
+  "lz4",
+  // Audio / video / docs
+  "mp3",
+  "mp4",
+  "m4a",
+  "m4v",
+  "mov",
+  "avi",
+  "mkv",
+  "webm",
+  "wav",
+  "flac",
+  "ogg",
+  "oga",
+  "ogv",
+  "aac",
+  "opus",
+  "pdf",
+  // Office / document containers
+  "xls",
+  "xlsx",
+  "xlsm",
+  "xlsb",
+  "doc",
+  "docx",
+  "docm",
+  "ppt",
+  "pptx",
+  "pptm",
+  "odt",
+  "ods",
+  "odp",
+  "pages",
+  "numbers",
+  "key",
+  "epub",
+  // Fonts
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  // Native / packed
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "bin",
+  "class",
+  "jar",
+  "wasm",
+  // Databases
+  "db",
+  "sqlite",
+  "sqlite3",
+  "mdb",
+  "lmdb",
+  // Misc binary
+  "pack",
+  "idx",
+  "psd",
+  "ai",
+  "sketch",
+  "fig",
+  "blend",
+  "obj",
+  "fbx",
+  "pyc",
+  "pyo",
+  "pyd",
+  // 3D / scene / point cloud (binary variants — `.usda` and `.gltf` are
+  // text and intentionally NOT listed; users can still edit those)
+  "usd",
+  "usdc",
+  "usdz",
+  "glb",
+  "stl",
+  "ply",
+  // Robotics logs
+  "bag",
+  "mcap",
+  // ML weights / saved models / serialized arrays
+  "pt",
+  "pth",
+  "ckpt",
+  "safetensors",
+  "onnx",
+  "pb",
+  "tflite",
+  "mlmodel",
+  "npy",
+  "npz",
+  "joblib",
+  "pkl",
+  // Tabular / scientific containers
+  "parquet",
+  "arrow",
+  "feather",
+  "h5",
+  "hdf5",
+  "nc",
+  "tfrecord"
+]);
+var BINARY_FILE_TRANSIENT_SUFFIXES = /* @__PURE__ */ new Set([
+  "part",
+  "partial",
+  "crdownload",
+  "download"
+]);
+var BINARY_FILE_BASENAMES = /* @__PURE__ */ new Set([
+  "aapt",
+  "aapt2",
+  "adb",
+  "apksigner",
+  "bcc_compat",
+  "dexdump",
+  "dmtracedump",
+  "etc1tool",
+  "fastboot",
+  "hprof-conv",
+  "llvm-rs-cc",
+  "mksdcard",
+  "qemu-aarch64-static",
+  "qemu-arm-static",
+  "qemu-i386-static",
+  "qemu-x86_64-static",
+  "split-select",
+  "sqlite3",
+  "zipalign"
+]);
+function basenameOf(path) {
+  const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return path.slice(slash + 1);
+}
+function extensionOfBasename(basename) {
+  const dot = basename.lastIndexOf(".");
+  if (dot <= 0 || dot === basename.length - 1) return null;
+  return basename.slice(dot + 1).toLowerCase();
+}
+function isBinaryFilePath(path) {
+  let basename = basenameOf(path).toLowerCase();
+  if (BINARY_FILE_BASENAMES.has(basename)) return true;
+  for (let i = 0; i < 2; i++) {
+    const ext = extensionOfBasename(basename);
+    if (!ext) return false;
+    if (BINARY_FILE_EXTENSIONS.has(ext)) return true;
+    if (!BINARY_FILE_TRANSIENT_SUFFIXES.has(ext)) return false;
+    basename = basename.slice(0, -(ext.length + 1));
+  }
+  return false;
+}
+function isBinaryBuffer(bytes, inspectBytes = 8192) {
+  const head = bytes.subarray(0, Math.min(bytes.length, inspectBytes));
+  if (head.includes(0)) return true;
+  const startsWith = (...signature) => signature.every((value, index) => head[index] === value);
+  const ascii = (value) => Array.from(value).every(
+    (char, index) => head[index] === char.charCodeAt(0)
+  );
+  return startsWith(80, 75, 3, 4) || startsWith(80, 75, 5, 6) || startsWith(208, 207, 17, 224, 161, 177, 26, 225) || ascii("%PDF-") || startsWith(137, 80, 78, 71, 13, 10, 26, 10) || startsWith(255, 216, 255) || startsWith(71, 73, 70, 56) || startsWith(82, 73, 70, 70);
+}
+
+export {
+  BINARY_FILE_EXTENSIONS,
+  BINARY_FILE_TRANSIENT_SUFFIXES,
+  BINARY_FILE_BASENAMES,
+  isBinaryFilePath,
+  isBinaryBuffer
+};
+//# sourceMappingURL=chunk-MDRCI2CN.js.map