@makinbakin/sdk 0.0.0-bootstrap.0 → 0.0.1-rc.2

package/utils/index.js

@@ -1824,9 +1824,277 @@ function formatSize(bytes) {
 function isStale(timestamp, thresholdMs = 15 * 60 * 1000) {
   return Date.now() - new Date(timestamp).getTime() > thresholdMs;
 }
+// src/components/integrated-brainstorm/session.ts
+var ACTIVITY_CONTENT_MAX_CHARS = 500;
+var ACTIVITY_PREVIEW_MAX_CHARS = 2000;
+var ACTIVITY_METADATA_MAX_CHARS = 4000;
+var ACTIVITY_DATA_MAX_KEYS = 24;
+function brainstormThreadId(scope, entityId, agentId) {
+  return [scope, entityId, agentId].map(threadIdPart).join(":");
+}
+function normalizeBrainstormActivityForStorage(activity) {
+  const content = typeof activity.content === "string" ? truncate(activity.content.trim(), ACTIVITY_CONTENT_MAX_CHARS) : "";
+  if (!content)
+    return null;
+  const data = normalizeActivityData(activity.data);
+  return {
+    kind: typeof activity.kind === "string" && activity.kind ? activity.kind : "runtime_status",
+    content,
+    ...data !== undefined ? { data } : {}
+  };
+}
+function normalizeBrainstormActivityMessageForStorage(activity) {
+  const normalized = normalizeBrainstormActivityForStorage(activity);
+  if (!normalized)
+    return null;
+  return {
+    role: "activity",
+    kind: normalized.kind,
+    content: normalized.content,
+    ...normalized.data !== undefined ? { data: normalized.data } : {}
+  };
+}
+function threadIdPart(value) {
+  const trimmed = value.trim();
+  return encodeURIComponent(trimmed || "default");
+}
+function normalizeActivityData(data) {
+  if (data === undefined)
+    return;
+  if (!isRecord(data))
+    return normalizeActivityValue(data, "value");
+  const out = {};
+  let count = 0;
+  for (const [key, value] of Object.entries(data)) {
+    if (count >= ACTIVITY_DATA_MAX_KEYS) {
+      out.truncatedKeys = Object.keys(data).length - count;
+      break;
+    }
+    out[key] = normalizeActivityValue(value, key);
+    count += 1;
+  }
+  return out;
+}
+function normalizeActivityValue(value, key) {
+  if (typeof value === "string") {
+    const max = isPreviewKey(key) ? ACTIVITY_PREVIEW_MAX_CHARS : ACTIVITY_METADATA_MAX_CHARS;
+    return truncate(value, max);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null)
+    return value;
+  if (value === undefined)
+    return;
+  return truncate(stringify(value), ACTIVITY_METADATA_MAX_CHARS);
+}
+function isPreviewKey(key) {
+  return key === "inputPreview" || key === "argumentsPreview" || key === "outputPreview" || key === "resultPreview";
+}
+function stringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncate(value, maxChars) {
+  if (value.length <= maxChars)
+    return value;
+  return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/components/integrated-brainstorm/activity.ts
+function newActivityId() {
+  return `act-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function runtimeChunkToBrainstormActivity(chunk) {
+  if (chunk.type === "status") {
+    return {
+      kind: "runtime_status",
+      content: chunk.content || "Agent status update",
+      data: chunk.data
+    };
+  }
+  if (chunk.type === "tool") {
+    return {
+      kind: "tool_call",
+      content: chunk.content || "Tool call",
+      data: chunk.data
+    };
+  }
+  if (chunk.type === "error") {
+    return {
+      kind: "error",
+      content: chunk.content || "Runtime stream error",
+      data: chunk.data
+    };
+  }
+  return null;
+}
+function brainstormActivityMessageFromCustom(name, data) {
+  if (name !== "activity")
+    return null;
+  const payload = data && typeof data === "object" && "activity" in data ? data.activity : data;
+  if (!payload || typeof payload !== "object")
+    return null;
+  const activity = payload;
+  const content = typeof activity.content === "string" ? activity.content : "";
+  if (!content)
+    return null;
+  const normalized = normalizeBrainstormActivityForStorage({
+    kind: typeof activity.kind === "string" ? activity.kind : "runtime_status",
+    content,
+    data: activity.data
+  });
+  if (!normalized)
+    return null;
+  return {
+    id: typeof activity.id === "string" ? activity.id : newActivityId(),
+    role: "activity",
+    kind: normalized.kind,
+    content: normalized.content,
+    ...normalized.data !== undefined ? { data: normalized.data } : {},
+    timestamp: typeof activity.timestamp === "string" ? activity.timestamp : new Date().toISOString()
+  };
+}
+function toBrainstormTimeline(agentId, input) {
+  return [
+    ...input.messages.map((message) => ({
+      id: message.id,
+      role: message.role === "user" ? "user" : "assistant",
+      content: message.content,
+      agentId: message.role === "user" ? undefined : agentId,
+      timestamp: message.timestamp
+    })),
+    ...(input.activities ?? []).map((activity) => ({
+      id: activity.id,
+      role: "activity",
+      kind: activity.kind,
+      content: activity.content,
+      data: activity.data,
+      timestamp: activity.timestamp
+    }))
+  ].sort((a, b) => {
+    const aTime = a.timestamp ? Date.parse(a.timestamp) : 0;
+    const bTime = b.timestamp ? Date.parse(b.timestamp) : 0;
+    return aTime - bTime;
+  });
+}
+// src/components/integrated-brainstorm/sse.ts
+async function readBrainstormSseResponse(response, ctx, options = {}) {
+  if (!response.ok || !response.body) {
+    const text = await response.text().catch(() => "");
+    throw new Error(text || `Server returned ${response.status}`);
+  }
+  const reader = response.body.getReader();
+  const abort = () => {
+    reader.cancel().catch(() => {});
+  };
+  ctx.signal.addEventListener("abort", abort, { once: true });
+  const decoder = new TextDecoder;
+  let buffer = "";
+  let accumulated = "";
+  let finalContent = "";
+  const dispatch = (frame) => {
+    if (frame.event === "token") {
+      const text = textField(frame.data, "text");
+      accumulated += text;
+      ctx.onToken(text);
+      return;
+    }
+    if (frame.event === "activity") {
+      ctx.onCustom?.("activity", frame.data);
+      return;
+    }
+    if (frame.event === "done") {
+      finalContent = textField(frame.data, "content") || accumulated;
+      return;
+    }
+    if (frame.event === "error") {
+      throw new Error(textField(frame.data, "message") || "Unknown error");
+    }
+    if (options.onCustomEvent?.(frame.event, frame.data) === true)
+      return;
+    ctx.onCustom?.(frame.event, frame.data);
+  };
+  try {
+    while (true) {
+      if (ctx.signal.aborted)
+        throw abortError();
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const parsed2 = drainSseFrames(buffer);
+      buffer = parsed2.remainder;
+      for (const frame of parsed2.frames)
+        dispatch(frame);
+    }
+    buffer += decoder.decode();
+    const parsed = drainSseFrames(buffer, true);
+    for (const frame of parsed.frames)
+      dispatch(frame);
+  } finally {
+    ctx.signal.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+  return { content: finalContent || accumulated };
+}
+function drainSseFrames(input, flush = false) {
+  const parts = input.split(/\r?\n\r?\n/);
+  const remainder = flush ? "" : parts.pop() ?? "";
+  const frames = parts.map(parseSseFrame).filter((frame) => frame !== null);
+  if (flush && parts.length === 0 && input.trim()) {
+    const frame = parseSseFrame(input);
+    if (frame)
+      frames.push(frame);
+  }
+  return { frames, remainder };
+}
+function parseSseFrame(frame) {
+  let event = "message";
+  const dataLines = [];
+  for (const rawLine of frame.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    if (line.startsWith("event:")) {
+      event = line.slice("event:".length).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice("data:".length).trimStart());
+    }
+  }
+  if (dataLines.length === 0)
+    return null;
+  const rawData = dataLines.join(`
+`);
+  let data = rawData;
+  try {
+    data = JSON.parse(rawData);
+  } catch {}
+  return { event, data };
+}
+function textField(data, key) {
+  if (!data || typeof data !== "object")
+    return "";
+  const value = data[key];
+  return typeof value === "string" ? value : "";
+}
+function abortError() {
+  const err = new Error("Aborted");
+  err.name = "AbortError";
+  return err;
+}
 export {
+  toBrainstormTimeline,
+  runtimeChunkToBrainstormActivity,
+  readBrainstormSseResponse,
+  normalizeBrainstormActivityMessageForStorage,
+  normalizeBrainstormActivityForStorage,
   isStale,
   formatSize,
   formatAge,
-  cn
+  cn,
+  brainstormThreadId,
+  brainstormActivityMessageFromCustom
 };