@sema-agent/client-core 0.91.0 → 0.92.0

package/dist/toolResult.d.ts

@@ -15,6 +15,8 @@ export declare const PROTOCOL_MARKERS: {
     readonly delegationTrailerFork: "Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.";
     readonly taskOutputLabel: RegExp;
     readonly taskOutputStatus: RegExp;
+    readonly taskOutputHeadSlots: RegExp;
+    readonly taskOutputResultNote: RegExp;
     readonly taskOutputNoneSentinel: "(none)";
     readonly taskOutputStdoutLine: RegExp;
     readonly taskOutputStderrLine: RegExp;
@@ -62,10 +64,16 @@ export type ModelFacingTaskOutput = {
     taskId?: string | undefined;
     status?: string | undefined;
     output: string;
+    state?: string;
+    error?: string;
+    resultNote?: string;
+    headRest?: string;
 } | {
     kind: 'unknown';
     taskId?: string | undefined;
     status?: string | undefined;
+    state?: string;
+    error?: string;
 };
 export declare function parseModelFacingTaskOutput(text: string): ModelFacingTaskOutput;
 export declare function backgroundReceiptParseCalls(): number;

package/dist/toolResult.js

@@ -30,6 +30,8 @@ export const PROTOCOL_MARKERS = {
     delegationTrailerFork: 'Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.',
     taskOutputLabel: /^TaskOutput\s+(\S+)$/,
     taskOutputStatus: /^status:\s*(.+)$/m,
+    taskOutputHeadSlots: /^(\r?\n)(?:(state: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?(?:(error: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?/,
+    taskOutputResultNote: /^--- result \(([^)\n]*)\) ---/,
     taskOutputNoneSentinel: '(none)',
     taskOutputStdoutLine: /^--- (?:new )?stdout[^\n]*---\n?/m,
     taskOutputStderrLine: /^--- (?:new )?stderr[^\n]*---\n?/m,
@@ -140,7 +142,8 @@ export function parseModelFacingTaskOutput(text) {
     const fence = stripUntrustedFence(text);
     const body = fence ? fence.body : text;
     const taskId = fence ? PROTOCOL_MARKERS.taskOutputLabel.exec(fence.label)?.[1] : undefined;
-    const status = PROTOCOL_MARKERS.taskOutputStatus.exec(body)?.[1]?.trim();
+    const mStatus = PROTOCOL_MARKERS.taskOutputStatus.exec(body);
+    const status = mStatus?.[1]?.trim();
     const none = (s) => {
         const t = s.replace(/\n$/, '');
         return t === PROTOCOL_MARKERS.taskOutputNoneSentinel ? '' : t;
@@ -159,9 +162,50 @@ export function parseModelFacingTaskOutput(text) {
     }
     const mRes = PROTOCOL_MARKERS.taskOutputResultLine.exec(body);
     if (mRes) {
-        return { kind: 'agent', taskId, status, output: body.slice(mRes.index + mRes[0].length).trimEnd() };
+        const lead = taskOutputHeadOf(body, mStatus, mRes.index);
+        const statusEnd = lead === null || mStatus === null ? 0 : mStatus[0].length;
+        const rest = lead === null ? body.slice(0, mRes.index) : body.slice(statusEnd + lead.consumed, mRes.index);
+        const resultNote = PROTOCOL_MARKERS.taskOutputResultNote.exec(mRes[0])?.[1];
+        return {
+            kind: 'agent',
+            taskId,
+            status,
+            output: body.slice(mRes.index + mRes[0].length).trimEnd(),
+            ...(lead?.state !== undefined ? { state: lead.state } : {}),
+            ...(lead?.error !== undefined ? { error: lead.error } : {}),
+            ...(resultNote !== undefined ? { resultNote } : {}),
+            ...(rest !== '' ? { headRest: rest } : {}),
+        };
     }
-    return { kind: 'unknown', taskId, status };
+    const lead = taskOutputHeadOf(body, mStatus, body.length);
+    return {
+        kind: 'unknown',
+        taskId,
+        status,
+        ...(lead?.state !== undefined ? { state: lead.state } : {}),
+        ...(lead?.error !== undefined ? { error: lead.error } : {}),
+    };
+}
+function taskOutputHeadOf(body, status, limit) {
+    if (status === null || status.index !== 0 || /[^\S \t]/.test(status[0]))
+        return null;
+    const head = PROTOCOL_MARKERS.taskOutputHeadSlots.exec(body.slice(status.index + status[0].length, limit));
+    if (head === null)
+        return null;
+    let consumed = head[1]?.length ?? 0;
+    let state;
+    let error;
+    if (head[2] !== undefined) {
+        if ((head[3] ?? '').trim() === '')
+            return { consumed };
+        state = head[3];
+        consumed += head[2].length;
+    }
+    if (head[4] !== undefined && (head[5] ?? '').trim() !== '') {
+        error = head[5];
+        consumed += head[4].length;
+    }
+    return { ...(state !== undefined ? { state } : {}), ...(error !== undefined ? { error } : {}), consumed };
 }
 const THREE_GEN_BG_RECEIPT_RE = /^(?:Started in background|Command running in background|Command moved to background); task_id=([A-Za-z0-9_-]+)/;
 const MONITOR_BG_RECEIPT_RE = /^Monitoring in background; task_id=([A-Za-z0-9_-]+)/;

package/dist/types/engineState.d.ts

@@ -1,15 +1,5 @@
-export interface HealthResponse {
-    status: string;
-    model?: string;
-    sessionBackend?: string;
-    sessions?: number;
-    instanceId?: string;
-    dataRoot?: string;
-    configHash?: string;
-    pid?: number;
-    port?: number;
-    restartRequired?: boolean;
-    version?: string;
+import type { EngineHealth } from '@sema-agent/sdk';
+export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version'> {
 }
 export interface EnginePortFile {
     port: number;

package/dist/userInvokedSkillsCapability.d.ts

@@ -0,0 +1,18 @@
+export type UserInvokedSkillsReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectUserInvokedSkillsCapability(caps: unknown): UserInvokedSkillsReading | undefined;
+export declare function noteEngineCapsForUserInvokedSkills(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+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

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.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')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'userInvokedSkills',
+    project: projectUserInvokedSkillsCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedUserInvokedSkills(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function userInvokedSkillsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+        return 'no';
+    return 'unknown';
+}
+export function userInvokedSkillsDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'user-invoked skills not reported by this engine — the engine predates it, so naming skills on a request is refused (do not send the key)';
+        case 'absent':
+            return 'user-invoked skills off on this deployment — naming skills on a request is not accepted';
+        case 'present':
+            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/wireFailureShape.d.ts

@@ -5,6 +5,8 @@ interface WireFailureShape {
     committed?: 'no' | 'unknown' | 'unreadable';
     bodyField?: string;
     bodyName?: string;
+    bodyVerdict?: string;
+    bodyCurrentName?: string;
     message: string;
 }
 export declare function readErrorNumber(o: object, key: string): number | undefined;

package/dist/wireFailureShape.js

@@ -131,6 +131,8 @@ export function wireFailureShapeOf(e) {
     };
     const bodyField = ownString('field');
     const bodyName = ownString('name');
+    const bodyVerdict = ownString('verdict');
+    const bodyCurrentName = ownString('currentName');
     let message;
     try {
         message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
@@ -155,6 +157,8 @@ export function wireFailureShapeOf(e) {
         ...(committed !== undefined ? { committed } : {}),
         ...(bodyField !== undefined ? { bodyField } : {}),
         ...(bodyName !== undefined ? { bodyName } : {}),
+        ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
+        ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
         message,
     };
 }

package/dist/workflowsJournalCapability.d.ts

@@ -0,0 +1,18 @@
+export type WorkflowsJournalReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectWorkflowsJournalCapability(caps: unknown): WorkflowsJournalReading | undefined;
+export declare function noteEngineCapsForWorkflowsJournal(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedWorkflowsJournal(baseUrl?: string | undefined): WorkflowsJournalReading;
+export declare function workflowsJournalAvailable(reading: WorkflowsJournalReading): 'yes' | 'no' | 'unknown';
+export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading): string;
+export declare function forgetWorkflowsJournalReading(baseUrl: string | undefined): void;
+export declare function __resetWorkflowsJournalReadingsForTests(): void;

package/dist/workflowsJournalCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectWorkflowsJournalCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'workflowsJournal'))
+        return { kind: 'not_reported' };
+    const v = caps.workflowsJournal;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'workflowsJournal',
+    project: projectWorkflowsJournalCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedWorkflowsJournal(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function workflowsJournalAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+export function workflowsJournalDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'workflow journal not reported by this engine — the engine predates the separate flag, so the workflow listing flag still covers the journal';
+        case 'absent':
+            return 'no workflow journal on this deployment — workflows can be listed and followed, but their execution journal cannot be read';
+        case 'present':
+            return 'workflow journal on — a workflow’s execution journal can be read';
+    }
+}
+export function forgetWorkflowsJournalReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetWorkflowsJournalReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/writeProtectionCapability.d.ts

@@ -1,7 +1,5 @@
-export interface WriteProtectionCapabilityView {
-    armed: boolean;
-    rows: number;
-    replaced: boolean;
+import type { WriteProtectionCapability } from '@sema-agent/sdk';
+export interface WriteProtectionCapabilityView extends Pick<WriteProtectionCapability, 'armed' | 'rows' | 'replaced'> {
 }
 export type WriteProtectionReading = {
     kind: 'unobserved';