@xopcai/xopc 0.0.284 → 0.0.286

package/dist/src/imports/types.d.ts

@@ -70,10 +70,63 @@ export declare class ImportError extends Error {
     readonly status: 400 | 403 | 404 | 409 | 413;
     constructor(code: string, message: string, status?: 400 | 403 | 404 | 409 | 413);
 }
+export type InventoryStatus = 'ready' | 'existing' | 'conflict' | 'blocked';
+export interface InventoryItem {
+    id: string;
+    kind: 'skill' | 'context' | 'project';
+    parentId?: string;
+    name: string;
+    description: string;
+    displayPath: string;
+    scope: ImportScope;
+    status: InventoryStatus;
+    reason?: string;
+    suggested: boolean;
+    targetName?: string;
+}
+export interface ImportInventory {
+    id: string;
+    source: ImportSource;
+    createdAt: number;
+    expiresAt: number;
+    candidates: InventoryItem[];
+    notices: string[];
+    complete: boolean;
+}
+export interface StoredInventoryItem extends InventoryItem {
+    location: string;
+    scanId?: string;
+    candidate?: ImportCandidate;
+    targetRoot?: string;
+    projectId?: string;
+}
+export interface StoredInventory extends Omit<ImportInventory, 'candidates'> {
+    candidates: StoredInventoryItem[];
+    scanIds: string[];
+}
+export interface ImportSelection {
+    inventoryId: string;
+    candidateIds: string[];
+    requestId: string;
+    retryOf?: string;
+}
+export interface ImportRunItem {
+    candidateId: string;
+    kind: InventoryItem['kind'];
+    name: string;
+    status: 'pending' | 'imported' | 'existing' | 'failed';
+    targetId?: string;
+    jobId?: string;
+    error?: string;
+}
 export interface ProductImportResult {
     id: string;
     source: ImportSource;
     createdAt: number;
+    inventoryId: string;
+    selectionHash: string;
+    status: 'running' | 'completed' | 'partial';
+    items: ImportRunItem[];
     skills: number;
     context: number;
     projects: number;

package/dist/src/infra/background-task.d.ts

@@ -0,0 +1,2 @@
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+export declare function createBackgroundTask(run: () => void | Promise<void>, onError: (error: unknown) => void): () => void;

package/dist/src/infra/background-task.js

@@ -0,0 +1,25 @@
+//#region src/infra/background-task.ts
+/** Run one background tick at a time, reporting once per consecutive failure period. */
+function createBackgroundTask(run, onError) {
+	let running = false;
+	let failed = false;
+	return () => {
+		if (running) return;
+		running = true;
+		(async () => {
+			try {
+				await run();
+				failed = false;
+			} catch (error) {
+				if (!failed) {
+					failed = true;
+					onError(error);
+				}
+			} finally {
+				running = false;
+			}
+		})();
+	};
+}
+//#endregion
+export { createBackgroundTask };

package/dist/src/infra/node-sqlite.js

@@ -1,7 +1,7 @@
-import { installProcessWarningFilter } from "./warning-filter.js";
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_warning_filter, installProcessWarningFilter } from "./warning-filter.js";
 import { createRequire } from "node:module";
 //#region src/infra/node-sqlite.ts
