@indexnetwork/protocol 6.12.1-rc.404.1 → 6.14.0-rc.406.1

package/dist/integrations/application/integration.tools.d.ts

@@ -0,0 +1,27 @@
+/**
+ * integrations/application — createIntegrationTools canonical implementation.
+ *
+ * Creates integration tools for the chat agent. Exposes `import_gmail_contacts`
+ * which authenticates via the integration adapter, fetches all Gmail contacts
+ * (paginated), and imports them as ghost users into the network.
+ *
+ * Feature gating: import_gmail_contacts creates ghost users, so it is gated
+ * behind the CONTACTS_ENABLED flag (deps.contactsEnabled). When disabled,
+ * the tool is not registered at all (defineTool registers as a side effect).
+ *
+ * IND-549: moved from integration/integration.tools.ts into the canonical
+ * integrations/application layer.
+ */
+import type { DefineTool } from '../../shared/agent/tool.helpers.js';
+import type { IntegrationToolDeps } from '../ports/index.js';
+/**
+ * Creates integration tools for the chat agent.
+ *
+ * Exposes `import_gmail_contacts` which authenticates via the integration adapter,
+ * fetches all Gmail contacts (paginated), and imports them as ghost users into the network.
+ *
+ * @param defineTool - Tool definition helper injected by the tool registry.
+ * @param deps - Shared tool dependencies including the integration adapter.
+ * @returns An array of tool definitions to register with the chat agent.
+ */
+export declare function createIntegrationTools(defineTool: DefineTool, deps: IntegrationToolDeps): any[];

package/dist/integrations/application/integration.tools.js

