@xopcai/xopc 0.0.211 → 0.0.213

package/dist/src/connectors/composio-managed-client.js

@@ -0,0 +1,135 @@
+import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../providers/xopc-cloud-config.js";
+import { getProviderAuthService, init_provider_auth_service } from "../providers/provider-auth-service.js";
+import { randomUUID } from "node:crypto";
+//#region src/connectors/composio-managed-client.ts
+init_provider_auth_service();
+init_xopc_cloud_config();
+var ManagedComposioError = class extends Error {
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "ManagedComposioError";
+	}
+};
+var ManagedComposioClient = class {
+	mode = "managed";
+	fetchImpl;
+	routerUrl;
+	credentials;
+	constructor(options = {}) {
+		this.fetchImpl = options.fetchImpl ?? fetch;
+		this.routerUrl = resolveXopcModelRouterUrl(options.routerUrl);
+		this.credentials = options.credentials ?? getProviderAuthService();
+	}
+	sessions = { create: async (_userId, config = {}) => {
+		if (config.authConfigs && Object.keys(config.authConfigs).length > 0) throw new Error("Custom Composio auth configs require BYOK mode.");
+		const enabledToolkits = Array.isArray(config.toolkits) ? config.toolkits : config.toolkits && "enable" in config.toolkits ? config.toolkits.enable : [];
+		const connectedAccounts = Object.fromEntries(Object.entries(config.connectedAccounts ?? {}).map(([toolkit, value]) => [toolkit, Array.isArray(value) ? value : [value]]));
+		return this.session(enabledToolkits, connectedAccounts);
+	} };
+	connectedAccounts = {
+		list: async () => this.request({ path: "/connectors/composio/connections" }),
+		delete: async (id) => this.request({
+			path: `/connectors/composio/connections/${encodeURIComponent(id)}`,
+			method: "DELETE"
+		}),
+		refresh: async (id) => this.request({
+			path: `/connectors/composio/connections/${encodeURIComponent(id)}/refresh`,
+			method: "POST"
+		})
+	};
+	authConfigs = { list: async () => ({ items: [] }) };
+	toolkits = { get: async (slug) => {
+		const response = await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(slug)}/auth` });
+		return {
+			composioManagedAuthSchemes: response.auth.managedAuthAvailable ? ["OAUTH2"] : [],
+			authConfigDetails: response.auth.requiresCustomAuthConfig ? [{}] : []
+		};
+	} };
+	async status() {
+		return this.request({ path: "/connectors/composio/status" });
+	}
+	async events(after = 0, limit = 50) {
+		return this.request({ path: `/connectors/composio/events?after=${after}&limit=${limit}` });
+	}
+	session(toolkits, connectedAccounts) {
+		const toolkit = () => {
+			if (toolkits.length !== 1 || !toolkits[0]) throw new Error("Managed Composio sessions require exactly one toolkit for this operation.");
+			return toolkits[0];
+		};
+		return {
+			sessionId: "managed",
+			toolkits: async () => {
+				return { items: (await this.request({ path: "/connectors/composio/toolkits" })).items };
+			},
+			authorize: async (requestedToolkit, options) => {
+				return (await this.request({
+					path: "/connectors/composio/authorizations",
+					method: "POST",
+					body: {
+						toolkit: requestedToolkit,
+						alias: options?.alias
+					}
+				})).item;
+			},
+			search: async () => {
+				return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(toolkit())}/tools` })).result;
+			},
+			execute: async (toolSlug, args = {}, options) => {
+				const selected = options?.account ?? connectedAccounts[toolkit()]?.[0];
+				return (await this.request({
+					path: "/connectors/composio/execute",
+					method: "POST",
+					body: {
+						toolkit: toolkit(),
+						toolSlug,
+						args,
+						...selected ? { accountId: selected } : {}
+					},
+					headers: { "idempotency-key": randomUUID() }
+				})).result;
+			}
+		};
+	}
+	async request(input) {
+		const accessToken = await this.credentials.resolveApiKey("xopc-cloud");
+		if (!accessToken) throw new ManagedComposioError("Sign in to XOPC Cloud to use managed app connections.", 401, "xopc_cloud_not_configured");
+		const response = await this.fetchImpl(`${this.routerUrl}${input.path}`, {
+			method: input.method ?? "GET",
+			headers: {
+				authorization: `Bearer ${accessToken}`,
+				accept: "application/json",
+				...input.body === void 0 ? {} : { "content-type": "application/json" },
+				...input.headers
+			},
+			...input.body === void 0 ? {} : { body: JSON.stringify(input.body) },
+			signal: AbortSignal.timeout(6e4)
+		});
+		const body = await response.json().catch(() => null);
+		if (!response.ok) {
+			const code = typeof body?.error?.code === "string" ? body.error.code : void 0;
+			const fallback = response.status === 403 && code === "insufficient_scope" ? "Reconnect XOPC Cloud to grant app connection permissions." : `Managed Composio request failed (${response.status})`;
+			throw new ManagedComposioError(typeof body?.error?.message === "string" ? body.error.message : fallback, response.status, code);
+		}
+		return body;
+	}
+};
+async function inspectManagedComposioStatus(options = {}) {
+	try {
+		const status = await new ManagedComposioClient(options).status();
+		return {
+			configured: status.configured,
+			mode: "managed",
+			...!status.configured ? { reason: "service_unavailable" } : {}
+		};
+	} catch (error) {
+		return {
+			configured: false,
+			mode: "managed",
+			reason: error instanceof ManagedComposioError && error.code === "insufficient_scope" ? "reauthorization_required" : error instanceof ManagedComposioError && error.status === 401 ? "signin_required" : "service_unavailable"
+		};
+	}
+}
+//#endregion
+export { ManagedComposioClient, inspectManagedComposioStatus };

