@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/usageAnalytics.js

@@ -0,0 +1,311 @@
+export const USAGE_SENTENCES = Object.freeze({
+    analyticsUnavailable: 'Usage analytics aren’t available on this backend.',
+    analyticsUnread: 'Usage analytics couldn’t be read just now.',
+    modelsUnavailable: "Per-model usage breakdown isn't available on this backend.",
+    modelsUnread: 'Per-model usage breakdown couldn’t be read just now.',
+});
+const _sdkClientIsAnInjection = [true];
+void _sdkClientIsAnInjection;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const nonNeg = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+export function classifyUsageFailure(e) {
+    let code;
+    let status;
+    try {
+        const o = e;
+        const rawCode = o?.errorCode;
+        const rawStatus = o?.status;
+        code = typeof rawCode === 'string' ? rawCode : undefined;
+        status = typeof rawStatus === 'number' ? rawStatus : undefined;
+    }
+    catch {
+        return { kind: 'failed', error: e };
+    }
+    if (code !== undefined) {
+        if (code.startsWith('capability.'))
+            return { kind: 'unavailable', why: 'capability' };
+        if (code.startsWith('feature.'))
+            return { kind: 'unavailable', why: 'feature' };
+        if (code === 'not_found.route')
+            return { kind: 'unavailable', why: 'route' };
+        return { kind: 'failed', error: e };
+    }
+    if (status === 501)
+        return { kind: 'unavailable', why: 'capability' };
+    return { kind: 'failed', error: e };
+}
+function windowOf(o) {
+    const w = { truncated: o.truncated === true };
+    if (nonEmpty(o.from))
+        w.from = o.from;
+    if (nonEmpty(o.to))
+        w.to = o.to;
+    return w;
+}
+const precisionOf = (estimated) => (estimated === false ? 'exact' : 'estimated');
+const TOTAL_FIELDS = ['tasks', 'tokensIn', 'tokensOut', 'cost'];
+const TOTAL_WIRE_KEYS = Object.freeze({ tasks: 'tasks', tokensIn: 'tokensIn', tokensOut: 'tokensOut', cost: 'costUsd' });
+function totalsOf(o) {
+    const t = { precision: precisionOf(o.estimated) };
+    for (const field of TOTAL_FIELDS) {
+        const v = o[TOTAL_WIRE_KEYS[field]];
+        if (nonNeg(v))
+            t[field] = v;
+    }
+    return t;
+}
+export function projectUsageSummary(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        return { ...windowOf(body), ...totalsOf(body) };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectUsageSeries(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        const series = body.series;
+        if (!Array.isArray(series))
+            return undefined;
+        const points = [];
+        let unreadable = 0;
+        for (const raw of series) {
+            if (!isRecord(raw) || !nonEmpty(raw.t) || !nonNeg(raw.v)) {
+                unreadable++;
+                continue;
+            }
+            const p = { t: raw.t, v: raw.v };
+            if (typeof raw.estimated === 'boolean')
+                p.estimated = raw.estimated;
+            points.push(p);
+        }
+        return { ...windowOf(body), points, unreadable };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectUsageBreakdown(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        const breakdown = body.breakdown;
+        if (!Array.isArray(breakdown))
+            return undefined;
+        const rows = [];
+        let unreadable = 0;
+        for (const raw of breakdown) {
+            if (!isRecord(raw) || !nonEmpty(raw.key)) {
+                unreadable++;
+                continue;
+            }
+            rows.push({ key: raw.key, ...totalsOf(raw) });
+        }
+        return { ...windowOf(body), rows, unreadable };
+    }
+    catch {
+        return undefined;
+    }
+}
+function windowBag(opts) {
+    const bag = {};
+    if (opts.from !== undefined)
+        bag.from = opts.from;
+    if (opts.to !== undefined)
+        bag.to = opts.to;
+    if (opts.principal !== undefined)
+        bag.principal = opts.principal;
+    if (opts.signal !== undefined)
+        bag.signal = opts.signal;
+    return bag;
+}
+async function readOne(call, project, what) {
+    try {
+        const pending = call();
+        if (pending === undefined)
+            return { kind: 'unavailable', why: 'route' };
+        const view = project(await pending);
+        if (view === undefined)
+            return { kind: 'failed', error: new Error(`usage ${what}: malformed body`) };
+        return { kind: 'ok', value: view };
+    }
+    catch (e) {
+        return classifyUsageFailure(e);
+    }
+}
+export function readUsageSummary(client, opts = {}) {
+    return readOne(() => (typeof client?.usage?.summary === 'function' ? client.usage.summary(windowBag(opts)) : undefined), projectUsageSummary, 'summary');
+}
+export function readUsageSeries(client, opts = {}) {
+    return readOne(() => {
+        if (typeof client?.usage?.series !== 'function')
+            return undefined;
+        const bag = windowBag(opts);
+        if (opts.metric !== undefined)
+            bag.metric = opts.metric;
+        if (opts.granularity !== undefined)
+            bag.granularity = opts.granularity;
+        return client.usage.series(bag);
+    }, projectUsageSeries, 'series');
+}
+export function readUsageBreakdown(client, opts = {}) {
+    return readOne(() => {
+        if (typeof client?.usage?.breakdown !== 'function')
+            return undefined;
+        const bag = windowBag(opts);
+        if (opts.dimension !== undefined)
+            bag.dimension = opts.dimension;
+        return client.usage.breakdown(bag);
+    }, projectUsageBreakdown, 'breakdown');
+}
+export function usageBoundPrefix(bound) {
+    return bound === 'lower' ? '≥' : bound === 'approximate' ? '≈' : '';
+}
+const DAY_MS = 86_400_000;
+export const USAGE_HEATMAP_MAX_DAYS = 70;
+export function usageWindowOfRange(range, now) {
+    if (range === 'all')
+        return { from: 0, to: now };
+    const days = range === '30d' ? 30 : 7;
+    return { from: now - days * DAY_MS, to: now };
+}
+function unavailableCauseOf(v) {
+    return v.kind === 'unavailable' ? 'no_backend_face' : 'read_failed';
+}
+function modelsUnavailable(cause) {
+    return { state: 'unavailable', cause, sentence: cause === 'no_backend_face' ? USAGE_SENTENCES.modelsUnavailable : USAGE_SENTENCES.modelsUnread };
+}
+const DAY_KEY_RE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ]|$)/;
+function dayKeyOf(iso) {
+    const m = DAY_KEY_RE.exec(iso);
+    if (m === null)
+        return undefined;
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    const d = Number(m[3]);
+    const at = new Date(Date.UTC(y, mo - 1, d));
+    return at.getUTCFullYear() === y && at.getUTCMonth() === mo - 1 && at.getUTCDate() === d ? iso.slice(0, 10) : undefined;
+}
+const isWhole = (v) => v.unreadable === 0 && !v.truncated;
+function hourOfDayUtc(iso) {
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? undefined : d.getUTCHours();
+}
+function peakHourOf(points) {
+    if (points.length === 0)
+        return undefined;
+    const perHour = new Array(24).fill(0);
+    for (const p of points) {
+        const h = hourOfDayUtc(p.t);
+        if (h === undefined)
+            return undefined;
+        perHour[h] = (perHour[h] ?? 0) + p.v;
+    }
+    let peakHour = -1;
+    let peakValue = -1;
+    perHour.forEach((value, h) => {
+        if (value > peakValue) {
+            peakValue = value;
+            peakHour = h;
+        }
+    });
+    return peakHour >= 0 && peakValue > 0 ? peakHour : undefined;
+}
+function heatmapOf(window, dayValues) {
+    if (!Number.isFinite(window.from) || !Number.isFinite(window.to))
+        return null;
+    const windowDays = Math.max(1, Math.round((window.to - window.from) / DAY_MS) + 1);
+    const days = Math.min(windowDays, USAGE_HEATMAP_MAX_DAYS);
+    const cells = [];
+    for (let i = days - 1; i >= 0; i--) {
+        const at = new Date(window.to - i * DAY_MS);
+        if (Number.isNaN(at.getTime()))
+            return null;
+        const key = at.toISOString().slice(0, 10);
+        cells.push({ date: key, tasks: dayValues.get(key) ?? 0 });
+    }
+    return cells;
+}
+export function projectUsageAnalytics(inputs, window) {
+    const s = inputs.summary;
+    if (s.kind !== 'ok') {
+        const cause = unavailableCauseOf(s);
+        return {
+            state: 'unavailable',
+            cause,
+            sentence: cause === 'no_backend_face' ? USAGE_SENTENCES.analyticsUnavailable : USAGE_SENTENCES.analyticsUnread,
+            models: modelsUnavailable(cause),
+        };
+    }
+    const sv = s.value;
+    const readings = {
+        state: sv.precision === 'estimated' ? 'estimated' : 'available',
+        truncated: sv.truncated,
+        heatmap: null,
+        models: modelsUnavailable('read_failed'),
+    };
+    if (sv.tasks !== undefined)
+        readings.runs = sv.tasks;
+    const exact = sv.precision === 'exact';
+    if (sv.tokensIn !== undefined && sv.tokensOut !== undefined) {
+        readings.tokens = { value: sv.tokensIn + sv.tokensOut, bound: !exact ? 'approximate' : sv.truncated ? 'lower' : 'exact' };
+    }
+    if (sv.cost !== undefined)
+        readings.cost = { value: sv.cost, bound: exact && !sv.truncated ? 'exact' : 'lower' };
+    const day = inputs.daySeries;
+    if (day.kind === 'ok' && isWhole(day.value)) {
+        const dayValues = new Map();
+        let allKeysReadable = true;
+        for (const p of day.value.points) {
+            const key = dayKeyOf(p.t);
+            if (key === undefined)
+                allKeysReadable = false;
+            else
+                dayValues.set(key, (dayValues.get(key) ?? 0) + p.v);
+        }
+        if (allKeysReadable) {
+            readings.activeDays = [...dayValues.values()].filter((v) => v > 0).length;
+            readings.heatmap = heatmapOf(window, dayValues);
+        }
+    }
+    const hour = inputs.hourSeries;
+    if (hour.kind === 'ok' && isWhole(hour.value)) {
+        const peak = peakHourOf(hour.value.points);
+        if (peak !== undefined)
+            readings.peakHourUtc = peak;
+    }
+    const br = inputs.modelBreakdown;
+    if (br.kind === 'ok') {
+        readings.models = { state: 'available', rows: br.value.rows, unreadable: br.value.unreadable };
+        if (isWhole(br.value)) {
+            let favorite;
+            for (const row of br.value.rows) {
+                if (row.tasks === undefined)
+                    continue;
+                if (favorite === undefined || row.tasks > (favorite.tasks ?? -1))
+                    favorite = row;
+            }
+            if (favorite !== undefined)
+                readings.favoriteModel = favorite.key;
+        }
+    }
+    else {
+        readings.models = modelsUnavailable(unavailableCauseOf(br));
+    }
+    return readings;
+}
+export async function readUsageAnalytics(client, window, opts = {}) {
+    const base = { from: window.from, to: window.to, ...(opts.signal ? { signal: opts.signal } : {}) };
+    const [summary, daySeries, hourSeries, modelBreakdown] = await Promise.all([
+        readUsageSummary(client, base),
+        readUsageSeries(client, { ...base, metric: 'tasks', granularity: 'day' }),
+        readUsageSeries(client, { ...base, metric: 'tasks', granularity: 'hour' }),
+        readUsageBreakdown(client, { ...base, dimension: 'model' }),
+    ]);
+    return projectUsageAnalytics({ summary, daySeries, hourSeries, modelBreakdown }, window);
+}

