@yaklabs-ai/plugin-sdk 0.52.1 → 0.54.0

package/dist/transcript.js

@@ -133,6 +133,268 @@ function readProducedResourceDeclarations(details) {
     return MALFORMED;
   return { kind: "declared", resources: claimed };
 }
+
+// packages/plugin-protocol/dist/turn-packet.js
+var RUN_STARTED = "session_run_started";
+function textOf(entry) {
+  const content = entry.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((part) => typeof part === "object" && part !== null && part.type === "text" && typeof part.text === "string" ? part.text : "").join("");
+}
+function turnMessageOrigin(entry) {
+  const m = entry.message;
+  if (m === void 0 || typeof m.clientIntentId !== "string")
+    return "unknown";
+  const details = m.details;
+  const deliveryId = typeof details === "object" && details !== null ? details.deliveryId : void 0;
+  return typeof deliveryId === "string" ? "human-verified" : "unknown";
+}
+function turnPacket(entries, settleEntryId, options = {}) {
+  const branch = branchEntryIds(entries);
+  const live = entries.filter((e) => branch.has(e.id));
+  const anchorIndex = live.findIndex((e) => e.id === settleEntryId);
+  const searchFrom = anchorIndex === -1 ? live.length - 1 : anchorIndex;
+  let runStart = -1;
+  for (let i = searchFrom; i >= 0; i -= 1) {
+    if (live[i]?.type === "custom" && live[i]?.customType === RUN_STARTED) {
+      runStart = i;
+      break;
+    }
+  }
+  let spanStart = runStart;
+  if (runStart === -1) {
+    spanStart = 0;
+    for (let i = searchFrom; i >= 0; i -= 1) {
+      if (live[i]?.type === "message" && live[i]?.message?.role === "user") {
+        spanStart = i;
+        break;
+      }
+    }
+  }
+  const span = live.slice(spanStart, searchFrom + 1);
+  const messages = span.filter((e) => e.type === "message" && e.message?.role !== void 0);
+  const people = messages.filter((e) => e.message?.role === "user");
+  const assistants = messages.filter((e) => e.message?.role === "assistant");
+  const opener = people[0];
+  if (opener === void 0)
+    return void 0;
+  const toPacket = (entry) => ({
+    entryId: entry.id,
+    timestamp: entry.timestamp,
+    text: textOf(entry),
+    origin: turnMessageOrigin(entry)
+  });
+  return {
+    personMessage: toPacket(opener),
+    personSteers: people.slice(1).map(toPacket),
+    assistantReplies: assistants.filter((e) => textOf(e).trim().length > 0).map(toPacket),
+    settleEntryId,
+    sessionTier: options.sessionTier ?? "unknown"
+  };
+}
+function precedingPersonMessages(entries, packet, count) {
+  if (count <= 0)
+    return [];
+  const branch = branchEntryIds(entries);
+  const live = entries.filter((e) => branch.has(e.id));
+  const openerIndex = live.findIndex((e) => e.id === packet.personMessage.entryId);
+  if (openerIndex === -1)
+    return [];
+  const found = [];
+  for (let i = openerIndex - 1; i >= 0 && found.length < count; i -= 1) {
+    const e = live[i];
+    if (e === void 0)
+      continue;
+    if (e.type !== "message" || e.message?.role !== "user")
+      continue;
+    if (turnMessageOrigin(e) !== "human-verified")
+      continue;
+    found.push({
+      entryId: e.id,
+      timestamp: e.timestamp,
+      text: textOf(e),
+      origin: "human-verified"
+    });
+  }
+  return found.reverse();
+}
+
+// packages/plugin-protocol/dist/skill-suggestion-evidence.js
+var UUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+var UUID_ID = new RegExp(`^${UUID}$`, "i");
+var ENTRY = "[a-z0-9_-]+";
+var ENTRY_ID = new RegExp(`^${ENTRY}$`, "i");
+var FRICTION_URI = /^friction:\/\/([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+var normalizeId = (value) => UUID_ID.test(value) ? value.toLowerCase() : value;
+function sessionPattern(options) {
+  const known = (options.sessionIds ?? []).filter((id) => ENTRY_ID.test(id) && !UUID_ID.test(id)).map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return `(?:${[UUID, ...new Set(known)].join("|")})`;
+}
+function sessionRef(sessionId, entryId, raw) {
+  return entryId === void 0 ? { kind: "session", sessionId: normalizeId(sessionId), raw } : {
+    kind: "message",
+    sessionId: normalizeId(sessionId),
+    entryId: normalizeId(entryId),
+    raw
+  };
+}
+function parseToken(raw, sessions) {
+  if (/^sessions?:\/\//i.test(raw)) {
+    const match = /^sessions?:\/\/([^/?#]+)([^?#]*)(?:\?([^#]*))?(?:#(.*))?$/i.exec(raw);
+    if (match === null)
+      return void 0;
+    const sessionId = match[1].replace(/\.jsonl$/i, "");
+    if (!new RegExp(`^${sessions}$`, "i").test(sessionId))
+      return void 0;
+    const path = match[2];
+    if (path !== "" && path !== "/" && !new RegExp(`^/${ENTRY}$`, "i").test(path))
+      return void 0;
+    const query = new URLSearchParams(match[3]);
+    const entryId = query.get("entry") ?? query.get("span") ?? query.get("from") ?? (path.length > 1 ? path.slice(1) : match[4]);
+    if (entryId !== void 0 && !ENTRY_ID.test(entryId))
+      return void 0;
+    return sessionRef(sessionId, entryId, raw);
+  }
+  if (/^friction:\/\//i.test(raw)) {
+    const reference = FRICTION_URI.exec(raw)?.[1];
+    return reference === void 0 || reference === "summary" ? void 0 : { kind: "friction", reference, raw };
+  }
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+    return { kind: "uri", uri: raw, raw };
+  }
+  const message = new RegExp(`^(${sessions})(?:\\.jsonl)?(?:[/#](${ENTRY})(?:#[0-9]+)?)?$`, "i").exec(raw);
+  return message === null ? void 0 : sessionRef(message[1], message[2], raw);
+}
+function findSkillSuggestionCitations(text, options = {}) {
+  const sessions = sessionPattern(options);
+  const tokens = new RegExp(`(?<![\\w/.:#-])(?:[a-z][a-z0-9+.-]*://[^\\s<>\`"'|\\[\\]()]+|${sessions}(?:\\.jsonl)?(?:[/#]${ENTRY}(?:#[0-9]+)?)?(?![\\w/#-]))`, "gi");
+  const citations = [];
+  for (const match of text.matchAll(tokens)) {
+    const raw = match[0].replace(/[.,;:!?]+$/u, "");
+    if (new RegExp(`^${UUID}(?:#[0-9]+)?$`, "i").test(raw) && /\b(?:call|result)(?:\s*:\s*|\s+)$/i.test(text.slice(0, match.index)))
+      continue;
+    const ref = parseToken(raw, sessions);
+    if (ref !== void 0)
+      citations.push({
+        start: match.index,
+        end: match.index + raw.length,
+        ref
+      });
+  }
+  const sessionIds = new Set(citations.flatMap(({ ref }) => ref.kind === "message" || ref.kind === "session" && ref.raw.indexOf("://") >= 0 ? [ref.sessionId] : []));
+  if (sessionIds.size === 1) {
+    const sessionId = [...sessionIds][0];
+    const relative = new RegExp(`\\b(?:call|result)(?:\\s*:\\s*|\\s+)((?:${UUID}|[0-9a-f]{8,32}|[0-9]+)|${ENTRY}(?=#[0-9]+))(?:#[0-9]+)?(?![\\w/#-])`, "gi");
+    for (const match of text.matchAll(relative)) {
+      const start = match.index;
+      const end = start + match[0].length;
+      if (citations.some((item) => start < item.end && end > item.start))
+        continue;
+      citations.push({
+        start,
+        end,
+        ref: sessionRef(sessionId, match[1], match[0])
+      });
+    }
+  }
+  return citations.sort((a, b) => a.start - b.start);
+}
+function skillSuggestionEvidenceKey(item) {
+  switch (item.kind) {
+    case "message":
+      return `message:${item.sessionId}/${item.entryId}`;
+    case "session":
+      return `session:${item.sessionId}`;
+    case "friction":
+      return `friction:${item.reference}`;
+    case "uri":
+      return `uri:${item.uri}`;
+    case "text":
+      return `text:${item.text.trim()}`;
+  }
+}
+function skillSuggestionEvidenceItems(evidence, options = {}) {
+  const items = [];
+  const keys = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new WeakSet();
+  const add = (item) => {
+    const key = skillSuggestionEvidenceKey(item);
+    if (keys.has(key))
+      return;
+    keys.add(key);
+    items.push(item);
+  };
+  const text = (value) => {
+    const citations = findSkillSuggestionCitations(value, options);
+    if (citations.length === 0) {
+      if (value.trim() !== "")
+        add({ kind: "text", text: value });
+      return;
+    }
+    let cursor = 0;
+    const rest = [];
+    for (const citation of citations) {
+      rest.push(value.slice(cursor, citation.start));
+      cursor = citation.end;
+    }
+    rest.push(value.slice(cursor));
+    const note = rest.join(" ").trim();
+    if (citations.every(({ ref }) => ref.kind === "uri") && /[\p{L}\p{N}]/u.test(note)) {
+      add({ kind: "text", text: value });
+      return;
+    }
+    for (const citation of citations)
+      add(citation.ref);
+    if (/[\p{L}\p{N}]/u.test(note.replace(/\b(?:call|result|view|pointer|and)\b/gi, "")))
+      add({ kind: "text", text: note.replace(/^[\s|,;`]+|[\s|,;`]+$/g, "") });
+  };
+  const visit = (value, depth) => {
+    if (value === null || value === void 0)
+      return;
+    if (typeof value === "string")
+      return text(value);
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint")
+      return text(String(value));
+    if (typeof value !== "object" || visited.has(value))
+      return;
+    visited.add(value);
+    if (depth >= 32) {
+      add({ kind: "text", text: "[evidence nested too deeply]" });
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value)
+        visit(entry, depth + 1);
+      return;
+    }
+    const object = value;
+    const sessionId = object.sessionId;
+    const entryId = object.entryId ?? object.messageId;
+    if (typeof sessionId === "string" && ENTRY_ID.test(sessionId) && (entryId === void 0 || typeof entryId === "string" && ENTRY_ID.test(entryId))) {
+      add(sessionRef(sessionId, entryId, `sessions://${sessionId}${entryId === void 0 ? "" : `/${entryId}`}`));
+      return;
+    }
+    if (object.kind === "text" && typeof object.text === "string") {
+      text(object.text);
+      return;
+    }
+    if (object.kind === "friction" && typeof object.reference === "string") {
+      text(`friction://${object.reference}`);
+      return;
+    }
+    if (object.kind === "uri" && typeof object.uri === "string") {
+      text(object.uri);
+      return;
+    }
+    for (const entry of Object.values(object))
+      visit(entry, depth + 1);
+  };
+  visit(evidence, 0);
+  return items;
+}
 export {
   ATTACHMENTS_CUSTOM_TYPE,
   NON_ACTIVITY_TOOL_NAMES,
@@ -145,7 +407,11 @@ export {
   branchEntryIds,
   customEntriesFromEntries,
   matchesWorkBlock,
+  precedingPersonMessages,
   readProducedResourceDeclarations,
+  skillSuggestionEvidenceItems,
+  turnMessageOrigin,
+  turnPacket,
   turnSegments,
   workBlockCoverage,
   workBlockKey

package/dist/vendored-mcp.js

@@ -263,6 +263,8 @@ function isLoneCapture(pattern) {
   return pattern.length === 1 && pattern[0].capture !== void 0 && pattern[0].rest !== true;
 }
 function matchParts(pattern, value, separator, captures, foldLiterals = false) {
+  if (pattern.length === 0)
+    return value === "";
   const parts = separator === void 0 ? [value] : value.split(separator);
   let partIndex = 0;
   for (let i = 0; i < pattern.length; i += 1) {

package/dist/whiteboard.d.ts

@@ -31,8 +31,8 @@ export declare const WhiteboardEntryInfo: z.ZodObject<{
         authorSessionId: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>;
     state: z.ZodEnum<{
-        unavailable: "unavailable";
         available: "available";
+        unavailable: "unavailable";
         "unsupported-version": "unsupported-version";
         invalid: "invalid";
     }>;
@@ -53,8 +53,8 @@ export declare const WhiteboardEntryInspection: z.ZodObject<{
         authorSessionId: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>;
     state: z.ZodEnum<{
-        unavailable: "unavailable";
         available: "available";
+        unavailable: "unavailable";
         "unsupported-version": "unsupported-version";
         invalid: "invalid";
     }>;
@@ -72,6 +72,9 @@ export declare const WhiteboardTypeInfo: z.ZodObject<{
     displayName: z.ZodString;
     schemaVersion: z.ZodNumber;
     available: z.ZodBoolean;
+    reference: z.ZodOptional<z.ZodObject<{
+        uriTemplate: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 
 export declare type WhiteboardTypeInfo = Readonly<z.infer<typeof WhiteboardTypeInfo>>;

package/dist/whiteboard.js

@@ -122,6 +122,9 @@ var { NonEmptyString, PluginId, PluginNamespace, LocalContributionId, GlobalCont
 var canonicalCommonSchemas = createCommonSchemas(true);
 
 // packages/plugin-protocol/dist/whiteboard.js
+var WhiteboardEntryReference = z4.strictObject({
+  uriTemplate: z4.string().regex(/^[a-z][a-z0-9+.-]*:\/\/[^\s?#{}]+\/\{name\}$/u)
+});
 var WhiteboardValue = JsonValue;
 var WhiteboardEntryEnvelope = z4.strictObject({
   id: NonEmptyString,
@@ -160,7 +163,8 @@ var WhiteboardTypeInfo = z4.strictObject({
   typeId: GlobalContributionId,
   displayName: NonEmptyString,
   schemaVersion: z4.number().int().positive(),
-  available: z4.boolean()
+  available: z4.boolean(),
+  reference: WhiteboardEntryReference.optional()
 });
 export {
   JsonValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaklabs-ai/plugin-sdk",
-  "version": "0.52.1",
+  "version": "0.54.0",
   "description": "The Kay plugin SDK — types and helpers for authoring a Kay directory plugin.",
   "author": "YakLabs",
   "type": "module",
@@ -33,6 +33,10 @@
       "types": "./dist/fs.d.ts",
       "default": "./dist/fs.js"
     },
+    "./text-diff": {
+      "types": "./dist/text-diff.d.ts",
+      "default": "./dist/text-diff.js"
+    },
     "./kay-agent/testing": {
       "types": "./dist/kay-agent-testing.d.ts",
       "default": "./dist/kay-agent-testing.js"