package/dist/src/connectors/composio-managed-events.d.ts

@@ -0,0 +1,41 @@
+import type { Config } from '../config/schema.js';
+type ManagedEvent = {
+    sequence: number;
+    id: string;
+    type: string;
+    toolkit?: string;
+    connectionId?: string;
+    payload: unknown;
+    createdAt: string;
+};
+type ManagedEventClient = {
+    events(after?: number, limit?: number): Promise<{
+        items: ManagedEvent[];
+        nextCursor: number;
+    }>;
+};
+export declare class ManagedComposioEventPoller {
+    private readonly input;
+    private timer?;
+    private cursor;
+    private syncing?;
+    constructor(input: {
+        getConfig: () => Config;
+        triggerAutomation: (event: {
+            type: string;
+            source: string;
+            payload: Record<string, unknown>;
+        }) => Promise<unknown>;
+        requestLearning: (toolkit: string) => void;
+        setLearningPaused: (connectionId: string, paused: boolean) => void;
+        client?: ManagedEventClient;
+        hasByok?: () => Promise<boolean>;
+        intervalMs?: number;
+    });
+    start(): void;
+    stop(): void;
+    sync(): Promise<void>;
+    private runSync;
+    private process;
+}
+export {};

package/dist/src/connectors/composio-managed-events.js