package/dist/userAttachmentEnvelope.d.ts

@@ -1,6 +1,13 @@
 import { type DescriptorView } from './humanTurnRead.js';
 export type UserAttachmentSource = 'at-mention' | 'compact-restore';
-export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied';
+export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed';
+export type UserAttachmentMcpResourcePart = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'binary';
+    readonly mimeType: string | null;
+};
 export interface UserAttachmentNotebookCell {
     readonly cellType?: string;
     readonly source?: string;
@@ -54,6 +61,20 @@ export type UserAttachmentDescriptor = {
     readonly path: string;
     readonly sizeBytes: number | null;
     readonly reason: UserAttachmentNotIncludedReason;
+} | {
+    readonly kind: 'not-included';
+    readonly target: 'mcp-resource';
+    readonly server: string;
+    readonly uri: string;
+    readonly name: string;
+    readonly reason: UserAttachmentNotIncludedReason;
+} | {
+    readonly kind: 'mcp-resource';
+    readonly server: string;
+    readonly uri: string;
+    readonly name: string;
+    readonly parts: readonly UserAttachmentMcpResourcePart[];
+    readonly truncated: boolean;
 };
 export declare function showAttachmentName(s: string): string;
 export declare function mintEnvelopeOf(d: DescriptorView, imageDelivery: 'attached' | 'not-attached'): string;

package/dist/userAttachmentEnvelope.js

@@ -162,16 +162,93 @@ const NOT_INCLUDED_REASON = Object.freeze({
     'too-large': "it is larger than the client's size limit for attaching files",
     unreadable: 'the client could not read it',
     'read-denied': "the user's permission rules do not allow reading it",
+    'approval-required': "this deployment's rules require approval before it is read, so the client did not attach it without asking",
+    'server-not-connected': 'the MCP server it comes from is not connected',
+    'resource-not-listed': 'the MCP server does not list that resource',
+    'read-failed': 'reading it from the MCP server failed',
 });
 function targetWhat(target) {
     return target === 'directory' ? 'a directory' : target === 'file' ? 'a file' : 'a file or directory';
 }
+function mcpWhere(server, uri) {
+    return `Server: ${showAttachmentName(server)}. URI: ${showAttachmentName(uri)}`;
+}
+function mintMcpResource(d) {
+    const l1 = firstLine('at-mention', 'an MCP resource', d.name);
+    const texts = d.parts.flatMap((p) => (p.kind === 'text' ? [p.text] : []));
+    const binaries = d.parts.flatMap((p) => (p.kind === 'binary' ? [p.mimeType] : []));
+    const typed = [...new Set(binaries.filter((t) => t !== null))];
+    const binaryNote = binaries.length > 0
+        ? `${plural(binaries.length, 'binary part', 'binary parts')}${typed.length > 0 ? ` (${typed.map(showAttachmentName).join(', ')})` : ''} ${binaries.length === 1 ? 'is' : 'are'} not included.`
+        : null;
+    const truncNote = d.truncated ? 'The client shortened the text; the rest is not included.' : null;
+    if (texts.length === 0) {
+        return [`${l1}\n${mcpWhere(d.server, d.uri)} (no text parts). The client read it from that server; it has no text to include.`, binaryNote, truncNote].filter((s) => s !== null).join(' ');
+    }
+    let anyEscaped = false;
+    const body = texts
+        .join('\n')
+        .split('\n')
+        .map((line, i) => {
+        const shown = showBodyLine(line);
+        if (shown.escaped)
+            anyEscaped = true;
+        return `${i + 1}\t${shown.text}`;
+    });
+    const head = [
+        l1,
+        `${mcpWhere(d.server, d.uri)} (${plural(texts.length, 'text part', 'text parts')}). The client read it from that server and copied the text between the two fence lines below. ${dataNote('at-mention', "the resource's contents")}`,
+    ];
+    if (binaryNote !== null)
+        head.push(binaryNote);
+    if (truncNote !== null)
+        head.push(truncNote);
+    if (anyEscaped)
+        head.push(ESCAPE_NOTE);
+    return fenced(head, body);
+}
 function mintNotIncluded(d) {
+    if (d.target === 'mcp-resource') {
+        return `${firstLine('at-mention', 'an MCP resource', d.name)}\n${mcpWhere(d.server, d.uri)}. It is not included in this message: ${NOT_INCLUDED_REASON[d.reason]}.`;
+    }
     const size = sizePart(d.sizeBytes);
     return (`${firstLine('at-mention', targetWhat(d.target), d.name)}\n` +
         `Full path: ${showAttachmentName(d.path)}${size !== null ? ` (${size})` : ''}. It is not included in this message: ${NOT_INCLUDED_REASON[d.reason]}.`);
 }
-export function mintEnvelopeOf(d, imageDelivery) {
+const TAG_OPEN = '<attachment';
+const TAG_CLOSE = '</attachment>';
+function attributeValue(s) {
+    let out = '';
+    for (const c of s) {
+        switch (c) {
+            case '&':
+                out += '&amp;';
+                break;
+            case '"':
+                out += '&quot;';
+                break;
+            case '<':
+                out += '&lt;';
+                break;
+            case '>':
+                out += '&gt;';
+                break;
+            default:
+                out += c;
+        }
+    }
+    return out;
+}
+function pathOf(d) {
+    if (d.kind === 'mcp-resource' || (d.kind === 'not-included' && d.target === 'mcp-resource'))
+        return undefined;
+    return d.path;
+}
+function tagAttributes(d) {
+    const path = pathOf(d);
+    return path === undefined ? '' : ` path="${attributeValue(showAttachmentName(path))}"`;
+}
+function envelopeInner(d, imageDelivery) {
     switch (d.kind) {
         case 'text':
             return mintText(d);
@@ -185,10 +262,18 @@ export function mintEnvelopeOf(d, imageDelivery) {
             return mintDirectory(d);
         case 'not-included':
             return mintNotIncluded(d);
+        case 'mcp-resource':
+            return mintMcpResource(d);
     }
 }
-export function mintReferenceOf(d) {
+export function mintEnvelopeOf(d, imageDelivery) {
+    return `${TAG_OPEN}${tagAttributes(d)}>\n${envelopeInner(d, imageDelivery)}\n${TAG_CLOSE}`;
+}
+function referenceSentence(d) {
     const name = showAttachmentName(d.name);
+    if (d.kind === 'mcp-resource' || (d.kind === 'not-included' && d.target === 'mcp-resource')) {
+        return `The user mentioned the MCP resource ${name} (${showAttachmentName(d.uri)} on the server ${showAttachmentName(d.server)}) in this message; its contents are not included here.`;
+    }
     const path = showAttachmentName(d.path);
     const what = d.kind === 'directory' ? 'directory' : d.kind === 'not-included' ? targetWhat(d.target).replace(/^an? /, '') : 'file';
     if (d.kind !== 'directory' && d.kind !== 'not-included' && d.source === 'compact-restore') {
@@ -196,6 +281,9 @@ export function mintReferenceOf(d) {
     }
     return `The user mentioned the ${what} ${name} (${path}) in this message; its contents are not included here.`;
 }
+export function mintReferenceOf(d) {
+    return `${TAG_OPEN}${tagAttributes(d)} />\n${referenceSentence(d)}`;
+}
 export function mintUserAttachmentEnvelope(descriptor) {
     const d = readDescriptor(descriptor, 'required');
     if (d === undefined)

package/dist/userInvokedSkillsCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForUserInvokedSkills(baseUrl: string, caps
 export declare function observedUserInvokedSkills(baseUrl?: string | undefined): UserInvokedSkillsReading;
 export declare function userInvokedSkillsAvailable(reading: UserInvokedSkillsReading): 'yes' | 'no' | 'unknown';
 export declare function userInvokedSkillsDoctorDetail(reading: UserInvokedSkillsReading): string;
-export declare function forgetUserInvokedSkillsReading(baseUrl: string | undefined): void;
 export declare function __resetUserInvokedSkillsReadingsForTests(): void;

package/dist/userInvokedSkillsCapability.js

@@ -1,16 +1,20 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectUserInvokedSkillsCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'userInvokedSkills'))
-        return { kind: 'not_reported' };
-    const v = caps.userInvokedSkills;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'userInvokedSkills');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'userInvokedSkills',
@@ -42,9 +46,6 @@ export function userInvokedSkillsDoctorDetail(reading) {
             return 'user-invoked skills on — skills the user names on a request take effect when the run starts';
     }
 }
-export function forgetUserInvokedSkillsReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetUserInvokedSkillsReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/webSearchBackendCapability.d.ts

@@ -18,5 +18,4 @@ export declare function noteEngineCapsForWebSearchBackend(baseUrl: string, caps:
 }): void;
 export declare function observedWebSearchBackend(baseUrl?: string | undefined): WebSearchBackendReading;
 export declare function webSearchBackendDoctorDetail(reading: WebSearchBackendReading): string;
-export declare function forgetWebSearchBackendReading(baseUrl: string | undefined): void;
 export declare function __resetWebSearchBackendReadingsForTests(): void;

package/dist/webSearchBackendCapability.js

@@ -1,25 +1,29 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export const WEB_SEARCH_BACKEND_NONE = 'none';
 export function projectWebSearchBackendCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'webSearch'))
