@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0

package/dist/enrichment/enrichment.tools.context-write.js

@@ -1,417 +0,0 @@
-/**
- * Enrichment tools that create or update a user context.
- */
-import { z } from "zod";
-import { requestContext } from "../shared/observability/request-context.js";
-import { success, error, needsClarification } from "../shared/agent/tool.helpers.js";
-import { detectSocialLabel } from "../shared/utils/social-label.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-import { enqueueEnrichmentRun, enrichFromUserRecord, isMeaningfulEnrichment, logger, markApprovedProfileConfirmed, mergeUserSocials, socialsRecordToRows } from "./enrichment.tools.helpers.js";
-export function createUserContextWriteTools(defineTool, deps) {
-    const { userDb, systemDb, graphs, enricher, grantDefaultSystemPermissions, reportToolError, getUserContextText } = deps;
-    const createUserContext = defineTool({
-        name: "create_user_context",
-        description: "Legacy/backward-compatible tool that creates or regenerates the authenticated user's profile. Prefer " +
-            "preview_user_context → confirm_user_context so the draft is shown before saving. " +
-            "Profiles are essential for discovery — they provide the semantic context used to match users with complementary intents.\n\n" +
-            "**How it works:** For generic clients, the system can enrich profile data from public web sources (LinkedIn, GitHub, Twitter) and/or explicit user input, " +
-            "then generates a structured profile with bio, skills, interests, location, and narrative context.\n\n" +
-            "**Usage patterns:**\n" +
-            "- No args: attempts auto-generation from account data. If insufficient info, returns `missingFields` — ask the user for name/social URLs and retry.\n" +
-            "- With social URLs (linkedinUrl, githubUrl, etc.): enriches from those specific URLs.\n" +
-            "- With bioOrDescription: creates profile from explicit text only (no web scraping).\n" +
-            "- First call may return a preview. Prefer preview_user_context instead because it does not persist enrichment side effects.\n\n" +
-            "**Returns:** The generated profile (name, bio, location, skills, interests) or a `needsClarification` response listing missing fields.\n\n" +
-            "**Next steps:** After profile creation, the user can create intents (create_intent) and join indexes (create_network_membership) to start discovering opportunities.",
-        querySchema: z.object({
-            name: z.string().optional().describe("User's full name (first and last). Pass when the user explicitly provides their name."),
-            linkedinUrl: z.string().optional().describe("LinkedIn profile URL (e.g. 'https://linkedin.com/in/username'). Pass when user shares a LinkedIn link."),
-            githubUrl: z.string().optional().describe("GitHub profile URL (e.g. 'https://github.com/username'). Pass when user shares a GitHub link."),
-            twitterUrl: z.string().optional().describe("X/Twitter profile URL (e.g. 'https://x.com/username'). Pass when user shares a Twitter/X link."),
-            websites: z.array(z.string()).optional().describe("Personal or portfolio website URLs. Pass when user shares website links."),
-            location: z.string().optional().describe("User's location (e.g. 'Berlin, Germany' or 'SF Bay Area'). Pass when the user mentions where they are based."),
-            bioOrDescription: z.string().optional().describe("Explicit profile text from the user (e.g. 'software engineer focused on AI/ML, based in SF'). When provided, creates/updates profile from this text only — no web scraping. Use when user describes themselves in chat."),
-            confirm: z.boolean().optional().describe("Set to true to save a previously previewed profile after the user approves the preview."),
-        }),
-        handler: async ({ context, query }) => {
-            // Persist user-info fields (name, location, socials) to users table before any branching.
-            // This ensures users.name is always updated regardless of which code path runs.
-            // Trim all string fields to avoid persisting whitespace-only values.
-            const name = query.name?.trim();
-            const location = query.location?.trim();
-            const linkedinUrl = query.linkedinUrl?.trim();
-            const githubUrl = query.githubUrl?.trim();
-            const twitterUrl = query.twitterUrl?.trim();
-            const websites = query.websites?.map((url) => url.trim()).filter(Boolean);
-            const hasSocialsFromQuery = Boolean(linkedinUrl || githubUrl || twitterUrl || websites?.length);
-            if (name || location) {
-                await userDb.updateUser({
-                    ...(name ? { name } : {}),
-                    ...(location ? { location } : {}),
-                });
-            }
-            if (hasSocialsFromQuery) {
-                const newSocials = [];
-                if (linkedinUrl)
-                    newSocials.push({ label: 'linkedin', value: linkedinUrl });
-                if (githubUrl)
-                    newSocials.push({ label: 'github', value: githubUrl });
-                if (twitterUrl)
-                    newSocials.push({ label: 'twitter', value: twitterUrl });
-                if (websites?.length) {
-                    for (const w of websites)
-                        newSocials.push({ label: detectSocialLabel(w), value: w });
-                }
-                await mergeUserSocials(deps, newSocials);
-            }
-            logger.verbose("Persisted user-info fields to user record", { userId: context.userId });
-            const isOnboarding = !(context.user.onboarding?.completedAt);
-            if (isOnboarding) {
-                // "Already enriched?" must key on a real enrichment signal, not getProfile():
-                // post-WS11 getProfile() returns a presentation row for EVERY existing user, so
-                // it would always short-circuit onboarding and refuse to enrich. The global
-                // user_context is the canonical signal (non-empty <=> the user has premises /
-                // has been enriched), mirroring findWithGraph's `hasProfile`.
-                const existingContext = getUserContextText
-                    ? (await getUserContextText(context.userId)).trim()
-                    : '';
-                if (existingContext) {
-                    const existingProfile = await userDb.getProfile();
-                    return success({
-                        alreadyExists: true,
-                        message: context.isMcp
-                            ? "Profile already exists. If they want changes, use create_user_context(bioOrDescription=\"...\", confirm=true)."
-                            : "Profile already exists. If the user confirmed it, call complete_onboarding() to finish setup. If they want changes, use create_user_context(bioOrDescription=\"...\", confirm=true).",
-                        ...(existingProfile
-                            ? {
-                                profile: {
-                                    name: existingProfile.identity.name,
-                                    bio: existingProfile.identity.bio,
-                                    location: existingProfile.identity.location,
-                                },
-                            }
-                            : {}),
-                    });
-                }
-                // Preview mode: enrich and persist enrichment results, but don't generate full profile
-                if (!query.confirm) {
-                    try {
-                        const user = await userDb.getUser();
-                        const enrichment = user ? await enrichFromUserRecord(deps, user) : null;
-                        if (isMeaningfulEnrichment(enrichment)) {
-                            // Persist enrichment data to user record so confirm path has it
-                            const updatePayload = {};
-                            if (enrichment.identity.name?.trim()) {
-                                updatePayload.name = enrichment.identity.name.trim();
-                            }
-                            if (enrichment.identity.bio?.trim())
-                                updatePayload.intro = enrichment.identity.bio.trim();
-                            if (enrichment.identity.location?.trim())
-                                updatePayload.location = enrichment.identity.location.trim();
-                            if (Object.keys(updatePayload).length > 0)
-                                await userDb.updateUser(updatePayload);
-                            const enrichedSocials = [];
-                            if (enrichment.socials.twitter)
-                                enrichedSocials.push({ label: 'twitter', value: enrichment.socials.twitter });
-                            if (enrichment.socials.linkedin)
-                                enrichedSocials.push({ label: 'linkedin', value: enrichment.socials.linkedin });
-                            if (enrichment.socials.github)
-                                enrichedSocials.push({ label: 'github', value: enrichment.socials.github });
-                            if (enrichment.socials.telegram)
-                                enrichedSocials.push({ label: 'telegram', value: enrichment.socials.telegram });
-                            if (enrichment.socials.websites?.length) {
-                                for (const w of enrichment.socials.websites)
-                                    enrichedSocials.push({ label: 'custom', value: w });
-                            }
-                            if (enrichedSocials.length > 0) {
-                                await mergeUserSocials(deps, enrichedSocials);
-                            }
-                            return success({
-                                preview: true,
-                                message: "Profile preview generated. Call create_user_context(confirm=true) to save.",
-                                profile: {
-                                    name: enrichment.identity.name,
-                                    bio: enrichment.identity.bio,
-                                    location: enrichment.identity.location,
-                                    skills: enrichment.attributes.skills,
-                                    interests: enrichment.attributes.interests,
-                                },
-                                // Always present when isMeaningfulEnrichment passes — may be {} if the
-                                // enrichment found no social handles. LLM should ask the user to provide
-                                // links when empty (see buildOnboarding step 3 in chat.prompt.ts).
-                                detectedSocials: enrichment.socials,
-                            });
-                        }
-                    }
-                    catch (err) {
-                        logger.warn("Enrichment preview failed", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                    return needsClarification({
-                        missingFields: ['bio_or_social_urls'],
-                        message: "I couldn't find enough public info. Could you share a short description of yourself, or a LinkedIn/GitHub/X profile link?",
-                    });
-                }
-                // Confirm mode: invoke graph in generate mode (enrichment data already persisted during preview)
-                // Do NOT re-run enrichFromUserRecord — the graph's autoGenerateNode handles enrichment
-                // from the (now well-populated) user record, avoiding non-deterministic drift.
-                try {
-                    const _confirmGraphStart = Date.now();
-                    const _confirmTraceEmitter = requestContext.getStore()?.traceEmitter;
-                    _confirmTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-                    const result = await invokeWithAbortSignal(graphs.profile, {
-                        userId: context.userId,
-                        operationMode: 'generate',
-                    });
-                    const _confirmGraphMs = Date.now() - _confirmGraphStart;
-                    _confirmTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _confirmGraphMs });
-                    if (result.error)
-                        return error(result.error);
-                    if (result.profile) {
-                        await markApprovedProfileConfirmed(deps, context);
-                        return success({
-                            created: true,
-                            message: "Profile saved.",
-                            profile: {
-                                name: result.profile.identity.name,
-                                bio: result.profile.identity.bio,
-                                location: result.profile.identity.location,
-                                skills: result.profile.attributes.skills,
-                                interests: result.profile.attributes.interests,
-                            },
-                            _graphTimings: [{ name: 'enrichment', durationMs: _confirmGraphMs, agents: result.agentTimings ?? [] }],
-                        });
-                    }
-                }
-                catch (err) {
-                    logger.warn("Profile generation on confirm failed, falling back to full graph", {
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                }
-                // Fallback: graph invocation failed on confirm, fall through to full graph invocation
-            }
-            const hasBioOrDescription = !!query.bioOrDescription?.trim();
-            if (hasBioOrDescription) {
-                // Create/update profile from user's explicit text only; do not persist to user record
-                // Include name and location in the input if provided so the EnrichmentGenerator can use them
-                const inputParts = [];
-                if (name)
-                    inputParts.push(`Name: ${name}`);
-                if (location)
-                    inputParts.push(`Location: ${location}`);
-                inputParts.push(query.bioOrDescription.trim());
-                const profileInput = inputParts.join('\n');
-                const _bioProfileGraphStart = Date.now();
-                const _bioProfileTraceEmitter = requestContext.getStore()?.traceEmitter;
-                _bioProfileTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-                const result = await invokeWithAbortSignal(graphs.profile, {
-                    userId: context.userId,
-                    operationMode: 'write',
-                    input: profileInput,
-                    forceUpdate: true,
-                });
-                const _bioProfileGraphMs = Date.now() - _bioProfileGraphStart;
-                _bioProfileTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _bioProfileGraphMs });
-                if (result.error) {
-                    return error(result.error);
-                }
-                if (result.profile) {
-                    if (isOnboarding && query.confirm)
-                        await markApprovedProfileConfirmed(deps, context);
-                    return success({
-                        created: true,
-                        message: "Profile created/updated with the information you provided.",
-                        profile: {
-                            name: result.profile.identity.name,
-                            bio: result.profile.identity.bio,
-                            location: result.profile.identity.location,
-                            skills: result.profile.attributes.skills,
-                            interests: result.profile.attributes.interests,
-                        },
-                        _graphTimings: [{ name: 'enrichment', durationMs: _bioProfileGraphMs, agents: result.agentTimings ?? [] }],
-                    });
-                }
-                if (isOnboarding && query.confirm)
-                    await markApprovedProfileConfirmed(deps, context);
-                return success({
-                    created: true,
-                    message: "Profile created/updated with the information you provided.",
-                    _graphTimings: [{ name: 'enrichment', durationMs: _bioProfileGraphMs, agents: result.agentTimings ?? [] }],
-                });
-            }
-            // Invoke profile graph in generate mode (uses enrichUserProfile Chat API)
-            const _generateProfileGraphStart = Date.now();
-            const _generateProfileTraceEmitter = requestContext.getStore()?.traceEmitter;
-            _generateProfileTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-            const result = await invokeWithAbortSignal(graphs.profile, {
-                userId: context.userId,
-                operationMode: 'generate',
-                forceUpdate: true,
-            });
-            const _generateProfileGraphMs = Date.now() - _generateProfileGraphStart;
-            _generateProfileTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _generateProfileGraphMs });
-            // If user info is insufficient, ask conversationally
-            if (result.needsUserInfo) {
-                return needsClarification({
-                    missingFields: result.missingUserInfo || ['social_urls', 'full_name'],
-                    message: "I need a bit more information to create your profile. Could you share your full name and any social links (LinkedIn, GitHub, or X/Twitter)?",
-                });
-            }
-            if (result.error) {
-                return error(result.error);
-            }
-            if (result.profile) {
-                if (isOnboarding && query.confirm)
-                    await markApprovedProfileConfirmed(deps, context);
-                return success({
-                    created: true,
-                    message: "Profile generated from your account data.",
-                    profile: {
-                        name: result.profile.identity.name,
-                        bio: result.profile.identity.bio,
-                        location: result.profile.identity.location,
-                        skills: result.profile.attributes.skills,
-                        interests: result.profile.attributes.interests,
-                    },
-                    _graphTimings: [{ name: 'enrichment', durationMs: _generateProfileGraphMs, agents: result.agentTimings ?? [] }],
-                });
-            }
-            return error("Failed to create profile. Please try again.");
-        },
-    });
-    const updateUserContext = defineTool({
-        name: "update_user_context",
-        description: "Updates the authenticated user's existing profile using a verb-style instruction interface.\n\n" +
-            "**How to use it:**\n" +
-            "- `action`: a natural-language instruction describing what to change (e.g. \"add interests\", \"update bio\", \"remove skill\", \"set location\").\n" +
-            "- `details`: the content to apply (e.g. \"procedural generation, roguelikes, narrative games\").\n" +
-            "- `socials`: optional social handles to merge into the user's reachable profile (e.g. `{ telegram: \"@alice\" }`).\n\n" +
-            "**Examples:**\n" +
-            "- `action=\"add interests\"`, `details=\"procedural generation, roguelikes\"`\n" +
-            "- `action=\"update bio\"`, `details=\"Product designer focused on desktop CRPG interfaces\"`\n" +
-            "- `action=\"set location\"`, `details=\"Berlin\"`\n" +
-            "- `action=\"remove all mentions of X\"` — existing profile facts matching X are retracted; the profile text regenerates without them shortly after.\n" +
-            "- `socials={ telegram: \"@alice\" }` to silently add a reachable chat handle without regenerating the profile.\n\n" +
-            "**When to use:** When the user wants to make specific changes without regenerating the whole profile. For full profile regeneration from social URLs, use create_user_context instead.\n\n" +
-            "**Important:** If the user provides a URL to update from, call scrape_url first, then pass the scraped content in `details`.\n\n" +
-            "**MCP behavior:** For MCP clients, text/profile graph updates are accepted immediately and completed in the background to avoid transport timeouts. Social-only updates still complete synchronously.\n\n" +
-            "**Returns:** Confirmation that the profile was updated or accepted for background update.",
-        querySchema: z.object({
-            profileId: z.string().optional().describe("Profile UUID from read_user_contexts. Omit to update the current user's own profile (most common usage)."),
-            action: z.string().optional().describe("Natural language description of ALL changes to make in a single call. Examples: 'update bio to focus on AI research', 'add Python and Rust to skills', 'change location to Berlin and add machine learning to interests'. Optional when only updating socials."),
-            details: z.string().optional().describe("Additional context or content to incorporate. Use this to pass scraped URL content (from scrape_url) or longer text the user provided."),
-            socials: z.record(z.string()).optional().describe("Social handles or URLs to merge into the user profile, keyed by label. Example: { telegram: '@alice', github: 'alice' }. Existing socials with other labels are preserved."),
-        }),
-        handler: async ({ context, query }) => {
-            const socialUpdates = socialsRecordToRows(query.socials);
-            const inputForProfile = [query.action, query.details].filter(Boolean).join("\n");
-            if (!inputForProfile.trim()) {
-                if (socialUpdates.length > 0) {
-                    await mergeUserSocials(deps, socialUpdates);
-                    return success({ message: "Profile socials updated." });
-                }
-                return error("Please specify what to update (e.g. action: 'update bio to X') or provide socials.");
-            }
-            const profileRunId = await enqueueEnrichmentRun(deps, context, "update_user_context", query);
-            if (profileRunId) {
-                return success({
-                    status: "queued",
-                    profileRunId,
-                    message: `Profile update started. Call get_enrichment_run with profileRunId="${profileRunId}" until it succeeds, fails, or is cancelled.`,
-                });
-            }
-            // Use profileGraph query mode to validate profile existence and get id
-            const _updateQueryProfileGraphStart = Date.now();
-            const _updateQueryProfileTraceEmitter = requestContext.getStore()?.traceEmitter;
-            _updateQueryProfileTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-            const queryResult = await invokeWithAbortSignal(graphs.profile, { userId: context.userId, operationMode: 'query' });
-            const _updateQueryProfileGraphMs = Date.now() - _updateQueryProfileGraphStart;
-            _updateQueryProfileTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _updateQueryProfileGraphMs });
-            if (!queryResult.readResult?.hasProfile && !queryResult.profile) {
-                return error("You don't have a profile yet. Use create_user_context first.");
-            }
-            const existingProfileId = queryResult.readResult?.profile?.id;
-            const providedProfileId = query.profileId?.trim();
-            if (providedProfileId && existingProfileId && providedProfileId !== existingProfileId) {
-                return error("Invalid profileId. Use the profile id from read_user_contexts.");
-            }
-            if (socialUpdates.length > 0) {
-                await mergeUserSocials(deps, socialUpdates);
-            }
-            if (context.isMcp) {
-                const _backgroundWriteProfileGraphStart = Date.now();
-                const _backgroundWriteProfileTraceEmitter = requestContext.getStore()?.traceEmitter;
-                _backgroundWriteProfileTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-                graphs.profile.invoke({
-                    userId: context.userId,
-                    operationMode: "write",
-                    input: inputForProfile,
-                    forceUpdate: true,
-                }).then((writeResult) => {
-                    if (writeResult.error) {
-                        logger.error("Background profile update failed", {
-                            userId: context.userId,
-                            error: writeResult.error,
-                        });
-                        reportToolError?.(new Error(writeResult.error), {
-                            subsystem: "enrichment",
-                            operation: "profile.update_background",
-                            toolName: "update_user_context",
-                            userId: context.userId,
-                            tags: { toolName: "update_user_context", execution: "background" },
-                            context: { profileId: existingProfileId ?? providedProfileId },
-                        });
-                    }
-                }).catch((err) => {
-                    const message = err instanceof Error ? err.message : String(err);
-                    logger.error("Background profile update failed", {
-                        userId: context.userId,
-                        error: message,
-                    });
-                    reportToolError?.(err, {
-                        subsystem: "enrichment",
-                        operation: "profile.update_background",
-                        toolName: "update_user_context",
-                        userId: context.userId,
-                        tags: { toolName: "update_user_context", execution: "background" },
-                        context: { profileId: existingProfileId ?? providedProfileId },
-                    });
-                }).finally(() => {
-                    const _backgroundWriteProfileGraphMs = Date.now() - _backgroundWriteProfileGraphStart;
-                    _backgroundWriteProfileTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _backgroundWriteProfileGraphMs });
-                });
-                return success({
-                    accepted: true,
-                    message: "Profile update accepted. The structured profile will refresh in the background.",
-                    _graphTimings: [
-                        { name: 'enrichment', durationMs: _updateQueryProfileGraphMs, agents: queryResult.agentTimings ?? [] },
-                    ],
-                });
-            }
-            // Execute update directly
-            const _updateWriteProfileGraphStart = Date.now();
-            const _updateWriteProfileTraceEmitter = requestContext.getStore()?.traceEmitter;
-            _updateWriteProfileTraceEmitter?.({ type: "graph_start", name: "enrichment" });
-            const _writeResult = await invokeWithAbortSignal(graphs.profile, {
-                userId: context.userId,
-                operationMode: "write",
-                input: inputForProfile,
-                forceUpdate: true,
-            });
-            const _updateWriteProfileGraphMs = Date.now() - _updateWriteProfileGraphStart;
-            _updateWriteProfileTraceEmitter?.({ type: "graph_end", name: "enrichment", durationMs: _updateWriteProfileGraphMs });
-            if (_writeResult.error) {
-                return error(_writeResult.error);
-            }
-            return success({
-                message: "Profile updated.",
-                _graphTimings: [
-                    { name: 'enrichment', durationMs: _updateQueryProfileGraphMs, agents: queryResult.agentTimings ?? [] },
-                    { name: 'enrichment', durationMs: _updateWriteProfileGraphMs, agents: _writeResult.agentTimings ?? [] },
-                ],
-            });
-        },
-    });
-    return { createUserContext, updateUserContext };
-}

