@agent-link/agent 0.1.343 → 0.1.345

package/dist/copilot.js

@@ -360,6 +360,7 @@ function sessionRef(sessionId) {
     };
 }
 function startCopilotTurn(state) {
+    state.steeringRequests = undefined;
     state.toolStartKeys = new Set();
     state.compactionRecord = undefined;
     state.reviewDocuments = new CopilotReviewDocuments();
@@ -418,6 +419,7 @@ function startCopilotTurn(state) {
     }
 }
 function finishCopilotTurn(state) {
+    settleCopilotSteering(state, 'failed');
     settleCopilotUserRequest(state, 'failed');
     state.turnActive = false;
     state.lastActivityAt = Date.now();
@@ -882,6 +884,171 @@ export function getCopilotConversation(conversationId) {
     conversationAliases.delete(conversationId);
     return undefined;
 }
+function copilotSteeringReceipt(state, request) {
+    const sessionId = state.commandSessionId || state.copilotSessionId || state.lastCopilotSessionId;
+    return { type: 'backend_event', providerId: request.providerId, conversationId: state.conversationId,
+        workDir: state.workDir, claudeSessionId: sessionId, turnId: request.backendTurnId, stateVersion: state.stateVersion,
+        event: { type: 'user_message', session: sessionRef(sessionId || 'pending'), message: { ...request } } };
+}
+export function getCopilotSteeringReceipts() {
+    return [...conversations.values()].flatMap(state => [...(state.steeringRequests?.values() || [])]
+        .filter(request => request.providerId === state.providerId && request.backendTurnId === state.turnId)
+        .map(request => copilotSteeringReceipt(state, request)));
+}
+function publishCopilotSteering(state, request) {
+    const sessionId = state.commandSessionId || state.copilotSessionId || state.lastCopilotSessionId;
+    try {
+        if (sessionId)
+            saveCopilotUserRequest(COPILOT_SESSION_DIR, sessionId, request);
+    }
+    finally {
+        sendFn(copilotSteeringReceipt(state, request));
+    }
+}
+function settleCopilotSteering(state, status) {
+    for (const request of state.steeringRequests?.values() || []) {
+        if (request.copilotRequestState !== 'pending')
+            continue;
+        request.copilotRequestState = status;
+        try {
+            publishCopilotSteering(state, request);
+        }
+        catch (error) {
+            console.warn('[Copilot:steering] Receipt persistence failed:', error);
+        }
+    }
+}
+export async function handleCopilotSteering(prompt, scope, send) {
+    let state;
+    let request;
+    try {
+        if (typeof prompt !== 'string' || !prompt.trim() || prompt.trim().startsWith('/')
+            || typeof scope.requestId !== 'string' || !/^[\w-]{1,100}$/.test(scope.requestId)) {
+            throw new Error('Steering requires text and a valid request ID');
+        }
+        state = getCopilotConversation(scope.conversationId);
+        const sessionId = state?.commandSessionId;
+        if (!state || scope.providerId !== 'copilot' || state.providerId !== scope.providerId
+            || !sessionId || scope.claudeSessionId !== sessionId || typeof scope.workDir !== 'string'
+            || resolve(scope.workDir) !== resolve(state.workDir) || !scope.turnId || scope.turnId !== state.turnId) {
+            throw new Error('Steering conversation, provider, directory, session or turn no longer matches');
+        }
+        state.steeringRequests ??= new Map();
+        const existing = state.steeringRequests.get(scope.requestId)
+            || readCopilotUserRequests(COPILOT_SESSION_DIR, sessionId).find(row => row.copilotRequestId === scope.requestId);
+        if (existing) {
+            if (!existing.copilotSteering || existing.content !== prompt.trim() || existing.backendTurnId !== scope.turnId) {
+                publishCopilotSteering(state, existing);
+                send({ type: 'error', operation: 'copilot_request', providerId: scope.providerId,
+                    conversationId: scope.conversationId, preserveActiveTurn: true,
+                    message: 'Steering request ID was already used for a different request' });
+                return;
+            }
+            publishCopilotSteering(state, existing);
+            return;
+        }
+        if (!state.turnActive || state.isCompacting || state.copilotMode !== 'interactive'
+            || state.planMode || state.planModePending || state.activeOperation !== 'chat'
+            || getPendingCopilotDecisions(state.conversationId).length || !state.commandRuntime?.isRunning()) {
+            throw new Error('Steering is unavailable: the interactive task is no longer accepting requirements');
+        }
+        request = { role: 'user', content: prompt.trim(), copilotRequestId: scope.requestId,
+            backendTurnId: scope.turnId, providerId: scope.providerId, copilotSteering: true,
+            copilotRequestState: 'pending', timestamp: new Date().toISOString() };
+        state.steeringRequests.set(scope.requestId, request);
+        publishCopilotSteering(state, request);
+        const runtime = state.commandRuntime;
+        const nativeId = await runtime.steer(sessionId, request.content);
+        if (state.commandRuntime !== runtime || state.commandSessionId !== sessionId || state.turnId !== scope.turnId
+            || state.providerId !== scope.providerId || resolve(state.workDir) !== resolve(scope.workDir)) {
+            console.warn('[Copilot:steering] Ignoring acknowledgment after ownership changed');
+            return;
+        }
+        request.copilotUserMessageId = nativeId;
+        request.copilotRequestDispatched = true;
+        publishCopilotSteering(state, request);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn('[Copilot:steering]', message);
+        if (request && state && state.commandSessionId === scope.claudeSessionId && state.turnId === scope.turnId
+            && state.providerId === scope.providerId && resolve(state.workDir) === resolve(scope.workDir)) {
+            if (request.copilotRequestState === 'pending')
+                request.copilotRequestState = 'failed';
+            request.copilotSteeringError = message;
+            try {
+                publishCopilotSteering(state, request);
+            }
+            catch (persistError) {
+                console.warn('[Copilot:steering] Failed receipt persistence:', persistError);
+            }
+        }
+        else {
+            send({ type: 'backend_event', providerId: scope.providerId, conversationId: scope.conversationId,
+                workDir: scope.workDir, claudeSessionId: scope.claudeSessionId, turnId: scope.turnId,
+                event: { type: 'user_message', session: sessionRef(scope.claudeSessionId),
+                    message: { role: 'user', content: typeof prompt === 'string' ? prompt : '', copilotSteering: true,
+                        copilotRequestId: scope.requestId, copilotRequestState: 'failed', copilotSteeringError: message,
+                        timestamp: new Date().toISOString() } } });
+        }
+    }
+}
+export async function handleCopilotBtwQuestion(question, scope, send) {
+    const reply = (message) => send({ type: 'btw_answer', ...scope, ...message });
+    try {
+        if (scope.providerId !== 'copilot') {
+            reply({ delta: '', done: true, errorCode: 'btw_unsupported' });
+            return;
+        }
+        if (!scope.requestId || typeof question !== 'string' || !question.trim()) {
+            reply({ delta: '', done: true, errorCode: 'btw_invalid' });
+            return;
+        }
+        const conversationId = scope.conversationId;
+        const state = conversationId ? getCopilotConversation(conversationId) : undefined;
+        const sessionId = state?.commandSessionId || state?.copilotSessionId || state?.lastCopilotSessionId;
+        if (!conversationId || !state || !sessionId || !scope.claudeSessionId || scope.claudeSessionId !== sessionId
+            || state.providerId !== scope.providerId || resolve(state.workDir) !== resolve(scope.workDir)) {
+            reply({ delta: '', done: true, errorCode: 'btw_no_session' });
+            return;
+        }
+        markCopilotRuntimeActivity(state);
+        if (state.runtimeInitPromise)
+            await state.runtimeInitPromise;
+        if (!state.commandRuntime?.isRunning()) {
+            if (state.turnActive || state.isCompacting) {
+                reply({ delta: '', done: true, errorCode: 'btw_unavailable' });
+                return;
+            }
+            await ensureCopilotRuntime(state, sessionId);
+        }
+        const runtime = state.commandRuntime;
+        const stillCurrent = () => getCopilotConversation(conversationId) === state
+            && state.providerId === scope.providerId
+            && resolve(state.workDir) === resolve(scope.workDir)
+            && state.commandRuntime === runtime && state.commandSessionId === sessionId;
+        if (!runtime || !stillCurrent()) {
+            reply({ delta: '', done: true, errorCode: 'btw_unavailable' });
+            return;
+        }
+        const answer = await runtime.ephemeralQuery(sessionId, question.trim(), delta => {
+            if (stillCurrent())
+                reply({ delta, done: false });
+        });
+        if (stillCurrent()) {
+            markCopilotRuntimeActivity(state);
+            reply({ answer, delta: '', done: true });
+        }
+        else
+            reply({ delta: '', done: true, errorCode: 'btw_unavailable' });
+    }
+    catch (error) {
+        console.warn(`[Copilot:btw] ${error instanceof Error ? error.message : String(error)}`);
+        const errorCode = error instanceof Error && 'code' in error && error.code === 'btw_busy'
+            ? 'btw_busy' : 'btw_failed';
+        reply({ delta: '', done: true, errorCode, error: error instanceof Error ? error.message : String(error) });
+    }
+}
 function rejectCopilotBusyRequest(conversationId, state) {
     // Reject this extra request, not the still-running turn shared by other pages.
     // Existing terminal-turn guards must not interpret it as the owner's failure.
@@ -3351,7 +3518,20 @@ function handleCopilotEvent(state, event) {
             const id = data?.messageId || event.id;
             if (typeof id !== 'string' || (!message && !attachments.length))
                 break;
-            if (state.userRequest?.copilotRequestState === 'pending') {
+            const steering = [...(state.steeringRequests?.values() || [])].find(row => row.copilotUserMessageId === id)
+                || [...(state.steeringRequests?.values() || [])].find(row => !row.copilotUserMessageId
+                    && row.content === content && ['steering', 'queued'].includes(data?.delivery));
+            if (steering) {
+                steering.copilotUserMessageId = id;
+                steering.copilotRequestState = 'delivered';
+                try {
+                    publishCopilotSteering(state, steering);
+                }
+                catch (error) {
+                    console.warn('[Copilot:steering] Could not save delivery:', error);
+                }
+            }
+            if (state.userRequest?.copilotRequestState === 'pending' && data?.delivery !== 'steering' && !steering) {
                 state.userRequest.copilotUserMessageId = id;
                 settleCopilotUserRequest(state, 'delivered');
             }
@@ -3360,6 +3540,7 @@ function handleCopilotEvent(state, event) {
                     ...(state.userRequest?.copilotUserMessageId === id ? {
                         copilotRequestId: state.userRequest.copilotRequestId, copilotRequestState: 'delivered',
                     } : {}),
+                    ...(steering ? { ...steering } : data?.delivery === 'steering' ? { copilotSteering: true } : {}),
                     copilotUserMessageId: id, ...(attachments.length ? { attachments } : {}) } });
             break;
         }
@@ -3817,6 +3998,8 @@ function handleCopilotEvent(state, event) {
 // ── Cancel ──────────────────────────────────────────────────────────────────
 export function cancelCopilotExecution(conversationId) {
     const state = getCopilotConversation(conversationId);
+    if (state)
+        settleCopilotSteering(state, 'cancelled');
     if (state)
         settleCopilotUserRequest(state, 'cancelled');
     cancelPendingCopilotDecisions(state?.conversationId || conversationId);
@@ -5528,7 +5711,10 @@ function mergeCopilotRequestHistory(messages, sessionId) {
         else
             requests[index] = owner.userRequest;
     }
-    return mergeCopilotUserRequests(messages, requests, owner?.userRequest?.copilotRequestId);
+    const liveIds = [owner?.userRequest?.copilotRequestId,
+        ...[...(owner?.steeringRequests?.values() || [])].map(row => row.copilotRequestId)]
+        .filter((id) => !!id);
+    return mergeCopilotUserRequests(messages, requests, liveIds);
 }
 export function readCopilotSessionMode(sessionId) {
     const sessionRoot = resolve(COPILOT_SESSION_DIR);