@xopcai/xopc 0.0.385 → 0.0.387

package/dist/src/personal-agent/repository.js

@@ -13,7 +13,7 @@ const DEFAULT_PERSONAL_PREFERENCES = {
 	warmth: "balanced",
 	humor: "occasional",
 	supportMode: "untangle",
-	detailLevel: "balanced",
+	detailLevel: "brief",
 	proactivity: "decisions"
 };
 function personalAgentId(ownerId) {

package/dist/src/personal-agent/request-delivery.js

@@ -9,6 +9,7 @@ import { getPersonalRequest, init_request_repository, updatePersonalRequest } fr
 import { appendTranscriptEntry, init_transcript_repository, loadLlmMessagesForSession } from "../storage/sqlite/transcript-repository.js";
 import { getPersonalAgentByConversation } from "./repository.js";
 import { emitSessionTranscriptUpdate } from "../session/transcript-events.js";
+import { warmPersonalResult } from "./result-reader.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { TaskCollaborationRepository } from "../tasks/task-collaboration-repository.js";
 import { PersonalRequestResultSchema, renderPersonalRequestResult } from "./request-result.js";
@@ -105,7 +106,7 @@ function drainPersonalRequestResults(notify) {
 			const parsed = !outdated && stored.result_json && stored.result_run_id === run.id ? PersonalRequestResultSchema.safeParse(JSON.parse(stored.result_json)) : void 0;
 			const assistant = (run.conversationId ? loadLlmMessagesForSession(run.conversationId) : []).filter((message) => message.role === "assistant").at(-1);
 			const fallback = assistant?.role === "assistant" ? assistant.content.filter((part) => part.type === "text").map((part) => part.text).join("\n").trim() : "";
-			const content = parsed?.success ? renderPersonalRequestResult(parsed.data) : fallback && fallback !== "NO_REPLY" ? fallback.slice(0, 16e3) : receipt?.summary?.trim() || "Request finished without a readable result.";
+			const content = parsed?.success ? renderPersonalRequestResult(parsed.data) : fallback && fallback !== "NO_REPLY" ? fallback : receipt?.summary?.trim() || "Request finished without a readable result.";
 			const failed = run.status !== "succeeded";
 			const adoptionWarning = outdated ? "Supplemental requirements arrived after the saved connected-app result. Their completion is unverified; do not treat the older structured items as current." : "";
 			const display = failed ? `查询未完成。\n\n${content}` : content;
@@ -134,6 +135,7 @@ function drainPersonalRequestResults(notify) {
 				createdAt: now
 			});
 			const personal = getPersonalAgentByConversation(request.conversationId);
+			if (personal) warmPersonalResult(request.conversationId, delivery.deliveryId);
 			if (personal) enqueuePersonalReply({
 				delivery,
 				objective: request.objective,

package/dist/src/personal-agent/request-repository.d.ts

@@ -12,6 +12,8 @@ export interface PersonalRequest {
     parameters: {
         brief?: string;
         allocate?: boolean;
+        taskRunId?: string;
+        cancellationCleanupCompleted?: boolean;
         timeRange?: {
             from: string;
             to: string;

package/dist/src/personal-agent/request-service.d.ts

@@ -17,5 +17,9 @@ export declare function resolvePersonalRequestConnection(wait: ConnectionWait, r
 /** A worker can request access recovery without requiring a new main-chat turn. */
 export declare function requirePersonalWorkerConnection(conversationId: string): PersonalRequest;
 export declare function personalRequestSnapshot(request: PersonalRequest): PersonalRequest;
+/** Dispatch only the request's bound execution; SDK acknowledgement must not block input. */
+export declare function stopPersonalRequestExecution(request: PersonalRequest): {
+    executionStopConfirmed: boolean;
+};
 export declare function cancelPersonalRequest(request: PersonalRequest): PersonalRequest;
 export declare function publishPersonalRequest(request: PersonalRequest): void;

package/dist/src/personal-agent/request-service.js

@@ -1,3 +1,5 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { TaskCreateRequestSchema } from "../../packages/gateway-contract/src/tasks.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
@@ -15,13 +17,14 @@ import { canAccessConnectorAccount } from "../connectors/account-access.js";
 import { connectorPrincipalForSession } from "../connectors/principal.js";
 import { resolveConnectionCandidate } from "../connectors/connection-candidates.js";
 import { TaskCollaborationRepository } from "../tasks/task-collaboration-repository.js";
-import { TaskApplicationService } from "../tasks/task-application-service.js";
 import { defineTaskContract } from "../tasks/task-contract-definition.js";
+import { abortEmbeddedRun } from "../agent/embedded/runs.js";
+import { TaskApplicationService } from "../tasks/task-application-service.js";
+import { PERSONAL_WORKER_RESULT_GUIDANCE } from "./communication.js";
 import { assessSpecialist } from "../agent-matching/service.js";
+import { personalCapabilities } from "./capability-service.js";
 import { AgentSelectionRepository, selectionRequestHash } from "../agent-matching/selection-repository.js";
 import { assertSpecialistEligible } from "../agent-matching/delegation-service.js";
-import { PERSONAL_WORKER_RESULT_GUIDANCE } from "./communication.js";
-import { personalCapabilities } from "./capability-service.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/personal-agent/request-service.ts
 init_src();
@@ -34,6 +37,9 @@ init_task_repository();
 init_task_run_repository();
 init_connector_account_repository();
 init_connector_repository();
+init_logger();
+const log = createLogger("PersonalRequest");
+const pendingStops = /* @__PURE__ */ new Set();
 function requestAssessment(request, accountId) {
 	const principal = connectorPrincipalForSession(request.conversationId);
 	const capability = personalCapabilities(request.conversationId, request.connectorId, accountId).find((item) => item.connectorId === request.connectorId);
@@ -294,7 +300,11 @@ function startPersonalRequest(request, accountId) {
 	return updatePersonalRequest(request, {
 		state: result.ok ? "queued" : "failed",
 		accountId,
-		taskId
+		taskId,
+		parameters: {
+			...request.parameters,
+			taskRunId: result.ok ? result.runId : void 0
+		}
 	});
 }
 /** Called inside the connection-resolution transaction; ordinary waits return undefined. */
@@ -407,7 +417,11 @@ function requirePersonalWorkerConnection(conversationId) {
 		});
 		return updatePersonalRequest(request, {
 			state: "waiting_connection",
-			connectionWaitId: result.waitId
+			connectionWaitId: result.waitId,
+			parameters: {
+				...request.parameters,
+				taskRunId: run.id
+			}
 		});
 	});
 }
@@ -420,16 +434,58 @@ function personalRequestSnapshot(request) {
 		state
 	};
 }
-function cancelPersonalRequestTask(request) {
+function personalRequestRunId(request) {
+	if (request.parameters.taskRunId) return request.parameters.taskRunId;
+	if (request.connectionWaitId) {
+		const wait = getSqliteDatabase().prepare(`SELECT task_run_id FROM task_waits
+      WHERE task_id = ? AND json_extract(condition_json, '$.connectionWaitId') = ? LIMIT 1`).get(request.taskId ?? null, request.connectionWaitId);
+		if (wait?.task_run_id) return wait.task_run_id;
+	}
+	const selected = new AgentSelectionRepository().find(request.conversationId, `personal-request-start:${request.requestId}`)?.taskRunId;
+	if (selected) return selected;
+	return (request.taskId ? getSqliteDatabase().prepare(`SELECT run_id FROM task_runs
+    WHERE task_id = ? AND parent_run_id IS NULL ORDER BY queued_at, rowid LIMIT 1`).get(request.taskId) : void 0)?.run_id;
+}
+/** Dispatch only the request's bound execution; SDK acknowledgement must not block input. */
+function stopPersonalRequestExecution(request) {
+	if (request.state !== "cancelled") return { executionStopConfirmed: false };
+	const runId = personalRequestRunId(request);
+	const run = runId ? new TaskRunRepository().get(runId) : void 0;
+	if (!run || !run.conversationId && !run.startedAt) return { executionStopConfirmed: true };
+	if (run.conversationId) {
+		const state = getSessionInputState(run.conversationId);
+		const input = state.activeInputId ? getSessionInputById(run.conversationId, state.activeInputId) : void 0;
+		if (state.activeRunId && input?.taskRunId === run.id && !pendingStops.has(state.activeRunId)) {
+			const executionId = state.activeRunId;
+			pendingStops.add(executionId);
+			abortEmbeddedRun(run.conversationId, "user_cancelled", executionId).catch((err) => {
+				log.warn({
+					err,
+					requestId: request.requestId,
+					runId,
+					executionId
+				}, "Request cancelled; execution stop was not confirmed");
+			}).finally(() => {
+				pendingStops.delete(executionId);
+			});
+		}
+	}
+	return { executionStopConfirmed: false };
+}
+function cancelPersonalRequestTask(request, runId = personalRequestRunId(request)) {
 	if (!request.taskId) return;
 	const runs = new TaskRunRepository();
-	const run = runs.getActiveRoot(request.taskId);
+	const run = runId ? runs.get(runId) : void 0;
 	if (!run) return;
-	for (const wait of runs.listActiveWaits(request.taskId)) if (wait.condition.connectionWaitId === request.connectionWaitId) runs.resolveWait({
-		waitId: wait.id,
-		actor: { kind: "user" },
-		resolution: { cancelled: true }
-	});
+	if (![
+		"queued",
+		"running",
+		"waiting",
+		"verifying",
+		"cancelled"
+	].includes(run.status)) return;
+	runs.resolveCancelledRunWaits(run.id, { kind: "user" });
+	if (run.status === "cancelled") return;
 	if (!new TaskApplicationService().completeRun({
 		runId: run.id,
 		expectedRunVersion: run.version,
@@ -452,12 +508,17 @@ function cancelPersonalRequestTask(request) {
 	}).ok) throw new Error("Task changed while cancelling");
 }
 function cancelPersonalRequest(request) {
-	const snapshot = personalRequestSnapshot(request);
-	if (request.state === "cancelled" || ["completed", "failed"].includes(snapshot.state)) return snapshot;
-	return runSqliteWriteTransaction(() => {
-		if (request.connectionWaitId) cancelConnectionObjective(request.conversationId);
-		cancelPersonalRequestTask(request);
-		if (request.taskId) {
+	const cancelled = runSqliteWriteTransaction(() => {
+		request = getPersonalRequest(request.requestId);
+		if (request.parameters.cancellationCleanupCompleted) return request;
+		const snapshot = personalRequestSnapshot(request);
+		if (["completed", "failed"].includes(snapshot.state)) return snapshot;
+		const active = request.taskId ? new TaskRunRepository().getActiveRoot(request.taskId) : void 0;
+		const runId = personalRequestRunId(request);
+		const replacementRun = active && runId && active.id !== runId;
+		if (request.connectionWaitId) cancelConnectionObjective(request.conversationId, request.connectionWaitId);
+		cancelPersonalRequestTask(request, runId);
+		if (request.taskId && !replacementRun) {
 			const task = new TaskRepository().require(request.taskId);
 			if (task.phase !== "closed") new TaskApplicationService().execute({
 				taskId: task.id,
@@ -471,11 +532,21 @@ function cancelPersonalRequest(request) {
 			});
 			getSqliteDatabase().prepare("UPDATE task_allocations SET status = 'cancelled', lease_token = NULL WHERE task_id = ?").run(request.taskId);
 		}
-		return updatePersonalRequest(getPersonalRequest(request.requestId), { state: "cancelled" });
+		const current = getPersonalRequest(request.requestId);
+		return updatePersonalRequest(current, {
+			state: "cancelled",
+			parameters: {
+				...current.parameters,
+				taskRunId: runId,
+				cancellationCleanupCompleted: true
+			}
+		});
 	});
+	stopPersonalRequestExecution(cancelled);
+	return cancelled;
 }
 function publishPersonalRequest(request) {
 	publishConnectionWait(request.conversationId);
 }
 //#endregion
-export { assertPersonalRequestTimeRange, cancelPersonalRequest, personalRequestSnapshot, publishPersonalRequest, requirePersonalWorkerConnection, resolvePersonalRequestConnection, submitPersonalRequest };
+export { assertPersonalRequestTimeRange, cancelPersonalRequest, personalRequestSnapshot, publishPersonalRequest, requirePersonalWorkerConnection, resolvePersonalRequestConnection, stopPersonalRequestExecution, submitPersonalRequest };

package/dist/src/personal-agent/result-extraction.d.ts

@@ -0,0 +1,42 @@
+export interface ResultSection {
+    id: string;
+    title: string;
+    offset: number;
+    length: number;
+    locator: Record<string, unknown>;
+}
+export interface ResultPreparation {
+    database: string;
+    documentId: string;
+    lease: string;
+    file?: string;
+    expectedSha256?: string;
+    title: string;
+    mimeType?: string;
+    text?: string;
+}
+export declare const RESULT_PARSER_VERSION = 2;
+export declare const resultFingerprint: (value: {
+    size: number;
+    mtimeMs: number;
+    ctimeMs: number;
+}) => string;
+/** Runs only in a bounded background worker. No document code or macros are executed. */
+export declare function extractResult(input: Pick<ResultPreparation, 'file' | 'title' | 'mimeType' | 'text' | 'expectedSha256'>): Promise<{
+    unsupported: true;
+    reason: string;
+    text?: undefined;
+    sections?: undefined;
+    limitations?: undefined;
+    fingerprint?: undefined;
+    revision?: undefined;
+} | {
+    unsupported: false;
+    text: string;
+    sections: ResultSection[];
+    limitations: string[];
+    fingerprint: string;
+    revision: string;
+    reason?: undefined;
+}>;
+export declare function prepareResultDocument(input: ResultPreparation): Promise<void>;