-const require = createRequire(import.meta.url);
 function requireNodeSqlite() {
 	installProcessWarningFilter();
 	try {
@@ -11,5 +11,11 @@ function requireNodeSqlite() {
 		throw new Error(`SQLite support is unavailable in this Node runtime (missing node:sqlite). ${message}`, { cause: err });
 	}
 }
+var require;
+var init_node_sqlite = __esmMin((() => {
+	init_warning_filter();
+	require = createRequire(import.meta.url);
+}));
 //#endregion
-export { requireNodeSqlite };
+init_node_sqlite();
+export { init_node_sqlite, requireNodeSqlite };

package/dist/src/infra/process-diagnostics.d.ts

@@ -0,0 +1,5 @@
+export declare function recordProcessDiagnostic(event: string, detail: unknown): void;
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+export declare function createProcessDiagnosticWriter(path: string): (event: string, detail: unknown) => void;
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+export declare function installProcessDiagnostics(path: string): () => void;

package/dist/src/infra/process-diagnostics.js

@@ -0,0 +1,101 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_redact, redactObject, redactSensitiveInfo } from "../utils/logger/redact.js";
+import { dirname } from "node:path";
+import { appendFileSync, mkdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { inspect } from "node:util";
+//#region src/infra/process-diagnostics.ts
+function diagnosticValue(value, depth = 0) {
+	if (depth > 5) return "[MaxDepth]";
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		stack: value.stack,
+		...value.cause === void 0 ? {} : { cause: diagnosticValue(value.cause, depth + 1) }
+	};
+	if (Array.isArray(value)) return value.slice(0, 30).map((item) => diagnosticValue(item, depth + 1));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).slice(0, 30).map(([key, item]) => [key, diagnosticValue(item, depth + 1)]));
+	return value;
+}
+function recordProcessDiagnostic(event, detail) {
+	activeWriter?.(event, detail);
+}
+/** Independent of SQLite and async logger transports; safe to use during process failure. */
+function createProcessDiagnosticWriter(path) {
+	return (event, detail) => {
+		try {
+			const text = typeof detail === "string" ? detail : inspect(redactObject(diagnosticValue(detail)), {
+				depth: 5,
+				maxArrayLength: 30,
+				maxStringLength: MAX_DETAIL_CHARS,
+				customInspect: false,
+				getters: false
+			});
+			const line = JSON.stringify({
+				time: (/* @__PURE__ */ new Date()).toISOString(),
+				pid: process.pid,
+				event,
+				detail: redactSensitiveInfo(text).slice(-MAX_DETAIL_CHARS)
+			}) + "\n";
+			mkdirSync(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			let size = 0;
+			try {
+				size = statSync(path).size;
+			} catch (err) {
+				if (err.code !== "ENOENT") throw err;
+			}
+			if (size + Buffer.byteLength(line) > MAX_LOG_BYTES) {
+				rmSync(`${path}.2`, { force: true });
+				try {
+					renameSync(`${path}.1`, `${path}.2`);
+				} catch (err) {
+					if (err.code !== "ENOENT") throw err;
+				}
+				renameSync(path, `${path}.1`);
+			}
+			appendFileSync(path, line, {
+				encoding: "utf8",
+				mode: 384
+			});
+		} catch {}
+	};
+}
+/** Observe fatal exceptions without resuming execution in an unknown process state. */
+function installProcessDiagnostics(path) {
+	const write = createProcessDiagnosticWriter(path);
+	const previousWriter = activeWriter;
+	activeWriter = write;
+	const onFatal = (error, origin) => write("uncaught_exception", {
+		origin,
+		error,
+		uptimeSeconds: process.uptime(),
+		memory: process.memoryUsage()
+	});
+	const onExit = (code) => write("process_exit", {
+		code,
+		uptimeSeconds: process.uptime()
+	});
+	process.on("uncaughtExceptionMonitor", onFatal);
+	process.on("exit", onExit);
+	write("process_start", {
+		node: process.version,
+		platform: process.platform,
+		arch: process.arch
+	});
+	return () => {
+		if (activeWriter === write) activeWriter = previousWriter;
+		process.removeListener("uncaughtExceptionMonitor", onFatal);
+		process.removeListener("exit", onExit);
+	};
+}
+var MAX_LOG_BYTES, MAX_DETAIL_CHARS, activeWriter;
+var init_process_diagnostics = __esmMin((() => {
+	init_redact();
+	MAX_LOG_BYTES = 2 * 1024 * 1024;
+	MAX_DETAIL_CHARS = 64 * 1024;
+}));
+//#endregion
+init_process_diagnostics();
+export { createProcessDiagnosticWriter, init_process_diagnostics, installProcessDiagnostics, recordProcessDiagnostic };

package/dist/src/infra/sqlite-errors.js

@@ -1,23 +1,5 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 //#region src/infra/sqlite-errors.ts
-const TRANSIENT_SQLITE_CODES = new Set([
-	"SQLITE_BUSY",
-	"SQLITE_CANTOPEN",
-	"SQLITE_IOERR",
-	"SQLITE_LOCKED"
-]);
-const TRANSIENT_SQLITE_ERRCODES = new Set([
-	5,
-	6,
-	10,
-	14
-]);
-const TRANSIENT_SQLITE_MESSAGE_CODE_RE = /\b(SQLITE_BUSY|SQLITE_CANTOPEN|SQLITE_IOERR|SQLITE_LOCKED)\b/i;
-const TRANSIENT_SQLITE_MESSAGE_SNIPPETS = [
-	"unable to open database file",
-	"database is locked",
-	"database table is locked",
-	"disk i/o error"
-];
 function normalizeLowercase(value) {
 	return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
@@ -71,5 +53,28 @@ function isTransientSqliteError(err) {
 	}
 	return false;
 }
+var TRANSIENT_SQLITE_CODES, TRANSIENT_SQLITE_ERRCODES, TRANSIENT_SQLITE_MESSAGE_CODE_RE, TRANSIENT_SQLITE_MESSAGE_SNIPPETS;
+var init_sqlite_errors = __esmMin((() => {
+	TRANSIENT_SQLITE_CODES = new Set([
+		"SQLITE_BUSY",
+		"SQLITE_CANTOPEN",
+		"SQLITE_IOERR",
+		"SQLITE_LOCKED"
+	]);
+	TRANSIENT_SQLITE_ERRCODES = new Set([
+		5,
+		6,
+		10,
+		14
+	]);
+	TRANSIENT_SQLITE_MESSAGE_CODE_RE = /\b(SQLITE_BUSY|SQLITE_CANTOPEN|SQLITE_IOERR|SQLITE_LOCKED)\b/i;
+	TRANSIENT_SQLITE_MESSAGE_SNIPPETS = [
+		"unable to open database file",
+		"database is locked",
+		"database table is locked",
+		"disk i/o error"
+	];
+}));
 //#endregion
-export { isTransientSqliteError };
+init_sqlite_errors();
+export { init_sqlite_errors, isTransientSqliteError };

package/dist/src/infra/unhandled-rejections.js

@@ -1,23 +1,34 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_global_singleton, resolveGlobalSingleton } from "../utils/global-singleton.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { resolveGlobalSingleton } from "../utils/global-singleton.js";
-import { isTransientSqliteError } from "./sqlite-errors.js";
+import { init_process_diagnostics, recordProcessDiagnostic } from "./process-diagnostics.js";
+import { init_sqlite_errors, isTransientSqliteError } from "./sqlite-errors.js";
 //#region src/infra/unhandled-rejections.ts
