@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/subagent/engineCompactWire.js

@@ -1,34 +1,38 @@
 import { hostLog, hostTimersFor } 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 { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+function usableCompactClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'compact']]);
+}
+const COMPACT_PROBE_SETTLE_MS = 5000;
 const pendingCompactKeys = new Set();
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
 const manualCompactCapableByBase = new Map();
 const capabilitiesProbeByBase = new Map();
-function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+function probeManualCompactCapability(wire) {
+    const base = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
+    if (base === undefined)
         return;
-    const base = cfg.baseUrl;
     if (capabilitiesProbeByBase.has(base))
         return;
     capabilitiesProbeByBase.set(base, (async () => {
         try {
-            const client = makeEngineWireClient({
-                baseUrl: base,
-                ...(cfg.token ? { token: cfg.token } : {}),
-                principal: cfg.principal,
-                timeoutMs: 5000,
-            });
-            if (!client) {
-                capabilitiesProbeByBase.delete(base);
-                return;
+            let caps;
+            if (wire.kind === 'injected') {
+                const injected = wire.client;
+                caps = await settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal }));
+            }
+            else {
+                const client = wire.make({ timeoutMs: 5000 });
+                if (!client) {
+                    capabilitiesProbeByBase.delete(base);
+                    return;
+                }
+                caps = await client.capabilities();
             }
-            const caps = await client.capabilities();
             if (typeof caps.manualCompact === 'boolean')
                 manualCompactCapableByBase.set(base, caps.manualCompact);
             else
@@ -55,31 +59,35 @@ function deferFire(ms, fn, why, sessionKey) {
     timers.setTimer(ms, fn);
     return true;
 }
-function freezeCompactShot(taskId, sessionKey) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+function freezeCompactShot(taskId, sessionKey, wire) {
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
     const sid = engineSessionParamFor(sessionKey);
+    let client;
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        client = () => injected;
+    }
+    else {
+        const make = wire.make;
+        client = () => make();
+    }
     return {
         taskId,
         sessionKey,
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token !== undefined ? { token: cfg.token } : {}),
-        ...(cfg.principal !== undefined ? { principal: cfg.principal } : {}),
+        client,
+        injected: wire.kind === 'injected',
         ...(sid !== undefined ? { session: sid } : {}),
     };
 }
 async function postCompact(shot, retriesLeft = 1) {
-    const client = makeEngineWireClient({
-        baseUrl: shot.baseUrl,
-        ...(shot.token ? { token: shot.token } : {}),
-        principal: shot.principal,
-    });
+    const client = shot.client();
     if (!client)
         return;
     const taskId = shot.taskId;
     try {
-        const ack = await client.runs.compact(taskId, shot.session !== undefined ? { session: shot.session } : {});
+        const fire = (signal) => client.runs.compact(taskId, { ...(shot.session !== undefined ? { session: shot.session } : {}), ...(signal ? { signal } : {}) });
+        const ack = shot.injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, fire) : await fire(undefined);
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
     }
     catch (e) {
@@ -94,18 +102,19 @@ async function postCompact(shot, retriesLeft = 1) {
         hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${String(e)}`);
     }
 }
-export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
+    const wire = engineWireFor(opts?.wire, sessionKey, usableCompactClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return 'offline';
-    probeManualCompactCapability(sessionKey);
-    if (manualCompactCapableByBase.get(cfg.baseUrl) === false) {
+    probeManualCompactCapability(wire);
+    const capsKey = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
+    if (capsKey !== undefined && manualCompactCapableByBase.get(capsKey) === false) {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }
     const taskId = activeEngineRunIdFor(sessionKey);
     if (taskId) {
-        const shot = freezeCompactShot(taskId, sessionKey);
+        const shot = freezeCompactShot(taskId, sessionKey, wire);
         if (shot !== null)
             void postCompact(shot);
         return 'fired';
@@ -114,11 +123,13 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
     return 'armed';
 }
 const BOUND_FIRE_DELAY_MS = 1500;
-export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY) {
-    probeManualCompactCapability(sessionKey);
+export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY, opts) {
+    const wire = engineWireFor(opts?.wire, sessionKey, usableCompactClient);
+    if (wire.kind !== 'no-target' && wire.kind !== 'injected-unusable')
+        probeManualCompactCapability(wire);
     if (!pendingCompactKeys.has(sessionKey))
         return;
-    const shot = freezeCompactShot(taskId, sessionKey);
+    const shot = freezeCompactShot(taskId, sessionKey, wire);
     if (shot === null)
         return;
     if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -1,3 +1,9 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type DelegatedPromptWireClient = {
+    sessions: Pick<AgentClient['sessions'], 'get'>;
+};
+export type DelegatedPromptWire = EngineWireInjection<DelegatedPromptWireClient>;
 export declare function recordEngineTranscriptId(taskId: string, transcriptId: string): void;
 export declare function getEngineTranscriptId(taskId: string): string | undefined;
 export declare function __resetEngineDelegatedPromptForTests(): void;
@@ -9,5 +15,7 @@ export interface DelegatedPromptFetch {
     prompt?: string;
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
 }
-export declare function fetchDelegatedPrompt(taskId: string): Promise<DelegatedPromptFetch>;
+export declare function fetchDelegatedPrompt(taskId: string, opts?: {
+    wire?: DelegatedPromptWire;
+}): Promise<DelegatedPromptFetch>;
 export {};

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,8 +1,10 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 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 { resolveOwnerContext } from './engineSubagentResume.js';
+function usableDelegatedPromptClient(client) {
+    return clientHasVerbs(client, [['sessions', 'get']]);
+}
 const TAIL_WINDOW = 200;
 const BLOB_CAP = 8 * 1024;
 const transcriptIdByTask = new Map();
@@ -89,27 +91,25 @@ let transcriptWindowReader = null;
 export function __setTranscriptWindowReaderForTests(r) {
     transcriptWindowReader = r;
 }
-async function readTranscriptWindow(transcriptId, sessionKey) {
+async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+    const wire = engineWireFor(injectedWire, sessionKey, usableDelegatedPromptClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         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;
-    const rec = await client.sessions.get(transcriptId, {
-        tail: TAIL_WINDOW,
-        blobCap: BLOB_CAP,
-    });
+    const rec = wire.kind === 'injected'
+        ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, (signal) => client.sessions.get(transcriptId, { tail: TAIL_WINDOW, blobCap: BLOB_CAP, signal }))
+        : await client.sessions.get(transcriptId, {
+            tail: TAIL_WINDOW,
+            blobCap: BLOB_CAP,
+        });
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
-export async function fetchDelegatedPrompt(taskId) {
+export async function fetchDelegatedPrompt(taskId, opts) {
     if (promptHydrateInFlight.has(taskId))
         return { outcome: 'skipped' };
     const transcriptId = transcriptIdByTask.get(taskId);
@@ -118,7 +118,7 @@ export async function fetchDelegatedPrompt(taskId) {
     promptHydrateInFlight.add(taskId);
     let msgs = null;
     try {
-        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key);
+        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, opts?.wire);
     }
     catch (e) {
         promptHydrateInFlight.delete(taskId);

package/dist/subagent/engineRowStopGate.d.ts

@@ -1,5 +1,5 @@
 export declare const engineOwnedRowIds: Set<string>;
 export declare const fleetViewStubRowIds: Set<string>;
 export declare function isEngineViewRow(taskId: string): boolean;
-export declare function engineTaskHandlesCapable(sessionKey?: string): boolean;
-export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string): boolean;
+export declare function engineTaskHandlesCapable(sessionKey?: string, capsBaseUrl?: string): boolean;
+export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string, capsBaseUrl?: string): boolean;

package/dist/subagent/engineRowStopGate.js

@@ -6,9 +6,9 @@ export const fleetViewStubRowIds = new Set();
 export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
-export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY) {
-    return engineCapTrue(engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
+export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY, capsBaseUrl) {
+    return engineCapTrue(capsBaseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
 }
-export function engineRowNeedsStopConfirm(taskId, sessionKey) {
-    return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY);
+export function engineRowNeedsStopConfirm(taskId, sessionKey, capsBaseUrl) {
+    return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY, capsBaseUrl);
 }

package/dist/subagent/engineSubagentOutput.d.ts

@@ -1,3 +1,10 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentReportWireClient = {
+    capabilities: AgentClient['capabilities'];
+    runs: Pick<AgentClient['runs'], 'subagentOutput'>;
+};
+export type SubagentReportWire = EngineWireInjection<SubagentReportWireClient>;
 export declare function __resetSubagentOutputCapCacheForTests(): void;
 export interface EngineSubagentReport {
     content: string;
@@ -5,4 +12,5 @@ export interface EngineSubagentReport {
 }
 export declare function fetchEngineSubagentReport(taskId: string, opts?: {
     signal?: AbortSignal;
+    wire?: SubagentReportWire;
 }): Promise<EngineSubagentReport | null>;

package/dist/subagent/engineSubagentOutput.js

@@ -1,19 +1,24 @@
 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 { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableReportClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentOutput']]);
+}
 const capByBase = new Map();
 const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
-async function subagentOutputCapable(client, baseUrl, signal) {
-    const hit = capByBase.get(baseUrl);
+async function subagentOutputCapable(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.subagentOutput === true;
-        capByBase.set(baseUrl, { ok, at: Date.now() });
+        if (cacheKey !== undefined)
+            capByBase.set(cacheKey, { ok, at: Date.now() });
         return ok;
     }
     catch {
@@ -25,28 +30,42 @@ export function __resetSubagentOutputCapCacheForTests() {
 }
 export async function fetchEngineSubagentReport(taskId, opts) {
     const { record: owner, runId, key } = resolveOwnerContext(taskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableReportClient);
+    if (wire.kind === 'no-target')
+        return null;
+    if (wire.kind === 'injected-unusable') {
+        hostLog('debug', `[subagent-output] ${taskId}: the engine client supplied by the host is not usable (needs capabilities and runs.subagentOutput) — nothing sent`);
         return null;
+    }
     if (!runId) {
         noteBgOwnerAbsence('subagent-output', taskId);
         return null;
     }
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
-    if (!client)
-        return null;
-    if (!(await subagentOutputCapable(client, cfg.baseUrl, opts?.signal)))
+    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 null;
+        client = made;
+        cacheKey = wire.target.baseUrl;
+        injected = false;
+    }
+    if (!(await subagentOutputCapable(client, cacheKey, opts?.signal, injected ? INJECTED_WIRE_SETTLE_MS : undefined)))
         return null;
     try {
         const session = owner?.sessionId ?? engineSessionParamFor(key);
-        const r = await client.runs.subagentOutput(runId, taskId, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const read = (signal) => client.runs.subagentOutput(runId, taskId, {
+            ...(signal ? { signal } : {}),
             ...(session ? { session } : {}),
         });
+        const r = injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, read) : await read(opts?.signal);
         const content = typeof r?.content === 'string' ? r.content : '';
         if (!content.trim())
             return null;

package/dist/subagent/engineSubagentResume.d.ts

@@ -1,4 +1,5 @@
-import type { SubagentSteerReceipt } from '@sema-agent/sdk';
+import type { AgentClient, SubagentSteerReceipt } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
 import { type SubagentOwnerRecord } from '../subagentContentStore.js';
 export declare const SUBAGENT_RESUME_CAP = "subagentResume";
 export declare function subagentResumeAvailable(baseUrl?: string, sessionKey?: string): boolean;
@@ -21,12 +22,14 @@ export type SubagentResumeOutcome = {
     detail: string;
     retryAfterSec?: number;
     code?: string;
+    unconfirmed?: true;
 };
 export interface SubagentResumeFailureVerdict {
     reason: SubagentResumeFailureKind;
     detail: string;
     retryAfterSec?: number;
     code?: string;
+    unconfirmed?: true;
 }
 export declare function classifySubagentResumeFailure(e: unknown): SubagentResumeFailureVerdict;
 export declare function resolveOwnerRunId(childTaskId?: string, activeRunId?: string | undefined): string | undefined;
@@ -41,7 +44,13 @@ export interface SubagentResumeContext {
     runId: string | undefined;
     session: Record<string, string>;
 }
-export declare function resolveSubagentResumeContext(childTaskId?: string): SubagentResumeContext;
+export type SubagentResumeWireClient = {
+    runs: Pick<AgentClient['runs'], 'resumeSubagent'>;
+};
+export type SubagentResumeWire = EngineWireInjection<SubagentResumeWireClient>;
+export declare function resolveSubagentResumeContext(childTaskId?: string, opts?: {
+    wire?: SubagentResumeWire;
+}): SubagentResumeContext;
 export declare function resumeSettledSubagent(facade: SubagentResumeFacade | null, runId: string | undefined, target: string, content: string, opts?: {
     session?: string;
     signal?: AbortSignal;

package/dist/subagent/engineSubagentResume.js

@@ -2,7 +2,7 @@ import { hostLog } from '../host.js';
 import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
 import { activeEngineRunId, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
@@ -33,6 +33,11 @@ function shapeOf(e) {
 }
 export function classifySubagentResumeFailure(e) {
     const { status, errorCode, message } = shapeOf(e);
+    if (status === undefined && errorCode === undefined) {
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null)
+            return { reason: 'error', detail: noAnswer, unconfirmed: true };
+    }
     const retryLater = resumeRetryLaterFromError(e);
     if (retryLater !== null) {
         return {
@@ -77,18 +82,27 @@ export function resolveOwnerContext(childTaskId) {
     const record = getBgParentRunOwner(childTaskId);
     return { record, runId: record?.runId, key: record?.sessionKey ?? DEFAULT_SESSION_KEY };
 }
-export function resolveSubagentResumeContext(childTaskId) {
+function usableResumeClient(client) {
+    return clientHasVerbs(client, [['runs', 'resumeSubagent']]);
+}
+export function resolveSubagentResumeContext(childTaskId, opts) {
     const { record: owner, key } = resolveOwnerContext(childTaskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
-        return { facade: null, runId: undefined, session: {} };
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        ...(cfg.principal !== undefined ? { principal: cfg.principal } : {}),
-    });
-    if (!client)
+    const wire = engineWireFor(opts?.wire, key, usableResumeClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return { facade: null, runId: undefined, session: {} };
+    let facade;
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        facade = {
+            resumeSubagent: (taskId, target, message, o) => settleInjected(INJECTED_WIRE_SETTLE_MS, o?.signal, (signal) => injected.runs.resumeSubagent(taskId, target, message, { ...(o?.session !== undefined ? { session: o.session } : {}), signal })),
+        };
+    }
+    else {
+        const client = wire.make();
+        if (!client)
+            return { facade: null, runId: undefined, session: {} };
+        facade = client.runs;
+    }
     const named = childTaskId !== undefined && childTaskId !== '';
     const sessionFromRow = owner?.sessionId;
     const fallback = named ? undefined : engineSessionParamFor(key);
@@ -97,7 +111,7 @@ export function resolveSubagentResumeContext(childTaskId) {
         : fallback !== undefined
             ? { session: fallback }
             : {};
-    return { facade: client.runs, runId: resolveOwnerRunId(childTaskId), session };
+    return { facade, runId: resolveOwnerRunId(childTaskId), session };
 }
 function clean(v, max = 200) {
     return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false, mark: 'dot', max });
@@ -111,7 +125,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
     if (text === '')
         return { ok: false, reason: 'bad-request', detail: 'empty message' };
     try {
-        const receipt = await facade.resumeSubagent(runId, target, { content: text }, opts);
+        const receipt = await sendOnce(opts?.signal, () => facade.resumeSubagent(runId, target, { content: text }, opts));
         const note = receipt?.note;
         return {
             ok: true,
@@ -122,7 +136,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
     }
     catch (e) {
         const f = classifySubagentResumeFailure(e);
-        hostLog('debug', `engineSubagentResume: resume(${clean(target, 64)}) → ${f.reason} (${clean(f.detail, 160)})`);
+        hostLog('debug', `engineSubagentResume: resume(${clean(target, 64)}) → ${f.reason}${f.unconfirmed === true ? ' (may have been received, no answer)' : ''} (${clean(f.detail, 160)})`);
         return { ok: false, ...f };
     }
 }

package/dist/subagent/engineSubagentSteer.d.ts

@@ -1,3 +1,9 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentSteerWireClient = {
+    runs: Pick<AgentClient['runs'], 'steerSubagent'>;
+};
+export type SubagentSteerWire = EngineWireInjection<SubagentSteerWireClient>;
 export type SubagentSteerOutcome = {
     ok: true;
     receipt: string;
@@ -5,5 +11,8 @@ export type SubagentSteerOutcome = {
     ok: false;
     reason: 'no-wire' | 'no-run' | 'not-running' | 'error';
     detail?: string;
+    unconfirmed?: true;
 };
-export declare function steerEngineSubagent(target: string, text: string, childTaskId?: string): Promise<SubagentSteerOutcome>;
+export declare function steerEngineSubagent(target: string, text: string, childTaskId?: string, opts?: {
+    wire?: SubagentSteerWire;
+}): Promise<SubagentSteerOutcome>;

package/dist/subagent/engineSubagentSteer.js

@@ -1,14 +1,16 @@
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected } from '../engineWireFor.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
-export async function steerEngineSubagent(target, text, childTaskId) {
+function usableSteerClient(client) {
+    return clientHasVerbs(client, [['runs', 'steerSubagent']]);
+}
+export async function steerEngineSubagent(target, text, childTaskId, opts) {
     const named = typeof childTaskId === 'string' && childTaskId !== '' ? childTaskId : undefined;
     const { record: owner, key } = resolveOwnerContext(named);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableSteerClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return { ok: false, reason: 'no-wire' };
     const runId = resolveOwnerRunId(named);
     if (!runId) {
@@ -16,11 +18,7 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             noteBgOwnerAbsence('subagent-steer', named);
         return { ok: false, reason: 'no-run' };
     }
-    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: 'no-wire' };
     const rowSession = owner?.sessionId;
@@ -31,7 +29,9 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             ? { session: fallbackSession }
             : {};
     try {
-        const body = await client.runs.steerSubagent(runId, target, { content: text }, session);
+        const body = wire.kind === 'injected'
+            ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, (signal) => client.runs.steerSubagent(runId, target, { content: text }, { ...session, signal }))
+            : await client.runs.steerSubagent(runId, target, { content: text }, session);
         let receipt = 'Message queued for delivery at the next tool round.';
         const copy = body?.note ?? body?.message;
         if (typeof copy === 'string' && copy.length > 0)
@@ -48,6 +48,11 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             }
             return { ok: false, reason: 'error', detail: `${status}` };
         }
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null) {
+            hostLog('debug', `engineSubagentSteer: may have been received, no answer — ${noAnswer}`);
+            return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
+        }
         hostLog('debug', `engineSubagentSteer: fetch failed ${String(e)}`);
         return { ok: false, reason: 'error', detail: String(e) };
     }

package/dist/subagent/engineSubagentTail.d.ts

@@ -1,3 +1,10 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentTailWireClient = {
+    capabilities: AgentClient['capabilities'];
+    runs: Pick<AgentClient['runs'], 'subagentStream'>;
+};
+export type SubagentTailWire = EngineWireInjection<SubagentTailWireClient>;
 export declare function __resetSubagentStreamCapCacheForTests(): void;
 export interface SubagentActivity {
     taskId: string;
@@ -14,7 +21,9 @@ export interface SubagentTailMeta {
 export type SubagentTailMetaSink = (m: SubagentTailMeta) => void;
 export declare function installSubagentTailMetaSink(sink: SubagentTailMetaSink | null): () => void;
 export declare function isEngineSubagentTailActive(taskId: string): boolean;
-export declare function tailEngineSubagent(taskId: string): void;
+export declare function tailEngineSubagent(taskId: string, opts?: {
+    wire?: SubagentTailWire;
+}): void;
 export declare function stopEngineSubagentTail(taskId: string): void;
 export declare function hasActiveSubagentTail(taskId: string): boolean;
 export declare function __activeTailCountForTests(): number;