@xopcai/xopc 0.0.359 → 0.0.360

package/dist/src/personal-agent/model-config.js

@@ -0,0 +1,59 @@
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_session_repository } from "../storage/sqlite/session-repository.js";
+import { getSessionConfig, init_config_repository, updateSessionConfig } from "../storage/sqlite/config-repository.js";
+import { RuntimePolicySchema } from "../agent-config/schema.js";
+import { init_agent_config } from "../agent-config/index.js";
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { resolveEffectiveAgentConfigForSession } from "../config/agent-profile.js";
+import { isPersonalConversation } from "./repository.js";
+//#region src/personal-agent/model-config.ts
+init_repository();
+init_agent_config();
+init_config_repository();
+init_session_repository();
+init_transaction();
+/** Personal AI has one conversation; its Agent is the source of model preferences. */
+function syncPersonalModelConfig(conversationId) {
+	const existing = getSessionConfig(conversationId);
+	if (!isPersonalConversation(conversationId)) return existing;
+	const effective = resolveEffectiveAgentConfigForSession(conversationId).config;
+	const modelOverride = effective.models.chat.primary;
+	const thinkingLevel = effective.runtime.thinkingLevel ?? "off";
+	if (existing?.modelOverride === modelOverride && existing.thinkingLevel === thinkingLevel && existing.fixedModel) return existing;
+	return updateSessionConfig(conversationId, {
+		modelOverride,
+		thinkingLevel,
+		fixedModel: true
+	}, process.cwd());
+}
+function savePersonalModelConfig(conversationId, model, thinkingLevel) {
+	return runSqliteWriteTransaction(() => {
+		const agentId = getSessionMetadata(conversationId).agentId;
+		const repository = new AgentCatalogRepository();
+		const agent = repository.get(agentId);
+		const { revision: _revision, provisioningState: _state, provisioningError: _error, createdAt: _created, updatedAt: _updated, deletedAt: _deleted, ...entry } = agent;
+		repository.update(agentId, agent.revision, {
+			...entry,
+			models: {
+				...agent.models,
+				chat: {
+					...agent.models?.chat,
+					primary: model,
+					fallbacks: agent.models?.chat?.fallbacks ?? []
+				}
+			},
+			runtime: {
+				...agent.runtime,
+				thinkingLevel: RuntimePolicySchema.shape.thinkingLevel.parse(thinkingLevel)
+			}
+		});
+		return updateSessionConfig(conversationId, {
+			modelOverride: model,
+			thinkingLevel,
+			fixedModel: true
+		}, process.cwd());
+	});
+}
+//#endregion
+export { savePersonalModelConfig, syncPersonalModelConfig };

package/dist/src/personal-agent/policy.d.ts

@@ -1 +1 @@
-export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_preference", "session_recall", "user_context_search", "user_context_get", "knowledge_search", "knowledge_get", "clarify"];
+export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_capability", "personal_request", "personal_preference", "session_recall", "user_context_search", "user_context_get", "knowledge_search", "knowledge_get", "clarify"];

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