-init_logger();
-const log = createLogger("UnhandledRejection");
-const installStateKey = Symbol.for("xopc.unhandledRejection.installed");
 function installSqliteTransientRejectionHandler() {
 	const state = resolveGlobalSingleton(installStateKey, () => ({ installed: false }));
 	if (state.installed) return;
 	process.on("unhandledRejection", (reason) => {
-		if (!isTransientSqliteError(reason)) return;
+		recordProcessDiagnostic("unhandled_rejection", reason);
 		const em = reason instanceof Error ? reason.message : String(reason);
-		log.warn({
+		const fields = {
 			err: reason instanceof Error ? reason : void 0,
 			errorMessage: em
-		}, `Transient SQLite rejection: ${em}`);
+		};
+		if (isTransientSqliteError(reason)) log.warn(fields, `Transient SQLite rejection: ${em}`);
+		else log.error(fields, `Unhandled promise rejection: ${em}`);
 	});
 	state.installed = true;
 }
+var log, installStateKey;
+var init_unhandled_rejections = __esmMin((() => {
+	init_process_diagnostics();
+	init_logger();
+	init_sqlite_errors();
+	init_global_singleton();
+	log = createLogger("UnhandledRejection");
+	installStateKey = Symbol.for("xopc.unhandledRejection.installed");
+}));
 //#endregion
-export { installSqliteTransientRejectionHandler };
+init_unhandled_rejections();
+export { init_unhandled_rejections, installSqliteTransientRejectionHandler };

package/dist/src/infra/warning-filter.js

@@ -1,6 +1,6 @@
-import { resolveGlobalSingleton } from "../utils/global-singleton.js";
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_global_singleton, resolveGlobalSingleton } from "../utils/global-singleton.js";
 //#region src/infra/warning-filter.ts
