@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/gateway/service/session-input-coordinator.js

@@ -0,0 +1,183 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "../../storage/sqlite/session-input-repository.js";
+import "../../storage/sqlite/index.js";
+import crypto from "node:crypto";
+//#region src/gateway/service/session-input-coordinator.ts
+init_logger();
+const log = createLogger("SessionInputCoordinator");
+const MAX_PENDING_INPUTS = 10;
+var SessionInputCoordinator = class {
+	draining = /* @__PURE__ */ new Set();
+	submissionTails = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	snapshot(sessionKey) {
+		return getSessionInputState(sessionKey);
+	}
+	publish(sessionKey) {
+		const state = this.snapshot(sessionKey);
+		this.deps.emit("session.input-state", state);
+		return state;
+	}
+	async submit(input) {
+		const sessionKey = input.sessionKey.trim();
+		const previous = this.submissionTails.get(sessionKey) ?? Promise.resolve();
+		let release = () => {};
+		const current = new Promise((resolve) => {
+			release = resolve;
+		});
+		const tail = previous.then(() => current);
+		this.submissionTails.set(sessionKey, tail);
+		await previous;
+		try {
+			return await this.submitLocked({
+				...input,
+				sessionKey
+			});
+		} finally {
+			release();
+			if (this.submissionTails.get(sessionKey) === tail) this.submissionTails.delete(sessionKey);
+		}
+	}
+	async submitLocked(input) {
+		const sessionKey = input.sessionKey;
+		const clientMessageId = input.clientMessageId.trim();
+		const content = input.content.trim();
+		if (!sessionKey || !clientMessageId || !content && !input.attachments?.length) return {
+			ok: false,
+			code: "BAD_REQUEST"
+		};
+		if (!await this.deps.sessionExists(sessionKey)) return {
+			ok: false,
+			code: "BAD_REQUEST"
+		};
+		const existing = findSessionInput(sessionKey, clientMessageId);
+		if (existing) return {
+			ok: true,
+			effectiveDelivery: existing.effectiveDelivery,
+			state: this.snapshot(sessionKey)
+		};
+		if (this.snapshot(sessionKey).inputs.length >= MAX_PENDING_INPUTS) return {
+			ok: false,
+			code: "QUEUE_FULL"
+		};
+		const attachments = await this.deps.prepareAttachments(sessionKey, input.attachments);
+		const runtime = this.snapshot(sessionKey);
+		const canSteer = input.delivery === "steer" && runtime.activeRunId !== void 0 && !attachments?.length;
+		const effectiveDelivery = canSteer ? "steer" : "next";
+		const row = insertSessionInput({
+			id: crypto.randomUUID(),
+			sessionKey,
+			clientMessageId,
+			requestedDelivery: input.delivery,
+			effectiveDelivery,
+			status: canSteer ? "injecting" : "queued",
+			content,
+			attachments,
+			thinking: input.thinking,
+			targetRunId: canSteer ? runtime.activeRunId : void 0
+		});
+		if (canSteer) {
+			if (!await this.deps.steer(sessionKey, content)) {
+				setSessionInputStatus(row.id, "queued", {
+					effectiveDelivery: "next",
+					targetRunId: null
+				});
+				this.drain(sessionKey);
+				return {
+					ok: true,
+					effectiveDelivery: "next",
+					state: this.publish(sessionKey)
+				};
+			}
+			return {
+				ok: true,
+				effectiveDelivery: "steer",
+				state: this.publish(sessionKey)
+			};
+		}
+		this.drain(sessionKey);
+		return {
+			ok: true,
+			effectiveDelivery: "next",
+			state: this.publish(sessionKey)
+		};
+	}
+	async drain(sessionKey) {
+		if (this.draining.has(sessionKey)) return;
+		this.draining.add(sessionKey);
+		try {
+			while (true) {
+				const runId = crypto.randomUUID();
+				const input = claimNextSessionInput(sessionKey, runId);
+				if (!input) return;
+				this.publish(sessionKey);
+				let result;
+				try {
+					result = await this.deps.execute({
+						runId,
+						sessionKey,
+						content: input.content,
+						attachments: input.attachments,
+						thinking: input.thinking
+					});
+				} catch (error) {
+					result = {
+						status: "error",
+						summary: error instanceof Error ? error.message : String(error)
+					};
+					log.warn({
+						err: error,
+						sessionKey,
+						runId,
+						inputId: input.id
+					}, "Session input execution failed");
+				}
+				const terminal = result.status === "ok" ? "completed" : result.status === "aborted" ? "cancelled" : "failed";
+				finishSessionInputRun(sessionKey, runId, terminal, terminal === "failed" ? result.summary : void 0);
+				this.publish(sessionKey);
+			}
+		} finally {
+			this.draining.delete(sessionKey);
+		}
+	}
+	async update(sessionKey, id, body) {
+		const attachments = body.attachments === void 0 ? void 0 : await this.deps.prepareAttachments(sessionKey, body.attachments);
+		const ok = mutateQueuedSessionInput({
+			sessionKey,
+			id,
+			...body,
+			attachments
+		});
+		return {
+			ok,
+			state: ok ? this.publish(sessionKey) : this.snapshot(sessionKey)
+		};
+	}
+	remove(sessionKey, id, version) {
+		const ok = cancelQueuedSessionInput(sessionKey, id, version);
+		return {
+			ok,
+			state: ok ? this.publish(sessionKey) : this.snapshot(sessionKey)
+		};
+	}
+	async waitForCompletion(sessionKey, clientMessageId) {
+		while (true) {
+			const row = findSessionInput(sessionKey, clientMessageId);
+			if (!row) throw new Error("Session input disappeared before completion");
+			if (row.status === "completed") return;
+			if (row.status === "failed" || row.status === "cancelled" || row.status === "interrupted") throw new Error(row.error ?? `Session input ended with status ${row.status}`);
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+	}
+	recover() {
+		for (const sessionKey of recoverSessionInputState()) {
+			this.publish(sessionKey);
+			this.drain(sessionKey);
+		}
+	}
+};
+//#endregion
+export { SessionInputCoordinator };

package/dist/src/gateway/service/sessions-api.d.ts

@@ -92,6 +92,7 @@ export declare class GatewaySessionsApi {
         reasoningLevel?: string | null;
         verboseLevel?: string;
         workingDirectory?: string;
+        responseLanguage?: string | null;
     }): Promise<import("../../agent/session/session-config-service.js").PatchSessionAgentConfigResult>;
     listCompactionBoundaries(key: string): Promise<import("../../session/types.js").CompactionBoundarySummary[]>;
     restoreBeforeCompactionBoundary(key: string, compactionId: string): Promise<void>;