@@ -1,6 +1,8 @@
 //#region src/personal-agent/policy.ts
 const PERSONAL_MAIN_TOOL_IDS = [
 	"personal_task",
+	"personal_capability",
+	"personal_request",
 	"personal_preference",
 	"session_recall",
 	"user_context_search",

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

@@ -6,6 +6,7 @@ export interface PersonalAgentRecord {
     conversationId: string;
     state: PersonalAgentState;
     displayName: string;
+    userCallName: string | null;
     appearance: PersonalAppearance;
     voicePreference: {
         provider: string;

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

@@ -2,6 +2,7 @@ import { init_connection, isXopcDatabaseOpen } from "../storage/sqlite/connectio
 import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { getUserProfileSnapshot } from "../user-model/profile.js";
 import { createHash } from "node:crypto";
 //#region src/personal-agent/repository.ts
 init_repository();
@@ -37,13 +38,14 @@ function appearanceFrom(agent) {
 }
 function toRecord(ownerId, agent, session) {
 	const config = session ? getSessionConfig(session.conversation_id) : null;
-	const ready = agent.provisioningState === "ready" && agent.runtime?.thinkingLevel === "off" && session && config?.thinkingLevel === "off" && config.fixedModel;
+	const ready = agent.provisioningState === "ready" && session && config?.fixedModel;
 	return {
 		ownerId,
 		agentId: agent.id,
 		conversationId: session?.conversation_id ?? personalConversationId(ownerId),
 		state: agent.provisioningState === "error" ? "error" : ready ? "ready" : "provisioning",
 		displayName: agent.profile?.name ?? "Ada",
+		userCallName: getUserProfileSnapshot().callName ?? null,
 		appearance: appearanceFrom(agent),
 		voicePreference: agent.profile?.voicePreference ?? null,
 		preferences: agent.profile?.responsePreferences ?? DEFAULT_PERSONAL_PREFERENCES,

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

@@ -0,0 +1,4 @@
+/** Closed authorization waits retain their feedback marker for restart-safe delivery. */
+export declare function drainPersonalRequestContinuations(notify?: (conversationId: string, requestId: string) => void): void;
+/** The request itself is the durable outbox; append and delivery marker commit together. */
+export declare function drainPersonalRequestResults(notify?: (conversationId: string, requestId: string) => void): void;

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

@@ -0,0 +1,159 @@
+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 { TASK_RESULT_DELIVERY_TYPE, TaskResultDeliverySchema } from "../../packages/gateway-contract/src/task-result-delivery.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "../storage/sqlite/session-instance-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../tasks/task-run-repository.js";
+import { getPersonalRequest, init_request_repository, updatePersonalRequest } from "./request-repository.js";
+import { appendTranscriptEntry, init_transcript_repository, loadLlmMessagesForSession } from "../storage/sqlite/transcript-repository.js";
+import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
+import { emitSessionTranscriptUpdate } from "../session/transcript-events.js";
+import { PersonalRequestResultSchema, renderPersonalRequestResult } from "./request-result.js";
+//#region src/personal-agent/request-delivery.ts
+init_src();
+init_transaction();
+init_transcript_repository();
+init_session_instance_repository();
+init_task_run_repository();
+init_logger();
+init_request_repository();
+const log = createLogger("PersonalRequestDelivery");
+/** Closed authorization waits retain their feedback marker for restart-safe delivery. */
+function drainPersonalRequestContinuations(notify) {
+	const db = getSqliteDatabase();
+	const rows = db.prepare(`SELECT wait.id, request.request_id FROM session_connection_waits wait
+    JOIN personal_requests request ON request.connection_wait_id = wait.id
+    WHERE wait.status = 'closed' AND json_extract(wait.data_json, '$.resolution') = 'continued'
+      AND json_extract(wait.data_json, '$.personalResumeFeedback.notifiedAt') IS NULL
+    ORDER BY request.created_at LIMIT 50`).all();
+	for (const row of rows) try {
+		const request = getPersonalRequest(row.request_id);
+		if (!runSqliteWriteTransaction(() => {
+			if (readCurrentTranscriptId(db, request.conversationId) !== request.transcriptId || request.state === "cancelled") {
+				db.prepare("UPDATE session_connection_waits SET data_json = json_set(data_json, '$.personalResumeFeedback.notifiedAt', ?) WHERE id = ?").run(Date.now(), row.id);
+				return;
+			}
+			const stored = db.prepare("SELECT json_extract(data_json, '$.personalResumeFeedback.entryId') AS entry_id FROM session_connection_waits WHERE id = ?").get(row.id);
+			if (stored.entry_id) return stored.entry_id;
+			const content = /[\u3400-\u9fff]/u.test(request.objective) ? "连接成功，正在继续处理你的请求。结果会直接发到这里。" : "Connected. Continuing your request; the result will appear here.";
+			const entry = appendTranscriptEntry(request.conversationId, {
+				role: "custom",
+				customType: "personal_request_status",
+				content,
+				details: {
+					requestId: request.requestId,
+					waitId: row.id,
+					taskId: request.taskId
+				},
+				display: true,
+				timestamp: Date.now()
+			});
+			db.prepare("UPDATE session_connection_waits SET data_json = json_set(data_json, '$.personalResumeFeedback.entryId', ?) WHERE id = ?").run(entry.entry_id, row.id);
+			return entry.entry_id;
+		})) continue;
+		emitSessionTranscriptUpdate({ conversationId: request.conversationId });
+		notify?.(request.conversationId, request.requestId);
+		db.prepare("UPDATE session_connection_waits SET data_json = json_set(data_json, '$.personalResumeFeedback.notifiedAt', ?) WHERE id = ?").run(Date.now(), row.id);
+	} catch (err) {
+		const errorMessage = (err instanceof Error ? err.message : String(err)).slice(0, 500);
+		if (db.prepare(`UPDATE session_connection_waits
+        SET data_json = json_set(data_json, '$.personalResumeFeedback.error', ?)
+        WHERE id = ? AND COALESCE(json_extract(data_json, '$.personalResumeFeedback.error'), '') != ?`).run(errorMessage, row.id, errorMessage).changes) log.warn({
+			err,
+			requestId: row.request_id,
+			waitId: row.id
+		}, "Connection continuation feedback will retry");
+	}
+}
+/** The request itself is the durable outbox; append and delivery marker commit together. */
+function drainPersonalRequestResults(notify) {
+	const db = getSqliteDatabase();
+	const rows = db.prepare(`SELECT request_id, delivery_attempts FROM personal_requests request WHERE task_id IS NOT NULL
+    AND state != 'cancelled' AND notified_at IS NULL AND delivery_attempts < 8 AND delivery_next_attempt_at <= ? AND EXISTS
+    (SELECT 1 FROM task_runs run WHERE run.task_id = request.task_id AND run.parent_run_id IS NULL
+      AND run.status IN ('succeeded','failed','cancelled')
+      AND NOT EXISTS (SELECT 1 FROM task_runs newer WHERE newer.task_id = run.task_id
+        AND newer.parent_run_id IS NULL AND newer.queued_at > run.queued_at))
+    ORDER BY created_at LIMIT 50`).all(Date.now());
+	for (const row of rows) try {
+		const request = getPersonalRequest(row.request_id);
+		const run = new TaskRunRepository().getLatestRoot(request.taskId);
+		if (!run || ![
+			"succeeded",
+			"failed",
+			"cancelled"
+		].includes(run.status)) continue;
+		const state = new TaskConversationRepository().getState(request.taskId);
+		const receipt = new TaskRunRepository().getReceipt(run.id);
+		runSqliteWriteTransaction(() => {
+			const stored = db.prepare("SELECT result_json, result_run_id, delivery_entry_id FROM personal_requests WHERE request_id = ?").get(request.requestId);
+			if (stored.delivery_entry_id) return;
+			if (readCurrentTranscriptId(db, request.conversationId) !== request.transcriptId) {
+				updatePersonalRequest(request, { state: run.status === "succeeded" ? "completed" : "failed" });
+				db.prepare("UPDATE personal_requests SET notified_at = ? WHERE request_id = ?").run(Date.now(), request.requestId);
+				return;
+			}
+			if (state?.activeConversationId !== run.conversationId) throw new Error("Task execution changed");
+			const parsed = 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 ?? "Request finished without a readable result.";
+			const failed = run.status !== "succeeded";
+			const display = failed ? `查询未完成。\n\n${content}` : content;
+			const now = Date.now();
+			const delivery = TaskResultDeliverySchema.parse({
+				version: 1,
+				deliveryId: `personal-request:${request.requestId}`,
+				taskId: request.taskId,
+				taskRunId: run.id,
+				taskTitle: request.objective.slice(0, 300),
+				conversationId: request.conversationId,
+				originTranscriptId: request.transcriptId,
+				requestInputId: request.inputId,
+				assignmentEpoch: state?.assignmentEpoch ?? 0,
+				outcome: {
+					version: 1,
+					outcomeId: `personal-request:${request.requestId}`,
+					runId: run.id,
+					turnId: `personal-request:${request.requestId}`,
+					status: failed ? "failed" : parsed?.success && parsed.data.coverage?.partial ? "partial" : "succeeded",
+					summary: content.slice(0, 2e3),
+					deliverables: [],
+					evidence: [],
+					createdAt: new Date(now).toISOString()
+				},
+				createdAt: now
+			});
+			const entry = appendTranscriptEntry(request.conversationId, {
+				role: "custom",
+				customType: TASK_RESULT_DELIVERY_TYPE,
+				content: display,
+				details: delivery,
+				display: true,
+				timestamp: now
+			});
+			updatePersonalRequest(request, { state: run.status === "cancelled" ? "cancelled" : failed ? "failed" : "completed" });
+			db.prepare("UPDATE personal_requests SET delivery_entry_id = ? WHERE request_id = ?").run(entry.entry_id, request.requestId);
+			db.prepare(`UPDATE task_main_update_deliveries SET status = 'delivered', decision = 'silent',
+          decision_reason = 'Personal request result delivered', updated_at = ? WHERE entry_id IN
+          (SELECT entry_id FROM task_collaboration_entries WHERE task_run_id = ? AND kind IN ('result','failure','progress'))`).run(now, run.id);
+		});
+		const delivered = db.prepare("SELECT delivery_entry_id, notified_at FROM personal_requests WHERE request_id = ?").get(request.requestId);
+		if (delivered.delivery_entry_id && !delivered.notified_at) {
+			emitSessionTranscriptUpdate({ conversationId: request.conversationId });
+			notify?.(request.conversationId, request.requestId);
+			db.prepare("UPDATE personal_requests SET notified_at = ? WHERE request_id = ?").run(Date.now(), request.requestId);
+		}
+	} catch (err) {
+		db.prepare(`UPDATE personal_requests SET delivery_attempts = delivery_attempts + 1,
+        delivery_next_attempt_at = ?, delivery_error = ? WHERE request_id = ?`).run(Date.now() + Math.min(6e4, 1e3 * 2 ** row.delivery_attempts), (err instanceof Error ? err.message : String(err)).slice(0, 500), row.request_id);
+		if (row.delivery_attempts === 0 || row.delivery_attempts === 7) log.warn({
+			err,
+			requestId: row.request_id,
+			attempts: row.delivery_attempts + 1
+		}, row.delivery_attempts === 7 ? "Personal request delivery exhausted retries" : "Personal request delivery will retry");
+	}
+}
+//#endregion
+export { drainPersonalRequestContinuations, drainPersonalRequestResults };

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

@@ -0,0 +1,33 @@
+import type { PersonalRequestResult } from './request-result.js';
+export type PersonalRequestState = 'preflighting' | 'waiting_connection' | 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface PersonalRequest {
+    requestId: string;
+    conversationId: string;
+    transcriptId: string;
+    inputId: string;
+    objective: string;
+    connectorId: string;
+    executorAgentId: string;
+    accountId?: string;
+    parameters: {
+        timeRange?: {
+            from: string;
+            to: string;
+            timezone: string;
+            expression: string;
+        };
+    };
+    state: PersonalRequestState;
+    connectionWaitId?: string;
+    taskId?: string;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    result?: PersonalRequestResult;
+}
+export declare function getPersonalRequest(requestId: string): PersonalRequest | undefined;
+export declare function personalRequestForWait(waitId: string): PersonalRequest | undefined;
+export declare function personalRequestForTask(taskId: string): PersonalRequest | undefined;
+export declare function personalRequestForExecution(conversationId: string): PersonalRequest | undefined;
+export declare function listPersonalRequests(conversationId: string): PersonalRequest[];
+export declare function updatePersonalRequest(request: PersonalRequest, patch: Partial<Pick<PersonalRequest, 'state' | 'connectionWaitId' | 'accountId' | 'taskId' | 'objective' | 'connectorId' | 'parameters'>>): PersonalRequest;

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

@@ -0,0 +1,71 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_connection, isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+//#region src/personal-agent/request-repository.ts
+function fromRow(row) {
+	return {
+		requestId: row.request_id,
+		conversationId: row.conversation_id,
+		transcriptId: row.transcript_id,
+		inputId: row.input_id,
+		objective: row.objective,
+		connectorId: row.connector_id,
+		executorAgentId: row.executor_agent_id,
+		accountId: row.account_id ?? void 0,
+		parameters: JSON.parse(row.parameters_json),
+		state: row.state,
+		connectionWaitId: row.connection_wait_id ?? void 0,
+		taskId: row.task_id ?? void 0,
+		version: row.version,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		...row.result_json ? { result: JSON.parse(row.result_json) } : {}
+	};
+}
+function getPersonalRequest(requestId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare("SELECT * FROM personal_requests WHERE request_id = ?").get(requestId);
+	return row ? fromRow(row) : void 0;
+}
+function personalRequestForWait(waitId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare("SELECT * FROM personal_requests WHERE connection_wait_id = ?").get(waitId);
+	return row ? fromRow(row) : void 0;
+}
+function personalRequestForTask(taskId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare("SELECT * FROM personal_requests WHERE task_id = ?").get(taskId);
+	return row ? fromRow(row) : void 0;
+}
+function personalRequestForExecution(conversationId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare(`SELECT request.* FROM personal_requests request
+    JOIN task_sessions session ON session.task_id = request.task_id
+    JOIN task_conversation_state state ON state.task_id = session.task_id
+      AND state.active_conversation_id = session.conversation_id AND state.assignment_epoch = session.assignment_epoch
+    WHERE session.conversation_id = ? AND session.role = 'execution' AND session.status = 'active'
+    ORDER BY session.created_at DESC LIMIT 1`).get(conversationId);
+	return row ? fromRow(row) : void 0;
+}
+function listPersonalRequests(conversationId) {
+	return getSqliteDatabase().prepare("SELECT * FROM personal_requests WHERE conversation_id = ? ORDER BY created_at DESC LIMIT 50").all(conversationId).map(fromRow);
+}
+function updatePersonalRequest(request, patch) {
+	const next = {
+		...request,
+		...patch,
+		version: request.version + 1,
+		updatedAt: Date.now()
+	};
+	if (!getSqliteDatabase().prepare(`UPDATE personal_requests SET state = ?, connection_wait_id = ?,
+    account_id = ?, task_id = ?, objective = ?, connector_id = ?, parameters_json = ?, version = ?, updated_at = ?
+    WHERE request_id = ? AND version = ?`).run(next.state, next.connectionWaitId ?? null, next.accountId ?? null, next.taskId ?? null, next.objective, next.connectorId, JSON.stringify(next.parameters), next.version, next.updatedAt, request.requestId, request.version).changes) throw new Error("PERSONAL_REQUEST_CHANGED");
+	return next;
+}
+var init_request_repository = __esmMin((() => {
+	init_transaction();
+	init_connection();
+}));
+//#endregion
+init_request_repository();
+export { getPersonalRequest, init_request_repository, listPersonalRequests, personalRequestForExecution, personalRequestForTask, personalRequestForWait, updatePersonalRequest };

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

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const PersonalRequestResultSchema: z.ZodObject<{
+    summary: z.ZodString;
+    coverage: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        scannedCount: z.ZodNumber;
+        partial: z.ZodBoolean;
+    }, z.core.$strip>>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        subject: z.ZodString;
+        sender: z.ZodString;
+        receivedAt: z.ZodString;
+        importanceReason: z.ZodString;
+        suggestedAction: z.ZodOptional<z.ZodString>;
+        openUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export type PersonalRequestResult = z.infer<typeof PersonalRequestResultSchema>;
+export declare function renderPersonalRequestResult(result: PersonalRequestResult): string;

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

@@ -0,0 +1,45 @@
+import { z } from "zod";
+//#region src/personal-agent/request-result.ts
+const PersonalRequestResultSchema = z.object({
+	summary: z.string().trim().min(1).max(8e3),
+	coverage: z.object({
+		from: z.string().datetime({ offset: true }),
+		to: z.string().datetime({ offset: true }),
+		scannedCount: z.number().int().nonnegative(),
+		partial: z.boolean()
+	}).optional(),
+	items: z.array(z.object({
+		messageId: z.string().min(1).max(500),
+		subject: z.string().max(500),
+		sender: z.string().max(500),
+		receivedAt: z.string().datetime({ offset: true }),
+		importanceReason: z.string().max(2e3),
+		suggestedAction: z.string().max(2e3).optional(),
+		openUrl: z.string().url().refine((value) => {
+			const url = new URL(value);
+			return url.protocol === "https:" && !url.username && !url.password && [
+				"mail.google.com",
+				"outlook.live.com",
+				"outlook.office.com",
+				"outlook.office365.com"
+			].includes(url.hostname);
+		}).optional()
+	})).max(50).default([])
+}).strict();
+function escapeMarkdown(value) {
+	return value.replace(/[\\`*_{}\[\]()<>#!|]/g, "\\$&").replace(/\r?\n/g, " ");
+}
+function renderPersonalRequestResult(result) {
+	const lines = [result.summary];
+	if (result.coverage) {
+		const { from, to, scannedCount, partial } = result.coverage;
+		lines.push(`查询范围：${escapeMarkdown(from)} — ${escapeMarkdown(to)}；已检查 ${scannedCount} 封邮件${partial ? "。查询尚未覆盖全部邮件。" : "。"}`);
+	}
+	for (const item of result.items) {
+		const title = escapeMarkdown(item.subject || "(无主题)");
+		lines.push(`${item.openUrl ? `[${title}](${encodeURI(item.openUrl).replace(/\(/g, "%28").replace(/\)/g, "%29")})` : title}\n\n${escapeMarkdown(item.sender)} · ${escapeMarkdown(item.receivedAt)}\n\n${escapeMarkdown(item.importanceReason)}${item.suggestedAction ? `\n\n${escapeMarkdown(item.suggestedAction)}` : ""}`);
+	}
+	return lines.join("\n\n");
+}
+//#endregion
+export { PersonalRequestResultSchema, renderPersonalRequestResult };

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

@@ -0,0 +1,18 @@
+import { type ConnectionWait } from '@xopcai/gateway-contract';
+import { type PersonalRequest } from './request-repository.js';
+export declare function submitPersonalRequest(input: {
+    conversationId: string;
+    connectorId: string;
+    objective: string;
+    agentId: string;
+    accountId?: string;
+    timeRange?: PersonalRequest['parameters']['timeRange'];
+    idempotencyKey: string;
+}): PersonalRequest;
+/** Called inside the connection-resolution transaction; ordinary waits return undefined. */
+export declare function resolvePersonalRequestConnection(wait: ConnectionWait, resolution: 'continued' | 'skipped'): PersonalRequest | undefined;
+/** 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;
+export declare function cancelPersonalRequest(request: PersonalRequest): PersonalRequest;
+export declare function publishPersonalRequest(request: PersonalRequest): void;