@ai-workbench/remote-agent 0.8.19 → 0.8.23

package/dist/workspace-notice.js

@@ -1,273 +0,0 @@
-import { SessionId } from '@deepseek-ai/dsh-session';
-import { BlockAssembler, expandAssistantStream } from '@deepseek-ai/dsh-llm';
-import { isDeepStrictEqual } from 'node:util';
-import { AGENTS } from "./agents.js";
-import { NeedError } from "./remote.js";
-const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-const string = (value) => typeof value === 'string' && value.length > 0;
-const workspaceName = (value) => string(value) && value !== '.' && value !== '..' && !/[\u0000-\u001f\u007f/\\]/u.test(value);
-function noticeText(name) {
-    // The native reply renderer accepts Markdown; escape the precise verified name as ordinary text.
-    return `此工作区对应远程主机上的 ${name.replace(/[\\`*_{}\[\]()<>#+.!|~-]/gu, '\\$&')}；本地文件不会自动上传。`;
-}
-function rawMarker(message) {
-    if (!object(message) || !object(message.source) || !object(message.source.replayState) || !object(message.source.replayState.response))
-        return;
-    return message.source.replayState.response;
-}
-export function parseWorkspaceNoticeMarker(message) {
-    if (!object(message) || message.role !== 'assistant' || !string(message.id) || !object(message.source))
-        return;
-    const source = message.source, marker = rawMarker(message), definition = AGENTS.find(item => item.id === source.provider);
-    if (!object(source.replayState) || Object.keys(source.replayState).some(key => key !== 'response'))
-        return;
-    if (!marker || !definition || source.kind !== 'model' || !string(source.model) || marker.kind !== 'workspace-notice' || marker.version !== 1
-        || marker.provider !== definition.id || marker.loginProvider !== definition.loginProvider
-        || !['sessionId', 'noticeId', 'claimId', 'deliveryId', 'messageId', 'bindingId', 'workspaceId'].every(key => string(marker[key]))
-        || marker.messageId !== message.id || marker.deliveryId !== message.id || !workspaceName(marker.workspaceName)
-        || !Array.isArray(message.content) || message.content.length !== 1 || !object(message.content[0])
-        || message.content[0].type !== 'text' || message.content[0].text !== noticeText(marker.workspaceName))
-        return;
-    return marker;
-}
-/** Only this plugin's complete, source-bound notice may be excluded from remote model history. */
-export function isWorkspaceNoticeMessage(message) { return parseWorkspaceNoticeMarker(message) !== undefined; }
-function rawPresentation(message) {
-    const response = rawMarker(message), presentation = response && object(response.presentation) ? response.presentation : undefined;
-    return presentation && object(presentation.workspaceNotice) ? presentation.workspaceNotice : undefined;
-}
-function shape(value) {
-    if (!object(value))
-        return false;
-    const agent = AGENTS.find(a => a.id === value.provider);
-    return !!agent && value.kind === 'workspace-notice' && value.version === 2 && value.loginProvider === agent.loginProvider
-        && ['sessionId', 'noticeId', 'claimId', 'bindingId', 'workspaceId'].every(k => string(value[k])) && workspaceName(value.workspaceName)
-        && Number.isSafeInteger(value.turn) && value.turn > 0 && Number.isSafeInteger(value.step) && value.step > 0
-        && value.blockIndex === 0 && value.text === noticeText(value.workspaceName) + '\n\n';
-}
-export function workspaceNoticeFromMessage(message) {
-    if (!object(message) || message.role !== 'assistant' || !object(message.source) || message.source.kind !== 'model')
-        return;
-    const marker = rawPresentation(message), pointer = rawMarker(message);
-    if (!shape(marker) || message.source.provider !== marker.provider || pointer?.agent !== marker.provider || pointer.dshSessionId !== marker.sessionId
-        || pointer.bindingId !== marker.bindingId || pointer.workspaceId !== marker.workspaceId || !Array.isArray(message.content))
-        return;
-    const block = message.content[marker.blockIndex];
-    if (!object(block) || block.type !== 'text' || block.text !== marker.text)
-        return;
-    return marker;
-}
-/** Preserve the model answer and exact remote replay pointer; ordinary text is never searched. */
-export function withoutWorkspaceNotice(message) {
-    const marker = workspaceNoticeFromMessage(message);
-    if (!marker)
-        return message;
-    return { ...message, content: message.content.filter((_block, index) => index !== marker.blockIndex) };
-}
-function unknown(cause) {
-    return Object.assign(new NeedError('PROJECT_NOTICE_DELIVERY_UNKNOWN', '工作区说明的最终回复持久回执无法核对；请联系管理员核对，本次未继续派发远端请求。', '完整的官方最终会话记录和L工作区说明回执'), cause === undefined ? {} : { cause });
-}
-function requireServices(ctx, request) {
-    const id = string(request.sessionId) ? SessionId(request.sessionId) : undefined;
-    const registry = ctx.get('agents'), store = ctx.get('sessions'), persistence = ctx.get('sessionPersistence');
-    const live = id && typeof registry?.get === 'function' ? registry.get(id) : undefined, session = live?.session;
-    if (!id || !live || live.id !== id || !session || session.id !== id || typeof store?.get !== 'function' || store.get(id) !== session
-        || typeof session.snapshotEvents !== 'function' || typeof session.append !== 'function' || typeof store.flush !== 'function' || typeof persistence?.open !== 'function') {
-        throw new NeedError('DEPENDENCY_REQUIRED', '我需要当前真实会话及官方持久化读取能力，才能确认工作区说明；本次未启动远端。', 'DSH agents、sessions、sessionPersistence公共能力');
-    }
-    return { session, flush: () => store.flush(session), persistence };
-}
-function requireAcknowledge(api) {
-    const method = api.acknowledgeWorkspaceNotice;
-    if (typeof method !== 'function')
-        throw new NeedError('DEPENDENCY_REQUIRED', '我需要工作区说明回执能力；本次未启动远端。', 'L acknowledgeWorkspaceNotice公共接口');
-    return method.bind(api);
-}
-function receipt(marker, outcome, deliveryId) {
-    const base = { noticeId: marker.noticeId, surface: 'provider', claimId: marker.claimId, sessionId: marker.sessionId, provider: marker.loginProvider };
-    if (outcome === 'delivered' && string(deliveryId))
-        return { ...base, outcome, deliveryId };
-    return { ...base, outcome: 'unknown' };
-}
-async function acknowledge(method, value) {
-    const result = await method(value);
-    if (!object(result) || result.ok !== true)
-        throw unknown(result);
-}
-async function reportUnknown(api, marker, cause) {
-    let failure = cause;
-    try {
-        await acknowledge(requireAcknowledge(api), receipt(marker, 'unknown'));
-    }
-    catch (error) {
-        failure = new AggregateError([cause, error], '说明核对和未知状态记录均未完成');
-    }
-    throw unknown(failure);
-}
-async function readDurable(services) {
-    if (!await services.flush())
-        throw unknown();
-    const handle = await services.persistence.open(services.session.id, 'read');
-    try {
-        if (!handle || handle.id !== services.session.id || handle.header?.id !== services.session.id || handle.access !== 'read' || typeof handle.read !== 'function' || typeof handle.close !== 'function')
-            throw unknown();
-        const result = await handle.read();
-        if (!result || !Array.isArray(result.events))
-            throw unknown();
-        return result.events;
-    }
-    finally {
-        if (typeof handle?.close === 'function')
-            await handle.close();
-    }
-}
-function validateFinal(event, marker, events) {
-    if (event.surfaceOp !== 'append' || event.data.interrupted === true || !Array.isArray(event.data.stream)
-        || event.data.turn !== marker.turn || event.data.step !== marker.step || !isDeepStrictEqual(workspaceNoticeFromMessage(event.data.message), marker))
-        throw unknown();
-    // Chat renders the last final for a step. An earlier append is not enough.
-    if (events.some(e => e.type === 'assistant/message' && e.surfaceOp === 'append' && e.seq > event.seq && e.data.turn === marker.turn && e.data.step === marker.step))
-        throw unknown();
-    const assembler = new BlockAssembler();
-    for (const member of expandAssistantStream(event.data.stream))
-        assembler.push(member.chunk);
-    if (!['stop', 'max-tokens'].includes(assembler.finish.kind) || !isDeepStrictEqual(assembler.blocks(), event.data.message.content)
-        || !isDeepStrictEqual(assembler.replayState, event.data.message.source.replayState))
-        throw unknown();
-}
-function activeRequest(session, agent) {
-    let turn, step, provider;
-    for (const event of session.snapshotEvents())
-        switch (event.type) {
-            case 'turn/start':
-                turn = event.data.turn;
-                step = undefined;
-                break;
-            case 'turn/end':
-                turn = undefined;
-                step = undefined;
-                break;
-            case 'step/start':
-                if (event.data.turn !== turn)
-                    throw unknown();
-                step = event.data.step;
-                break;
-            case 'step/end':
-                step = undefined;
-                break;
-            case 'request/header':
-                provider = event.data.header.config.provider;
-                break;
-        }
-    if (!Number.isSafeInteger(turn) || turn < 1 || !Number.isSafeInteger(step) || step < 1 || provider !== agent.id)
-        throw unknown();
-    return { turn: turn, step: step };
-}
-export function createWorkspaceNoticeConsumer(ctx, agent) {
-    const pending = new Map();
-    const flights = new Map();
-    const failures = new Map();
-    const verify = async (sessionId, api, marker, event) => {
-        try {
-            const services = requireServices(ctx, { mode: 'session', sessionId }), events = await readDurable(services);
-            const current = event ? events.find(e => e.seq === event.seq) : undefined;
-            if (!event || current?.type !== 'assistant/message' || !isDeepStrictEqual(current, event))
-                throw unknown();
-            validateFinal(current, marker, events);
-            await acknowledge(requireAcknowledge(api), receipt(marker, 'delivered', current.data.message.id));
-            pending.delete(sessionId);
-            failures.delete(sessionId);
-        }
-        catch (error) {
-            return reportUnknown(api, marker, error);
-        }
-    };
-    ctx.on('session/event', (session, event) => {
-        const preparation = pending.get(session.id);
-        if (!preparation)
-            return;
-        const { marker, api } = preparation;
-        let relevant;
-        if (event.type === 'assistant/message' && event.data.turn === marker.turn && event.data.step === marker.step && event.data.message.source.provider === agent.id)
-            relevant = event;
-        else if (event.type === 'turn/end' && event.data.turn === marker.turn && !session.snapshotEvents().some(e => e.type === 'assistant/message' && e.data.turn === marker.turn && e.data.step === marker.step && e.data.message.source.provider === agent.id))
-            relevant = undefined;
-        else
-            return;
-        if (flights.has(session.id))
-            return;
-        // Wait for the synchronous event dispatch to enqueue the writer, then flush.
-        const operation = Promise.resolve().then(() => verify(session.id, api, marker, relevant));
-        flights.set(session.id, operation);
-        void operation.catch(error => { failures.set(session.id, error); });
-    });
-    const reconcile = async (request, api) => {
-        request.signal?.throwIfAborted();
-        const services = requireServices(ctx, request);
-        requireAcknowledge(api);
-        const flight = flights.get(services.session.id);
-        if (flight) {
-            try {
-                await flight;
-                return;
-            }
-            finally {
-                if (flights.get(services.session.id) === flight)
-                    flights.delete(services.session.id);
-            }
-        }
-        const events = await readDurable(services), seen = new Set();
-        let found = false;
-        for (const event of services.session.snapshotEvents()) {
-            if (event.type !== 'assistant/message')
-                continue;
-            const raw = rawPresentation(event.data.message);
-            if (!shape(raw) || raw.provider !== agent.id || raw.sessionId !== services.session.id)
-                continue;
-            if (seen.has(raw.noticeId))
-                return reportUnknown(api, raw, unknown());
-            seen.add(raw.noticeId);
-            found = true;
-            const durable = events.find(e => e.seq === event.seq);
-            if (durable?.type !== 'assistant/message' || !isDeepStrictEqual(durable, event))
-                return reportUnknown(api, raw, unknown());
-            try {
-                validateFinal(durable, raw, events);
-                await acknowledge(requireAcknowledge(api), receipt(raw, 'delivered', durable.data.message.id));
-                failures.delete(services.session.id);
-                pending.delete(services.session.id);
-            }
-            catch (error) {
-                return reportUnknown(api, raw, error);
-            }
-        }
-        if (!found && failures.has(services.session.id))
-            throw unknown(failures.get(services.session.id));
-        request.signal?.throwIfAborted();
-    };
-    const deliver = async (notice, resolved, request, api) => {
-        request.signal?.throwIfAborted();
-        const services = requireServices(ctx, request);
-        requireAcknowledge(api);
-        if (!notice || !string(notice.noticeId) || !string(notice.claimId) || notice.messageKey !== 'remote-workspace-binding' || !workspaceName(notice.workspaceName)
-            || resolved.sessionId !== services.session.id || !string(resolved.bindingId) || !string(resolved.workspaceId) || resolved.project?.name !== notice.workspaceName)
-            throw unknown();
-        const { turn, step } = activeRequest(services.session, agent);
-        const marker = { kind: 'workspace-notice', version: 2, provider: agent.id, loginProvider: agent.loginProvider, sessionId: services.session.id,
-            noticeId: notice.noticeId, claimId: notice.claimId, workspaceName: notice.workspaceName, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, turn, step, blockIndex: 0, text: noticeText(notice.workspaceName) + '\n\n' };
-        const prior = pending.get(services.session.id);
-        if (prior) {
-            if (!isDeepStrictEqual(prior.marker, marker))
-                throw unknown();
-            return prior.marker;
-        }
-        const recorded = services.session.snapshotEvents().filter((e) => e.type === 'assistant/message').find(e => workspaceNoticeFromMessage(e.data.message)?.noticeId === notice.noticeId);
-        if (recorded) {
-            await reconcile(request, api);
-            return undefined;
-        }
-        pending.set(services.session.id, { marker, api });
-        return marker;
-    };
-    return { reconcile, deliver };
-}

package/dist/workspace-source-confirmation.d.ts

@@ -1,4 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-import type { WorkspaceSourceOptions } from './workspace-source.ts';
-/** Official same-turn one-shot question; never changes policy or fabricates a tool call. */
-export declare function nativeWorkspaceSourceConfirmation(ctx: Context): WorkspaceSourceOptions['confirm'];

package/dist/workspace-source-confirmation.js

@@ -1,12 +0,0 @@
-import { SessionId } from '@deepseek-ai/dsh-session';
-/** Official same-turn one-shot question; never changes policy or fabricates a tool call. */
-export function nativeWorkspaceSourceConfirmation(ctx) {
-    return async (question, request) => {
-        const agent = request.sessionId ? ctx.get('agents')?.get(SessionId(request.sessionId)) : undefined;
-        const approval = ctx.get('approval');
-        const session = request.sessionId ? ctx.get('sessions')?.get(SessionId(request.sessionId)) : undefined;
-        if (!agent || !approval || !session || agent.session !== session)
-            return 'unavailable';
-        return approval.request({ agent, toolName: question.action, reason: question.question, signal: request.signal });
-    };
-}