package/dist/src/gateway/service.d.ts

@@ -1,7 +1,7 @@
 import { AgentService } from '../agent/service.js';
 import { MessageBus } from '../infra/bus/index.js';
 import { AutomationService } from '../automations/index.js';
-import { DiscussionLiveWorker, DiscussionService, DiscussionWorker } from '../discussions/index.js';
+import { DiscussionLiveWorker, DiscussionOrganizerWorker, DiscussionSealer, DiscussionService } from '../discussions/index.js';
 import { NotesService } from '../notes/index.js';
 import { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
 import { ExtensionLoader } from '../extensions/index.js';
@@ -9,11 +9,8 @@ import { SessionIndex } from '../session/index.js';
 import type { Config } from '../config/schema.js';
 import { type ResolvedGatewayAuth } from './auth.js';
 import { ModelCatalogSyncService } from '../providers/model-catalog-sync-service.js';
-import { AgentRunRelay } from './agent-run-relay.js';
-import { type EnqueueGoalRunOptions } from '../goals/index.js';
 import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
-import { WorkItemService } from '../work-items/index.js';
 import { type BrowserRecipeService } from '../browser/recipes/index.js';
 import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker } from '../proactive/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
@@ -63,8 +60,8 @@ export declare class GatewayService {
     private startupTrace;
     private workflowSessionBridge;
     private workflowRunServiceInstance;
-    private goalRunner;
-    private goalNotifications;
+    private taskRunDispatcher;
+    private taskRunDispatchTimer;
     private mobileNotifications;
     private connectorSupervisor;
     private connectorLearningCoordinator;
@@ -78,8 +75,6 @@ export declare class GatewayService {
      * `activeWebchatRunBySession` + `runAbortControllers` maps.
      */
     readonly agentRunner: GatewayAgentRunner;
-    /** Read-only alias re-exported from `agentRunner.runRelay` for legacy callers. */
-    get runRelay(): AgentRunRelay;
     /**
      * Session CRUD / search / compaction / tag-archive-pin / stats — the gateway
      * REST surface for sessions. Routes should depend on this narrow service
@@ -93,10 +88,10 @@ export declare class GatewayService {
     readonly marketplace: GatewayMarketplaceService;
     /** First-class project grouping surface. */
     readonly projects: ProjectService;
-    readonly workItems: WorkItemService;
     readonly discussions: DiscussionService;
-    readonly discussionWorker: DiscussionWorker;
+    readonly discussionWorker: DiscussionOrganizerWorker;
     readonly discussionLiveWorker: DiscussionLiveWorker;
+    readonly discussionSealer: DiscussionSealer;
     /** Local user-created apps, their coder projects, previews, and installs. */
     readonly localApps: LocalAppService;
     /** Unified durable event spine for proactive scenarios. */
@@ -114,15 +109,32 @@ export declare class GatewayService {
     refreshUserProfileContext(): void;
     private ensureAgentService;
     private ensureHeartbeatService;
-    private createGoalRunner;
-    private createGoalNotificationService;
+    private createTaskRunDispatcher;
     private createMobileNotificationService;
-    enqueueGoalRun(goalId: string, options?: EnqueueGoalRunOptions): import("../goals/goal-queue-types.js").GoalQueueItemSnapshot;
-    getGoalQueueSnapshot(): import("../goals/goal-queue-types.js").GoalQueueItemSnapshot[];
+    dispatchTaskRuns(): void;
     runAgent(...args: Parameters<GatewayAgentRunner['runAgent']>): ReturnType<GatewayAgentRunner['runAgent']>;
-    abortAgentRun(runId: string): boolean;
+    submitSessionInput(...args: Parameters<GatewayAgentRunner['submitSessionInput']>): Promise<{
+        ok: true;
+        effectiveDelivery: import("../storage/sqlite/session-input-repository.js").SessionInputDelivery;
+        state: import("../storage/sqlite/session-input-repository.js").SessionInputState;
+    } | {
+        ok: false;
+        code: "BAD_REQUEST" | "QUEUE_FULL";
+    }>;
+    getSessionInputState(...args: Parameters<GatewayAgentRunner['getSessionInputState']>): import("../storage/sqlite/session-input-repository.js").SessionInputState;
+    updateSessionInput(...args: Parameters<GatewayAgentRunner['updateSessionInput']>): Promise<{
+        ok: boolean;
+        state: import("../storage/sqlite/session-input-repository.js").SessionInputState;
+    }>;
+    removeSessionInput(...args: Parameters<GatewayAgentRunner['removeSessionInput']>): {
+        ok: boolean;
+        state: import("../storage/sqlite/session-input-repository.js").SessionInputState;
+    };
+    abortAgentRun(runId: string): Promise<{
+        aborted: boolean;
+        idle: boolean;
+    }>;
     getActiveWebchatRunId(sessionKey: string): string | undefined;
-    steerWebchatAgent(sessionKey: string, message: string): ReturnType<GatewayAgentRunner['steerWebchatAgent']>;
     submitClarifyResponse(requestId: string, answer: string): boolean;
     private initializeExtensionLoader;
     private registerExtensionChannelPlugins;