@@ -0,0 +1,105 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { claimConnectorWebhookDelivery, completeConnectorWebhookDelivery, releaseConnectorWebhookDelivery } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { resolveComposioApiKey } from "./composio-sessions.js";
+import { ManagedComposioClient } from "./composio-managed-client.js";
+import { appendComposioTriggerEvent, applyComposioConnectionLifecycleEvent, normalizeComposioTriggerPayload } from "./composio-triggers.js";
+import { createHash } from "node:crypto";
+//#region src/connectors/composio-managed-events.ts
+init_logger();
+const log = createLogger("Connectors:ComposioManagedEvents");
+function hasInstalledComposioToolkit(config) {
+	return Object.values(config.connectors?.instances ?? {}).some((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+		const runtime = value.runtime;
+		return Boolean(runtime && typeof runtime === "object" && !Array.isArray(runtime) && runtime.type === "composio" && runtime.role === "toolkit");
+	});
+}
+var ManagedComposioEventPoller = class {
+	timer;
+	cursor = 0;
+	syncing;
+	constructor(input) {
+		this.input = input;
+	}
+	start() {
+		if (this.timer) return;
+		this.sync().catch(() => {});
+		this.timer = setInterval(() => {
+			this.sync().catch(() => {});
+		}, this.input.intervalMs ?? 15e3);
+		this.timer.unref?.();
+	}
+	stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = void 0;
+	}
+	sync() {
+		this.syncing ??= this.runSync().finally(() => {
+			this.syncing = void 0;
+		});
+		return this.syncing;
+	}
+	async runSync() {
+		const config = this.input.getConfig();
+		const hasByok = this.input.hasByok ?? (async () => Boolean(await resolveComposioApiKey()));
+		if (!hasInstalledComposioToolkit(config) || await hasByok()) return;
+		const client = this.input.client ?? new ManagedComposioClient();
+		try {
+			for (let page = 0; page < 20; page += 1) {
+				const response = await client.events(this.cursor, 100);
+				for (const event of response.items) await this.process(config, event);
+				const next = Math.max(this.cursor, response.nextCursor);
+				if (next === this.cursor || response.items.length === 0) break;
+				this.cursor = next;
+				if (response.items.length < 100) break;
+			}
+		} catch (error) {
+			log.debug({
+				err: error,
+				phase: "event_poll"
+			}, "Managed Composio event poll skipped");
+			throw error;
+		}
+	}
+	async process(config, event) {
+		const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) ? {
+			...event.payload,
+			id: event.id
+		} : {
+			id: event.id,
+			type: event.type,
+			data: event.payload
+		};
+		const hash = createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+		if (claimConnectorWebhookDelivery({
+			id: event.id,
+			provider: "composio",
+			payloadHash: hash
+		}) !== "claimed") return;
+		try {
+			const normalized = normalizeComposioTriggerPayload(payload, event.id);
+			const inactiveConnectionId = applyComposioConnectionLifecycleEvent(payload);
+			if (inactiveConnectionId) this.input.setLearningPaused(inactiveConnectionId, true);
+			await appendComposioTriggerEvent(config, payload);
+			const toolkit = normalized.toolkit ?? event.toolkit;
+			if (toolkit) this.input.requestLearning(toolkit);
+			await this.input.triggerAutomation({
+				type: `connector.${normalized.trigger ?? normalized.type}`,
+				source: toolkit ? `composio:${toolkit}` : "composio",
+				payload: {
+					...normalized.data,
+					connectorId: toolkit ? `composio-${toolkit}` : "composio",
+					webhookId: event.id
+				}
+			});
+			completeConnectorWebhookDelivery(event.id);
+		} catch (error) {
+			releaseConnectorWebhookDelivery(event.id, error);
+			throw error;
+		}
+	}
+};
+//#endregion
+export { ManagedComposioEventPoller };

package/dist/src/connectors/composio-sessions.d.ts

@@ -2,7 +2,7 @@ import type { ToolRouterCreateSessionConfig } from '@composio/core';
 import { CredentialResolver } from '../auth/credentials.js';
 import type { ConnectorActionMetadata, ConnectorConnection, ConnectorInstallationPolicy } from './types.js';
 export declare function resolveComposioApiKey(resolver?: CredentialResolver): Promise<string | null>;