package/dist/enrichment/enrichment.tools.d.ts

@@ -1,13 +0,0 @@
-/**
- * The enrichment tool registry.
- *
- * The user-context read and write tools live in sibling modules and the shared
- * helpers in `enrichment.tools.helpers.ts`; this file owns the enrichment-run
- * and onboarding tools and assembles the registry.
- */
-import type { DefineTool } from "../shared/agent/tool.helpers.js";
-import type { EnrichmentToolDeps } from "../contexts/context.tools.port.js";
-import type { ToolSurface } from "../shared/agent/utility.tools.js";
-export declare function createEnrichmentTools(defineTool: DefineTool, deps: EnrichmentToolDeps, options?: {
-    surface?: ToolSurface;
-}): readonly [any, any, any, any, any, any, any, any];

package/dist/enrichment/enrichment.tools.helpers.d.ts

@@ -1,139 +0,0 @@
-/**
- * Helpers shared by the enrichment tools.
- *
- * These were nested functions inside `createEnrichmentTools`, closing over the
- * destructured host capabilities. They are top-level now, each taking the tool
- * deps explicitly, so the three tool modules can share them.
- */
-import { z } from "zod";
-import type { ResolvedToolContext } from "../shared/agent/tool.helpers.js";
-import type { EnrichmentToolDeps } from "../contexts/context.tools.port.js";
-import type { EnrichmentResult } from "../shared/interfaces/enrichment.interface.js";
-import type { OnboardingProfileSeed, OnboardingState, UserRecord } from "../shared/interfaces/database.interface.js";
-import type { EnrichmentRunInput, EnrichmentRunOperation } from "../shared/interfaces/enrichment-run.interface.js";
-export declare const logger: import("../shared/observability/log.js").LoggerWithSource;
-export declare function isMeaningfulEnrichment(enrichment: EnrichmentResult | null): enrichment is EnrichmentResult;
-export declare const approvedProfileDraftSchema: z.ZodObject<{
-    identity: z.ZodObject<{
-        name: z.ZodString;
-        bio: z.ZodString;
-        location: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        bio: string;
-        location: string;
-    }, {
-        name: string;
-        bio: string;
-        location: string;
-    }>;
-    narrative: z.ZodObject<{
-        context: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        context: string;
-    }, {
-        context: string;
-    }>;
-    attributes: z.ZodObject<{
-        interests: z.ZodArray<z.ZodString, "many">;
-        skills: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        skills: string[];
-        interests: string[];
-    }, {
-        skills: string[];
-        interests: string[];
-    }>;
-}, "strip", z.ZodTypeAny, {
-    identity: {
-        name: string;
-        bio: string;
-        location: string;
-    };
-    narrative: {
-        context: string;
-    };
-    attributes: {
-        skills: string[];
-        interests: string[];
-    };
-}, {
-    identity: {
-        name: string;
-        bio: string;
-        location: string;
-    };
-    narrative: {
-        context: string;
-    };
-    attributes: {
-        skills: string[];
-        interests: string[];
-    };
-}>;
-type ApprovedProfileDraft = z.infer<typeof approvedProfileDraftSchema>;
-export declare function trimToUndefined(value: string | null | undefined): string | undefined;
-export declare function isPlaceholderName(value: string): boolean;
-export declare function enrichFromUserRecord(deps: EnrichmentToolDeps, user: {
-    name?: string | null;
-    email?: string | null;
-    socials: Array<{
-        id: string;
-        userId: string;
-        label: string;
-        value: string;
-    }>;
-}): Promise<EnrichmentResult | null>;
-export declare function selectProfileSeed(onboarding: OnboardingState | null | undefined, networkId?: string): OnboardingProfileSeed | undefined;
-export declare function normalizeSocialUpdate(label: string, value: string): {
-    label: string;
-    value: string;
-} | null;
-export declare function mergeUserSocials(deps: EnrichmentToolDeps, incoming: {
-    label: string;
-    value: string;
-}[]): Promise<void>;
-export declare function socialsRecordToRows(socials: Record<string, string> | undefined): {
-    label: string;
-    value: string;
-}[];
-export declare function enqueueEnrichmentRun(deps: EnrichmentToolDeps, context: ResolvedToolContext, operation: EnrichmentRunOperation, input: EnrichmentRunInput): Promise<string | null>;
-export declare function persistApprovedProfileContext(deps: EnrichmentToolDeps, profile: {
-    identity: {
-        name: string;
-        bio: string;
-        location: string;
-    };
-}, user: UserRecord | null, networkId?: string): Promise<void>;
-export declare function markApprovedProfileConfirmed(deps: EnrichmentToolDeps, context: ResolvedToolContext): Promise<void>;
-export declare function buildProfileInput(parts: {
-    name?: string;
-    location?: string;
-    bioOrDescription?: string;
-    socials?: Array<{
-        label: string;
-        value: string;
-    }>;
-}): string;
-export declare function toProfileSummary(profile: {
-    identity: {
-        name: string;
-        bio: string;
-        location: string;
-    };
-    attributes: {
-        skills: string[];
-        interests: string[];
-    };
-}): {
-    name: string;
-    bio: string;
-    location: string;
-    skills: string[];
-    interests: string[];
-};
-export declare function buildApprovedDraftProfileInput(draft: ApprovedProfileDraft): string;
-export declare function decomposeApprovedDraftProfile(deps: EnrichmentToolDeps, profile: ApprovedProfileDraft & {
-    userId: string;
-}): Promise<void>;
-export {};