@xopcai/xopc 0.0.211 → 0.0.214

package/dist/src/connectors/composio-session-types.d.ts

@@ -0,0 +1,91 @@
+import type { ToolRouterCreateSessionConfig } from '@composio/core';
+export type ComposioAuthConfigOption = {
+    id: string;
+    name: string;
+    status: 'ENABLED' | 'DISABLED';
+    authScheme?: string;
+    isComposioManaged: boolean;
+    isEnabledForToolRouter: boolean;
+};
+export type ComposioToolkitAuthState = {
+    toolkit: string;
+    managedAuthAvailable: boolean;
+    requiresCustomAuthConfig: boolean;
+    authConfigs: ComposioAuthConfigOption[];
+};
+type SessionToolkitResponse = {
+    items: Array<{
+        slug: string;
+        name: string;
+        logo?: string;
+        isNoAuth: boolean;
+        connection?: {
+            isActive: boolean;
+            connectedAccount?: {
+                status: string;
+                id: string;
+            };
+        };
+    }>;
+    cursor?: string;
+};
+export type ComposioSessionLike = {
+    sessionId: string;
+    toolkits(options?: {
+        toolkits?: string[];
+        isConnected?: boolean;
+        limit?: number;
+        cursor?: string;
+    }): Promise<SessionToolkitResponse>;
+    authorize(toolkit: string, options?: {
+        callbackUrl?: string;
+        alias?: string;
+    }): Promise<{
+        id: string;
+        status: string;
+        redirectUrl?: string | null;
+    }>;
+    search(params: {
+        query: string;
+        toolkits?: string[];
+    }): Promise<unknown>;
+    execute(toolSlug: string, args?: Record<string, unknown>, options?: {
+        account?: string;
+    }): Promise<unknown>;
+};
+export type ComposioSessionsClient = {
+    mode?: 'managed' | 'byok';
+    sessions: {
+        create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ComposioSessionLike>;
+    };
+    connectedAccounts: {
+        list(query?: {
+            userIds?: string[];
+            toolkitSlugs?: string[];
+        }): Promise<unknown>;
+        delete(id: string): Promise<unknown>;
+        refresh(id: string): Promise<unknown>;
+    };
+    authConfigs?: {
+        list(query?: {
+            toolkit?: string;
+            showDisabled?: boolean;
+        }): Promise<{
+            items: Array<{
+                id: string;
+                name: string;
+                status: 'ENABLED' | 'DISABLED';
+                authScheme?: string;
+                isComposioManaged?: boolean;
+                isEnabledForToolRouter?: boolean;
+            }>;
+        }>;
+    };
+    toolkits?: {
+        get(slug: string): Promise<{
+            composioManagedAuthSchemes?: string[];
+            authConfigDetails?: unknown[];
+        }>;
+    };
+};
+export {};

package/dist/src/connectors/composio-session-types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,8 @@
-import type { ToolRouterCreateSessionConfig } from '@composio/core';
 import { CredentialResolver } from '../auth/credentials.js';
+import type { ComposioSessionLike, ComposioSessionsClient, ComposioToolkitAuthState } from './composio-session-types.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;
@@ -17,94 +17,7 @@ export type ComposioAuthorizeResult = {
     connectUrl?: string;
     status: string;
 };
-export type ComposioAuthConfigOption = {
-    id: string;
-    name: string;
-    status: 'ENABLED' | 'DISABLED';
-    authScheme?: string;
-    isComposioManaged: boolean;
-    isEnabledForToolRouter: boolean;
-};
-export type ComposioToolkitAuthState = {
-    toolkit: string;
-    managedAuthAvailable: boolean;
-    requiresCustomAuthConfig: boolean;
-    authConfigs: ComposioAuthConfigOption[];
-};
-type SessionToolkitResponse = {
-    items: Array<{
-        slug: string;
-        name: string;
-        logo?: string;
-        isNoAuth: boolean;
-        connection?: {
-            isActive: boolean;
-            connectedAccount?: {
-                status: string;
-                id: string;
-            };
-        };
-    }>;
-    cursor?: string;
-};
-export type ComposioSessionLike = {
-    sessionId: string;
-    toolkits(options?: {
-        toolkits?: string[];
-        isConnected?: boolean;
-        limit?: number;
-        cursor?: string;
-    }): Promise<SessionToolkitResponse>;
-    authorize(toolkit: string, options?: {
-        callbackUrl?: string;
-        alias?: string;
-    }): Promise<{
-        id: string;
-        status: string;
-        redirectUrl?: string | null;
-    }>;
-    search(params: {
-        query: string;
-        toolkits?: string[];
-    }): Promise<unknown>;
-    execute(toolSlug: string, args?: Record<string, unknown>, options?: {
-        account?: string;
-    }): Promise<unknown>;
-};
-export type ComposioSessionsClient = {
-    sessions: {
-        create(userId: string, config?: ToolRouterCreateSessionConfig): Promise<ComposioSessionLike>;
-    };
-    connectedAccounts: {
-        list(query?: {
-            userIds?: string[];
-            toolkitSlugs?: string[];
-        }): Promise<unknown>;
-        delete(id: string): Promise<unknown>;
-        refresh(id: string): Promise<unknown>;
-    };
-    authConfigs?: {
-        list(query?: {
-            toolkit?: string;
-            showDisabled?: boolean;
-        }): Promise<{
-            items: Array<{
-                id: string;
-                name: string;
-                status: 'ENABLED' | 'DISABLED';
-                authScheme?: string;
-                isComposioManaged?: boolean;
-                isEnabledForToolRouter?: boolean;
-            }>;
-        }>;
-    };
-    toolkits?: {
-        get(slug: string): Promise<{
-            composioManagedAuthSchemes?: string[];
-            authConfigDetails?: unknown[];
-        }>;
-    };
-};
+export type { ComposioAuthConfigOption, ComposioSessionLike, ComposioSessionsClient, ComposioToolkitAuthState, } from './composio-session-types.js';
 export type ComposioSessionContext = {
     principalId: string;
     installationScope?: string;
@@ -153,4 +66,3 @@ export declare class ComposioSessionsAdapter {
         reason: string;
     }>;
 }
-export {};

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;