@@ -0,0 +1,98 @@
+/**
+ * integrations/application — createIntegrationTools canonical implementation.
+ *
+ * Creates integration tools for the chat agent. Exposes `import_gmail_contacts`
+ * which authenticates via the integration adapter, fetches all Gmail contacts
+ * (paginated), and imports them as ghost users into the network.
+ *
+ * Feature gating: import_gmail_contacts creates ghost users, so it is gated
+ * behind the CONTACTS_ENABLED flag (deps.contactsEnabled). When disabled,
+ * the tool is not registered at all (defineTool registers as a side effect).
+ *
+ * IND-549: moved from integration/integration.tools.ts into the canonical
+ * integrations/application layer.
+ */
+import { z } from 'zod';
+import { success, error } from '../../shared/agent/tool.helpers.js';
+import { requestContext } from "../../shared/observability/request-context.js";
+import { protocolLogger } from '../../shared/observability/protocol.logger.js';
+const logger = protocolLogger('ChatTools:Integration');
+/**
+ * Creates integration tools for the chat agent.
+ *
+ * Exposes `import_gmail_contacts` which authenticates via the integration adapter,
+ * fetches all Gmail contacts (paginated), and imports them as ghost users into the network.
+ *
+ * @param defineTool - Tool definition helper injected by the tool registry.
+ * @param deps - Shared tool dependencies including the integration adapter.
+ * @returns An array of tool definitions to register with the chat agent.
+ */
+export function createIntegrationTools(defineTool, deps) {
+    const { integration, integrationImporter } = deps;
+    // import_gmail_contacts creates ghost users, so it is gated behind the
+    // CONTACTS_ENABLED flag (injected as deps.contactsEnabled). When disabled the
+    // tool is not registered at all (defineTool registers as a side effect).
+    if (deps.contactsEnabled !== true) {
+        return [];
+    }
+    const import_gmail_contacts = defineTool({
+        name: 'import_gmail_contacts',
+        description: "Imports contacts from the user's connected Gmail/Google account into their personal network. " +
+            "This is the preferred method for importing Google Contacts — handles OAuth authentication, pagination, and deduplication automatically.\n\n" +
+            "**Authentication flow:** If Gmail is not yet connected, returns an `authUrl` the user must visit to grant access. " +
+            "After they complete OAuth, call this tool again to perform the actual import.\n\n" +
+            "**What happens on import:** All Gmail contacts with valid name+email are imported. " +
+            "Contacts without existing platform accounts become ghost users (enriched with public profile data from LinkedIn, GitHub, etc.). " +
+            "All imported contacts are added to the user's personal network for opportunity discovery.\n\n" +
+            "**When to use:** When the user asks to import or sync their Gmail/Google contacts. No parameters needed.\n\n" +
+            "**Returns:** Either `{ requiresAuth: true, authUrl }` (user needs to authenticate) or import statistics: " +
+            "imported (total), newContacts (ghost users created), existingContacts (already in network), skipped (invalid entries).",
+        querySchema: z.object({}),
+        handler: async ({ context }) => {
+            try {
+                const session = await integration.createSession(context.userId);
+                const toolkits = await session.toolkits();
+                const gmailToolkit = toolkits.items.find(t => t.slug === 'gmail');
+                const isConnected = !!gmailToolkit?.connection?.connectedAccount?.id;
+                if (!isConnected) {
+                    logger.info('Gmail not connected, returning auth URL', { userId: context.userId });
+                    const originUrl = requestContext.getStore()?.originUrl;
+                    const callbackUrl = originUrl ? `${originUrl}/oauth/callback` : undefined;
+                    const authRequest = await session.authorize('gmail', callbackUrl ? { callbackUrl } : undefined);
+                    return success({
+                        requiresAuth: true,
+                        message: 'Please connect your Gmail account to import contacts.',
+                        authUrl: authRequest.redirectUrl,
+                    });
+                }
+                const importResult = await integrationImporter.importContacts(context.userId, 'gmail');
+                logger.info('Gmail contacts imported', {
+                    userId: context.userId,
+                    imported: importResult.imported,
+                    skipped: importResult.skipped,
+                    newContacts: importResult.newContacts,
+                    existingContacts: importResult.existingContacts,
+                });
+                return success({
+                    message: importResult.newContacts > 0
+                        ? `Imported ${importResult.imported} contacts from Gmail. ${importResult.newContacts} new, ${importResult.existingContacts} already in your network.`
+                        : importResult.imported > 0
+                            ? `All ${importResult.imported} contacts from Gmail were already in your network. No new contacts added.`
+                            : 'No contacts with valid name and email found in your Gmail account.',
+                    imported: importResult.imported,
+                    newContacts: importResult.newContacts,
+                    existingContacts: importResult.existingContacts,
+                    skipped: importResult.skipped,
+                });
+            }
+            catch (err) {
+                logger.error('import_gmail_contacts failed', {
+                    userId: context.userId,
+                    err,
+                });
+                return error('Failed to import Gmail contacts. Please try again.');
+            }
+        },
+    });
+    return [import_gmail_contacts];
+}

package/dist/integrations/domain/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * integrations/domain — pure integration entity value types.
+ *
+ * Contains IntegrationSession, IntegrationSessionOptions, ToolActionResponse,
+ * and IntegrationConnection.
+ *
+ * ## What does NOT live here
+ *
+ * - IntegrationAdapter: platform adapter port — lives in integrations/ports.
+ * - IntegrationImporter: bulk-import port — lives in integrations/ports.
+ * - IntegrationToolDeps: tool host port — lives in integrations/ports.
+ * - createIntegrationTools: application layer — lives in integrations/application.
+ *
+ * IND-549: canonical domain layer for the integrations capability.
+ * Legacy path (shared/interfaces/integration.interface.ts) is a thin
+ * compatibility shim.
+ */
+export type { IntegrationSession, IntegrationSessionOptions, ToolActionResponse, IntegrationConnection, } from "./integration.types.js";

package/dist/integrations/domain/index.js

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

