@jini-ai/chat 0.6.6 → 0.6.7

package/dist/core/turn-usage.js

@@ -19,13 +19,16 @@ export function replySegments({ events }, _optional = {}) {
             started = false;
             continue;
         }
-        const target = event.kind === 'usage' && !started && segments.length > 1 ? segments.length - 2 : segments.length - 1;
-        if (event.kind !== 'usage' && event.kind !== 'status' && event.kind !== 'raw')
-            started = true;
-        segments[target].push(event);
+        const lateResult = event.kind === 'usage' && !started && segments.length > 1;
+        started ||= producesReplyOutput({ event });
+        segments[segments.length - (lateResult ? 2 : 1)].push(event);
     }
     return segments;
 }
+/** Usage, status and raw lines are bookkeeping; anything else means the reply has produced output. */
+function producesReplyOutput({ event }, _optional = {}) {
+    return event.kind !== 'usage' && event.kind !== 'status' && event.kind !== 'raw';
+}
 /** Resolve one charge against this agent/session's last snapshot. State is local to an
  * ordered transcript projection; revisiting a session keeps its baseline. A lower snapshot
  * starts a new counter epoch (some CLIs reset their counter on resume). O(1) map access. */
@@ -57,17 +60,21 @@ export function turnUsage({ events }, { sessions = new Map(), agentId = '' } = {
         if (event.kind !== 'usage')
             continue;
         total ??= { kind: 'usage' };
-        for (const field of ['inputTokens', 'outputTokens', 'durationMs']) {
-            const value = event[field];
-            if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
-                total[field] = (total[field] ?? 0) + value;
-        }
+        addReportedCounts({ total, event });
         const cost = usageCost({ event, agentId, sessions });
         if (cost !== undefined)
             total.costUsd = (total.costUsd ?? 0) + cost;
     }
     return total;
 }