-const warningFilterKey = Symbol.for("xopc.warning-filter");
 function shouldIgnoreWarning(warning) {
 	if (warning.code === "DEP0040" && warning.message?.includes("punycode")) return true;
 	if (warning.code === "DEP0060" && warning.message?.includes("util._extend")) return true;
@@ -53,5 +53,11 @@ function installProcessWarningFilter() {
 	process.emitWarning = wrappedEmitWarning;
 	state.installed = true;
 }
+var warningFilterKey;
+var init_warning_filter = __esmMin((() => {
+	init_global_singleton();
+	warningFilterKey = Symbol.for("xopc.warning-filter");
+}));
 //#endregion
-export { installProcessWarningFilter, shouldIgnoreWarning };
+init_warning_filter();
+export { init_warning_filter, installProcessWarningFilter, shouldIgnoreWarning };

package/dist/src/knowledge/ingestion-service.js

@@ -89,6 +89,7 @@ var KnowledgeIngestionService = class {
 		const cursorBefore = this.state.getCursor(params.instanceId, params.collectionScope);
 		const run = startKnowledgeSyncRun({
 			sourceInstanceId: params.instanceId,
+			collectionScope: params.collectionScope,
 			cursorBefore
 		});
 		const controller = params.signal ? null : new AbortController();

package/dist/src/knowledge-memory/domain.d.ts

@@ -21,7 +21,7 @@ export interface KnowledgeItem {
     reviewAt?: number;
     originClass: KnowledgeOriginClass;
     sourceAgentId?: string;
-    sourceSessionId?: string;
+    sourceConversationId?: string;
     sourceTurnId?: string;
     derivedFromRecalledContext: boolean;
     source: Record<string, unknown>;
@@ -32,5 +32,5 @@ export interface KnowledgeVisibilityContext {
     agentId: string;
     workspaceId: string;
     projectId?: string;
-    sessionId: string;
+    conversationId: string;
 }

package/dist/src/knowledge-memory/repository.d.ts

@@ -16,7 +16,7 @@ export interface WriteKnowledgeInput {
     reviewAt?: number;
     originClass: KnowledgeOriginClass;
     sourceAgentId?: string;
-    sourceSessionId?: string;
+    sourceConversationId?: string;
     sourceTurnId?: string;
     derivedFromRecalledContext?: boolean;
     source?: Record<string, unknown>;

package/dist/src/knowledge-memory/repository.js

@@ -1,8 +1,10 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { validateScope } from "../user-model/domain.js";
-import { buildFts5SearchQuery } from "../storage/sqlite/fts.js";
+import { buildFts5SearchQuery, init_fts } from "../storage/sqlite/fts.js";
 import { randomUUID } from "node:crypto";
 //#region src/knowledge-memory/repository.ts
+init_fts();
+init_transaction();
 function fromRow(row) {
 	return {
 		id: row.knowledge_id,
@@ -24,7 +26,7 @@ function fromRow(row) {
 		...row.review_at === null ? {} : { reviewAt: row.review_at },
 		originClass: row.origin_class,
 		...row.source_agent_id ? { sourceAgentId: row.source_agent_id } : {},
-		...row.source_session_id ? { sourceSessionId: row.source_session_id } : {},
+		...row.source_conversation_id ? { sourceConversationId: row.source_conversation_id } : {},
 		...row.source_turn_id ? { sourceTurnId: row.source_turn_id } : {},
 		derivedFromRecalledContext: row.derived_from_recalled_context === 1,
 		source: JSON.parse(row.source_json),
@@ -67,8 +69,8 @@ function writeKnowledgeItem(input) {
 		if (existing) {
 			db.prepare(`UPDATE knowledge_items SET kind = ?, content = ?, record_class = ?, status = ?, confidence = ?,
         importance = ?, valid_from = ?, valid_to = ?, expires_at = ?, review_at = ?,
-        origin_class = ?, source_agent_id = ?, source_session_id = ?, source_turn_id = ?,
-        derived_from_recalled_context = ?, source_json = ?, updated_at = ? WHERE knowledge_id = ?`).run(input.kind, input.content.trim(), input.recordClass ?? "memory", input.status ?? (input.originClass === "owner" ? "active" : "candidate"), input.confidence, input.importance, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, input.originClass, input.sourceAgentId ?? null, input.sourceSessionId ?? null, input.sourceTurnId ?? null, input.derivedFromRecalledContext ? 1 : 0, JSON.stringify(input.source ?? {}), now, existing.knowledge_id);
+        origin_class = ?, source_agent_id = ?, source_conversation_id = ?, source_turn_id = ?,
+        derived_from_recalled_context = ?, source_json = ?, updated_at = ? WHERE knowledge_id = ?`).run(input.kind, input.content.trim(), input.recordClass ?? "memory", input.status ?? (input.originClass === "owner" ? "active" : "candidate"), input.confidence, input.importance, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, input.originClass, input.sourceAgentId ?? null, input.sourceConversationId ?? null, input.sourceTurnId ?? null, input.derivedFromRecalledContext ? 1 : 0, JSON.stringify(input.source ?? {}), now, existing.knowledge_id);
 			db.prepare("DELETE FROM knowledge_items_fts WHERE knowledge_id = ?").run(existing.knowledge_id);
 			db.prepare("INSERT INTO knowledge_items_fts(content, knowledge_id) VALUES (?, ?)").run(input.content.trim(), existing.knowledge_id);
 			return {
@@ -80,9 +82,9 @@ function writeKnowledgeItem(input) {
 		db.prepare(`INSERT INTO knowledge_items (
       knowledge_id, principal_id, kind, scope_type, scope_id, content, canonical_key, record_class,
       status, confidence, importance, valid_from, valid_to, expires_at, review_at,
-      origin_class, source_agent_id, source_session_id, source_turn_id,
+      origin_class, source_agent_id, source_conversation_id, source_turn_id,
       derived_from_recalled_context, source_json, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.kind, input.scope.type, input.scope.id ?? null, input.content.trim(), input.canonicalKey.trim(), input.recordClass ?? "memory", input.status ?? (input.originClass === "owner" ? "active" : "candidate"), input.confidence, input.importance, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, input.originClass, input.sourceAgentId ?? null, input.sourceSessionId ?? null, input.sourceTurnId ?? null, input.derivedFromRecalledContext ? 1 : 0, JSON.stringify(input.source ?? {}), now, now);
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.kind, input.scope.type, input.scope.id ?? null, input.content.trim(), input.canonicalKey.trim(), input.recordClass ?? "memory", input.status ?? (input.originClass === "owner" ? "active" : "candidate"), input.confidence, input.importance, input.validFrom ?? null, input.validTo ?? null, input.expiresAt ?? null, input.reviewAt ?? null, input.originClass, input.sourceAgentId ?? null, input.sourceConversationId ?? null, input.sourceTurnId ?? null, input.derivedFromRecalledContext ? 1 : 0, JSON.stringify(input.source ?? {}), now, now);
 		db.prepare("INSERT INTO knowledge_items_fts(content, knowledge_id) VALUES (?, ?)").run(input.content.trim(), id);
 		return {
 			item: fromRow(db.prepare("SELECT * FROM knowledge_items WHERE knowledge_id = ?").get(id)),
@@ -124,7 +126,7 @@ function visibilityClause(context) {
 	const values = [
 		context.agentId ?? "",
 		context.workspaceId ?? "",
-		context.sessionId ?? ""
+		context.conversationId ?? ""
 	];
 	if (context.projectId) {
 		parts.push("(k.scope_type = 'project' AND k.scope_id = ?)");

package/dist/src/mcp/channel-bridge.d.ts

@@ -26,15 +26,15 @@ export declare class XopcChannelBridge {
         search?: string;
         channel?: string;
     }): Promise<ConversationDescriptor[]>;
-    getConversation(sessionKey: string): Promise<ConversationDescriptor | null>;
-    readMessages(sessionKey: string, limit: number): Promise<Array<Record<string, unknown>>>;
+    getConversation(conversationId: string): Promise<ConversationDescriptor | null>;
+    readMessages(conversationId: string, limit: number): Promise<Array<Record<string, unknown>>>;
     pollEvents(filter: WaitFilter, limit: number): {
         events: QueueEvent[];
         nextCursor: number;
     };
     waitForEvent(filter: WaitFilter, timeoutMs: number): Promise<QueueEvent | null>;
     sendMessage(params: {
-        sessionKey: string;
+        conversationId: string;
         text: string;
     }): Promise<Record<string, unknown>>;
     listPendingApprovals(): PendingApproval[];

package/dist/src/mcp/channel-bridge.js

@@ -95,7 +95,7 @@ var XopcChannelBridge = class {
 		if (type.includes("message") || type.includes("session")) this.pushEvent({
 			cursor: ++this.cursor,
 			type: "message",
-			sessionKey: String(data.sessionKey ?? data.key ?? ""),
+			conversationId: String(data.conversationId ?? data.key ?? ""),
 			raw: data
 		});
 	}
@@ -113,19 +113,19 @@ var XopcChannelBridge = class {
 		const rows = await client.getJson(`/api/sessions${qs ? `?${qs}` : ""}`);
 		return (Array.isArray(rows) ? rows : rows.sessions ?? []).map((row) => toConversation(row)).filter((c) => c !== null);
 	}
-	async getConversation(sessionKey) {
+	async getConversation(conversationId) {
 		const client = this.client;
 		try {
-			return toConversation(await client.getJson(`/api/sessions/${encodeURIComponent(sessionKey)}`));
+			return toConversation(await client.getJson(`/api/sessions/${encodeURIComponent(conversationId)}`));
 		} catch {
 			return null;
 		}
 	}
-	async readMessages(sessionKey, limit) {
-		return (await this.client.getJson(`/api/sessions/${encodeURIComponent(sessionKey)}/messages?limit=${limit}`)).messages ?? [];
+	async readMessages(conversationId, limit) {
+		return (await this.client.getJson(`/api/sessions/${encodeURIComponent(conversationId)}/messages?limit=${limit}`)).messages ?? [];
 	}
 	pollEvents(filter, limit) {
-		const events = this.queue.filter((e) => e.cursor > filter.afterCursor).filter((e) => !filter.sessionKey || "sessionKey" in e && e.sessionKey === filter.sessionKey).slice(0, limit);
+		const events = this.queue.filter((e) => e.cursor > filter.afterCursor).filter((e) => !filter.conversationId || "conversationId" in e && e.conversationId === filter.conversationId).slice(0, limit);
 		return {
 			events,
 			nextCursor: events.length > 0 ? events[events.length - 1].cursor : filter.afterCursor
@@ -141,7 +141,7 @@ var XopcChannelBridge = class {
 		return null;
 	}
 	async sendMessage(params) {
-		return this.client.postJson(`/api/sessions/${encodeURIComponent(params.sessionKey)}/inputs`, {
+		return this.client.postJson(`/api/sessions/${encodeURIComponent(params.conversationId)}/inputs`, {
 			clientMessageId: crypto.randomUUID(),
 			delivery: "next",
 			content: params.text

package/dist/src/mcp/channel-shared.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { normalizeOptionalString as toText } from '../utils/string-coerce.js';
 export type ClaudeChannelMode = "off" | "on" | "auto";
 export type ConversationDescriptor = {
-    sessionKey: string;
+    conversationId: string;
     channel: string;
     to: string;
     accountId?: string;
@@ -49,7 +49,7 @@ export type ChatHistoryResult = {
     }>;
 };
 export type SessionMessagePayload = {
-    sessionKey?: string;
+    conversationId?: string;
     messageId?: string;
     messageSeq?: number;
     message?: {
@@ -75,7 +75,7 @@ export type PendingApproval = {
 export type QueueEvent = {
     cursor: number;
     type: "message";
-    sessionKey: string;
+    conversationId: string;
     conversation?: ConversationDescriptor;
     messageId?: string;
     messageSeq?: number;
@@ -105,7 +105,7 @@ export type ClaudePermissionRequest = {
 };
 export type WaitFilter = {
     afterCursor: number;
-    sessionKey?: string;
+    conversationId?: string;
 };
 export declare const ClaudePermissionRequestSchema: z.ZodObject<{
     method: z.ZodLiteral<"notifications/claude/channel/permission_request">;

package/dist/src/mcp/channel-shared.js

@@ -31,7 +31,7 @@ function toConversation(row) {
 	const to = normalizeOptionalString(row.deliveryContext?.to) ?? normalizeOptionalString(row.lastTo);
 	if (!channel || !to) return null;
 	return {
-		sessionKey: row.key,
+		conversationId: row.key,
 		channel,
 		to,
 		accountId: normalizeOptionalString(row.deliveryContext?.accountId) ?? normalizeOptionalString(row.lastAccountId) ?? normalizeOptionalString(row.origin?.accountId),
@@ -45,8 +45,8 @@ function toConversation(row) {
 }
 function matchEventFilter(event, filter) {
 	if (event.cursor <= filter.afterCursor) return false;
-	if (!filter.sessionKey) return true;
-	return "sessionKey" in event && event.sessionKey === filter.sessionKey;
+	if (!filter.conversationId) return true;
+	return "conversationId" in event && event.conversationId === filter.conversationId;
 }
 function extractAttachmentsFromMessage(message) {
 	if (!message || typeof message !== "object") return [];

package/dist/src/mcp/channel-tools.js

@@ -23,39 +23,39 @@ function registerChannelMcpTools(server, bridge) {
 			structuredContent: { conversations }
 		};
 	});
-	server.tool("conversation_get", "Get one OpenClaw conversation by session key.", { session_key: z.string().min(1) }, async ({ session_key }) => {
-		const conversation = await bridge.getConversation(session_key);
+	server.tool("conversation_get", "Get one OpenClaw conversation by session key.", { conversation_id: z.string().min(1) }, async ({ conversation_id }) => {
+		const conversation = await bridge.getConversation(conversation_id);
 		if (!conversation) return {
 			content: [{
 				type: "text",
-				text: `conversation not found: ${session_key}`
+				text: `conversation not found: ${conversation_id}`
 			}],
 			isError: true
 		};
 		return {
 			content: [{
 				type: "text",
-				text: `conversation ${conversation.sessionKey}`
+				text: `conversation ${conversation.conversationId}`
 			}],
 			structuredContent: { conversation }
 		};
 	});
 	server.tool("messages_read", "Read recent messages for one OpenClaw conversation.", {
-		session_key: z.string().min(1),
+		conversation_id: z.string().min(1),
 		limit: z.number().int().min(1).max(200).optional()
-	}, async ({ session_key, limit }) => {
-		const messages = await bridge.readMessages(session_key, limit ?? 20);
+	}, async ({ conversation_id, limit }) => {
+		const messages = await bridge.readMessages(conversation_id, limit ?? 20);
 		return {
 			...summarizeResult("messages", messages.length),
 			structuredContent: { messages }
 		};
 	});
 	server.tool("attachments_fetch", "List non-text attachments for a message in one OpenClaw conversation.", {
-		session_key: z.string().min(1),
+		conversation_id: z.string().min(1),
 		message_id: z.string().min(1),
 		limit: z.number().int().min(1).max(200).optional()
-	}, async ({ session_key, message_id, limit }) => {
-		const message = (await bridge.readMessages(session_key, limit ?? 100)).find((entry) => resolveMessageId(entry) === message_id);
+	}, async ({ conversation_id, message_id, limit }) => {
+		const message = (await bridge.readMessages(conversation_id, limit ?? 100)).find((entry) => resolveMessageId(entry) === message_id);
 		if (!message) return {
 			content: [{
 				type: "text",
@@ -74,12 +74,12 @@ function registerChannelMcpTools(server, bridge) {
 	});
 	server.tool("events_poll", "Poll queued OpenClaw conversation events since a cursor.", {
 		after_cursor: z.number().int().min(0).optional(),
-		session_key: z.string().optional(),
+		conversation_id: z.string().optional(),
 		limit: z.number().int().min(1).max(200).optional()
-	}, async ({ after_cursor, session_key, limit }) => {
+	}, async ({ after_cursor, conversation_id, limit }) => {
 		const { events, nextCursor } = bridge.pollEvents({
 			afterCursor: after_cursor ?? 0,
-			sessionKey: normalizeOptionalString(session_key)
+			conversationId: normalizeOptionalString(conversation_id)
 		}, limit ?? 20);
 		return {
 			...summarizeResult("events", events.length),
@@ -91,12 +91,12 @@ function registerChannelMcpTools(server, bridge) {
 	});
 	server.tool("events_wait", "Wait for the next queued OpenClaw conversation event.", {
 		after_cursor: z.number().int().min(0).optional(),
-		session_key: z.string().optional(),
+		conversation_id: z.string().optional(),
 		timeout_ms: z.number().int().min(1).max(3e5).optional()
-	}, async ({ after_cursor, session_key, timeout_ms }) => {
+	}, async ({ after_cursor, conversation_id, timeout_ms }) => {
 		const event = await bridge.waitForEvent({
 			afterCursor: after_cursor ?? 0,
-			sessionKey: normalizeOptionalString(session_key)
+			conversationId: normalizeOptionalString(conversation_id)
 		}, timeout_ms ?? 3e4);
 		return {
 			content: [{
@@ -107,16 +107,16 @@ function registerChannelMcpTools(server, bridge) {
 		};
 	});
 	server.tool("messages_send", "Send a message back through the same OpenClaw conversation route.", {
-		session_key: z.string().min(1),
+		conversation_id: z.string().min(1),
 		text: z.string().min(1)
-	}, async ({ session_key, text }) => {
+	}, async ({ conversation_id, text }) => {
 		return {
 			content: [{
 				type: "text",
 				text: "sent"
 			}],
 			structuredContent: { result: await bridge.sendMessage({
-				sessionKey: session_key,
+				conversationId: conversation_id,
 				text
 			}) }
 		};