package/dist/integrations/domain/integration.types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * integrations/domain — pure integration entity value types.
+ *
+ * Contains session shapes, connection records, and tool action responses.
+ * No application logic, no LLM calls, no cross-capability imports.
+ *
+ * IND-549: canonical domain layer for the integrations capability.
+ * Legacy path (shared/interfaces/integration.interface.ts) is a thin
+ * compatibility shim pointing here.
+ */
+/**
+ * Session for interacting with an external integration platform.
+ * Provides access to tools, OAuth authorization, and toolkit discovery.
+ */
+export interface IntegrationSession {
+    tools(): Promise<unknown[]>;
+    authorize(toolkit: string): Promise<{
+        redirectUrl: string;
+        waitForConnection(timeout?: number): Promise<unknown>;
+    }>;
+    toolkits(): Promise<{
+        items: Array<{
+            slug: string;
+            name: string;
+            connection?: {
+                connectedAccount?: {
+                    id: string;
+                };
+            };
+        }>;
+    }>;
+}
+/** Options for creating an integration session. */
+export interface IntegrationSessionOptions {
+    manageConnections?: boolean | {
+        callbackUrl?: string;
+    };
+    /** Toolkit slug → auth config ID mapping to pin existing auth configs. */
+    authConfigs?: Record<string, string>;
+}
+/** Response from executing a tool action on the integration platform. */
+export interface ToolActionResponse {
+    successful: boolean;
+    error?: string;
+    data?: Record<string, unknown>;
+}
+/** A connected integration account for a user. */
+export interface IntegrationConnection {
+    id: string;
+    toolkit: string;
+    status: string;
+    createdAt: string;
+}

package/dist/integrations/domain/integration.types.js

@@ -0,0 +1,11 @@
+/**
+ * integrations/domain — pure integration entity value types.
+ *
+ * Contains session shapes, connection records, and tool action responses.
+ * No application logic, no LLM calls, no cross-capability imports.
+ *
+ * IND-549: canonical domain layer for the integrations capability.
+ * Legacy path (shared/interfaces/integration.interface.ts) is a thin
+ * compatibility shim pointing here.
+ */
+export {};

package/dist/integrations/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * integrations — domain-first module root.
+ *
+ * Re-exports the curated public surface. Other modules inside the integrations
+ * capability import directly from integrations/domain, integrations/application,
+ * or integrations/ports; this barrel is for cross-capability consumers that
+ * must go through the integrations public surface.
+ *
+ * IND-549: canonical home for integration capabilities previously spread
+ * across integration/, shared/interfaces/integration.interface.ts, and
+ * capabilities/integrations.tools.port.ts.
+ *
+ * Retains host-integration configuration/actions semantics: the module owns
+ * the OAuth session lifecycle and bulk contact import pipeline contracts.
+ * Runtime foreground transport (authentication headers, request context) and
+ * all-capability composition remain in runtime/foreground.
+ *
+ * Allowed outbound capability dependencies: none (empty set). The integrations
+ * module is a leaf capability that only depends on shared/ primitives.
+ *
+ * Legacy paths:
+ * - integration/integration.tools.ts — thin compatibility shim → integrations/application
+ * - shared/interfaces/integration.interface.ts — thin compatibility shim → integrations/ports
+ * - capabilities/integrations.tools.port.ts — thin compatibility shim → integrations/ports
+ * - capabilities/integrations.facade.ts — thin re-export via integrations/public
+ */
+export * from "./public/index.js";

package/dist/integrations/index.js

@@ -0,0 +1,27 @@
+/**
+ * integrations — domain-first module root.
+ *
+ * Re-exports the curated public surface. Other modules inside the integrations
+ * capability import directly from integrations/domain, integrations/application,
+ * or integrations/ports; this barrel is for cross-capability consumers that
+ * must go through the integrations public surface.
+ *
+ * IND-549: canonical home for integration capabilities previously spread
+ * across integration/, shared/interfaces/integration.interface.ts, and
+ * capabilities/integrations.tools.port.ts.
+ *
+ * Retains host-integration configuration/actions semantics: the module owns
+ * the OAuth session lifecycle and bulk contact import pipeline contracts.
+ * Runtime foreground transport (authentication headers, request context) and
+ * all-capability composition remain in runtime/foreground.
+ *
+ * Allowed outbound capability dependencies: none (empty set). The integrations
+ * module is a leaf capability that only depends on shared/ primitives.
+ *
+ * Legacy paths:
+ * - integration/integration.tools.ts — thin compatibility shim → integrations/application
+ * - shared/interfaces/integration.interface.ts — thin compatibility shim → integrations/ports
+ * - capabilities/integrations.tools.port.ts — thin compatibility shim → integrations/ports
+ * - capabilities/integrations.facade.ts — thin re-export via integrations/public
+ */
+export * from "./public/index.js";

