@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/subagent/engineSubagentTail.js

@@ -1,20 +1,25 @@
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableTailClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
+}
 const capByBase = new Map();
 const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
-async function subagentStreamCapable(client, baseUrl, signal) {
-    const hit = capByBase.get(baseUrl);
+async function subagentStreamCapable(client, cacheKey, signal, deadlineMs) {
+    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
     if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
         return hit.ok;
     try {
-        const caps = await client.capabilities({ ...(signal ? { signal } : {}) });
+        const caps = deadlineMs !== undefined
+            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
+            : await client.capabilities({ ...(signal ? { signal } : {}) });
         const ok = caps.subagentStream === true;
-        capByBase.set(baseUrl, { ok, at: Date.now() });
+        if (cacheKey !== undefined)
+            capByBase.set(cacheKey, { ok, at: Date.now() });
         return ok;
     }
     catch {
@@ -44,24 +49,37 @@ export function installSubagentTailMetaSink(sink) {
 export function isEngineSubagentTailActive(taskId) {
     return activeTails.has(taskId);
 }
-export function tailEngineSubagent(taskId) {
+export function tailEngineSubagent(taskId, opts) {
     if (activeTails.has(taskId))
         return;
     const { record: owner, runId, key } = resolveOwnerContext(taskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableTailClient);
+    if (wire.kind === 'no-target')
+        return;
+    if (wire.kind === 'injected-unusable') {
+        hostLog('debug', `[subagent-tail] ${taskId}: the engine client supplied by the host is not usable (needs capabilities and runs.subagentStream) — tail not opened`);
         return;
+    }
     if (!runId) {
         noteBgOwnerAbsence('subagent-tail', taskId);
         return;
     }
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
-    if (!client)
-        return;
+    let client;
+    let cacheKey;
+    let injected;
+    if (wire.kind === 'injected') {
+        client = wire.client;
+        cacheKey = wire.capsBaseUrl;
+        injected = true;
+    }
+    else {
+        const made = wire.make();
+        if (!made)
+            return;
+        client = made;
+        cacheKey = wire.target.baseUrl;
+        injected = false;
+    }
     const ac = new AbortController();
     activeTails.set(taskId, ac);
     const openedAt = Date.now();
@@ -70,7 +88,7 @@ export function tailEngineSubagent(taskId) {
     let firstContentLogged = false;
     void (async () => {
         try {
-            if (!(await subagentStreamCapable(client, cfg.baseUrl, ac.signal)))
+            if (!(await subagentStreamCapable(client, cacheKey, ac.signal, injected ? INJECTED_WIRE_SETTLE_MS : undefined)))
                 return;
             const session = owner?.sessionId ?? engineSessionParamFor(key);
             const stream = client.runs.subagentStream(runId, taskId, {

package/dist/subagent/engineTaskHandleWire.d.ts

@@ -1,3 +1,13 @@
+import { type AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type EngineTaskOutputWireClient = {
+    runs: Pick<AgentClient['runs'], 'taskOutput'>;
+};
+export type EngineTaskOutputWire = EngineWireInjection<EngineTaskOutputWireClient>;
+export type EngineTaskStopWireClient = {
+    runs: Pick<AgentClient['runs'], 'taskStop'>;
+};
+export type EngineTaskStopWire = EngineWireInjection<EngineTaskStopWireClient>;
 export interface EngineTaskOutputResult {
     content: string;
     status?: string;
@@ -7,6 +17,7 @@ export interface EngineTaskOutputResult {
 export declare function __resetTaskHandleWireForTests(): void;
 export declare function fetchEngineTaskOutput(handle: string, opts?: {
     signal?: AbortSignal;
+    wire?: EngineTaskOutputWire;
 }): Promise<EngineTaskOutputResult | null>;
 export interface TaskOutputMergeHint {
     readonly type?: string;
@@ -41,8 +52,10 @@ export type EngineTaskStopOutcome = {
     ok: false;
     reason: 'unavailable' | 'error';
     detail?: string;
+    unconfirmed?: true;
 };
 export declare function classifyTaskStopConflict(e: unknown): EngineTaskStopOutcome;
 export declare function stopEngineTask(handle: string, opts?: {
     signal?: AbortSignal;
+    wire?: EngineTaskStopWire;
 }): Promise<EngineTaskStopOutcome>;

package/dist/subagent/engineTaskHandleWire.js

@@ -1,11 +1,19 @@
 import { TaskStopConflictError } from '@sema-agent/sdk';
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireDebugEnabled, engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
+import { engineWireDebugEnabled } from '../engineWireTarget.js';
+import { engineCapTrue } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableTaskOutputClient(client) {
+    return clientHasVerbs(client, [['runs', 'taskOutput']]);
+}
+function usableTaskStopClient(client) {
+    return clientHasVerbs(client, [['runs', 'taskStop']]);
+}
+const CAPS_KEY_REQUIRED_DETAIL = 'capability evidence for taskHandles is not available under the key the host named (capsBaseUrl) — nothing sent';
 import { spoolMarkerOf } from '../toolResult.js';
 import { STOP_CONFLICT_CODES, STOP_NOT_LANDED, STOP_NOT_LOCAL, STOP_PARKED, STOP_PARK_ARBITER_UNREACHABLE, STOP_PARK_RESUME_WON, } from '../engineErrorCodes.js';
 function resolveHostRun(handle) {
@@ -26,24 +34,30 @@ export function __resetTaskHandleWireForTests() {
 }
 export async function fetchEngineTaskOutput(handle, opts) {
     const owner = resolveOwnerContext(handle);
-    const cfg = engineWireTargetFor(owner.key);
-    if (!cfg || !engineTaskHandlesCapable(owner.key))
+    const wire = engineWireFor(opts?.wire, owner.key, usableTaskOutputClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
+        return null;
+    if (wire.kind === 'injected') {
+        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles')) {
+            hostLog('debug', `[task-handle] output ${handle}: ${CAPS_KEY_REQUIRED_DETAIL}`);
+            return null;
+        }
+    }
+    else if (!engineTaskHandlesCapable(owner.key)) {
         return null;
+    }
     const runId = resolveHostRun(handle);
     if (!runId)
         return null;
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
+    const client = wire.kind === 'injected' ? wire.client : wire.make();
     if (!client)
         return null;
     try {
-        const r = await client.runs.taskOutput(runId, handle, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const read = (signal) => client.runs.taskOutput(runId, handle, {
+            ...(signal ? { signal } : {}),
             ...(sessionOf(owner)),
         });
+        const r = wire.kind === 'injected' ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, read) : await read(opts?.signal);
         const fresh = typeof r?.content === 'string' ? r.content : '';
         const prev = accumulated.get(handle) ?? '';
         const cursorSemantics = r?.cursorSemantics;
@@ -121,24 +135,28 @@ export function classifyTaskStopConflict(e) {
 }
 export async function stopEngineTask(handle, opts) {
     const owner = resolveOwnerContext(handle);
-    const cfg = engineWireTargetFor(owner.key);
-    if (!cfg || !engineTaskHandlesCapable(owner.key))
+    const wire = engineWireFor(opts?.wire, owner.key, usableTaskStopClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
+        return { ok: false, reason: 'unavailable' };
+    if (wire.kind === 'injected') {
+        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles'))
+            return { ok: false, reason: 'unavailable', detail: CAPS_KEY_REQUIRED_DETAIL };
+    }
+    else if (!engineTaskHandlesCapable(owner.key)) {
         return { ok: false, reason: 'unavailable' };
+    }
     const runId = resolveHostRun(handle);
     if (!runId)
         return { ok: false, reason: 'unavailable', detail: 'no host run mapping' };
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
+    const client = wire.kind === 'injected' ? wire.client : wire.make();
     if (!client)
         return { ok: false, reason: 'unavailable' };
     try {
-        const r = await client.runs.taskStop(runId, handle, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const stop = (signal) => client.runs.taskStop(runId, handle, {
+            ...(signal ? { signal } : {}),
             ...(sessionOf(owner)),
         });
+        const r = wire.kind === 'injected' ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, stop) : await sendOnce(opts?.signal, () => stop(opts?.signal));
         const out = r?.output ?? {};
         if (engineWireDebugEnabled()) {
             hostLog('debug', `[task-handle] stop ${handle} via run ${runId}: ok status=${typeof out.status === 'string' ? out.status : '-'} stoppedBy=${typeof out.stoppedBy === 'string' ? out.stoppedBy : '-'}`);
@@ -156,6 +174,9 @@ export async function stopEngineTask(handle, opts) {
         if (e instanceof TaskStopConflictError || status === 409) {
             return classifyTaskStopConflict(e);
         }
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null)
+            return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
         return { ok: false, reason: 'error', detail };
     }
 }

package/dist/subagent/subagentOwnerAbsence.js

@@ -11,12 +11,9 @@ export function noteBgOwnerAbsence(leg, taskId) {
             noted.delete(oldest);
     }
     noted.add(key);
-    try {
-        hostLog('warn', `[subagent-owner] ${leg}: no host-run mapping for ${taskId} — not connecting (owner ledger absent ⇒ honest absence; active-run fallback removed per [4000] Q3)`);
-    }
-    catch {
+    const delivered = hostLog('warn', `[subagent-owner] ${leg}: no host-run mapping for ${taskId} — not connecting (owner ledger absent ⇒ honest absence; active-run fallback removed per [4000] Q3)`);
+    if (!delivered)
         noted.delete(key);
-    }
 }
 export function __resetBgOwnerAbsenceForTests() {
     noted.clear();

package/dist/taskRequestWords.d.ts

@@ -0,0 +1,5 @@
+import type { TaskRequest } from '@sema-agent/sdk';
+export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
+export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto"];

package/dist/taskRequestWords.js

@@ -0,0 +1,4 @@
+export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
+const _taskRequestWordPins = [true, true, true, true];
+void _taskRequestWordPins;

package/dist/wireErrorTriage.d.ts

@@ -5,6 +5,7 @@ export type TurnWireErrorVerdict = {
     errorCode?: string;
     message: string;
     storedRowWhere?: string;
+    sessionUnreadable?: true;
 } | {
     kind: 'stream-ended-without-terminal';
 } | {

package/dist/wireErrorTriage.js

@@ -1,6 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-import { DRAINING_ERROR_CODE, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
+import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
 function wireErrorDetail(err) {
     const e = err;
@@ -15,12 +15,14 @@ export function classifyTurnWireError(err) {
         const errorCode = typeof e.errorCode === 'string' && e.errorCode.length > 0 ? e.errorCode : undefined;
         const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
         const storedRowWhere = corruptStoredRowWhere(err);
+        const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
         return {
             kind: 'http',
             status: e.status,
             ...(errorCode !== undefined ? { errorCode } : {}),
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
+            ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
         };
     }
     const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'

package/dist/wireRefusalCopy.d.ts

@@ -23,3 +23,13 @@ export interface DenyAttributionRefusalDetail {
 }
 export declare function denyAttributionRefusalFromError(err: unknown, sentSettledBy: boolean): DenyAttributionRefusalDetail | null;
 export declare function denyAttributionRefusalContent(detail: Pick<DenyAttributionRefusalDetail, 'kind' | 'field'>): string;
+export declare const CONFLICT_SESSION_CHILDREN_ALIVE = "conflict.session_children_alive";
+export type SessionDeleteConflictKind = 'children_alive' | 'active_run' | 'unrecognized';
+export interface SessionDeleteConflictDetail {
+    kind: SessionDeleteConflictKind;
+    code?: string;
+    remaining?: readonly string[];
+    activeTaskId?: string;
+}
+export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
+export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>): string;

package/dist/wireRefusalCopy.js

@@ -1,5 +1,6 @@
-import { readErrorNumber } from './wireFailureShape.js';
-import { USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
 function readStringField(o, key) {
@@ -151,3 +152,62 @@ export function denyAttributionRefusalContent(detail) {
         }
     }
 }
+export const CONFLICT_SESSION_CHILDREN_ALIVE = 'conflict.session_children_alive';
+export function sessionDeleteConflictFromError(err) {
+    try {
+        if (err === null || typeof err !== 'object')
+            return null;
+        const o = err;
+        const rawStatus = o.status ?? o.statusCode;
+        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
+        if (!is409)
+            return null;
+        const code = readStringField(o, 'errorCode');
+        if (code === CONFLICT_SESSION_CHILDREN_ALIVE) {
+            const remaining = readErrorStringList(err, 'remaining')?.filter((id) => id.length > 0);
+            return { kind: 'children_alive', code, ...(remaining !== undefined && remaining.length > 0 ? { remaining: Object.freeze(remaining) } : {}) };
+        }
+        if (code === ACTIVE_RUN_BUSY_ERROR_CODE) {
+            const activeTaskId = readErrorString(err, 'activeTaskId');
+            return { kind: 'active_run', code, ...(activeTaskId !== undefined && activeTaskId.length > 0 ? { activeTaskId } : {}) };
+        }
+        return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+const DELETE_CONFLICT_IDS_SHOWN = 3;
+const DELETE_CONFLICT_ID_MAX = 64;
+function sessionDeleteConflictUnrecognizedContent() {
+    return ('The engine refused to delete this session with a conflict it did not explain · ' +
+        'Check whether the session is still listed and whether anything of it is still running, then try the delete again');
+}
+export function sessionDeleteConflictContent(detail) {
+    try {
+        if (detail === null || typeof detail !== 'object')
+            return sessionDeleteConflictUnrecognizedContent();
+        switch (detail.kind) {
+            case 'children_alive': {
+                const raw = detail.remaining;
+                const ids = Array.isArray(raw) ? raw.filter((id) => typeof id === 'string' && id.length > 0) : [];
+                const shown = ids.slice(0, DELETE_CONFLICT_IDS_SHOWN).map((id) => capForDisplay(id, DELETE_CONFLICT_ID_MAX));
+                const more = ids.length > shown.length ? ` and ${ids.length - shown.length} more` : '';
+                const which = shown.length > 0 ? ` (${shown.join(', ')}${more})` : '';
+                return (`This session was not deleted: background agents it started are still running where this engine cannot stop them${which} · ` +
+                    'Nothing was deleted — delete it again once they finish, or stop them where they run first');
+            }
+            case 'active_run': {
+                const active = detail.activeTaskId;
+                const run = typeof active === 'string' && active.length > 0 ? ` (run ${capForDisplay(active, DELETE_CONFLICT_ID_MAX)})` : '';
+                return (`This session was not deleted: it still has a run in progress${run} · ` +
+                    'Nothing was deleted — cancel that run or let it finish, then delete the session again');
+            }
+            default:
+                return sessionDeleteConflictUnrecognizedContent();
+        }
+    }
+    catch {
+        return sessionDeleteConflictUnrecognizedContent();
+    }
+}