@sema-agent/client-core 0.86.0 → 0.87.0

package/dist/toolHistoryMismatch.js

@@ -0,0 +1,425 @@
+export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
+    'tool_use_without_result',
+    'orphan_tool_result',
+    'duplicate_tool_use_id',
+]);
+const ID_AFTER_COLON = /^:\s*([^\s,;]+)/;
+export const TOOL_HISTORY_MISMATCH_ANCHORS = Object.freeze([
+    Object.freeze({
+        kind: 'tool_use_without_result',
+        template: /^`?tool_use`? ids were found without `?tool_result`? blocks immediately after\b/,
+        idAfter: ID_AFTER_COLON,
+    }),
+    Object.freeze({
+        kind: 'orphan_tool_result',
+        template: /^unexpected `?tool_use_id`? found in `?tool_result`?(?: blocks?)?(?=[\s:,.]|$)/,
+        idAfter: ID_AFTER_COLON,
+    }),
+    Object.freeze({
+        kind: 'duplicate_tool_use_id',
+        template: /^`?tool_use`? ids must be unique\b/,
+        idAfter: null,
+    }),
+]);
+const ENGINE_HTTP_400_LEAD = /^(?:\[invalid_request\]\s*)?[^\n:]{0,60}?\bHTTP 400:\s*/;
+const MESSAGES_LOCATOR = /^messages(?:\.[A-Za-z0-9_]+)+\s*:\s*/;
+const PROVIDER_REJECTED_REQUEST_CODE = 'invalid_request';
+function idOfToken(after, idAfter, endIsBoundary) {
+    const hit = idAfter.exec(after);
+    if (hit === null || hit[1] === undefined)
+        return undefined;
+    if (hit[0].length >= after.length && !endIsBoundary)
+        return undefined;
+    const next = after[hit[0].length];
+    let id = hit[1];
+    if (next !== ',' && next !== ';') {
+        if (id.endsWith('.'))
+            id = id.slice(0, -1);
+        if (id.endsWith('.') || id.endsWith(':'))
+            return undefined;
+    }
+    return ROW_KEY_ID.test(id) ? id : undefined;
+}
+function matchAnchoredSentence(sentence, endIsBoundary) {
+    const rest = sentence.replace(MESSAGES_LOCATOR, '');
+    for (const anchor of TOOL_HISTORY_MISMATCH_ANCHORS) {
+        const hit = anchor.template.exec(rest);
+        if (hit === null)
+            continue;
+        if (anchor.idAfter === null)
+            return { kind: anchor.kind };
+        const id = idOfToken(rest.slice(hit[0].length), anchor.idAfter, endIsBoundary);
+        return id !== undefined ? { kind: anchor.kind, toolUseId: id } : { kind: anchor.kind };
+    }
+    return null;
+}
+function envelopeMessages(body) {
+    const out = [];
+    const n = body.length;
+    let i = 0;
+    const skipWs = () => {
+        while (i < n && (body[i] === ' ' || body[i] === '\t' || body[i] === '\n' || body[i] === '\r'))
+            i++;
+    };
+    const readString = () => {
+        i++;
+        let text = '';
+        while (i < n) {
+            const c = body[i];
+            if (c === '"') {
+                i++;
+                return { text, closed: true };
+            }
+            if (c === '\\') {
+                const e = body[i + 1];
+                if (e === undefined) {
+                    i = n;
+                    break;
+                }
+                if (e === 'u') {
+                    const hex = body.slice(i + 2, i + 6);
+                    if (!/^[0-9A-Fa-f]{4}$/.test(hex)) {
+                        i = n;
+                        break;
+                    }
+                    text += String.fromCharCode(parseInt(hex, 16));
+                    i += 6;
+                    continue;
+                }
+                text += e === 'n' ? '\n' : e === 't' ? '\t' : e === 'r' ? '\r' : e === 'b' ? '\b' : e === 'f' ? '\f' : e;
+                i += 2;
+                continue;
+            }
+            text += c;
+            i++;
+        }
+        return { text, closed: false };
+    };
+    skipWs();
+    if (body[i] !== '{')
+        return out;
+    const path = [];
+    const want = [];
+    const onEnvelopePath = () => (path.length === 1 && path[0] === 'message') || (path.length === 2 && path[0] === 'error' && path[1] === 'message');
+    i++;
+    path.push(undefined);
+    want.push('key');
+    while (i < n && path.length > 0 && out.length < 4) {
+        skipWs();
+        if (i >= n)
+            break;
+        const c = body[i];
+        const top = want.length - 1;
+        const state = want[top];
+        const inArray = path[top] === null;
+        if (state === 'key') {
+            if (c === '}') {
+                i++;
+                path.pop();
+                want.pop();
+                if (want.length > 0)
+                    want[want.length - 1] = 'next';
+                continue;
+            }
+            if (c !== '"')
+                break;
+            const key = readString();
+            if (!key.closed)
+                break;
+            path[top] = key.text;
+            want[top] = 'colon';
+            continue;
+        }
+        if (state === 'colon') {
+            if (c !== ':')
+                break;
+            i++;
+            want[top] = 'value';
+            continue;
+        }
+        if (state === 'next') {
+            if (c === ',') {
+                i++;
+                want[top] = inArray ? 'value' : 'key';
+                continue;
+            }
+            if (c === (inArray ? ']' : '}')) {
+                i++;
+                path.pop();
+                want.pop();
+                if (want.length > 0)
+                    want[want.length - 1] = 'next';
+                continue;
+            }
+            break;
+        }
+        if (inArray && c === ']') {
+            i++;
+            path.pop();
+            want.pop();
+            if (want.length > 0)
+                want[want.length - 1] = 'next';
+            continue;
+        }
+        if (c === '"') {
+            const value = readString();
+            if (!path.includes(null) && onEnvelopePath())
+                out.push(value);
+            want[top] = 'next';
+            continue;
+        }
+        if (c === '{' || c === '[') {
+            i++;
+            want[top] = 'next';
+            path.push(c === '{' ? undefined : null);
+            want.push(c === '{' ? 'key' : 'value');
+            continue;
+        }
+        const lit = /^(?:true|false|null|-?[0-9][0-9.eE+-]*)/.exec(body.slice(i, i + 64));
+        if (lit === null)
+            break;
+        i += lit[0].length;
+        want[top] = 'next';
+    }
+    return out;
+}
+export function classifyToolHistoryMismatch(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    let status;
+    let rawMessage;
+    try {
+        code = err.code;
+        status = err.status;
+        rawMessage = err.message;
+    }
+    catch {
+        return null;
+    }
+    if (typeof rawMessage !== 'string' || rawMessage.length === 0)
+        return null;
+    if (typeof status === 'number' && status !== 400)
+        return null;
+    if (typeof code === 'string' && code.length > 0 && code !== PROVIDER_REJECTED_REQUEST_CODE)
+        return null;
+    let detail = rawMessage.trimStart();
+    const lead = ENGINE_HTTP_400_LEAD.exec(detail);
+    if (lead !== null)
+        detail = detail.slice(lead[0].length);
+    else if (status !== 400)
+        return null;
+    const body = detail.replace(/^400\s+/, '');
+    const direct = matchAnchoredSentence(body, false);
+    if (direct !== null)
+        return direct;
+    for (const value of envelopeMessages(body)) {
+        const hit = matchAnchoredSentence(value.text, value.closed);
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}
+export const TOOL_HISTORY_REWIND_SENTENCE = 'Run /rewind to recover the conversation.';
+export function toolHistoryRepeatSentence(n) {
+    return `The same error has now happened ${n} times in a row; /rewind is the only way to recover this conversation.`;
+}
+let conversationRewindJudge;
+export function _wireConversationRewindJudge(judge) {
+    conversationRewindJudge = judge;
+}
+export function toolHistoryRewindOffered(declared) {
+    const decl = declared;
+    if (decl === true)
+        return true;
+    if (typeof decl !== 'object' || decl === null)
+        return false;
+    try {
+        if (Array.isArray(decl))
+            return false;
+        const base = decl.engineBaseUrl;
+        const judge = conversationRewindJudge;
+        if (typeof base !== 'string' || base.length === 0 || judge === undefined)
+            return true;
+        return judge(base) !== 'unavailable';
+    }
+    catch {
+        return true;
+    }
+}
+const isKind = (v) => typeof v === 'string' && TOOL_HISTORY_MISMATCH_KINDS.includes(v);
+const ROW_KEY_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+export function toolHistoryMismatchRowKey(m, consecutive) {
+    return {
+        kind: m.kind,
+        ...(m.toolUseId !== undefined ? { toolUseId: m.toolUseId } : {}),
+        ...(consecutive !== undefined && consecutive >= 2 ? { consecutive } : {}),
+    };
+}
+export function readToolHistoryMismatchKey(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    try {
+        const got = v;
+        const kind = got.kind;
+        if (!isKind(kind))
+            return undefined;
+        const id = got.toolUseId;
+        const n = got.consecutive;
+        return {
+            kind,
+            ...(typeof id === 'string' && ROW_KEY_ID.test(id) ? { toolUseId: id } : {}),
+            ...(typeof n === 'number' && Number.isSafeInteger(n) && n >= 2 ? { consecutive: n } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export const TOOL_HISTORY_LEDGER_CAP = 64;
+const PRIOR_RUN_IDS_CAP = 16;
+const ECHOED_SESSION_IDS_CAP = TOOL_HISTORY_LEDGER_CAP * 4;
+const toolHistoryLedger = new Map();
+let toolHistoryGenerationSeq = 0;
+const echoedSessionIds = new Set();
+let unattributedTerminalSeq = 0;
+function rememberEchoedSession(sessionId) {
+    echoedSessionIds.delete(sessionId);
+    echoedSessionIds.add(sessionId);
+    while (echoedSessionIds.size > ECHOED_SESSION_IDS_CAP) {
+        const oldest = echoedSessionIds.values().next();
+        if (oldest.done === true)
+            break;
+        echoedSessionIds.delete(oldest.value);
+    }
+}
+export function openToolHistoryGeneration() {
+    toolHistoryGenerationSeq += 1;
+    return toolHistoryGenerationSeq;
+}
+const fingerprintOf = (m) => `${m.kind}\u0000${m.toolUseId ?? ''}`;
+export function noteToolHistoryTerminal(note) {
+    const { sessionId, generation, runId, replay, mismatch } = note;
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+        unattributedTerminalSeq += 1;
+        return undefined;
+    }
+    if (note.sessionEchoed === true)
+        rememberEchoedSession(sessionId);
+    else if (!echoedSessionIds.has(sessionId))
+        unattributedTerminalSeq += 1;
+    const row = toolHistoryLedger.get(sessionId);
+    const fingerprint = mismatch === null ? null : fingerprintOf(mismatch);
+    const run = !replay && typeof runId === 'string' && runId.length > 0 ? runId : undefined;
+    if (row !== undefined && generation < row.writtenGeneration) {
+        if (row.fingerprint !== fingerprint) {
+            touchLedgerRow(sessionId, {
+                fingerprint,
+                segmentRunIds: new Set(),
+                writtenGeneration: row.writtenGeneration,
+                unattributedMark: unattributedTerminalSeq,
+                lastRunId: undefined,
+                recentRunIds: run !== undefined ? [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP) : row.recentRunIds,
+            });
+        }
+        return undefined;
+    }
+    if (row !== undefined)
+        row.writtenGeneration = generation;
+    const interrupted = row !== undefined && row.unattributedMark < unattributedTerminalSeq;
+    if (run !== undefined && row !== undefined && (row.segmentRunIds.has(run) || row.recentRunIds.includes(run))) {
+        return !interrupted && row.lastRunId === run && fingerprint !== null && row.fingerprint === fingerprint ? row.segmentRunIds.size : undefined;
+    }
+    if (row !== undefined && row.fingerprint === fingerprint && !(interrupted && fingerprint !== null && run !== undefined)) {
+        if (run === undefined)
+            return undefined;
+        if (fingerprint !== null)
+            row.segmentRunIds.add(run);
+        row.lastRunId = run;
+        row.recentRunIds = [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP);
+        touchLedgerRow(sessionId, row);
+        return fingerprint === null ? undefined : row.segmentRunIds.size;
+    }
+    touchLedgerRow(sessionId, {
+        fingerprint,
+        segmentRunIds: fingerprint !== null && run !== undefined ? new Set([run]) : new Set(),
+        writtenGeneration: generation,
+        unattributedMark: unattributedTerminalSeq,
+        lastRunId: run,
+        recentRunIds: run !== undefined ? [...(row?.recentRunIds ?? []), run].slice(-PRIOR_RUN_IDS_CAP) : [...(row?.recentRunIds ?? [])],
+    });
+    return fingerprint !== null && run !== undefined ? 1 : undefined;
+}
+function touchLedgerRow(sessionId, row) {
+    toolHistoryLedger.delete(sessionId);
+    toolHistoryLedger.set(sessionId, row);
+    while (toolHistoryLedger.size > TOOL_HISTORY_LEDGER_CAP) {
+        const oldest = toolHistoryLedger.keys().next();
+        if (oldest.done === true)
+            break;
+        toolHistoryLedger.delete(oldest.value);
+    }
+}
+export function _resetToolHistoryLedgerForTest() {
+    toolHistoryLedger.clear();
+    echoedSessionIds.clear();
+}
+export const TOOL_HISTORY_UNDECIDABLE_REASONS = Object.freeze([
+    'no-mismatch',
+    'no-tool-use-id',
+    'id-not-found',
+    'prompt-not-found',
+    'prompt-without-handle',
+    'unreadable-rows',
+]);
+const listHas = (list, id) => Array.isArray(list) && list.includes(id);
+export function resolveToolHistoryRewindTarget(rows, mismatch) {
+    let kind;
+    try {
+        if (typeof mismatch !== 'object' || mismatch === null)
+            return { undecidable: 'no-mismatch' };
+        kind = mismatch.kind;
+    }
+    catch {
+        return { undecidable: 'no-mismatch' };
+    }
+    if (!isKind(kind))
+        return { undecidable: 'no-mismatch' };
+    let id;
+    try {
+        id = mismatch.toolUseId;
+    }
+    catch {
+        return { undecidable: 'no-mismatch' };
+    }
+    if (typeof id !== 'string' || id.length === 0)
+        return { undecidable: 'no-tool-use-id' };
+    try {
+        if (!Array.isArray(rows))
+            return { undecidable: 'unreadable-rows' };
+        let hit = -1;
+        for (let i = 0; i < rows.length; i++) {
+            const r = rows[i];
+            if (typeof r !== 'object' || r === null || r.local === true)
+                continue;
+            if (listHas(r.toolUseIds, id) || listHas(r.toolResultIds, id)) {
+                hit = i;
+                break;
+            }
+        }
+        if (hit < 0)
+            return { undecidable: 'id-not-found' };
+        for (let j = hit; j >= 0; j--) {
+            const r = rows[j];
+            if (typeof r !== 'object' || r === null || r.local === true || r.prompt !== true)
+                continue;
+            if (r.sessionRoot === true)
+                return { rootReopen: true };
+            return typeof r.engineHandle === 'string' && r.engineHandle.length > 0 ? { target: r } : { undecidable: 'prompt-without-handle' };
+        }
+        return { undecidable: 'prompt-not-found' };
+    }
+    catch {
+        return { undecidable: 'unreadable-rows' };
+    }
+}

package/dist/workflowClient.d.ts

@@ -1,4 +1,5 @@
 import type { WorkflowRun, WorkflowStreamEvent } from '@sema-agent/sdk';
+import { type WireAuthTokenSource } from './engineWireSdk.js';
 import type { WorkflowRunState, WorkflowToolCall } from './workflowMonitor.js';
 export interface LiveWorkflowController {
     snapshot(): WorkflowRunState | null;
@@ -40,7 +41,7 @@ export type WorkflowResolution = {
 };
 export interface LiveWorkflowConfig {
     baseUrl: string;
-    authToken: string | {
+    authToken: WireAuthTokenSource | {
         mode: 'same-origin-relay';
     };
     principal: string | undefined;
@@ -78,7 +79,7 @@ export interface WorkflowActivityLedgerView {
 }
 export interface WorkflowActivityLedgerConfig {
     baseUrl: string;
-    authToken: string | {
+    authToken: WireAuthTokenSource | {
         mode: 'same-origin-relay';
     };
     principal: string | undefined;

package/dist/workflowClient.js

@@ -347,9 +347,9 @@ function sameActivityScope(a, b) {
         return false;
     const at = a.authToken;
     const bt = b.authToken;
-    if (typeof at === 'string' || typeof bt === 'string')
-        return at === bt;
-    return at.mode === bt.mode;
+    if (typeof at === 'object' && typeof bt === 'object')
+        return at.mode === bt.mode;
+    return at === bt;
 }
 function newActivityAcc(label) {
     return { label, calls: new Map(), order: [], startCount: 0 };