-        return { kind: 'not_reported' };
-    const ws = caps.webSearch;
-    if (ws === undefined)
-        return { kind: 'not_reported' };
-    if (ws === null || typeof ws !== 'object' || Array.isArray(ws))
-        return undefined;
-    const backend = ws.backend;
-    if (typeof backend !== 'string' || backend === '')
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const ws = ownDataField(caps, 'webSearch');
+        if (ws === undefined)
+            return { kind: 'not_reported' };
+        if (ws === null || typeof ws !== 'object' || Array.isArray(ws))
+            return undefined;
+        const backend = ownDataField(ws, 'backend');
+        if (typeof backend !== 'string' || backend === '')
+            return undefined;
+        if (backend === WEB_SEARCH_BACKEND_NONE)
+            return { kind: 'none' };
+        return { kind: 'present', view: { backend } };
+    }
+    catch {
         return undefined;
-    if (backend === WEB_SEARCH_BACKEND_NONE)
-        return { kind: 'none' };
-    return { kind: 'present', view: { backend } };
+    }
 }
 const reader = createEngineCapReader({
     name: 'webSearch.backend',
@@ -51,9 +55,6 @@ export function webSearchBackendDoctorDetail(reading) {
                 '(per-request overrides are not echoed here)');
     }
 }
-export function forgetWebSearchBackendReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetWebSearchBackendReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/webSearchWireCaps.js

