@xopcai/xopc 0.0.208 → 0.0.211

package/dist/src/connectors/connected-source-normalizers.js

@@ -65,11 +65,13 @@ function normalizeCalendar(result) {
 		const externalId = text(event, "id", "eventId", "event_id");
 		if (!externalId) return [];
 		const occurredAt = time(event.start ?? event.startTime ?? event.start_time);
+		const sourceUpdatedAt = time(event.updated ?? event.updatedAt ?? event.updated_at);
 		return [{
 			externalId,
 			itemType: "calendar_event",
 			occurredAt,
-			sourceUpdatedAt: time(event.updated ?? event.updatedAt ?? event.updated_at),
+			sourceUpdatedAt,
+			...event.status === "cancelled" ? { deletedAt: sourceUpdatedAt ?? (/* @__PURE__ */ new Date()).toISOString() } : {},
 			value: compact({
 				id: externalId,
 				title: text(event, "summary", "title", "name"),
@@ -88,6 +90,34 @@ function normalizeCalendar(result) {
 		}];
 	});
 }
+function normalizeGoogleDrive(result) {
+	return rows(payload(result), "files", "items").flatMap((file) => {
+		const externalId = text(file, "id", "fileId", "file_id");
+		const name = text(file, "name", "title");
+		if (!externalId || !name || file.trashed === true) return [];
+		const modifiedAt = time(file.modifiedTime ?? file.modified_time ?? file.modifiedDate);
+		return [{
+			externalId,
+			itemType: "cloud_document",
+			occurredAt: modifiedAt ?? time(file.createdTime ?? file.created_time ?? file.createdDate),
+			sourceUpdatedAt: modifiedAt,
+			value: compact({
+				id: externalId,
+				title: name,
+				mimeType: text(file, "mimeType", "mime_type"),
+				modifiedAt,
+				owners: file.owners,
+				webViewLink: text(file, "webViewLink", "web_view_link")
+			}),
+			metadata: {
+				observationKind: "document_metadata",
+				logicalEventKey: `googledrive:file:${externalId}`,
+				mimeType: text(file, "mimeType", "mime_type")
+			},
+			synthesisStatus: "ignored"
+		}];
+	});
+}
 function repositoryName(row) {
 	const explicit = text(record(row.repository) ?? record(row.repo), "full_name", "name") ?? text(row, "repository_full_name", "full_name", "repo");
 	if (explicit) return explicit;
@@ -178,8 +208,9 @@ function normalizeExternalTasks(result, toolkit) {
 function normalizeConnectedSourceResult(input) {
 	if (input.toolkit === "gmail") return normalizeGmail(input.result);
 	if (input.toolkit === "googlecalendar") return normalizeCalendar(input.result);
+	if (input.toolkit === "googledrive") return normalizeGoogleDrive(input.result);
 	if (input.toolkit === "github") return normalizeGitHub(input.result, input.actionId);
-	if (input.toolkit === "linear" || input.toolkit === "jira") return normalizeExternalTasks(input.result, input.toolkit);
+	if (input.toolkit === "linear") return normalizeExternalTasks(input.result, input.toolkit);
 	return [];
 }
 //#endregion

package/dist/src/connectors/connected-source-sanitization.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeConnectedSourceValue(value: unknown, depth?: number): unknown;

package/dist/src/connectors/connected-source-sanitization.js

@@ -0,0 +1,21 @@
+//#region src/connectors/connected-source-sanitization.ts
+const SENSITIVE_KEY_RE = /(?:^|_)(?:api_?key|token|secret|password|passwd|authorization|credential|private_?key)(?:$|_)/i;
+const INLINE_SECRET_PATTERNS = [
+	/\bsk-[A-Za-z0-9_-]{8,}\b/g,
+	/\bghp_[A-Za-z0-9]{20,}\b/g,
+	/\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g,
+	/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g
+];
+function record(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function sanitizeConnectedSourceValue(value, depth = 0) {
+	if (depth > 12) return "[MaxDepth]";
+	if (typeof value === "string") return INLINE_SECRET_PATTERNS.reduce((text, pattern) => text.replace(pattern, "[REDACTED]"), value);
+	if (Array.isArray(value)) return value.map((item) => sanitizeConnectedSourceValue(item, depth + 1));
+	const source = record(value);
+	if (!source) return value;
+	return Object.fromEntries(Object.entries(source).map(([key, nested]) => [key, SENSITIVE_KEY_RE.test(key) ? "[REDACTED]" : sanitizeConnectedSourceValue(nested, depth + 1)]));
+}
+//#endregion
+export { sanitizeConnectedSourceValue };

package/dist/src/connectors/connector-identity.js

@@ -23,6 +23,13 @@ function normalizeConnectorIdentity(toolkit, result) {
 		profileUrl: text(row, ["html_url"])
 	};
 	if (toolkit === "gmail") return { email: text(row, ["emailAddress", "email"]) };
+	if (toolkit === "googledrive") {
+		const user = object(row.user);
+		return {
+			email: text(user, ["emailAddress", "email"]) ?? text(row, ["emailAddress", "email"]),
+			displayName: text(user, ["displayName", "name"])
+		};
+	}
 	if (toolkit === "slack") return {
 		enterpriseId: text(row, ["enterprise_id", "enterpriseId"]),
 		workspaceId: text(row, ["team_id", "teamId"]),
@@ -62,9 +69,9 @@ function connectorIdentityKey(toolkit, identity) {
 		if (!workspaceId || !subjectId) return void 0;
 		return `slack:${text(identity, ["enterpriseId", "enterprise_id"]) ?? "-"}:${workspaceId}:${subjectId}`;
 	}
-	if (normalizedToolkit === "gmail") {
+	if (normalizedToolkit === "gmail" || normalizedToolkit === "googledrive") {
 		const email = text(identity, ["email"]);
-		return email ? `gmail:${email.toLowerCase()}` : void 0;
+		return email ? `${normalizedToolkit}:${email.toLowerCase()}` : void 0;
 	}
 	if (normalizedToolkit === "github") {
 		const username = text(identity, ["username"]);
@@ -75,6 +82,7 @@ function mergeConnectorIdentity(toolkit, current, incoming) {
 	const normalizedToolkit = toolkit.trim().toLowerCase();
 	if (![
 		"gmail",
+		"googledrive",
 		"github",
 		"slack"
 	].includes(normalizedToolkit)) return {

package/dist/src/connectors/content-enrichment.d.ts

@@ -0,0 +1,29 @@
+import { ComposioSessionsAdapter } from './composio-sessions.js';
+type ContentReadAdapter = Pick<ComposioSessionsAdapter, 'executeWithPolicy'>;
+export type ConnectedContentCandidate = {
+    sourceItemId: string;
+    sourceInstanceId: string;
+    toolkit: 'gmail' | 'googledrive';
+    title: string;
+    occurredAt?: string;
+    mimeType?: string;
+};
+export type ConnectedContentReadResult = {
+    requested: number;
+    completed: number;
+    failed: Array<{
+        sourceItemId: string;
+        error: string;
+    }>;
+    recordIds: string[];
+};
+export declare function listConnectedContentCandidates(options: {
+    agentId: string;
+    limit?: number;
+}): ConnectedContentCandidate[];
+export declare function readConnectedContent(input: {
+    sourceItemIds: string[];
+    agentId: string;
+    adapterFactory?: (downloadDirectory: string) => ContentReadAdapter;
+}): Promise<ConnectedContentReadResult>;
+export {};

package/dist/src/connectors/content-enrichment.js

@@ -0,0 +1,273 @@
+import { getKnowledgeSourceItem, listKnowledgeSourceItems, upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getConnectorConnection, getConnectorInstallation } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
+import { sanitizeConnectedSourceValue } from "./connected-source-sanitization.js";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, realpath, rm } from "node:fs/promises";
+//#region src/connectors/content-enrichment.ts
+const MAX_SELECTION = 5;
+const MAX_CONTENT_BYTES = 1e6;
+const MAX_CONTENT_CHARS = 24e3;
+const GOOGLE_DOCUMENT_MIME = "application/vnd.google-apps.document";
+const DOWNLOADABLE_TEXT_MIMES = new Set([
+	"application/json",
+	"application/xml",
+	"text/csv",
+	"text/html",
+	"text/markdown",
+	"text/plain",
+	"text/tab-separated-values",
+	"text/xml"
+]);
+function record(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function normalizedRecord(item) {
+	if (!item.normalizedText) return {};
+	try {
+		return record(JSON.parse(item.normalizedText));
+	} catch {
+		return {};
+	}
+}
+function text(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function candidateFor(item) {
+	if (item.deletedAt || item.sensitivity === "secret" || item.sensitivity === "regulated") return void 0;
+	const toolkit = text(item.metadata.toolkit);
+	const value = normalizedRecord(item);
+	const title = text(value.title) ?? text(value.subject);
+	if (!title) return void 0;
+	if (toolkit === "gmail" && item.itemType === "email") return {
+		sourceItemId: item.id,
+		sourceInstanceId: item.sourceInstanceId,
+		toolkit,
+		title,
+		occurredAt: item.occurredAt
+	};
+	const mimeType = text(item.metadata.mimeType) ?? text(value.mimeType);
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType && (mimeType === GOOGLE_DOCUMENT_MIME || DOWNLOADABLE_TEXT_MIMES.has(mimeType))) return {
+		sourceItemId: item.id,
+		sourceInstanceId: item.sourceInstanceId,
+		toolkit,
+		title,
+		occurredAt: item.occurredAt,
+		mimeType
+	};
+}
+function listConnectedContentCandidates(options) {
+	const limit = Math.max(1, Math.min(20, options.limit ?? 10));
+	const items = listKnowledgeSourceItems({
+		agentId: options.agentId,
+		includeDeleted: false,
+		limit: 500
+	});
+	const completedReads = new Set(items.map((item) => text(item.metadata.sourceMetadataItemId)).filter((id) => Boolean(id)));
+	return items.filter((item) => !completedReads.has(item.id)).map(candidateFor).filter((candidate) => Boolean(candidate)).slice(0, limit);
+}
+function contentRecipe(item) {
+	const toolkit = text(item.metadata.toolkit);
+	if (toolkit === "gmail" && item.itemType === "email") return {
+		actionId: "GMAIL_GET_EMAIL",
+		args: { message_id: item.externalId },
+		mode: "inline"
+	};
+	const value = normalizedRecord(item);
+	const mimeType = text(item.metadata.mimeType) ?? text(value.mimeType);
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType === GOOGLE_DOCUMENT_MIME) return {
+		actionId: "GOOGLEDRIVE_EXPORT_GOOGLE_WORKSPACE_FILE",
+		args: {
+			fileId: item.externalId,
+			mimeType: "text/plain"
+		},
+		mode: "file"
+	};
+	if (toolkit === "googledrive" && item.itemType === "cloud_document" && mimeType && DOWNLOADABLE_TEXT_MIMES.has(mimeType)) return {
+		actionId: "GOOGLEDRIVE_DOWNLOAD_FILE",
+		args: { file_id: item.externalId },
+		mode: "file"
+	};
+	throw new Error("This source item does not support bounded content reading.");
+}
+function collectInlineText(value, output, depth = 0) {
+	if (depth > 8 || output.join("\n").length >= MAX_CONTENT_CHARS) return;
+	if (Array.isArray(value)) {
+		for (const item of value) collectInlineText(item, output, depth + 1);
+		return;
+	}
+	const row = record(value);
+	for (const [key, nested] of Object.entries(row)) {
+		if (typeof nested === "string" && [
+			"body",
+			"content",
+			"plainText",
+			"plain_text",
+			"snippet",
+			"text"
+		].includes(key)) {
+			if (nested.trim()) output.push(nested.trim());
+			continue;
+		}
+		if (nested && typeof nested === "object") collectInlineText(nested, output, depth + 1);
+	}
+}
+function inlineContent(result) {
+	const values = [];
+	collectInlineText(result, values);
+	return [...new Set(values)].join("\n\n").slice(0, MAX_CONTENT_CHARS);
+}
+function candidateFilePaths(value, output, depth = 0) {
+	if (depth > 8) return;
+	if (typeof value === "string") {
+		if (value.startsWith("file://")) output.push(new URL(value).pathname);
+		else if (isAbsolute(value)) output.push(value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) candidateFilePaths(item, output, depth + 1);
+		return;
+	}
+	for (const nested of Object.values(record(value))) candidateFilePaths(nested, output, depth + 1);
+}
+async function downloadedContent(result, downloadDirectory) {
+	const directory = await realpath(downloadDirectory);
+	const paths = [];
+	candidateFilePaths(result, paths);
+	for (const path of paths) {
+		const resolved = await realpath(path).catch(() => void 0);
+		if (!resolved) continue;
+		const pathFromDirectory = relative(directory, resolved);
+		if (pathFromDirectory.startsWith(`..${sep}`) || pathFromDirectory === ".." || isAbsolute(pathFromDirectory)) continue;
+		const content = await readFile(resolved);
+		if (content.byteLength > MAX_CONTENT_BYTES) throw new Error("Downloaded content exceeds the 1 MB read limit.");
+		return content.toString("utf8").slice(0, MAX_CONTENT_CHARS);
+	}
+	throw new Error("The connector did not return readable text content.");
+}
+function updatedSourceItem(item, content, actionId) {
+	const contentReadAt = (/* @__PURE__ */ new Date()).toISOString();
+	const sanitizedContent = String(sanitizeConnectedSourceValue(content));
+	const normalizedText = JSON.stringify({
+		...normalizedRecord(item),
+		content: sanitizedContent,
+		contentReadAt
+	});
+	return {
+		sourceInstanceId: item.sourceInstanceId,
+		collectionScope: "content-reads",
+		externalId: item.id,
+		itemType: "connected_content",
+		authorRole: item.authorRole,
+		occurredAt: item.occurredAt,
+		sourceUpdatedAt: item.sourceUpdatedAt,
+		contentHash: createHash("sha256").update(normalizedText).digest("hex"),
+		normalizedText,
+		payloadRef: item.payloadRef,
+		metadata: {
+			...item.metadata,
+			explicitContentRead: true,
+			sourceMetadataItemId: item.id,
+			contentReadActionId: actionId,
+			contentReadAt
+		},
+		sensitivity: item.sensitivity,
+		retentionClass: "bounded",
+		synthesisPipeline: "connected_knowledge",
+		synthesisStatus: "pending"
+	};
+}
+async function readConnectedContent(input) {
+	const sourceItemIds = [...new Set(input.sourceItemIds.map((id) => id.trim()).filter(Boolean))];
+	if (!sourceItemIds.length || sourceItemIds.length > MAX_SELECTION) throw new Error(`Select between 1 and ${MAX_SELECTION} source items.`);
+	const downloadDirectory = await mkdtemp(join(tmpdir(), "xopc-content-read-"));
+	const adapter = input.adapterFactory?.(downloadDirectory) ?? new ComposioSessionsAdapter({ fileDownloadDir: downloadDirectory });
+	const result = {
+		requested: sourceItemIds.length,
+		completed: 0,
+		failed: [],
+		recordIds: []
+	};
+	const updatedSources = /* @__PURE__ */ new Set();
+	const completedReads = new Set(listKnowledgeSourceItems({
+		agentId: input.agentId,
+		includeDeleted: false,
+		limit: 500
+	}).map((item) => text(item.metadata.sourceMetadataItemId)).filter((id) => Boolean(id)));
+	try {
+		for (const sourceItemId of sourceItemIds) try {
+			const item = getKnowledgeSourceItem(sourceItemId);
+			if (!item || item.deletedAt || item.metadata.agentId !== input.agentId) throw new Error("Source item is unavailable.");
+			if (completedReads.has(item.id)) throw new Error("Source item content was already read.");
+			if (!candidateFor(item)) throw new Error("Source item is not eligible for content reading.");
+			const connectorId = text(item.metadata.connectorId);
+			const connectionId = text(item.metadata.connectionId);
+			const toolkit = text(item.metadata.toolkit);
+			if (!connectorId || !connectionId || !toolkit) throw new Error("Source item has incomplete connector provenance.");
+			const connection = getConnectorConnection(connectionId);
+			const installation = getConnectorInstallation(`${connectorId}-local-owner`);
+			if (!connection || connection.status !== "active" || !installation?.enabled) throw new Error("The connected account is not active.");
+			const recipe = contentRecipe(item);
+			const execution = await adapter.executeWithPolicy({
+				context: {
+					principalId: connection.principalId,
+					toolkits: [toolkit]
+				},
+				installation: {
+					...installation,
+					maxScope: "read",
+					confirmationPolicy: "always"
+				},
+				connection,
+				agentId: input.agentId,
+				action: {
+					connectorId,
+					actionId: recipe.actionId,
+					toolkit,
+					scope: "read",
+					curated: true,
+					cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+				},
+				args: recipe.args,
+				confirmed: true
+			});
+			if (execution.decision !== "allowed") throw new Error(execution.reason);
+			const content = recipe.mode === "inline" ? inlineContent(execution.result) : await downloadedContent(execution.result, downloadDirectory);
+			if (!content.trim()) throw new Error("The connector returned empty text content.");
+			upsertKnowledgeSourceItems([updatedSourceItem(item, content, recipe.actionId)]);
+			completedReads.add(item.id);
+			updatedSources.add(item.sourceInstanceId);
+			result.completed += 1;
+		} catch (error) {
+			result.failed.push({
+				sourceItemId,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+		for (const sourceInstanceId of updatedSources) {
+			const item = listKnowledgeSourceItems({
+				sourceInstanceId,
+				synthesisStatus: "pending",
+				limit: 1
+			})[0];
+			if (!item) continue;
+			const synthesized = await new ConnectedKnowledgePipeline({
+				agentId: input.agentId,
+				workspaceId: text(item.metadata.workspaceId) ?? "default"
+			}).processPending(sourceInstanceId);
+			result.recordIds.push(...synthesized.recordIds);
+		}
+		return result;
+	} finally {
+		await rm(downloadDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { listConnectedContentCandidates, readConnectedContent };

package/dist/src/connectors/health.js

@@ -1,6 +1,6 @@
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { materializeConnectorMcpServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
 //#region src/connectors/health.ts
 function classifyConnectorHealthError(error) {

package/dist/src/connectors/learning-coordinator.js

@@ -27,7 +27,6 @@ function connectorSourceCategory(toolkit) {
 	if (toolkit === "gmail") return "mail";
 	if (toolkit === "googlecalendar") return "calendar";
 	if (toolkit === "github" || toolkit === "linear") return "code_activity";
-	if (toolkit === "slack") return "messages";
 	return "files";
 }
 function ensureUnderstandingSourceRun(job, toolkit, displayName) {
@@ -189,7 +188,7 @@ function startConnectorLearningCoordinator(options) {
 			itemsIndexed
 		}));
 		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
-		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
+		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.agentId);
 		for (const record of understanding.createdRecords.filter((item) => item.kind === "project_context")) upsertUserFocus({
 			canonicalKey: `connector-focus:${job.accountId}:${record.id}`,
 			title: record.content.slice(0, 120),

package/dist/src/connectors/learning-recipes.js

@@ -1,5 +1,7 @@
+import { decodeConnectedSourceCursor } from "./connected-source-cursor.js";
 //#region src/connectors/learning-recipes.ts
 function buildConnectorLearningArguments(plan, stream, input, identity) {
+	const cursor = decodeConnectedSourceCursor(input.cursor);
 	if (plan.toolkit === "github" && stream.scope === "authored-work") {
 		const username = typeof identity.username === "string" ? identity.username.trim() : "";
 		if (!username) throw new Error("GitHub activity sync requires the authenticated username.");
@@ -8,18 +10,28 @@ function buildConnectorLearningArguments(plan, stream, input, identity) {
 			q: `author:${username} sort:updated-desc`
 		};
 	}
-	if (!input.cursor) return { ...stream.arguments };
 	if (plan.toolkit === "gmail") {
-		const after = Math.floor(Date.parse(input.cursor) / 1e3);
-		return Number.isFinite(after) ? {
+		const after = cursor?.checkpoint ? Math.floor(Date.parse(cursor.checkpoint) / 1e3) : NaN;
+		return {
 			...stream.arguments,
-			query: `after:${after} -in:spam -in:trash`
-		} : { ...stream.arguments };
+			...Number.isFinite(after) ? { query: `after:${after} -in:spam -in:trash` } : {},
+			...cursor?.pageToken ? { page_token: cursor.pageToken } : {}
+		};
 	}
 	if (plan.toolkit === "googlecalendar") return {
 		...stream.arguments,
-		time_min: input.cursor
+		...cursor?.syncToken ? { sync_token: cursor.syncToken } : {},
+		...cursor?.pageToken ? { page_token: cursor.pageToken } : {}
 	};
+	if (plan.toolkit === "googledrive") {
+		const checkpoint = cursor?.checkpoint && Number.isFinite(Date.parse(cursor.checkpoint)) ? cursor.checkpoint : void 0;
+		const baseQuery = typeof stream.arguments.q === "string" ? stream.arguments.q : "";
+		return {
+			...stream.arguments,
+			...checkpoint ? { q: [baseQuery, `modifiedTime > '${checkpoint}'`].filter(Boolean).join(" and ") } : {},
+			...cursor?.pageToken ? { pageToken: cursor.pageToken } : {}
+		};
+	}
 	return { ...stream.arguments };
 }
 const PLANS = {
@@ -42,47 +54,30 @@ const PLANS = {
 		toolkit: "googlecalendar",
 		streams: [{
 			scope: "events",
-			actionId: "GOOGLECALENDAR_LIST_EVENTS",
+			actionId: "GOOGLECALENDAR_SYNC_EVENTS",
 			kind: "activity",
-			arguments: { max_results: 200 }
+			arguments: { max_results: 500 }
 		}],
 		bootstrapWindowDays: 90,
 		intervalMinutes: 15
 	},
 	googledrive: {
 		toolkit: "googledrive",
+		identityProbe: { actionId: "GOOGLEDRIVE_GET_ABOUT" },
 		streams: [{
 			scope: "files",
-			actionId: "GOOGLEDRIVE_SEARCH_FILES",
+			actionId: "GOOGLEDRIVE_FIND_FILE",
 			kind: "inventory",
-			arguments: {}
-		}],
-		bootstrapWindowDays: 90,
-		intervalMinutes: 30
-	},
-	notion: {
-		toolkit: "notion",
-		streams: [{
-			scope: "pages",
-			actionId: "NOTION_SEARCH",
-			kind: "inventory",
-			arguments: {}
+			arguments: {
+				q: "trashed = false",
+				orderBy: "modifiedTime desc",
+				pageSize: 100,
+				fields: "nextPageToken,files(id,name,mimeType,createdTime,modifiedTime,owners,webViewLink,trashed)"
+			}
 		}],
 		bootstrapWindowDays: 90,
 		intervalMinutes: 30
 	},
-	slack: {
-		toolkit: "slack",
-		identityProbe: { actionId: "SLACK_TEST_AUTH" },
-		streams: [{
-			scope: "channels",
-			actionId: "SLACK_LIST_CHANNELS",
-			kind: "inventory",
-			arguments: {}
-		}],
-		bootstrapWindowDays: 30,
-		intervalMinutes: 15
-	},
 	github: {
 		toolkit: "github",
 		identityProbe: { actionId: "GITHUB_GET_THE_AUTHENTICATED_USER" },

package/dist/src/connectors/runtime-adapter-registry.js

@@ -107,7 +107,7 @@ registerConnectorRuntimeAdapter({
 		if (definition.runtime.type !== "composio") throw new Error(`Invalid Composio connector definition: ${definition.id}`);
 		if (definition.runtime.role === "credential") await saveComposioApiKey(input, resolver);
 		if (definition.runtime.role === "toolkit") await assertComposioApiKeyConfigured(resolver);
-		const instance = installRecord(config, definition, definition.runtime.role === "toolkit" ? { scope: "read" } : {});
+		const instance = installRecord(config, definition, definition.runtime.role === "toolkit" ? { scope: "read" } : {}, definition.runtime.role === "toolkit" ? { config: input.config ?? {} } : {});
 		if (definition.runtime.role === "toolkit" && isXopcDatabaseOpen()) {
 			const installationId = `${definition.id}-local-owner`;
 			const existing = getConnectorInstallation(installationId);
@@ -129,6 +129,19 @@ registerConnectorRuntimeAdapter({
 		if (definition.runtime.type !== "composio") throw new Error(`Invalid Composio connector definition: ${definition.id}`);
 		uninstallRecord(config, instance.instanceId);
 		if (definition.runtime.role === "toolkit" && isXopcDatabaseOpen()) deleteConnectorInstallation(`${definition.id}-local-owner`);
+	},
+	update({ config, definition, input, instanceId }) {
+		if (definition.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Invalid Composio toolkit definition: ${definition.id}`);
+		const record = config.connectors?.instances?.[instanceId];
+		const marker = record?.xopcConnector;
+		if (!marker || typeof marker !== "object" || Array.isArray(marker)) throw new Error(`Connector instance not found: ${instanceId}`);
+		const markerRecord = marker;
+		if (markerRecord.managed !== true) throw new Error(`Connector instance not found: ${instanceId}`);
+		record.xopcConnector = {
+			...markerRecord,
+			config: input.config ?? {}
+		};
+		return installedInstance(config, instanceId, definition.id);
 	}
 });
 for (const type of [

package/dist/src/discussions/live-worker.d.ts

@@ -28,6 +28,7 @@ export declare class DiscussionLiveWorker {
     start(): void;
     stop(): Promise<void>;
     tick(): Promise<void>;
+    private resolveConcurrency;
     private processOne;
     private transcribeSegment;
     private enrichOnce;

package/dist/src/discussions/live-worker.js

@@ -42,13 +42,19 @@ var DiscussionLiveWorker = class {
 		if (this.running) return;
 		this.running = true;
 		try {
-			await Promise.all(Array.from({ length: this.concurrency }, () => this.processOne()));
+			await Promise.all(Array.from({ length: this.resolveConcurrency() }, () => this.processOne()));
 		} finally {
 			this.running = false;
 			const waiters = this.stoppedWaiters.splice(0);
 			for (const resolve of waiters) resolve();
 		}
 	}
+	resolveConcurrency() {
+		if (this.deps.transcribeSegment) return this.concurrency;
+		const config = this.deps.getConfig();
+		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
+		return sttConfig.provider === "xopc-local" || sttConfig.provider === "local" ? 1 : this.concurrency;
+	}
 	async processOne() {
 		const segment = claimNextDiscussionTranscriptSegment(this.owner);
 		if (!segment) return;

package/dist/src/discussions/repository.js

@@ -128,13 +128,23 @@ function getDiscussionMetrics() {
       WHERE s.discussion_id = d.id AND s.status = 'confirmed') - d.recording_started_at) first_ms,
     AVG(CASE WHEN d.completed_at IS NOT NULL THEN d.completed_at - d.recording_started_at END) complete_ms
     FROM discussion_captures d`).get();
+	const segmentMetrics = db.prepare(`SELECT
+    COUNT(*) total,
+    SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) failed,
+    SUM(CASE WHEN attempt_count > 1 THEN 1 ELSE 0 END) retried,
+    AVG(CASE WHEN status = 'confirmed' THEN updated_at - created_at END) latency_ms
+    FROM discussion_transcript_segments`).get();
 	const byStatus = Object.fromEntries(DISCUSSION_STATUSES.map((status) => [status, 0]));
 	for (const row of rows) byStatus[row.status] = row.count;
 	return {
 		total: rows.reduce((sum, row) => sum + row.count, 0),
 		byStatus,
 		averageTimeToFirstTranscriptMs: timing.first_ms == null ? null : Math.max(0, Math.round(timing.first_ms)),
-		averageTimeToCompleteMs: timing.complete_ms == null ? null : Math.max(0, Math.round(timing.complete_ms))
+		averageTimeToCompleteMs: timing.complete_ms == null ? null : Math.max(0, Math.round(timing.complete_ms)),
+		totalSegments: segmentMetrics.total,
+		failedSegments: segmentMetrics.failed ?? 0,
+		retriedSegments: segmentMetrics.retried ?? 0,
+		averageSegmentLatencyMs: segmentMetrics.latency_ms == null ? null : Math.max(0, Math.round(segmentMetrics.latency_ms))
 	};
 }
 function updateDiscussionCapture(id, patch, expectedStatuses) {

package/dist/src/discussions/sealer.d.ts

@@ -4,7 +4,7 @@ import type { DiscussionCapture } from './types.js';
 export interface DiscussionSealerDeps {
     notes: NotesService;
     getConfig: () => Config;
-    transcribeRecording?: (buffer: Buffer, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
+    transcribeRecording?: (filePath: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
         text: string;
         language?: string;
     }>;