package/dist/integrations/ports/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * integrations/ports — injected dependency contracts for the integrations capability.
+ *
+ * Re-exports the narrow port types that the integrations module declares as
+ * explicit injected boundaries. Consumers import these to wire host
+ * implementations without depending on the application layer.
+ *
+ * ## Port groups
+ *
+ * ### Platform adapter port
+ * - IntegrationAdapter — session creation, tool execution, connection management,
+ *   OAuth auth URLs, and disconnection.
+ *
+ * ### Bulk import port
+ * - IntegrationImporter — toolkit-to-contacts bulk import pipeline.
+ * - IntegrationImportResult — aggregate import statistics.
+ *
+ * ### Tool host port
+ * - IntegrationToolDeps — host capabilities for integration-backed tools.
+ *
+ * IND-549: canonical ports surface for the integrations capability.
+ * Legacy paths:
+ *   - shared/interfaces/integration.interface.ts → re-exports types from here
+ *   - capabilities/integrations.tools.port.ts → re-exports IntegrationToolDeps from here
+ */
+export type { IntegrationAdapter } from "./integration.adapter.port.js";
+export type { IntegrationImporter, IntegrationImportResult } from "./integration.importer.port.js";
+export type { IntegrationToolDeps } from "./integration.tools.port.js";

package/dist/integrations/ports/index.js

@@ -0,0 +1,26 @@
+/**
+ * integrations/ports — injected dependency contracts for the integrations capability.
+ *
+ * Re-exports the narrow port types that the integrations module declares as
+ * explicit injected boundaries. Consumers import these to wire host
+ * implementations without depending on the application layer.
+ *
+ * ## Port groups
+ *
+ * ### Platform adapter port
+ * - IntegrationAdapter — session creation, tool execution, connection management,
+ *   OAuth auth URLs, and disconnection.
+ *
+ * ### Bulk import port
+ * - IntegrationImporter — toolkit-to-contacts bulk import pipeline.
+ * - IntegrationImportResult — aggregate import statistics.
+ *
+ * ### Tool host port
+ * - IntegrationToolDeps — host capabilities for integration-backed tools.
+ *
+ * IND-549: canonical ports surface for the integrations capability.
+ * Legacy paths:
+ *   - shared/interfaces/integration.interface.ts → re-exports types from here
+ *   - capabilities/integrations.tools.port.ts → re-exports IntegrationToolDeps from here
+ */
+export {};

package/dist/integrations/ports/integration.adapter.port.d.ts