@@ -1,3 +1,4 @@
+import { SETTINGS_IS_HIERARCHICAL_URL } from './generated/settingsSchemaFns.js';
 import { hostEnv } from './hostEnv.js';
 export const WEBSEARCH_ENV = {
     provider: 'SEMA_WEBSEARCH_PROVIDER',
@@ -6,15 +7,6 @@ export const WEBSEARCH_ENV = {
     maxResults: 'SEMA_WEBSEARCH_MAX_RESULTS',
 };
 const isBlankText = (v) => v.trim() === '';
-function isHierarchicalUrl(raw) {
-    try {
-        const u = new URL(raw);
-        return u.href.startsWith(u.protocol + '//');
-    }
-    catch {
-        return false;
-    }
-}
 function judgeProvider(raw) {
     const word = typeof raw === 'string' ? raw.trim().toLowerCase() : undefined;
     if (word === 'brave' || word === 'tavily' || word === 'searxng')
@@ -71,7 +63,7 @@ function judgeEndpoint(raw) {
         return { ok: false, issue: ENDPOINT_ISSUE };
     if (isBlankText(raw))
         return { ok: true, value: undefined };
-    if (!isHierarchicalUrl(raw))
+    if (!SETTINGS_IS_HIERARCHICAL_URL(raw))
         return { ok: false, issue: ENDPOINT_ISSUE };
     const u = new URL(raw);
     return u.username !== '' || u.password !== ''
@@ -236,7 +228,7 @@ export function webSearchVerdictMessage(verdict, context = 'submit') {
         : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.`;
 }
 export function webSearchEndpointForDisplay(raw) {
-    if (typeof raw !== 'string' || !isHierarchicalUrl(raw))
+    if (typeof raw !== 'string' || !SETTINGS_IS_HIERARCHICAL_URL(raw))
         return undefined;
     try {
         const u = new URL(raw);

package/dist/wireErrorTriage.d.ts

@@ -28,6 +28,17 @@ export declare function drainingRetryDelayMs(err: unknown, attempt: number, opts
     ladder?: readonly number[];
     retryAfterCapMs?: number;
 }): number;
+export declare function isInStreamDrainingEnd(frame: unknown): boolean;
+export declare const STREAM_DRAINING_RECONNECT_MAX = 3;
+export type StreamDrainingGiveUp = 'not_draining_end' | 'attempts_exhausted';
+export type StreamDrainingDecision = {
+    readonly reconnectAfterMs: number;
+} | {
+    readonly giveUp: StreamDrainingGiveUp;
+};
+export declare function streamDrainingDecision(frame: unknown, attempt: number, opts?: {
+    ladder?: readonly number[];
+}): StreamDrainingDecision;
 export interface ScenarioDenyDetail {
     allowlist: string[];
 }