+/** Add an event's well-formed token and duration counts into `total`, in place. */
+function addReportedCounts({ total, event }, _optional = {}) {
+    for (const field of ['inputTokens', 'outputTokens', 'durationMs']) {
+        const value = event[field];
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+            total[field] = (total[field] ?? 0) + value;
+    }
+}
 /** Add one reply's usage into a message total; fields absent from both stay absent. O(1). */
 function addUsage({ total, usage }, _optional = {}) {
     if (!usage)
@@ -92,30 +99,45 @@ export function conversationUsage({ messages }, _optional = {}) {
     for (const message of messages) {
         if (message.role !== 'assistant')
             continue;
-        // Replies run in event order through one session map, so their sum equals the whole-message charge.
-        const segments = [];
-        let usage;
-        for (const events of replySegments({ events: message.events })) {
-            const segment = turnUsage({ events }, { sessions, agentId: message.agentId ?? '' });
-            usage = addUsage({ total: usage, usage: segment });
-            if (segment?.costUsd !== undefined)
-                totalCostUsd = (totalCostUsd ?? 0) + segment.costUsd;
-            segments.push(segment && { ...segment, ...(totalCostUsd === undefined ? {} : { totalCostUsd }) });
-        }
-        if (!usage)
-            continue;
-        // Tokens-only runtimes still have run timestamps; those cannot time individual mid-run replies.
-        if (segments.length === 1 && usage.durationMs === undefined && message.startedAt !== undefined && message.endedAt !== undefined) {
-            const durationMs = message.endedAt - message.startedAt;
-            if (Number.isFinite(durationMs) && durationMs >= 0)
-                usage.durationMs = durationMs;
-        }
-        summaries.set(message.id, {
-            ...usage,
-            ...(totalCostUsd === undefined ? {} : { totalCostUsd }),
-            ...(segments.length > 1 ? { segments } : {}),
-        });
+        const result = messageUsage({ message, sessions, totalCostUsd });
+        totalCostUsd = result.totalCostUsd;
+        if (result.usage)
+            summaries.set(message.id, messageSummary({ ...result, usage: result.usage, message }));
     }
     return summaries;
 }
+/** A message's summary: its usage, the prefix total, and per-reply segments when it holds several replies. */
+function messageSummary({ usage, segments, totalCostUsd, message }, _optional = {}) {
+    // Tokens-only runtimes still have run timestamps; those cannot time individual mid-run replies.
+    if (segments.length === 1)
+        fillRunDuration({ usage, message });
+    return {
+        ...usage,
+        ...(totalCostUsd === undefined ? {} : { totalCostUsd }),
+        ...(segments.length > 1 ? { segments } : {}),
+    };
+}
+/** One assistant message's summed usage and per-reply summaries, advancing the conversation's prefix total. */
+function messageUsage({ message, sessions, totalCostUsd }, _optional = {}) {
+    // Replies run in event order through one session map, so their sum equals the whole-message charge.
+    const segments = [];
+    let usage;
+    let prefixTotal = totalCostUsd;
+    for (const events of replySegments({ events: message.events })) {
+        const segment = turnUsage({ events }, { sessions, agentId: message.agentId ?? '' });
+        usage = addUsage({ total: usage, usage: segment });
+        if (segment?.costUsd !== undefined)
+            prefixTotal = (prefixTotal ?? 0) + segment.costUsd;
+        segments.push(segment && { ...segment, ...(prefixTotal === undefined ? {} : { totalCostUsd: prefixTotal }) });
+    }
+    return { usage, segments, totalCostUsd: prefixTotal };
+}
+/** Use the message's elapsed run time when no reply reported a duration; invalid timestamps stay unknown. */
+function fillRunDuration({ usage, message }, _optional = {}) {
+    if (usage.durationMs !== undefined || message.startedAt === undefined || message.endedAt === undefined)
+        return;
+    const durationMs = message.endedAt - message.startedAt;
+    if (Number.isFinite(durationMs) && durationMs >= 0)
+        usage.durationMs = durationMs;
+}
 //# sourceMappingURL=turn-usage.js.map

package/dist/core/user-text-redaction.js

@@ -7,6 +7,9 @@ const INTERNAL_REMOVED = '[REDACTED:chat_secret]';
 const REDACTION_MARKER = /\[REDACTED:[^\]\r\n]+\]/g;
 const CHAT_RULES = [
     { kind: 'chat_key', pattern: /(?<![A-Za-z0-9_-])sk-[A-Za-z0-9_-]{16,}/g, replacement: () => INTERNAL_REMOVED },
+    // Kept on top of the shared Slack rule: that rule refuses a token preceded by `-` (e.g. a URL path
+    // segment `/-xoxb-…`) and the entropy fallback below exempts URLs, so without this rule such a token
+    // would reach storage and model history. Only drop it once the shared rule covers that case.
     { kind: 'chat_key', pattern: /(?<![A-Za-z0-9_])xox[baprs]-[A-Za-z0-9-]{16,}/g, replacement: () => INTERNAL_REMOVED },
     // Explicit authorization syntax catches even short values. Exempt scheme descriptions in prose.
     { kind: 'chat_bearer', pattern: /\bBearer[ \t]+(?!\[REDACTED)(?!(?:token|tokens|authentication|authorization|auth|scheme|credentials?)\b)[A-Za-z0-9._~+\/=-]+/gi, replacement: () => 'Bearer ' + INTERNAL_REMOVED },

package/dist/core/util/manifest.js

@@ -27,33 +27,27 @@ function normalizeExt(name) {
     const i = name.lastIndexOf('.');
     return i >= 0 ? name.slice(i).toLowerCase() : '';
 }
-function inferKindFromEntry(entry) {
-    const ext = normalizeExt(entry);
-    if (['.html', '.htm'].includes(ext))
-        return 'html';
-    if (ext === '.svg')
-        return 'svg';
-    if (ext === '.md')
-        return 'markdown-document';
-    if (['.jsx', '.tsx'].includes(ext))
-        return 'react-component';
-    if (['.js', '.ts', '.json', '.css'].includes(ext))
-        return 'code-snippet';
-    return null;
-}
-function exportsForKind(kind) {
-    if (kind === 'deck')
-        return ['html', 'pdf', 'zip'];
-    if (kind === 'react-component')
-        return ['jsx', 'html', 'zip'];
-    if (kind === 'markdown-document')
-        return ['md', 'html', 'pdf', 'zip'];
-    if (kind === 'svg' || kind === 'diagram')
-        return ['svg', 'zip'];
-    if (kind === 'code-snippet')
-        return ['txt', 'zip'];
-    return ['html', 'pdf', 'zip'];
-}
+const LEGACY_KIND_BY_EXT = new Map([
+    ['.html', 'html'],
+    ['.htm', 'html'],
+    ['.svg', 'svg'],
+    ['.md', 'markdown-document'],
+    ['.jsx', 'react-component'],
+    ['.tsx', 'react-component'],
+    ['.js', 'code-snippet'],
+    ['.ts', 'code-snippet'],
+    ['.json', 'code-snippet'],
+    ['.css', 'code-snippet'],
+]);
+/** Renderer and export set for every kind `inferLegacyManifest` can resolve to (the inferred kinds plus the deck-name heuristic's `deck`). */
+const LEGACY_KIND_INFO = {
+    html: { renderer: 'html', exports: ['html', 'pdf', 'zip'] },
+    deck: { renderer: 'deck-html', exports: ['html', 'pdf', 'zip'] },
+    'markdown-document': { renderer: 'markdown', exports: ['md', 'html', 'pdf', 'zip'] },
+    'react-component': { renderer: 'react-component', exports: ['jsx', 'html', 'zip'] },
+    'code-snippet': { renderer: 'code', exports: ['txt', 'zip'] },
+    svg: { renderer: 'svg', exports: ['svg', 'zip'] }, // 'svg' is a valid ArtifactRendererId as-is
+};
 /** The manifest sidecar file name convention for a given artifact entry file name. */
 export function artifactManifestNameFor({ entry }) {
     return `${entry}.artifact.json`;
@@ -90,50 +84,62 @@ export function serializeArtifactManifest({ manifest }) {
  * @complexity O(k) in the manifest's own field/array count — no I/O.
  */
 export function parseArtifactManifest({ raw }) {
+    let parsed;
     try {
-        const parsed = JSON.parse(raw);
-        if (parsed?.version !== MANIFEST_VERSION)
-            return null;
-        if (typeof parsed.entry !== 'string' || !parsed.entry)
-            return null;
-        if (typeof parsed.title !== 'string' || !parsed.title)
-            return null;
-        if (!Array.isArray(parsed.exports))
-            return null;
-        if (typeof parsed.kind !== 'string' || typeof parsed.renderer !== 'string') {
-            return null;
-        }
-        if (!ALLOWED_KINDS.has(parsed.kind))
-            return null;
-        if (!ALLOWED_RENDERERS.has(parsed.renderer))
-            return null;
-        if (parsed.status !== undefined && !ALLOWED_STATUS.has(parsed.status)) {
-            return null;
-        }
-        if (parsed.exports.length === 0)
-            return null;
-        if (parsed.exports.some((value) => !ALLOWED_EXPORTS.has(value)))
-            return null;
-        return {
-            version: MANIFEST_VERSION,
-            kind: parsed.kind,
-            title: parsed.title,
-            entry: parsed.entry,
-            renderer: parsed.renderer,
-            status: ALLOWED_STATUS.has(parsed.status) ? parsed.status : 'complete',
-            exports: parsed.exports,
-            primary: parsed.primary === true || typeof parsed.primary === 'string' ? parsed.primary : undefined,
-            supportingFiles: Array.isArray(parsed.supportingFiles) ? parsed.supportingFiles.filter((x) => typeof x === 'string') : undefined,
-            createdAt: typeof parsed.createdAt === 'string' ? parsed.createdAt : undefined,
-            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : undefined,
-            sourceSkillId: typeof parsed.sourceSkillId === 'string' ? parsed.sourceSkillId : undefined,
-            designSystemId: typeof parsed.designSystemId === 'string' || parsed.designSystemId === null ? parsed.designSystemId : undefined,
-            metadata: parsed.metadata && typeof parsed.metadata === 'object' && !Array.isArray(parsed.metadata) ? parsed.metadata : undefined,
-        };
+        parsed = JSON.parse(raw);
     }
     catch {
         return null;
     }
+    if (!hasRequiredManifestFields(parsed) || !hasKnownManifestValues(parsed))
+        return null;
+    return {
+        version: MANIFEST_VERSION,
+        kind: parsed.kind,
+        title: parsed.title,
+        entry: parsed.entry,
+        renderer: parsed.renderer,
+        status: parsed.status ?? 'complete',
+        exports: parsed.exports,
+        ...optionalManifestFields(parsed),
+    };
+}
+/** The optional manifest fields, each kept only when it has its documented type (anything else is dropped, not rejected). */
+function optionalManifestFields(parsed) {
+    return {
+        primary: parsed.primary === true || typeof parsed.primary === 'string' ? parsed.primary : undefined,
+        supportingFiles: Array.isArray(parsed.supportingFiles) ? parsed.supportingFiles.filter(isString) : undefined,
+        createdAt: stringOrUndefined(parsed.createdAt),
+        updatedAt: stringOrUndefined(parsed.updatedAt),
+        sourceSkillId: stringOrUndefined(parsed.sourceSkillId),
+        designSystemId: parsed.designSystemId === null ? null : stringOrUndefined(parsed.designSystemId),
+        metadata: parsed.metadata && typeof parsed.metadata === 'object' && !Array.isArray(parsed.metadata) ? parsed.metadata : undefined,
+    };
+}
+function hasRequiredManifestFields(parsed) {
+    if (parsed?.version !== MANIFEST_VERSION)
+        return false;
+    if (!isNonEmptyString(parsed.entry) || !isNonEmptyString(parsed.title))
+        return false;
+    return Array.isArray(parsed.exports) && isString(parsed.kind) && isString(parsed.renderer);
+}
+function hasKnownManifestValues(parsed) {
+    if (!ALLOWED_KINDS.has(parsed.kind))
+        return false;
+    if (!ALLOWED_RENDERERS.has(parsed.renderer))
+        return false;
+    if (parsed.status !== undefined && !ALLOWED_STATUS.has(parsed.status))
+        return false;
+    return parsed.exports.length > 0 && parsed.exports.every((value) => ALLOWED_EXPORTS.has(value));
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNonEmptyString(value) {
+    return isString(value) && value !== '';
+}
+function stringOrUndefined(value) {
+    return isString(value) ? value : undefined;
 }
 /**
  * Infer a manifest for a legacy artifact file that predates manifest
@@ -141,31 +147,20 @@ export function parseArtifactManifest({ raw }) {
  * @returns `null` when the extension isn't a recognized artifact kind.
  */
 export function inferLegacyManifest(input) {
-    const kind = inferKindFromEntry(input.entry);
+    const kind = LEGACY_KIND_BY_EXT.get(normalizeExt(input.entry));
     if (!kind)
         return null;
-    const lowerEntry = input.entry.toLowerCase();
-    const isDeck = kind === 'html' && (lowerEntry.includes('deck') || lowerEntry.includes('slides') || lowerEntry.includes('pitch'));
-    const renderer = isDeck
-        ? 'deck-html'
-        : kind === 'html'
-            ? 'html'
-            : kind === 'markdown-document'
-                ? 'markdown'
-                : kind === 'react-component'
-                    ? 'react-component'
-                    : kind === 'code-snippet'
-                        ? 'code'
-                        : kind; // only 'svg' remains — a valid ArtifactRendererId as-is
+    const isDeck = kind === 'html' && /deck|slides|pitch/.test(input.entry.toLowerCase());
     const resolvedKind = isDeck ? 'deck' : kind;
+    const info = LEGACY_KIND_INFO[resolvedKind];
     return {
         version: MANIFEST_VERSION,
         kind: resolvedKind,
         title: input.title || input.entry,
         entry: input.entry,
-        renderer,
+        renderer: info.renderer,
         status: 'complete',
-        exports: exportsForKind(resolvedKind),
+        exports: [...info.exports],
         primary: resolvedKind === 'html' || resolvedKind === 'deck' ? true : undefined,
         metadata: input.metadata,
     };

package/dist/core/util/markdown-context.js

@@ -53,66 +53,64 @@ export function isRealArtifactOpenAt({ content, idx }) {
  *   backtick scan per accumulated paragraph block.
  */
 export function computeSkipRanges({ buffer }) {
-    const ranges = [];
-    // Paragraph-block regions are contiguous spans of paragraph lines outside
-    // any fenced code block; inline-code scanning is restricted to one block at
-    // a time so backticks never pair across a block boundary.
-    const blockRegions = [];
+    const scan = { ranges: [], blockRegions: [], fenceStart: -1, blockStart: -1 };
+    for (const line of linesOf(buffer)) {
+        if (scan.fenceStart === -1)
+            visitLineOutsideFence(scan, line);
+        else
+            visitLineInsideFence(scan, line);
+    }
+    const unclosedFenceStart = scan.fenceStart === -1 ? null : scan.fenceStart;
+    if (unclosedFenceStart === null)
+        closeBlockBefore(scan, buffer.length); // flush an open paragraph region at end-of-buffer
+    for (const [s, e] of scan.blockRegions) {
+        for (const m of buffer.slice(s, e).matchAll(INLINE_CODE_RE)) {
+            scan.ranges.push([s + m.index, s + m.index + m[0].length]);
+        }
+    }
+    return { ranges: scan.ranges, unclosedFenceStart };
+}
+function* linesOf(buffer) {
     let pos = 0;
-    let inFence = false;
-    let fenceStart = -1;
-    let blockStart = -1;
-    const closeBlockBefore = (idx) => {
-        if (blockStart !== -1 && idx > blockStart)
-            blockRegions.push([blockStart, idx]);
-        blockStart = -1;
-    };
     while (pos < buffer.length) {
         const eol = buffer.indexOf('\n', pos);
-        const lineEnd = eol === -1 ? buffer.length : eol;
-        const line = buffer.slice(pos, lineEnd);
-        const lineHasNewline = eol !== -1;
-        if (!inFence) {
-            if (lineHasNewline && FENCE_OPEN_RE.test(line)) {
-                closeBlockBefore(pos);
-                inFence = true;
-                fenceStart = pos;
-            }
-            else if (line.trim() === '') {
-                closeBlockBefore(pos);
-            }
-            else if (HEADING_RE.test(line) || UL_ITEM_RE.test(line) || OL_ITEM_RE.test(line)) {
-                // Each heading/list-item line is its own inline-scan region rather
-                // than joining adjacent paragraphs.
-                closeBlockBefore(pos);
-                blockRegions.push([pos, lineEnd]);
-            }
-            else {
-                if (blockStart === -1)
-                    blockStart = pos;
-            }
-        }
-        else if (lineHasNewline && FENCE_CLOSE_RE.test(line)) {
-            inFence = false;
-            ranges.push([fenceStart, eol + 1]);
-            fenceStart = -1;
+        if (eol === -1) {
+            // trailing partial line — classified like any other, but never as a fence delimiter
+            yield { start: pos, end: buffer.length, text: buffer.slice(pos), hasNewline: false };
+            return;
         }
-        if (!lineHasNewline)
-            break; // trailing partial line — already accounted for above
+        yield { start: pos, end: eol, text: buffer.slice(pos, eol), hasNewline: true };
         pos = eol + 1;
     }
-    if (!inFence)
-        closeBlockBefore(buffer.length); // flush an open paragraph region at end-of-buffer
-    for (const [s, e] of blockRegions) {
-        INLINE_CODE_RE.lastIndex = 0;
-        const segment = buffer.slice(s, e);
-        let m = INLINE_CODE_RE.exec(segment);
-        while (m !== null) {
-            ranges.push([s + m.index, s + m.index + m[0].length]);
-            m = INLINE_CODE_RE.exec(segment);
-        }
+}
+function closeBlockBefore(scan, idx) {
+    if (scan.blockStart !== -1 && idx > scan.blockStart)
+        scan.blockRegions.push([scan.blockStart, idx]);
+    scan.blockStart = -1;
+}
+function visitLineInsideFence(scan, line) {
+    if (!line.hasNewline || !FENCE_CLOSE_RE.test(line.text))
+        return;
+    scan.ranges.push([scan.fenceStart, line.end + 1]);
+    scan.fenceStart = -1;
+}
+function visitLineOutsideFence(scan, line) {
+    if (line.hasNewline && FENCE_OPEN_RE.test(line.text)) {
+        closeBlockBefore(scan, line.start);
+        scan.fenceStart = line.start;
+    }
+    else if (line.text.trim() === '') {
+        closeBlockBefore(scan, line.start);
+    }
+    else if (HEADING_RE.test(line.text) || UL_ITEM_RE.test(line.text) || OL_ITEM_RE.test(line.text)) {
+        // Each heading/list-item line is its own inline-scan region rather
+        // than joining adjacent paragraphs.
+        closeBlockBefore(scan, line.start);
+        scan.blockRegions.push([line.start, line.end]);
+    }
+    else if (scan.blockStart === -1) {
+        scan.blockStart = line.start;
     }
-    return { ranges, unclosedFenceStart: inFence ? fenceStart : null };
 }
 /** `true` when position `p` falls inside one of `ranges` (half-open intervals). */
 export function rangeContains({ ranges, p }) {