@@ -0,0 +1,62 @@
+/**
+ * integrations/ports — IntegrationAdapter platform adapter port.
+ *
+ * Injected boundary for external integration platform access (OAuth sessions,
+ * tool execution, connection management). Implemented by the host application
+ * and passed into the protocol layer at the composition root.
+ *
+ * Retains host-integration configuration/actions semantics: adapter provides
+ * session creation, tool execution, connection listing, OAuth auth URLs, and
+ * disconnection — all platform-agnostic operations.
+ *
+ * IND-549: extracted from shared/interfaces/integration.interface.ts into the
+ * integrations capability's dedicated ports layer.
+ */
+import type { IntegrationSession, IntegrationSessionOptions, ToolActionResponse, IntegrationConnection } from "../domain/index.js";
+/**
+ * Adapter for external integration platforms (OAuth sessions, tool execution).
+ *
+ * @remarks
+ * Implementations wrap a specific platform SDK (e.g. Composio) and expose
+ * a platform-agnostic API for creating user sessions and executing tool actions.
+ */
+export interface IntegrationAdapter {
+    /**
+     * Create an authenticated session for a user.
+     * @param userId - User ID for the session
+     * @param options - Session configuration (e.g. connection management)
+     * @returns A session object for interacting with the platform
+     */
+    createSession(userId: string, options?: IntegrationSessionOptions): Promise<IntegrationSession>;
+    /**
+     * Execute a named tool action on behalf of a user.
+     * @param slug - Tool action identifier (e.g. 'GMAIL_GET_CONTACTS')
+     * @param userId - User to execute the action for
+     * @param args - Arguments to pass to the tool action
+     * @returns The tool execution response
+     */
+    executeToolAction(slug: string, userId: string, args: Record<string, unknown>): Promise<ToolActionResponse>;
+    /**
+     * List all connected accounts for a user.
+     * @param userId - User to list connections for
+     * @returns Array of connected integration accounts
+     */
+    listConnections(userId: string): Promise<IntegrationConnection[]>;
+    /**
+     * Get an OAuth authorization URL to connect a toolkit.
+     * @param userId - User to authorize
+     * @param toolkit - Toolkit slug (e.g. 'gmail')
+     * @param callbackUrl - URL to redirect to after OAuth
+     * @returns The redirect URL for OAuth
+     */
+    getAuthUrl(userId: string, toolkit: string, callbackUrl?: string): Promise<{
+        redirectUrl: string;
+    }>;
+    /**
+     * Disconnect (delete) a connected account.
+     * @param connectedAccountId - The connected account ID to remove
+     */
+    disconnect(connectedAccountId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/integrations/ports/integration.adapter.port.js

@@ -0,0 +1,15 @@
+/**
+ * integrations/ports — IntegrationAdapter platform adapter port.
+ *
+ * Injected boundary for external integration platform access (OAuth sessions,
+ * tool execution, connection management). Implemented by the host application
+ * and passed into the protocol layer at the composition root.
+ *
+ * Retains host-integration configuration/actions semantics: adapter provides
+ * session creation, tool execution, connection listing, OAuth auth URLs, and
+ * disconnection — all platform-agnostic operations.
+ *
+ * IND-549: extracted from shared/interfaces/integration.interface.ts into the
+ * integrations capability's dedicated ports layer.
+ */
+export {};

package/dist/integrations/ports/integration.importer.port.d.ts

@@ -0,0 +1,31 @@
+/**
+ * integrations/ports — IntegrationImporter bulk-import port.
+ *
+ * Narrow port for bulk contact import from integration toolkits (e.g. Gmail).
+ * Implemented by the host application and injected at the composition root.
+ *
+ * Decoupled from IntegrationAdapter: the importer handles the full import
+ * pipeline (fetching, deduplication, ghost creation) so tools only need to
+ * invoke it by toolkit slug — they do not need raw toolkit access.
+ *
+ * IND-549: extracted from the inline `integrationImporter` type in
+ * shared/agent/tool.helpers.ts into the integrations capability's dedicated
+ * ports layer as a named interface.
+ */
+/** Result of a bulk contact import from an integration toolkit. */
+export interface IntegrationImportResult {
+    imported: number;
+    skipped: number;
+    newContacts: number;
+    existingContacts: number;
+}
+/**
+ * Bulk contact importer for integration toolkit sources.
+ *
+ * Implementors handle the full fetch→match→ghost-create pipeline.
+ * The tool layer invokes importContacts with the userId and the
+ * toolkit slug (e.g. 'gmail') and receives aggregate import statistics.
+ */
+export interface IntegrationImporter {
+    importContacts(userId: string, toolkit: string): Promise<IntegrationImportResult>;
+}

package/dist/integrations/ports/integration.importer.port.js

@@ -0,0 +1,15 @@
+/**
+ * integrations/ports — IntegrationImporter bulk-import port.
+ *
+ * Narrow port for bulk contact import from integration toolkits (e.g. Gmail).
+ * Implemented by the host application and injected at the composition root.
+ *
+ * Decoupled from IntegrationAdapter: the importer handles the full import
+ * pipeline (fetching, deduplication, ghost creation) so tools only need to
+ * invoke it by toolkit slug — they do not need raw toolkit access.
+ *
+ * IND-549: extracted from the inline `integrationImporter` type in
+ * shared/agent/tool.helpers.ts into the integrations capability's dedicated
+ * ports layer as a named interface.
+ */
+export {};

package/dist/integrations/ports/integration.tools.port.d.ts

@@ -0,0 +1,28 @@
+/**
+ * integrations/ports — IntegrationToolDeps tool host port.
+ *
+ * Narrow port type consumed by createIntegrationTools. The host provides an
+ * IntegrationAdapter, an IntegrationImporter, and the contactsEnabled flag
+ * that gates the import_gmail_contacts tool (which creates ghost users).
+ *
+ * NOTE: This type is intentionally defined inline (not derived via Pick from
+ * ToolRegistryCompositionDeps in shared/agent/tool.helpers.ts) to avoid a
+ * module cycle. ToolRegistryCompositionDeps imports IntegrationAdapter from
+ * shared/interfaces/integration.interface.ts, which after IND-549 forwards
+ * to integrations/ports — creating a cycle back here.
+ *
+ * Structural equivalence with the Pick<ToolRegistryCompositionDeps,
+ * "integration" | "integrationImporter" | "contactsEnabled"> definition in
+ * the legacy shim is preserved.
+ *
+ * IND-549: extracted from capabilities/integrations.tools.port.ts into the
+ * integrations capability's dedicated ports layer.
+ */
+import type { IntegrationAdapter } from "./integration.adapter.port.js";
+import type { IntegrationImporter } from "./integration.importer.port.js";
+/** Host capabilities consumed by integration-backed contact import tools. */
+export type IntegrationToolDeps = {
+    integration: IntegrationAdapter;
+    integrationImporter: IntegrationImporter;
+    contactsEnabled?: boolean;
+};

package/dist/integrations/ports/integration.tools.port.js

@@ -0,0 +1,21 @@
+/**
+ * integrations/ports — IntegrationToolDeps tool host port.
+ *
+ * Narrow port type consumed by createIntegrationTools. The host provides an
+ * IntegrationAdapter, an IntegrationImporter, and the contactsEnabled flag
+ * that gates the import_gmail_contacts tool (which creates ghost users).
+ *
+ * NOTE: This type is intentionally defined inline (not derived via Pick from
+ * ToolRegistryCompositionDeps in shared/agent/tool.helpers.ts) to avoid a
+ * module cycle. ToolRegistryCompositionDeps imports IntegrationAdapter from
+ * shared/interfaces/integration.interface.ts, which after IND-549 forwards
+ * to integrations/ports — creating a cycle back here.
+ *
+ * Structural equivalence with the Pick<ToolRegistryCompositionDeps,
+ * "integration" | "integrationImporter" | "contactsEnabled"> definition in
+ * the legacy shim is preserved.
+ *
+ * IND-549: extracted from capabilities/integrations.tools.port.ts into the
+ * integrations capability's dedicated ports layer.
+ */
+export {};

package/dist/integrations/public/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * integrations/public — curated public surface of the integrations capability.
+ *
+ * Re-exports stable contracts from domain, application, and ports.
+ * Runtime adapter creation (tool factories) is accessible here for package
+ * consumers; internal module details remain private to the application layer.
+ *
+ * ## Boundary
+ *
+ * References only integrations/domain, integrations/application, and
+ * integrations/ports. Never imports from runtime/foreground, host
+ * implementations, or other capability internals.
+ *
+ * ## Intentionally excluded from public surface
+ *
+ * The following are application-internal or use-site specific:
+ * - OAuth callback URL derivation — runtime context detail in integration.tools.ts.
+ * - AuthorizeFn cast — internal type coercion for integration platform SDK.
+ *
+ * ## Foreground adapters (participant-directed, authenticated)
+ *
+ * - `createIntegrationTools` — import_gmail_contacts MCP tool for importing
+ *   the user's Google contacts. Gated behind `contactsEnabled`.
+ *
+ * ## Allowed outbound dependencies
+ *
+ * integrations has no allowed capability dependencies (empty set in
+ * capability-boundaries.ts). It may only depend on shared/ primitives.
+ *
+ * IND-549: canonical public surface for the integrations capability.
+ * Legacy path (capabilities/integrations.facade.ts) re-exports from here.
+ */
+export type { IntegrationSession, IntegrationSessionOptions, ToolActionResponse, IntegrationConnection, } from "../domain/index.js";
+export type { IntegrationAdapter } from "../ports/index.js";
+export type { IntegrationImporter, IntegrationImportResult } from "../ports/index.js";
+export type { IntegrationToolDeps } from "../ports/index.js";
+export { createIntegrationTools } from "../application/index.js";

package/dist/integrations/public/index.js

@@ -0,0 +1,34 @@
+/**
+ * integrations/public — curated public surface of the integrations capability.
+ *
+ * Re-exports stable contracts from domain, application, and ports.
+ * Runtime adapter creation (tool factories) is accessible here for package
+ * consumers; internal module details remain private to the application layer.
+ *
+ * ## Boundary
+ *
+ * References only integrations/domain, integrations/application, and
+ * integrations/ports. Never imports from runtime/foreground, host
+ * implementations, or other capability internals.
+ *
+ * ## Intentionally excluded from public surface
+ *
+ * The following are application-internal or use-site specific:
+ * - OAuth callback URL derivation — runtime context detail in integration.tools.ts.
+ * - AuthorizeFn cast — internal type coercion for integration platform SDK.
+ *
+ * ## Foreground adapters (participant-directed, authenticated)
+ *
+ * - `createIntegrationTools` — import_gmail_contacts MCP tool for importing
+ *   the user's Google contacts. Gated behind `contactsEnabled`.
+ *
+ * ## Allowed outbound dependencies
+ *
+ * integrations has no allowed capability dependencies (empty set in
+ * capability-boundaries.ts). It may only depend on shared/ primitives.
+ *
+ * IND-549: canonical public surface for the integrations capability.
+ * Legacy path (capabilities/integrations.facade.ts) re-exports from here.
+ */
+// ── Application: foreground adapter tools ─────────────────────────────────────
+export { createIntegrationTools } from "../application/index.js";

package/dist/intent/intent.clarifier.d.ts

@@ -1,52 +1,3 @@
-import { z } from "zod";
-declare const clarificationSchema: z.ZodDiscriminatedUnion<"needsClarification", [z.ZodObject<{
-    needsClarification: z.ZodLiteral<false>;
-    reason: z.ZodString;
-    suggestedDescription: z.ZodNullable<z.ZodString>;
-    clarificationMessage: z.ZodNullable<z.ZodString>;
-    underspecificationType: z.ZodNull;
-}, "strip", z.ZodTypeAny, {
-    reason: string;
-    underspecificationType: null;
-    needsClarification: false;
-    suggestedDescription: string | null;
-    clarificationMessage: string | null;
-}, {
-    reason: string;
-    underspecificationType: null;
-    needsClarification: false;
-    suggestedDescription: string | null;
-    clarificationMessage: string | null;
-}>, z.ZodObject<{
-    needsClarification: z.ZodLiteral<true>;
-    reason: z.ZodString;
-    suggestedDescription: z.ZodString;
-    clarificationMessage: z.ZodString;
-    underspecificationType: z.ZodEnum<["missing_constituent", "missing_constraint", "open_alternative_set"]>;
-}, "strip", z.ZodTypeAny, {
-    reason: string;
-    underspecificationType: "missing_constituent" | "missing_constraint" | "open_alternative_set";
-    needsClarification: true;
-    suggestedDescription: string;
-    clarificationMessage: string;
-}, {
-    reason: string;
-    underspecificationType: "missing_constituent" | "missing_constraint" | "open_alternative_set";
-    needsClarification: true;
-    suggestedDescription: string;
-    clarificationMessage: string;
-}>]>;
-export type IntentClarifierOutput = z.infer<typeof clarificationSchema>;
-export declare class IntentClarifier {
-    private readonly model;
-    private readonly suggestionModel;
-    private readonly clarificationDraftModel;
-    constructor();
-    /** Build the shared user prompt with intent, profile, and active-intent context. */
-    private buildPrompt;
-    invoke(description: string, profileContext: string, activeIntentsContext: string): Promise<IntentClarifierOutput>;
-    private generateSuggestion;
-    private generateClarificationDraft;
-}
-export {};
-//# sourceMappingURL=intent.clarifier.d.ts.map
+/** @deprecated Canonical location: signals/application/intent.clarifier — retained for backward compatibility (IND-544). */
+export { IntentClarifier } from "../signals/application/intent.clarifier.js";
+export type { IntentClarifierOutput } from "../signals/application/intent.clarifier.js";