@indexnetwork/protocol 14.3.2-rc.477.1 → 17.0.0-rc.479.1

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

@@ -1,98 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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.
- */
-export type { IntegrationSession, IntegrationSessionOptions, ToolActionResponse, IntegrationConnection, } from "./integration.types.js";

package/dist/integrations/domain/index.js

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

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

@@ -1,51 +0,0 @@
-/**
- * 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.
- */
-/**
- * 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

@@ -1,9 +0,0 @@
-/**
- * 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.
- */
-export {};

package/dist/integrations/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * integrations — the capability's sole cross-capability surface.
- *
- * Anything outside this capability imports from here and nowhere else.
- * Supersedes the capabilities/*.facade.ts + integrations/public/ pair; the export
- * list is the union of the facades it replaces, so the contract is unchanged.
- */
-export { createIntegrationTools, } from "./application/index.js";
-export type { IntegrationConnection, IntegrationSession, IntegrationSessionOptions, ToolActionResponse, } from "./domain/index.js";
-export type { IntegrationAdapter, IntegrationToolDeps, } from "./ports/index.js";

package/dist/integrations/index.js

@@ -1,8 +0,0 @@
-/**
- * integrations — the capability's sole cross-capability surface.
- *
- * Anything outside this capability imports from here and nowhere else.
- * Supersedes the capabilities/*.facade.ts + integrations/public/ pair; the export
- * list is the union of the facades it replaces, so the contract is unchanged.
- */
-export { createIntegrationTools, } from "./application/index.js";

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

@@ -1,25 +0,0 @@
-/**
- * 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.
- */
-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

@@ -1,23 +0,0 @@
-/**
- * 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.
- */
-export {};

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

@@ -1,62 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,31 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-/**
- * 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

@@ -1,25 +0,0 @@
-/**
- * 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 rather than derived from
- * ToolRegistryCompositionDeps, keeping the capability port independent from
- * the all-capability composition contract.
- *
- * Its shape remains structurally equivalent to the matching
- * ToolRegistryCompositionDeps fields.
- *
- * 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

@@ -1,18 +0,0 @@
-/**
- * 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 rather than derived from
- * ToolRegistryCompositionDeps, keeping the capability port independent from
- * the all-capability composition contract.
- *
- * Its shape remains structurally equivalent to the matching
- * ToolRegistryCompositionDeps fields.
- *
- * IND-549: extracted from capabilities/integrations.tools.port.ts into the
- * integrations capability's dedicated ports layer.
- */
-export {};

package/dist/opportunities/application/opportunity.card-presentation.d.ts

@@ -1,44 +0,0 @@
-/**
- * Minimal shape consumed by buildOpportunityPresentation for prose rendering.
- * Card data objects in the codebase carry additional frontend-only fields;
- * only these are surfaced to MCP agents.
- */
-export type OpportunityCardLike = Record<string, unknown> & {
-    opportunityId: string;
-    userId?: string | undefined;
-    name?: string | undefined;
-    mainText?: string | undefined;
-    digestSummary?: string | undefined;
-    status?: string | undefined;
-    feedCategory?: string | undefined;
-    profileUrl?: string | undefined;
-    /** Universal link that opens this opportunity's card (`/o/<id>`). */
-    appUrl?: string | undefined;
-    /** Deep-link to the A2A negotiation trace that produced this opportunity. */
-    negotiationUrl?: string | undefined;
-    score?: number | undefined;
-    /** Digest-mode cooldown re-show — the user has seen this card before. */
-    redelivery?: boolean | undefined;
-};
-/**
- * Format opportunity cards into the "opportunities" portion of a tool response.
- *
- * Web chat (`isMcp=false`): emits ```opportunity``` code fences with an
- * "include EXACTLY as-is" directive so the frontend card renderer can parse
- * and render interactive cards.
- *
- * MCP (`isMcp=true`): emits prose (name, reason, status, appUrl and profileUrl
- * when present, feedCategory when present) and includes `opportunityId` for
- * every card so the agent can act via the tools. The trailing instruction
- * reminds the agent to synthesize in natural language, to surface the `appUrl`
- * verbatim as the one link that opens the card, and to fabricate no other URL.
- * MCP clients have no card renderer, so code fences would surface as raw JSON
- * to end users.
- */
-export declare function buildOpportunityPresentation(inputCards: OpportunityCardLike[], opts: {
-    isMcp: boolean;
-    leadIn: string;
-    label?: 'opportunity' | 'opportunities';
-    /** Include hidden digest metadata markers so scheduled brief tooling can confirm delivery. */
-    includeDigestMarkers?: boolean;
-}): string;

package/dist/opportunities/application/opportunity.card-presentation.js

