@xopcai/xopc 0.0.208 → 0.0.211

package/dist/src/config/schema.js

@@ -834,7 +834,7 @@ activityDetailDefault: z.enum([
 			"always",
 			"inbound",
 			"tagged"
-		]).default("inbound"),
+		]).default("off"),
 		fallback: TTSFallbackConfigSchema.optional(),
 		maxTextLength: z.number().int().min(1).default(512),
 		timeoutMs: z.number().int().min(1e3).max(18e4).default(6e4),

package/dist/src/connectors/auth-provider-registry.d.ts

@@ -1,3 +1,4 @@
+import type { Config } from '../config/schema.js';
 import type { ConnectorDefinition } from './types.js';
 export type ConnectorAuthStartResult = {
     connectorId: string;
@@ -6,4 +7,4 @@ export type ConnectorAuthStartResult = {
     authorizationUrl?: string;
     connectionId?: string;
 };
-export declare function startConnectorAuthorization(definition: ConnectorDefinition): Promise<ConnectorAuthStartResult>;
+export declare function startConnectorAuthorization(definition: ConnectorDefinition, config?: Config): Promise<ConnectorAuthStartResult>;

package/dist/src/connectors/auth-provider-registry.js

@@ -1,8 +1,11 @@
 import { startComposioAuthorize } from "./composio.js";
+import { getConnectorInstance } from "./instances.js";
 //#region src/connectors/auth-provider-registry.ts
-async function startConnectorAuthorization(definition) {
+async function startConnectorAuthorization(definition, config) {
 	if (definition.auth.mode !== "oauth" || definition.auth.provider !== "composio" || definition.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector "${definition.id}" does not support Composio authorization.`);
-	const authorization = await startComposioAuthorize(definition.id, definition.runtime.toolkit);
+	const configuredAuthConfigId = config ? getConnectorInstance(config, definition.id)?.config?.authConfigId : void 0;
+	const authConfigId = typeof configuredAuthConfigId === "string" && configuredAuthConfigId.trim() ? configuredAuthConfigId.trim() : void 0;
+	const authorization = await startComposioAuthorize(definition.id, definition.runtime.toolkit, void 0, authConfigId);
 	return {
 		connectorId: definition.id,
 		provider: "composio",

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

@@ -17,6 +17,20 @@ 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;
@@ -69,12 +83,34 @@ export type ComposioSessionsClient = {
         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 ComposioSessionContext = {
     principalId: string;
     installationScope?: string;
     providerPrincipalId?: string;
     toolkits?: string[];
+    authConfigs?: Record<string, string>;
     connectedAccounts?: Record<string, string[]>;
     callbackUrl?: string;
 };
@@ -86,11 +122,14 @@ export declare class ComposioSessionsAdapter {
     constructor(options?: {
         resolver?: CredentialResolver;
         clientFactory?: ClientFactory;
+        fileDownloadDir?: string;
     });
     createSession(context: ComposioSessionContext): Promise<ComposioSessionLike>;
+    getToolkitAuthState(toolkit: string): Promise<ComposioToolkitAuthState>;
     listToolkitCatalog(context: Omit<ComposioSessionContext, 'toolkits'>): Promise<ComposioToolkitCatalogItem[]>;
     authorize(context: ComposioSessionContext & {
         toolkit: string;
+        authConfigId?: string;
         installationId?: string;
         alias?: string;
     }): Promise<ComposioAuthorizeResult>;

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

@@ -63,6 +63,25 @@ function connectionStatus(value) {
 		default: return "unknown";
 	}
 }
+function errorChainMessage(error) {
+	const messages = [];
+	const visited = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current && !visited.has(current)) {
+		visited.add(current);
+		if (current instanceof Error) messages.push(current.message);
+		else if (typeof current === "string") messages.push(current);
+		if (!current || typeof current !== "object" || !("cause" in current)) break;
+		current = current.cause;
+	}
+	return messages.join(" ");
+}
+function missingAuthConfigMessage(error, toolkit, authConfigId) {
+	const message = errorChainMessage(error);
+	if (!message.includes("require auth configs") && !message.includes("cannot be auto-created")) return null;
+	if (authConfigId) return `The Composio auth config "${authConfigId}" is not available for toolkit "${toolkit}". Make sure it is enabled for Tool Router and belongs to the same Composio project as the configured API key.`;
+	return `The Composio toolkit "${toolkit}" requires a custom auth config. Create one in the Composio dashboard, enable it for Tool Router, then select it in the connector settings.`;
+}
 var ComposioSessionsAdapter = class {
 	createClient;
 	constructor(options = {}) {
@@ -84,8 +103,9 @@ var ComposioSessionsAdapter = class {
 				apiKey,
 				baseURL: process.env.XOPC_COMPOSIO_BASE_URL?.trim() || void 0,
 				allowTracking: false,
-				dangerouslyAllowAutoUploadDownloadFiles: false,
+				dangerouslyAllowAutoUploadDownloadFiles: Boolean(options.fileDownloadDir),
 				fileUploadDirs: false,
+				...options.fileDownloadDir ? { fileDownloadDir: options.fileDownloadDir } : {},
 				provider: new PiProvider(),
 				host: "xopc"
 			});
@@ -106,10 +126,36 @@ var ComposioSessionsAdapter = class {
 				requireExplicitSelection: true
 			},
 			...context.toolkits?.length ? { toolkits: { enable: context.toolkits } } : {},
+			...context.authConfigs && Object.keys(context.authConfigs).length > 0 ? { authConfigs: context.authConfigs } : {},
 			...context.connectedAccounts && Object.keys(context.connectedAccounts).length > 0 ? { connectedAccounts: context.connectedAccounts } : {}
 		};
 		return client.sessions.create(context.providerPrincipalId ?? createComposioPrincipalId(context.principalId, context.installationScope), config);
 	}
+	async getToolkitAuthState(toolkit) {
+		const normalizedToolkit = toolkit.trim().toLowerCase();
+		if (!normalizedToolkit) throw new Error("Composio toolkit is required.");
+		const client = await this.createClient();
+		if (!client.authConfigs || !client.toolkits) throw new Error("The installed Composio runtime does not support auth config discovery.");
+		const [toolkitDetails, authConfigList] = await Promise.all([client.toolkits.get(normalizedToolkit), client.authConfigs.list({
+			toolkit: normalizedToolkit,
+			showDisabled: true
+		})]);
+		const managedAuthAvailable = (toolkitDetails.composioManagedAuthSchemes?.length ?? 0) > 0;
+		const authConfigs = authConfigList.items.map((item) => ({
+			id: item.id,
+			name: item.name,
+			status: item.status,
+			authScheme: item.authScheme,
+			isComposioManaged: item.isComposioManaged === true,
+			isEnabledForToolRouter: item.isEnabledForToolRouter !== false
+		}));
+		return {
+			toolkit: normalizedToolkit,
+			managedAuthAvailable,
+			requiresCustomAuthConfig: !managedAuthAvailable && (toolkitDetails.authConfigDetails?.length ?? 0) > 0,
+			authConfigs
+		};
+	}
 	async listToolkitCatalog(context) {
 		const session = await this.createSession(context);
 		const items = [];
@@ -134,11 +180,20 @@ var ComposioSessionsAdapter = class {
 	}
 	async authorize(context) {
 		const providerPrincipalId = createComposioPrincipalId(context.principalId, context.installationScope);
-		const request = await (await this.createSession({
-			...context,
-			providerPrincipalId,
-			toolkits: [context.toolkit]
-		})).authorize(context.toolkit, {
+		let session;
+		try {
+			session = await this.createSession({
+				...context,
+				providerPrincipalId,
+				toolkits: [context.toolkit],
+				...context.authConfigId ? { authConfigs: { [context.toolkit]: context.authConfigId } } : {}
+			});
+		} catch (error) {
+			const actionableMessage = missingAuthConfigMessage(error, context.toolkit, context.authConfigId);
+			if (actionableMessage) throw new Error(actionableMessage, { cause: error });
+			throw error;
+		}
+		const request = await session.authorize(context.toolkit, {
 			callbackUrl: context.callbackUrl,
 			alias: context.alias
 		});
@@ -159,7 +214,8 @@ var ComposioSessionsAdapter = class {
 			}).length === 0,
 			metadata: {
 				toolkit: context.toolkit,
-				providerPrincipalId
+				providerPrincipalId,
+				...context.authConfigId ? { authConfigId: context.authConfigId } : {}
 			}
 		});
 		return {
@@ -207,6 +263,7 @@ var ComposioSessionsAdapter = class {
 				connectedAt: readString(row, ["createdAt", "created_at"]),
 				lastError: readString(row, ["lastError", "last_error"]),
 				metadata: {
+					...existing?.metadata,
 					toolkit,
 					providerPrincipalId
 				}
@@ -266,10 +323,12 @@ var ComposioSessionsAdapter = class {
 			const toolkit = input.action.toolkit;
 			const connectedAccounts = toolkit && input.connection ? { [toolkit]: [input.connection.providerConnectionId] } : input.context.connectedAccounts;
 			const providerPrincipalId = input.connection?.metadata.providerPrincipalId;
+			const connectionAuthConfigId = input.connection?.metadata.authConfigId;
 			if (input.connection && (typeof providerPrincipalId !== "string" || !providerPrincipalId.trim())) throw new Error("Connected account is missing its provider identity. Reconnect the account and try again.");
 			const result = await (await this.createSession({
 				...input.context,
 				connectedAccounts,
+				...toolkit && typeof connectionAuthConfigId === "string" && connectionAuthConfigId.trim() ? { authConfigs: { [toolkit]: connectionAuthConfigId.trim() } } : {},
 				...typeof providerPrincipalId === "string" ? { providerPrincipalId } : {}
 			})).execute(input.action.actionId, input.args ?? {}, input.connection ? { account: input.connection.providerConnectionId } : void 0);
 			appendConnectorExecutionAudit({

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

@@ -1,5 +1,6 @@
 import { CredentialResolver } from '../auth/credentials.js';
 import type { Config } from '../config/schema.js';
+import { type ComposioToolkitAuthState } from './composio-sessions.js';
 import type { ConnectorConfirmationPolicy, ConnectorDefinition, ConnectorInstallationPolicy } from './types.js';
 export type ComposioConnection = {
     id: string;
@@ -38,6 +39,7 @@ export type ComposioConnectorHealth = {
     recovery: 'none' | 'connect' | 'reconnect' | 'retry';
     errorCode?: 'missing_credential' | 'unauthorized' | 'forbidden' | 'network' | 'timeout' | 'provider_error';
 };
+export declare function getConfiguredComposioAuthConfigs(config: Config | undefined, toolkits: string[]): Record<string, string>;
 export declare function toolkitFromComposioSlug(slug: string): string | undefined;
 export declare function scopeForComposioAction(slug: string): {
     toolkit?: string;
@@ -64,6 +66,7 @@ export declare function saveComposioApiKey(input: {
 export declare function configureComposioApiKey(apiKey: string, resolver?: CredentialResolver): Promise<void>;
 export declare function listComposioConnections(resolver?: CredentialResolver): Promise<ComposioConnection[]>;
 export declare function inspectComposioConnectorHealth(toolkit: string, resolver?: CredentialResolver): Promise<ComposioConnectorHealth>;
+export declare function getComposioToolkitAuthState(toolkit: string, resolver?: CredentialResolver): Promise<ComposioToolkitAuthState>;
 export declare function getComposioInstallationPolicy(config: Config | undefined, toolkit: string): ConnectorInstallationPolicy;
 export declare function updateComposioInstallationPolicy(config: Config | undefined, toolkit: string, patch: {
     allowedAgentIds?: string[];
@@ -76,7 +79,7 @@ export declare function updateComposioConnection(id: string, patch: {
 }): ComposioConnection;
 export declare function refreshComposioConnection(id: string, resolver?: CredentialResolver): Promise<void>;
 export declare function revokeComposioConnection(id: string, resolver?: CredentialResolver): Promise<void>;
-export declare function startComposioAuthorize(connectorId: string, toolkit: string, resolver?: CredentialResolver): Promise<{
+export declare function startComposioAuthorize(connectorId: string, toolkit: string, resolver?: CredentialResolver, authConfigId?: string): Promise<{
     toolkit: string;
     connectUrl: string;
     connectionId?: string;

package/dist/src/connectors/composio.js

@@ -92,14 +92,19 @@ const COMPOSIO_CURATED_ACTIONS = {
 	},
 	googlecalendar: {
 		GOOGLECALENDAR_FIND_EVENT: "read",
-		GOOGLECALENDAR_LIST_EVENTS: "read",
+		GOOGLECALENDAR_SYNC_EVENTS: "read",
 		GOOGLECALENDAR_CREATE_EVENT: "write",
 		GOOGLECALENDAR_UPDATE_EVENT: "write",
 		GOOGLECALENDAR_DELETE_EVENT: "admin"
 	},
 	googledrive: {
-		GOOGLEDRIVE_SEARCH_FILES: "read",
-		GOOGLEDRIVE_GET_FILE: "read",
+		GOOGLEDRIVE_FIND_FILE: "read",
+		GOOGLEDRIVE_GET_ABOUT: "read",
+		GOOGLEDRIVE_GET_FILE_METADATA: "read",
+		GOOGLEDRIVE_DOWNLOAD_FILE: "read",
+		GOOGLEDRIVE_EXPORT_GOOGLE_WORKSPACE_FILE: "read",
+		GOOGLEDRIVE_GET_CHANGES_START_PAGE_TOKEN: "read",
+		GOOGLEDRIVE_LIST_CHANGES: "read",
 		GOOGLEDRIVE_CREATE_FILE: "write",
 		GOOGLEDRIVE_UPDATE_FILE: "write",
 		GOOGLEDRIVE_DELETE_FILE: "admin"
@@ -174,6 +179,22 @@ function toolkitFromConnectionMetadata(connection) {
 function normalizeToolkit(toolkit) {
 	return toolkit.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "");
 }
+function getConfiguredComposioAuthConfigs(config, toolkits) {
+	const requested = new Set(toolkits.map(normalizeToolkit));
+	return Object.values(config?.connectors?.instances ?? {}).reduce((result, record) => {
+		if (!record || typeof record !== "object" || Array.isArray(record)) return result;
+		const row = record;
+		const runtime = row.runtime;
+		const marker = row.xopcConnector;
+		if (!runtime || typeof runtime !== "object" || Array.isArray(runtime) || runtime.type !== "composio" || runtime.role !== "toolkit" || typeof runtime.toolkit !== "string" || !marker || typeof marker !== "object" || Array.isArray(marker)) return result;
+		const toolkit = normalizeToolkit(runtime.toolkit);
+		if (!requested.has(toolkit)) return result;
+		const configValue = marker.config;
+		const authConfigId = configValue && typeof configValue === "object" && !Array.isArray(configValue) ? configValue.authConfigId : void 0;
+		if (typeof authConfigId === "string" && authConfigId.trim()) result[toolkit] = authConfigId.trim();
+		return result;
+	}, {});
+}
 function toolkitFromComposioSlug(slug) {
 	const upper = slug.trim().toUpperCase();
 	if (!upper) return void 0;
@@ -399,6 +420,9 @@ async function inspectComposioConnectorHealth(toolkit, resolver = new Credential
 		};
 	}
 }
+async function getComposioToolkitAuthState(toolkit, resolver = new CredentialResolver()) {
+	return new ComposioSessionsAdapter({ resolver }).getToolkitAuthState(normalizeToolkit(toolkit));
+}
 function classifyComposioHealthError(error) {
 	const message = error instanceof Error ? error.message : String(error);
 	if (/api key is not configured|missing.*api key/i.test(message)) return {
@@ -473,11 +497,12 @@ async function revokeComposioConnection(id, resolver = new CredentialResolver())
 	await new ComposioSessionsAdapter({ resolver }).revokeConnection(connection);
 	if (connection.accountId) refreshConnectorAccountCurrent(connection.accountId);
 }
-async function startComposioAuthorize(connectorId, toolkit, resolver = new CredentialResolver()) {
+async function startComposioAuthorize(connectorId, toolkit, resolver = new CredentialResolver(), authConfigId) {
 	const normalizedToolkit = normalizeToolkit(toolkit);
 	const authorization = await new ComposioSessionsAdapter({ resolver }).authorize({
 		principalId: LOCAL_OWNER_PRINCIPAL,
 		toolkit: normalizedToolkit,
+		authConfigId,
 		installationId: getConnectorInstallation(`${connectorId}-${LOCAL_OWNER_PRINCIPAL}`)?.id
 	});
 	if (!authorization.connectUrl) throw new Error("Composio authorize did not return a connect URL.");
@@ -491,7 +516,8 @@ async function listComposioTools(toolkit, config, resolver = new CredentialResol
 	const normalizedToolkit = normalizeToolkit(toolkit);
 	const payload = await (await new ComposioSessionsAdapter({ resolver }).createSession({
 		principalId: LOCAL_OWNER_PRINCIPAL,
-		toolkits: [normalizedToolkit]
+		toolkits: [normalizedToolkit],
+		authConfigs: getConfiguredComposioAuthConfigs(config, [normalizedToolkit])
 	})).search({
 		query: `List the available ${normalizedToolkit} actions and their exact input contracts.`,
 		toolkits: [normalizedToolkit]
@@ -551,7 +577,8 @@ async function executeComposioTool(params, resolver = new CredentialResolver())
 	const result = await new ComposioSessionsAdapter({ resolver }).executeWithPolicy({
 		context: {
 			principalId: LOCAL_OWNER_PRINCIPAL,
-			toolkits: [allowed.toolkit]
+			toolkits: [allowed.toolkit],
+			authConfigs: getConfiguredComposioAuthConfigs(params.config, [allowed.toolkit])
 		},
 		installation,
 		connection,
@@ -570,4 +597,4 @@ async function executeComposioTool(params, resolver = new CredentialResolver())
 	return result.result;
 }
 //#endregion
-export { COMPOSIO_CONNECTORS, canUseComposioAction, configureComposioApiKey, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitScope, inspectComposioConnectorHealth, isComposioActionAllowedByCatalog, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, saveComposioApiKey, scopeForComposioAction, setComposioToolkitScope, startComposioAuthorize, toolkitFromComposioSlug, updateComposioConnection, updateComposioInstallationPolicy };
+export { COMPOSIO_CONNECTORS, canUseComposioAction, configureComposioApiKey, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitAuthState, getComposioToolkitScope, getConfiguredComposioAuthConfigs, inspectComposioConnectorHealth, isComposioActionAllowedByCatalog, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, saveComposioApiKey, scopeForComposioAction, setComposioToolkitScope, startComposioAuthorize, toolkitFromComposioSlug, updateComposioConnection, updateComposioInstallationPolicy };

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

@@ -0,0 +1,9 @@
+export type ConnectedSourceCursor = {
+    version: 1;
+    checkpoint?: string;
+    scanStartedAt?: string;
+    pageToken?: string;
+    syncToken?: string;
+};
+export declare function decodeConnectedSourceCursor(value: string | undefined): ConnectedSourceCursor | undefined;
+export declare function encodeConnectedSourceCursor(cursor: Omit<ConnectedSourceCursor, 'version'>): string;

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

@@ -0,0 +1,30 @@
+//#region src/connectors/connected-source-cursor.ts
+function optionalText(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function decodeConnectedSourceCursor(value) {
+	if (!value) return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+		const row = parsed;
+		if (row.version !== 1) return void 0;
+		return {
+			version: 1,
+			...optionalText(row.checkpoint) ? { checkpoint: optionalText(row.checkpoint) } : {},
+			...optionalText(row.scanStartedAt) ? { scanStartedAt: optionalText(row.scanStartedAt) } : {},
+			...optionalText(row.pageToken) ? { pageToken: optionalText(row.pageToken) } : {},
+			...optionalText(row.syncToken) ? { syncToken: optionalText(row.syncToken) } : {}
+		};
+	} catch {
+		return;
+	}
+}
+function encodeConnectedSourceCursor(cursor) {
+	return JSON.stringify({
+		version: 1,
+		...cursor
+	});
+}
+//#endregion
+export { decodeConnectedSourceCursor, encodeConnectedSourceCursor };

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

@@ -1,51 +1,29 @@
 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 { getConnectorInstance } from "./instances.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
+import { getConnectorInstance } from "./instances.js";
 import { KnowledgeIngestionService } from "../knowledge/ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
 import { LocalFolderKnowledgeSourceAdapter } from "../knowledge/local-folder-adapter.js";
 import "../knowledge/index.js";
 import { normalizeConnectedSourceResult } from "./connected-source-normalizers.js";
+import { sanitizeConnectedSourceValue } from "./connected-source-sanitization.js";
 import { createHash } from "node:crypto";
 //#region src/connectors/connected-source-ingestion.ts
 const COMPOSIO_CONNECTED_SOURCE_TOOLKITS = new Set([
 	"gmail",
 	"googlecalendar",
 	"googledrive",
-	"googledocs",
-	"googlesheets",
-	"notion",
-	"slack",
 	"github",
-	"linear",
-	"jira",
-	"outlook",
-	"microsoft_teams",
-	"one_drive",
-	"excel"
+	"linear"
 ]);
-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 asRecord(value) {
 	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function sanitizeSourceValue(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) => sanitizeSourceValue(item, depth + 1));
-	const record = asRecord(value);
-	if (!record) return value;
-	return Object.fromEntries(Object.entries(record).map(([key, nested]) => [key, SENSITIVE_KEY_RE.test(key) ? "[REDACTED]" : sanitizeSourceValue(nested, depth + 1)]));
-}
 function boundedPersonValue(value, maxLength = 320) {
 	return typeof value === "string" ? value.trim().slice(0, maxLength) : "";
 }
@@ -66,7 +44,7 @@ function personEntities(record) {
 		const nested = asRecord(value);
 		if (!nested) return [];
 		const name = boundedPersonValue(nested.name, 160) || boundedPersonValue(nested.displayName, 160);
-		const email = boundedPersonValue(nested.email);
+		const email = boundedPersonValue(nested.email) || boundedPersonValue(nested.emailAddress);
 		const username = boundedPersonValue(nested.username, 160);
 		return name || email || username ? [{
 			role,
@@ -83,6 +61,7 @@ function personEntities(record) {
 		"user",
 		"username",
 		"owner",
+		"owners",
 		"assignee",
 		"attendees",
 		"participants"
@@ -108,14 +87,26 @@ function peopleSignals(entities) {
 function connectionIdentities(identity) {
 	return [...new Set(Object.values(identity).filter((value) => typeof value === "string").map((value) => value.trim().toLowerCase()).filter(Boolean))];
 }
+function resultPayload(value) {
+	const root = asRecord(value) ?? {};
+	return asRecord(root.data) ?? root;
+}
+function paginationValue(result, ...keys) {
+	const payload = resultPayload(result);
+	const pagination = asRecord(payload.pagination) ?? asRecord(payload.pageInfo) ?? {};
+	for (const key of keys) {
+		const value = payload[key] ?? pagination[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+}
 function resultToSourceItems(input) {
 	return normalizeConnectedSourceResult(input).slice(0, 200).map((entity) => {
 		const record = entity.value;
 		const people = personEntities(record);
 		const ownerIdentities = connectionIdentities(input.connectionIdentity);
 		const observedIdentities = peopleSignals(people).map((value) => value.toLowerCase());
-		const actorAttributed = entity.metadata.actorAttributed === true || input.toolkit === "gmail" || input.toolkit === "googlecalendar" || input.toolkit === "github" && observedIdentities.some((value) => ownerIdentities.includes(value));
-		const serialized = JSON.stringify(sanitizeSourceValue(entity.value), null, 2);
+		const actorAttributed = entity.metadata.actorAttributed === true || input.toolkit === "gmail" || input.toolkit === "googlecalendar" || ["github", "googledrive"].includes(input.toolkit) && observedIdentities.some((value) => ownerIdentities.includes(value));
+		const serialized = JSON.stringify(sanitizeConnectedSourceValue(entity.value), null, 2);
 		const normalizedText = serialized.length > 8e3 ? `${serialized.slice(0, 8e3)}\n…` : serialized;
 		const contentHash = createHash("sha256").update(serialized).digest("hex");
 		return {
@@ -144,7 +135,8 @@ function resultToSourceItems(input) {
 			sensitivity: "personal",
 			retentionClass: "bounded",
 			synthesisPipeline: "connected_knowledge",
-			synthesisStatus: input.streamKind === "inventory" ? "ignored" : entity.synthesisStatus
+			synthesisStatus: input.streamKind === "inventory" ? "ignored" : entity.synthesisStatus,
+			deletedAt: entity.deletedAt
 		};
 	});
 }
@@ -154,7 +146,10 @@ var ComposioKnowledgeSourceAdapter = class {
 		this.input = input;
 	}
 	async pull(pull) {
-		const execution = await this.input.adapter.executeWithPolicy({
+		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]
@@ -174,26 +169,52 @@ var ComposioKnowledgeSourceAdapter = class {
 				curated: true,
 				cachedAt: (/* @__PURE__ */ new Date()).toISOString()
 			},
-			args: this.input.buildArguments?.(pull) ?? this.input.arguments,
+			args: this.input.buildArguments?.({
+				...pull,
+				cursor: cursorValue
+			}) ?? this.input.arguments,
 			confirmed: true
 		});
+		let execution;
+		try {
+			execution = await execute(pull.cursor);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (this.input.toolkit !== "googlecalendar" || !cursor?.syncToken || !/\b410\b|sync.?token/i.test(message)) throw error;
+			warnings.push("Expired Google Calendar sync token was replaced with a full sync.");
+			execution = await execute(void 0);
+		}
 		if (execution.decision !== "allowed") throw new Error(execution.reason);
+		const items = resultToSourceItems({
+			result: execution.result,
+			sourceInstanceId: pull.instanceId,
+			collectionScope: pull.collectionScope,
+			streamKind: this.input.streamKind,
+			connectorId: this.input.connectorId,
+			connectionId: this.input.connection.id,
+			actionId: this.input.actionId,
+			toolkit: this.input.toolkit,
+			agentId: this.input.agentId,
+			workspaceId: this.input.workspaceId,
+			connectionIdentity: this.input.connection.identity
+		});
+		const nextPageToken = paginationValue(execution.result, "nextPageToken", "next_page_token");
+		const nextSyncToken = paginationValue(execution.result, "nextSyncToken", "next_sync_token");
+		const completeSnapshot = this.input.streamKind === "inventory" && (this.input.toolkit === "github" || !cursor?.checkpoint);
 		return {
-			items: resultToSourceItems({
-				result: execution.result,
-				sourceInstanceId: pull.instanceId,
-				collectionScope: pull.collectionScope,
-				streamKind: this.input.streamKind,
-				connectorId: this.input.connectorId,
-				connectionId: this.input.connection.id,
-				actionId: this.input.actionId,
-				toolkit: this.input.toolkit,
-				agentId: this.input.agentId,
-				workspaceId: this.input.workspaceId,
-				connectionIdentity: this.input.connection.identity
+			items,
+			nextCursor: nextPageToken ? encodeConnectedSourceCursor({
+				checkpoint: cursor?.checkpoint,
+				scanStartedAt,
+				pageToken: nextPageToken,
+				syncToken: cursor?.syncToken
+			}) : encodeConnectedSourceCursor({
+				checkpoint: scanStartedAt,
+				...nextSyncToken ? { syncToken: nextSyncToken } : {}
 			}),
-			nextCursor: (/* @__PURE__ */ new Date()).toISOString(),
-			warnings: []
+			hasMore: Boolean(nextPageToken),
+			warnings,
+			...completeSnapshot ? { snapshotExternalIds: items.map((item) => item.externalId) } : {}
 		};
 	}
 };

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

@@ -4,6 +4,7 @@ export type ConnectedSourceEntity = {
     itemType: string;
     occurredAt?: string;
     sourceUpdatedAt?: string;
+    deletedAt?: string;
     value: Record<string, unknown>;
     metadata: Record<string, unknown>;
     synthesisStatus: KnowledgeSynthesisStatus;