-export declare function assertComposioApiKeyConfigured(resolver?: CredentialResolver): Promise<string>;
+export declare function assertComposioAccessConfigured(resolver?: CredentialResolver): Promise<'byok' | 'managed'>;
 export type ComposioToolkitCatalogItem = {
     slug: string;
     name: string;
@@ -72,6 +72,7 @@ export type ComposioSessionLike = {
     }): Promise<unknown>;
 };
 export type ComposioSessionsClient = {
+    mode?: 'managed' | 'byok';
     sessions: {
         create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ComposioSessionLike>;
     };

package/dist/src/connectors/composio-sessions.js

@@ -17,10 +17,10 @@ const COMPOSIO_API_KEY_PROVIDER = "connector-composio-api-key";
 async function resolveComposioApiKey(resolver = new CredentialResolver()) {
 	return (await resolver.resolveApiKey(COMPOSIO_API_KEY_PROVIDER).catch(() => void 0))?.trim() || process.env.XOPC_COMPOSIO_API_KEY?.trim() || process.env.COMPOSIO_API_KEY?.trim() || null;
 }
-async function assertComposioApiKeyConfigured(resolver = new CredentialResolver()) {
-	const apiKey = await resolveComposioApiKey(resolver);
-	if (!apiKey) throw new Error("Composio API key is not configured. Install the \"Composio API Key\" connector first.");
-	return apiKey;
+async function assertComposioAccessConfigured(resolver = new CredentialResolver()) {
+	if (await resolveComposioApiKey(resolver)) return "byok";
+	if ((await resolver.resolveApiKey("xopc-cloud").catch(() => null))?.trim()) return "managed";
+	throw new Error("Composio API key is not configured and XOPC Cloud is not signed in. Install the \"Composio API Key\" connector first or sign in to XOPC Cloud.");
 }
 function stableHash(value) {
 	return createHash("sha256").update(value).digest("hex").slice(0, 24);
@@ -91,7 +91,11 @@ var ComposioSessionsAdapter = class {
 		}
 		const resolver = options.resolver ?? new CredentialResolver();
 		this.createClient = async () => {
-			const apiKey = await assertComposioApiKeyConfigured(resolver);
+			const apiKey = await resolveComposioApiKey(resolver);
+			if (!apiKey) {
+				const { ManagedComposioClient } = await import("./composio-managed-client.js");
+				return new ManagedComposioClient();
+			}
 			let Composio;
 			let PiProvider;
 			try {
@@ -99,7 +103,7 @@ var ComposioSessionsAdapter = class {
 			} catch (cause) {
 				throw new Error("The xopc installation is missing the bundled Composio runtime. Reinstall @xopcai/xopc and restart the gateway.", { cause });
 			}
-			return new Composio({
+			const client = new Composio({
 				apiKey,
 				baseURL: process.env.XOPC_COMPOSIO_BASE_URL?.trim() || void 0,
 				allowTracking: false,
@@ -109,6 +113,8 @@ var ComposioSessionsAdapter = class {
 				provider: new PiProvider(),
 				host: "xopc"
 			});
+			client.mode = "byok";
+			return client;
 		};
 	}
 	async createSession(context) {
@@ -375,4 +381,4 @@ var ComposioSessionsAdapter = class {
 	}
 };
 //#endregion
-export { ComposioSessionsAdapter, assertComposioApiKeyConfigured, createComposioPrincipalId, resolveComposioApiKey };
+export { ComposioSessionsAdapter, assertComposioAccessConfigured, createComposioPrincipalId, resolveComposioApiKey };

package/dist/src/connectors/composio.js

@@ -2,7 +2,7 @@ import { getConnectorConnection, getConnectorInstallation, listConnectorConnecti
 import { getConnectorAccount, refreshConnectorAccountCurrent } from "../storage/sqlite/connector-account-repository.js";
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
 import { connectorIdentityKey } from "./connector-identity.js";
-import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { ComposioSessionsAdapter, assertComposioAccessConfigured } from "./composio-sessions.js";
 import { COMPOSIO_AGENT_READY_TOOLKITS, COMPOSIO_TOOLKIT_DISPLAY_NAMES, connectorDefinitionFromComposioToolkit } from "./composio-catalog.js";
 import { consumeConnectorSetupSecretRef } from "./setup-secrets.js";
 //#region src/connectors/composio.ts
@@ -370,6 +370,7 @@ async function listComposioConnections(resolver = new CredentialResolver()) {
 async function inspectComposioConnectorHealth(toolkit, resolver = new CredentialResolver()) {
 	const normalizedToolkit = normalizeToolkit(toolkit);
 	try {
+		await assertComposioAccessConfigured(resolver);
 		const connections = (await listComposioConnections(resolver)).filter((connection) => connection.toolkit.toLowerCase() === normalizedToolkit);
 		const byAccount = /* @__PURE__ */ new Map();
 		for (const connection of connections) {

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

@@ -1,11 +1,13 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
 import { getConnectorInstallation, listConnectorConnections } from "../storage/sqlite/connector-repository.js";
 import "../storage/sqlite/index.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { decodeConnectedSourceCursor, encodeConnectedSourceCursor } from "./connected-source-cursor.js";
 import { scopeForComposioAction } from "./composio.js";
 import { getConnectorDefinition } from "./catalog.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { getConnectorInstance } from "./instances.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { KnowledgeIngestionService } from "../knowledge/ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
 import { LocalFolderKnowledgeSourceAdapter } from "../knowledge/local-folder-adapter.js";
@@ -14,6 +16,8 @@ import { normalizeConnectedSourceResult } from "./connected-source-normalizers.j
 import { sanitizeConnectedSourceValue } from "./connected-source-sanitization.js";
 import { createHash } from "node:crypto";
 //#region src/connectors/connected-source-ingestion.ts
+init_logger();
+const log = createLogger("ConnectedSourceIngestion");
 const COMPOSIO_CONNECTED_SOURCE_TOOLKITS = new Set([
 	"gmail",
 	"googlecalendar",
@@ -99,6 +103,17 @@ function paginationValue(result, ...keys) {
 		if (typeof value === "string" && value.trim()) return value.trim();
 	}
 }
+function isPayloadTooLargeError(error) {
+	const details = asRecord(error);
+	const status = details?.status ?? details?.statusCode;
+	const code = details?.code;
+	const message = error instanceof Error ? error.message : String(error);
+	return String(status) === "413" || String(code) === "4345" || /\b413\b|ToolRouterV2_PayloadTooLarge|payload is too large/i.test(message);
+}
+function maxResultsValue(args) {
+	const value = args.max_results;
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
 function resultToSourceItems(input) {
 	return normalizeConnectedSourceResult(input).slice(0, 200).map((entity) => {
 		const record = entity.value;
@@ -142,6 +157,7 @@ function resultToSourceItems(input) {
 }
 var ComposioKnowledgeSourceAdapter = class {
 	kind = "composio";
+	adaptiveMaxResults;
 	constructor(input) {
 		this.input = input;
 	}
@@ -149,32 +165,58 @@ var ComposioKnowledgeSourceAdapter = class {
 		const cursor = decodeConnectedSourceCursor(pull.cursor);
 		const scanStartedAt = cursor?.scanStartedAt ?? (/* @__PURE__ */ new Date()).toISOString();
 		const warnings = pull.cursor && !cursor ? ["Stored connected-source cursor was invalid and was replaced."] : [];
-		const execute = (cursorValue) => this.input.adapter.executeWithPolicy({
-			context: {
-				principalId: "local-owner",
-				toolkits: [this.input.toolkit]
-			},
-			installation: {
-				...this.input.installation,
-				maxScope: "read",
-				confirmationPolicy: "never"
-			},
-			connection: this.input.connection,
-			agentId: this.input.agentId,
-			action: {
-				connectorId: this.input.connectorId,
-				actionId: this.input.actionId,
-				toolkit: this.input.toolkit,
-				scope: "read",
-				curated: true,
-				cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-			},
-			args: this.input.buildArguments?.({
+		const execute = async (cursorValue) => {
+			const configuredArgs = this.input.buildArguments?.({
 				...pull,
 				cursor: cursorValue
-			}) ?? this.input.arguments,
-			confirmed: true
-		});
+			}) ?? this.input.arguments;
+			const configuredMaxResults = maxResultsValue(configuredArgs);
+			let args = this.adaptiveMaxResults && configuredMaxResults && configuredMaxResults > this.adaptiveMaxResults ? {
+				...configuredArgs,
+				max_results: this.adaptiveMaxResults
+			} : configuredArgs;
+			for (;;) try {
+				return await this.input.adapter.executeWithPolicy({
+					context: {
+						principalId: "local-owner",
+						toolkits: [this.input.toolkit]
+					},
+					installation: {
+						...this.input.installation,
+						maxScope: "read",
+						confirmationPolicy: "never"
+					},
+					connection: this.input.connection,
+					agentId: this.input.agentId,
+					action: {
+						connectorId: this.input.connectorId,
+						actionId: this.input.actionId,
+						toolkit: this.input.toolkit,
+						scope: "read",
+						curated: true,
+						cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+					},
+					args,
+					confirmed: true
+				});
+			} catch (error) {
+				const currentMaxResults = maxResultsValue(args);
+				if (!isPayloadTooLargeError(error) || !currentMaxResults || currentMaxResults <= 1) throw error;
+				const reducedMaxResults = Math.max(1, Math.floor(currentMaxResults / 2));
+				this.adaptiveMaxResults = reducedMaxResults;
+				log.info({
+					connectorId: this.input.connectorId,
+					actionId: this.input.actionId,
+					previousMaxResults: currentMaxResults,
+					maxResults: reducedMaxResults,
+					phase: "payload_too_large_retry"
+				}, `Retrying connector action with page size ${reducedMaxResults}`);
+				args = {
+					...args,
+					max_results: reducedMaxResults
+				};
+			}
+		};
 		let execution;
 		try {
 			execution = await execute(pull.cursor);

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-recipes.js

@@ -44,6 +44,8 @@ const PLANS = {
 			kind: "activity",
 			arguments: {
 				max_results: 100,
+				include_payload: false,
+				verbose: false,
 				query: "newer_than:30d -in:spam -in:trash"
 			}
 		}],

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

@@ -1,7 +1,7 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { deleteConnectorInstallation, getConnectorInstallation, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
 import "../storage/sqlite/index.js";
-import { assertComposioApiKeyConfigured } from "./composio-sessions.js";
+import { assertComposioAccessConfigured } from "./composio-sessions.js";
 import { saveComposioApiKey } from "./composio.js";
 import { saveConnectorSecrets } from "./secret-store.js";
 import { isManagedConnectorServer, materializeConnectorMcpServer } from "./materialize.js";
@@ -106,7 +106,7 @@ registerConnectorRuntimeAdapter({
 	async install({ config, definition, input, resolver }) {
 		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);
+		if (definition.runtime.role === "toolkit") await assertComposioAccessConfigured(resolver);
 		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`;

package/dist/src/discussions/sealer.js

@@ -6,7 +6,7 @@ import { isSTTAvailable } from "../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
 import { getDiscussionCapture, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
-import { appendTranscriptWithoutOverlap, assembleDiscussionTranscript } from "./transcript.js";
+import { appendSequentialTranscript, assembleDiscussionTranscript } from "./transcript.js";
 import { createHash } from "node:crypto";
 //#region src/discussions/sealer.ts
 init_logger();
@@ -96,7 +96,7 @@ var DiscussionSealer = class {
 				mime: "audio/wav",
 				fileName: `discussion-recovery-${index}.wav`
 			});
-			text = appendTranscriptWithoutOverlap(text, result.text);
+			text = appendSequentialTranscript(text, result.text);
 			language ??= result.language;
 		});
 		return {

package/dist/src/discussions/service.js

@@ -153,13 +153,16 @@ var DiscussionService = class {
 	uploadSegment(input) {
 		const capture = getDiscussionCapture(input.discussionId);
 		if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
-		if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "Discussion no longer accepts transcript segments");
+		const acceptsSegments = capture.status === "recording" || capture.status === "stopping";
+		const originalRecordingSupersedesSegment = capture.audioAttachmentId && (capture.status === "sealing" || capture.status === "organizing" || capture.status === "completed");
+		if (!acceptsSegments && !originalRecordingSupersedesSegment) throw new DiscussionServiceError("conflict", "Discussion no longer accepts transcript segments");
 		if (!Number.isInteger(input.sequence) || input.sequence < 0 || input.sequence > 2e3) throw new DiscussionServiceError("invalid_input", "Invalid segment sequence");
 		if (input.file.mimeType !== "audio/wav" && input.file.mimeType !== "audio/x-wav") throw new DiscussionServiceError("invalid_input", "Live transcript segments must be WAV audio");
 		if (input.file.buffer.length === 0 || input.file.buffer.length > 2097152) throw new DiscussionServiceError("invalid_input", "Live transcript segment is empty or too large");
 		if (!Number.isFinite(input.startedAtMs) || !Number.isFinite(input.endedAtMs) || input.startedAtMs < 0 || input.endedAtMs <= input.startedAtMs || input.endedAtMs - input.startedAtMs > 25e3) throw new DiscussionServiceError("invalid_input", "Invalid live transcript segment timing");
 		const actualSha256 = createHash("sha256").update(input.file.buffer).digest("hex");
 		if (input.sha256 !== actualSha256) throw new DiscussionServiceError("invalid_input", "Segment checksum mismatch");
+		if (originalRecordingSupersedesSegment) return this.transcript(input.discussionId);
 		const existing = getDiscussionTranscriptSegment(input.discussionId, input.sequence);
 		if (existing && existing.audioSha256 !== actualSha256) throw new DiscussionServiceError("conflict", "Segment sequence already contains different audio");
 		if (!existing) {
@@ -219,7 +222,8 @@ var DiscussionService = class {
 				name: file.name.trim().slice(0, 200) || `discussion-${id}.webm`,
 				buffer: file.buffer,
 				mimeType: file.mimeType,
-				duration: Math.round(durationMs / 1e3)
+				duration: Math.round(durationMs / 1e3),
+				retainWithoutReference: true
 			});
 			if (!attachment) throw new DiscussionServiceError("not_found", "Discussion note not found");
 			try {

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

@@ -1,3 +1,5 @@
 import type { DiscussionTranscriptSegment } from './types.js';
+/** Joins transcripts from adjacent audio chunks that have no audio overlap. */
+export declare function appendSequentialTranscript(existing: string, next: string): string;
 export declare function appendTranscriptWithoutOverlap(existing: string, next: string): string;
 export declare function assembleDiscussionTranscript(segments: DiscussionTranscriptSegment[]): string;

package/dist/src/discussions/transcript.js

@@ -15,7 +15,20 @@ function searchableCharacters(value) {
 	};
 }
 function joinOverlap(left, remainder) {
-	return `${left}${/[\p{P}\p{S}]$/u.test(left) ? remainder.replace(/^[\s\p{P}\p{S}]+/u, "") : remainder}`.trim();
+	const next = /\p{P}$/u.test(left) ? remainder.replace(/^\p{P}+/u, "") : remainder;
+	if (!next || /^\s/u.test(next)) return `${left}${next}`.trim();
+	const leftCharacter = Array.from(left).findLast((character) => /[\p{L}\p{N}\p{S}]/u.test(character));
+	const rightCharacter = Array.from(next).find((character) => /[\p{L}\p{N}\p{S}]/u.test(character));
+	const compactScript = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+	return `${left}${leftCharacter && rightCharacter && !compactScript.test(leftCharacter) && !compactScript.test(rightCharacter) ? " " : ""}${next}`.trim();
+}
+/** Joins transcripts from adjacent audio chunks that have no audio overlap. */
+function appendSequentialTranscript(existing, next) {
+	const left = existing.trim();
+	const right = next.trim();
+	if (!left) return right;
+	if (!right) return left;
+	return `${left}\n${right}`;
 }
 function appendTranscriptWithoutOverlap(existing, next) {
 	const left = existing.trim();
@@ -32,10 +45,10 @@ function appendTranscriptWithoutOverlap(existing, next) {
 		const sourceEnd = rightSearchable.sourceEnds[size - 1];
 		return joinOverlap(left, right.slice(sourceEnd));
 	}
-	return `${left}\n${right}`;
+	return appendSequentialTranscript(left, right);
 }
 function assembleDiscussionTranscript(segments) {
 	return segments.reduce((text, segment) => appendTranscriptWithoutOverlap(text, segment.displayText ?? ""), "");
 }
 //#endregion
-export { appendTranscriptWithoutOverlap, assembleDiscussionTranscript };
+export { appendSequentialTranscript, appendTranscriptWithoutOverlap, assembleDiscussionTranscript };

package/dist/src/extensions/install.d.ts

@@ -3,6 +3,16 @@
  * Supports installing from npm packages, local directories, and xopc-store zips
  * Supports three-tier storage: workspace, global, bundled
  */
+export type ValidatedNpmPackageSpec = {
+    ok: true;
+    packageName: string;
+    version?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/** Accept registry package names with an optional exact semver; reject URLs, paths, tags, and ranges. */
+export declare function validateNpmPackageSpec(packageSpec: string): ValidatedNpmPackageSpec;
 export interface InstallOptions {
     source: 'npm' | 'local';
     targetDir: string;