@@ -1,93 +0,0 @@
-import { stripUnsupportedOpportunityClaims } from '../../shared/utils/claim-safety.js';
-import { stripUuids } from '../domain/opportunity.presentation.js';
-const CODE_FENCE = String.fromCharCode(96, 96, 96);
-function sanitizeJsonForCodeFence(json) {
-    return json.replace(/`/g, '\\u0060');
-}
-function sanitizeOpportunityCardProse(card) {
-    const sanitized = { ...card };
-    for (const key of ['mainText', 'digestSummary', 'headline', 'cta', 'mutualIntentsLabel']) {
-        const value = card[key];
-        if (typeof value === 'string') {
-            sanitized[key] = stripUnsupportedOpportunityClaims(stripUuids(value)) || 'A suggested connection.';
-        }
-    }
-    const narratorChip = card.narratorChip;
-    if (narratorChip && typeof narratorChip === 'object' && !Array.isArray(narratorChip)) {
-        const narrator = narratorChip;
-        if (typeof narrator.text === 'string') {
-            sanitized.narratorChip = {
-                ...narrator,
-                text: stripUnsupportedOpportunityClaims(stripUuids(narrator.text)) || 'A potential connection worth exploring.',
-            };
-        }
-    }
-    return sanitized;
-}
-/**
- * Format opportunity cards into the "opportunities" portion of a tool response.
- *
- * Web chat (`isMcp=false`): emits ```opportunity``` code fences with an
- * "include EXACTLY as-is" directive so the frontend card renderer can parse
- * and render interactive cards.
- *
- * MCP (`isMcp=true`): emits prose (name, reason, status, appUrl and profileUrl
- * when present, feedCategory when present) and includes `opportunityId` for
- * every card so the agent can act via the tools. The trailing instruction
- * reminds the agent to synthesize in natural language, to surface the `appUrl`
- * verbatim as the one link that opens the card, and to fabricate no other URL.
- * MCP clients have no card renderer, so code fences would surface as raw JSON
- * to end users.
- */
-export function buildOpportunityPresentation(inputCards, opts) {
-    const cards = inputCards.map(sanitizeOpportunityCardProse);
-    if (cards.length === 0)
-        return opts.leadIn;
-    if (opts.isMcp) {
-        const prose = cards
-            .map((card, i) => {
-            const lines = [`${i + 1}. ${card.name ?? "Unknown"}`];
-            if (opts.includeDigestMarkers) {
-                const markerId = String(card.opportunityId).replace(/[\s>]/g, "");
-                if (markerId)
-                    lines.push(`   <!-- digest-opportunity:id=${markerId} -->`);
-            }
-            if (opts.includeDigestMarkers && card.digestSummary) {
-                lines.push(`   ${card.digestSummary}`);
-            }
-            else if (card.mainText) {
-                lines.push(`   ${card.mainText}`);
-            }
-            if (card.status)
-                lines.push(`   status: ${card.status}`);
-            if (card.appUrl)
-                lines.push(`   appUrl: ${card.appUrl}`);
-            if (card.profileUrl)
-                lines.push(`   profileUrl: ${card.profileUrl}`);
-            if (opts.includeDigestMarkers && card.negotiationUrl)
-                lines.push(`   negotiationUrl: ${card.negotiationUrl}`);
-            if (card.feedCategory)
-                lines.push(`   feedCategory: ${card.feedCategory}`);
-            if (opts.includeDigestMarkers && card.score != null)
-                lines.push(`   confidence: ${Math.round(card.score * 100)}`);
-            if (opts.includeDigestMarkers && card.redelivery)
-                lines.push(`   redelivery: true`);
-            lines.push(`   opportunityId: ${card.opportunityId}`);
-            return lines.join("\n");
-        })
-            .join("\n\n");
-        const idInstructions = `Use opportunityId values only when calling update_opportunity (send/accept/reject) or confirm_opportunity_delivery.`;
-        return (`${opts.leadIn}\n\n${prose}\n\n` +
-            `Summarize these for the user in natural prose — mention first names and a brief match reason per connection. ` +
-            `For each card that has a profileUrl, link the person's name to it. Some cards may have no URL — render those as plain text and never fabricate URLs for them. ` +
-            `For each card that has an appUrl, show that link so the user can open the opportunity: it opens the card in the Index app when installed, and an Index web page otherwise. Show only an appUrl a tool returned — never assemble one from an opportunityId. ` +
-            `No link accepts on the user's behalf: accepting happens in the Index app (or via update_opportunity) — never invent an accept URL. ` +
-            `Do NOT print raw JSON, field labels, or opportunityIds. ` +
-            `${idInstructions}`);
-    }
-    const label = opts.label ?? (cards.length === 1 ? "opportunity" : "opportunities");
-    const blocks = cards
-        .map((card) => CODE_FENCE + "opportunity\n" + sanitizeJsonForCodeFence(JSON.stringify(card)) + "\n" + CODE_FENCE)
-        .join("\n\n");
-    return (`${opts.leadIn} IMPORTANT: Include the following ${CODE_FENCE}${label} code blocks EXACTLY as-is in your response (they render as interactive cards):\n\n${blocks}`);
-}