@indexnetwork/protocol 22.0.0-rc.498.1 → 64.0.0-rc.604.2

package/dist/shared/agent/tool.helpers.js

@@ -1,232 +0,0 @@
-import { deriveAllowedNetworkIds, scopeFromNetworkId } from "./tool.scope.js";
-/**
- * Thrown when a requested chat scope is invalid for the authenticated user.
- * Controllers can map this to an HTTP status code.
- */
-export class ChatContextAccessError extends Error {
-    constructor(message, statusCode, code) {
-        super(message);
-        this.statusCode = statusCode;
-        this.code = code;
-        this.name = "ChatContextAccessError";
-    }
-}
-/**
- * Resolve the canonical context used by chat tools and system prompt.
- * This preloads user identity, profile, network memberships, and scoped index role.
- */
-export async function resolveChatContext(params) {
-    const { database, userId, networkId, sessionId } = params;
-    const [user, rawProfile, userNetworks, globalContext] = await Promise.all([
-        database.getUser(userId),
-        database.getProfile(userId),
-        database.getNetworkMemberships(userId),
-        // The premise-derived global user_context paragraph. getProfile deliberately
-        // leaves `context` empty (WS8: narrative lives in user_contexts, not users);
-        // without this read the system prompt's only narrative is the stale onboarding
-        // bio, which resurrects facts the user has since retracted. Best-effort: a
-        // missing row or a minimal test adapter degrades to the empty string.
-        Promise.resolve()
-            .then(() => database.getUserContext?.(userId, null))
-            .catch(() => null),
-    ]);
-    const userProfile = rawProfile ?? null;
-    if (userProfile && !userProfile.context && globalContext?.text) {
-        userProfile.context = globalContext.text;
-    }
-    if (!user) {
-        throw new ChatContextAccessError("User not found", 404, "USER_NOT_FOUND");
-    }
-    let scopedIndex = undefined;
-    let scopedMembershipRole = undefined;
-    let isOwner = false;
-    let indexName;
-    if (networkId) {
-        const [index, isMember, owner] = await Promise.all([
-            database.getNetwork(networkId),
-            database.isNetworkMember(networkId, userId),
-            database.isIndexOwner(networkId, userId),
-        ]);
-        if (!index) {
-            throw new ChatContextAccessError("Index not found", 404, "INDEX_NOT_FOUND");
-        }
-        if (!isMember) {
-            throw new ChatContextAccessError("You are not a member of this network", 403, "INDEX_MEMBERSHIP_REQUIRED");
-        }
-        let membership = userNetworks.find((m) => m.networkId === index.id);
-        if (membership === undefined) {
-            membership = (await database.getNetworkMembership(index.id, userId)) ?? undefined;
-        }
-        scopedIndex = {
-            id: index.id,
-            title: index.title,
-            prompt: membership?.indexPrompt ?? null,
-            permissions: index.permissions ?? {},
-        };
-        isOwner = owner;
-        indexName = index.title;
-        scopedMembershipRole = owner ? "owner" : "member";
-    }
-    const userName = user.name ?? "Unknown";
-    const userEmail = user.email ?? "";
-    const hasName = !!user.name?.trim();
-    const scope = scopeFromNetworkId(networkId);
-    // Deprecated compatibility reach. New call sites should call
-    // deriveAllowedNetworkIds({ memberships: userNetworks, ...scope }) directly.
-    const allowedNetworkIds = deriveAllowedNetworkIds({
-        memberships: userNetworks,
-        ...scope,
-    });
-    return {
-        userId,
-        userName,
-        userEmail,
-        networkId,
-        ...scope,
-        indexName,
-        isOwner,
-        user,
-        userProfile,
-        userNetworks,
-        indexScope: allowedNetworkIds,
-        scopedIndex,
-        scopedMembershipRole,
-        isOnboarding: !(user.onboarding?.completedAt),
-        hasName,
-        ...(sessionId !== undefined ? { sessionId } : {}),
-    };
-}
-// ═══════════════════════════════════════════════════════════════════════════════
-// TOOL RESULT HELPERS
-// ═══════════════════════════════════════════════════════════════════════════════
-export function success(data) {
-    return JSON.stringify({ success: true, data });
-}
-export function error(message, debugSteps) {
-    return JSON.stringify({
-        success: false,
-        error: message,
-        ...(debugSteps?.length ? { debugSteps } : {}),
-    });
-}
-/** Return needsClarification for missing required fields. */
-export function needsClarification(params) {
-    return JSON.stringify({
-        success: false,
-        needsClarification: true,
-        ...params,
-    });
-}
-// ═══════════════════════════════════════════════════════════════════════════════
-// CONSTANTS & UTILITIES
-// ═══════════════════════════════════════════════════════════════════════════════
-/** Matches http/https URLs in text; captures full URL. */
-const URL_IN_TEXT_REGEX = /https?:\/\/[^\s"'<>)\]]+/gi;
-/**
- * Matches bare domain URLs without protocol (e.g. github.com/foo, www.example.com).
- * Requires at least a SLD.TLD pattern followed by optional path.
- * Negative lookbehind ensures we don't double-match URLs already caught by URL_IN_TEXT_REGEX.
- */
-const BARE_URL_REGEX = /(?<!\w:\/\/)(?<![/\w])(?:www\.)?[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.(?:com|org|net|io|dev|co|ai|app|xyz|me|info|gg|so|sh|cc|ly|fm|tv|to|tech|design|network|world|edu|gov|mil|int|us|uk|eu|de|fr|ca|au|jp|cn|in|br|nl|se|no|fi|dk|ch|at|be|it|es|pt|pl|cz|ru|kr|tw|hk|sg|nz|za|mx|ar|cl|id|ph|th|vn|my|ie)(?:\/[^\s"'<>)\]]*)?/gi;
-/** UUID v4 format: 8-4-4-4-12 hex chars (e.g. c2505011-2e45-426e-81dd-b9abb9b72023) */
-export const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * Resolves an array of network IDs to their display titles.
- * Skips any IDs that don't resolve (deleted or invalid networks).
- */
-export async function resolveIndexNames(database, networkIds) {
-    if (networkIds.length === 0)
-        return [];
-    const results = await Promise.all(networkIds.map(id => database.getNetwork(id)));
-    return results.filter(Boolean).map(idx => idx.title);
-}
-/**
- * Normalize a URL string: if it lacks a protocol, prepend "https://".
- * Returns the normalized URL or null if the result is not a valid URL.
- */
-export function normalizeUrl(raw) {
-    let url = raw.replace(/[.,;:!?)]+$/, "").trim();
-    if (!/^https?:\/\//i.test(url)) {
-        url = `https://${url}`;
-    }
-    try {
-        new URL(url);
-        return url;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Extract unique, valid URLs from a string (e.g. user message or details).
- * Handles both full URLs (https://...) and bare domains (github.com/...).
- */
-export function extractUrls(text) {
-    if (!text || typeof text !== "string")
-        return [];
-    const seen = new Set();
-    const out = [];
-    // Pass 1: full protocol URLs
-    const fullMatches = text.match(URL_IN_TEXT_REGEX) ?? [];
-    for (const raw of fullMatches) {
-        const url = normalizeUrl(raw);
-        if (url && !seen.has(url)) {
-            seen.add(url);
-            out.push(url);
-        }
-    }
-    // Pass 2: bare domain URLs (e.g. github.com/foo)
-    const bareMatches = text.match(BARE_URL_REGEX) ?? [];
-    for (const raw of bareMatches) {
-        const url = normalizeUrl(raw);
-        if (url && !seen.has(url)) {
-            seen.add(url);
-            out.push(url);
-        }
-    }
-    return out;
-}
-const SENSITIVE_FIELD_KEYS = new Set([
-    "secret",
-    "webhooksecret",
-    "password",
-    "apikey",
-    "token",
-    "accesstoken",
-    "refreshtoken",
-    "privatekey",
-    "authtoken",
-    "bearertoken",
-    "clientsecret",
-]);
-/**
- * Recursively redacts sensitive field values from an arbitrary payload before
- * it is passed to a structured logger. Matches field names case-insensitively
- * and ignoring underscores, so `api_key`, `apiKey`, and `API_KEY` all match.
- * Non-sensitive fields are passed through unchanged. Never mutates the input —
- * returns a new value.
- *
- * Intended for structured-log redaction only. Do NOT use as a security
- * boundary for data in motion.
- *
- * @param value - Arbitrary JSON-like payload (query object, config blob, etc.)
- * @returns A new value with sensitive fields replaced by `"[redacted]"`.
- */
-export function redactSensitiveFields(value) {
-    if (value === null || typeof value !== "object")
-        return value;
-    if (Array.isArray(value)) {
-        return value.map((item) => redactSensitiveFields(item));
-    }
-    const out = {};
-    for (const [key, inner] of Object.entries(value)) {
-        const normalized = key.toLowerCase().replace(/_/g, "");
-        if (SENSITIVE_FIELD_KEYS.has(normalized)) {
-            out[key] = "[redacted]";
-        }
-        else {
-            out[key] = redactSensitiveFields(inner);
-        }
-    }
-    return out;
-}

package/dist/shared/agent/tool.registry.d.ts

@@ -1,25 +0,0 @@
-import type { ToolDeps, ToolRegistry } from './tool.helpers.js';
-import type { ToolSurface } from './utility.tools.js';
-import type { OpportunityOwnerApprovalDeps } from '../../opportunities/opportunity.tools.port.js';
-export interface CreateToolRegistryOptions {
-    /**
-     * Tool-surface profile. The default `'rest'` profile (direct HTTP Tool API)
-     * exposes contact/Gmail tools, `scrape_url`, and `complete_onboarding`. The
-     * restricted `'mcp'` profile omits those surfaces (IND-596/597). Retired
-     * profile/profile-run compatibility aliases are absent from both profiles
-     * (IND-373/598).
-     */
-    surface?: ToolSurface;
-}
-/**
- * Creates a tool registry containing all tool handlers indexed by name.
- * Handlers are raw async functions (not LangChain tool() wrappers) that
- * accept { context, query } and return a JSON string.
- *
- * @param deps - Shared tool dependencies (graphs, database, embedder, etc.)
- * @param options - Surface profile selecting the MCP-restricted or full REST set.
- * @returns Map of tool name to raw tool definition.
- */
-/** Complete registry composition with the opportunity-local owner-proof port. */
-export type ToolRegistryDeps = ToolDeps & OpportunityOwnerApprovalDeps;
-export declare function createToolRegistry(deps: ToolRegistryDeps, options?: CreateToolRegistryOptions): ToolRegistry;

package/dist/shared/agent/tool.registry.js

@@ -1,76 +0,0 @@
-import { error, redactSensitiveFields } from './tool.helpers.js';
-import { createEnrichmentTools } from '../../enrichment/enrichment.tools.js';
-import { Intents } from '../../intents/intent.module.js';
-import { Networks } from '../../networks/network.module.js';
-import { createOpportunityTools } from '../../opportunities/opportunity.module.js';
-import { createUtilityTools } from './utility.tools.js';
-import { createContactTools } from '../../contacts/contact.module.js';
-import { createAgentTools } from '../../agents/agent.module.js';
-import { createNegotiationTools } from '../../negotiations/negotiation.module.js';
-import { createChatTools } from '../../chat/chat.tools.js';
-import { createPremiseTools } from '../../premises/premise.tools.js';
-import { protocolLogger } from '../observability/protocol.logger.js';
-import { requestContext } from '../observability/request-context.js';
-const logger = protocolLogger('ToolRegistry');
-export function createToolRegistry(deps, options = {}) {
-    const registry = new Map();
-    const isMcpSurface = options.surface === 'mcp';
-    // defineTool that captures raw handlers into the registry
-    function defineTool(opts) {
-        const entry = {
-            name: opts.name,
-            description: opts.description,
-            schema: opts.querySchema,
-            handler: async (input) => {
-                logger.verbose('Tool invoked', {
-                    toolName: opts.name,
-                    context: { userId: input.context.userId, scopeType: input.context.scopeType, scopeId: input.context.scopeId },
-                    query: redactSensitiveFields(input.query),
-                });
-                try {
-                    return await opts.handler({ context: input.context, query: input.query });
-                }
-                catch (err) {
-                    const abortSignal = requestContext.getStore()?.abortSignal;
-                    if (abortSignal?.aborted) {
-                        throw err;
-                    }
-                    logger.error('Tool failed', {
-                        toolName: opts.name,
-                        error: err instanceof Error ? err.message : String(err),
-                    });
-                    return error(`Failed to execute ${opts.name}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            },
-        };
-        registry.set(opts.name, entry);
-        // Return a dummy — create*Tools functions collect return values into arrays,
-        // but for the registry path we only need the side-effect on the Map.
-        return null;
-    }
-    // Create all tool domains -- each one calls defineTool() which populates the registry.
-    // The local defineTool is compatible with DefineTool (which returns any).
-    const dt = defineTool;
-    createEnrichmentTools(dt, deps, { surface: isMcpSurface ? 'mcp' : 'rest' });
-    Intents.createTools(dt, deps);
-    Networks.createTools(dt, deps);
-    createOpportunityTools(dt, deps);
-    // Utility tools always register read_docs + read_activity_summary; on the
-    // MCP surface scrape_url is omitted and read_docs guidance is sanitized
-    // (IND-597). The retired report_agent_activity name retains no alias on
-    // either surface (IND-605).
-    createUtilityTools(dt, deps, { surface: isMcpSurface ? 'mcp' : 'rest' });
-    // Contact tools are omitted from the MCP surface (IND-596). Their
-    // implementations remain available to the REST Tool API and chat agent.
-    if (!isMcpSurface) {
-        createContactTools(dt, deps);
-    }
-    createAgentTools(dt, deps);
-    createNegotiationTools(dt, deps);
-    createPremiseTools(dt, deps);
-    if (deps.chatSession) {
-        createChatTools(dt, deps);
-    }
-    logger.verbose('Tool registry created', { toolCount: registry.size, surface: options.surface ?? 'rest' });
-    return registry;
-}

package/dist/shared/agent/tool.runtime.d.ts

@@ -1,28 +0,0 @@
-import type { TraceEmitter } from "../observability/request-context.js";
-import type { RawToolDefinition, ResolvedToolContext } from "./tool.helpers.js";
-export type ToolTimeoutClass = "fast" | "bounded_slow" | "async_candidate";
-export type ToolRuntimeErrorCode = "TOOL_TIMEOUT" | "TOOL_CANCELLED" | "TOOL_OUTPUT_TOO_LARGE";
-export interface ToolTimeoutPolicy {
-    class: ToolTimeoutClass;
-    timeoutMs: number;
-    maxOutputBytes: number;
-}
-export interface ToolInvocationRuntimeInput {
-    toolName: string;
-    tool: Pick<RawToolDefinition, "handler">;
-    context: ResolvedToolContext;
-    query: unknown;
-    signal?: AbortSignal;
-    traceEmitter?: TraceEmitter;
-    timeoutMs?: number;
-    maxOutputBytes?: number;
-}
-export declare function getToolTimeoutPolicy(toolName: string): ToolTimeoutPolicy;
-export declare class ToolRuntimeError extends Error {
-    readonly code: ToolRuntimeErrorCode;
-    readonly toolName: string;
-    readonly policy: ToolTimeoutPolicy;
-    constructor(code: ToolRuntimeErrorCode, message: string, toolName: string, policy: ToolTimeoutPolicy);
-}
-export declare function invokeToolRuntime(input: ToolInvocationRuntimeInput): Promise<string>;
-export declare function toolRuntimeErrorToResult(err: unknown): string | null;

package/dist/shared/agent/tool.runtime.js

@@ -1,194 +0,0 @@
-import { timed } from "../observability/performance.js";
-import { requestContext } from "../observability/request-context.js";
-const FAST_TIMEOUT_MS = 10000;
-const BOUNDED_SLOW_TIMEOUT_MS = 45000;
-const ASYNC_CANDIDATE_TIMEOUT_MS = 50000;
-const DEFAULT_MAX_OUTPUT_BYTES = 1000000;
-const FAST_TOOLS = new Set([
-    "create_intent_index",
-    "delete_intent_index",
-    "search_intents",
-    "read_networks",
-    "update_network",
-    "create_network",
-    "delete_network",
-    "create_network_membership",
-    "delete_network_membership",
-    "confirm_opportunity_delivery",
-    "read_docs",
-    "get_enrichment_run",
-    "cancel_enrichment_run",
-    "remove_contact",
-    "read_own_agent",
-    "register_agent",
-    "list_agents",
-    "update_agent",
-    "delete_agent",
-    "grant_agent_permission",
-    "revoke_agent_permission",
-    "retract_premise",
-]);
-const ASYNC_CANDIDATE_TOOLS = new Set([
-    "read_user_contexts",
-    "preview_user_context",
-    "create_user_context",
-    "update_user_context",
-    "create_intent",
-    "update_intent",
-    "scrape_url",
-    "respond_to_negotiation",
-    "create_premise",
-    "update_premise",
-]);
-function parsePositiveIntEnv(name, fallback) {
-    const raw = process.env[name];
-    if (!raw)
-        return fallback;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed > 0 && parsed <= Number.MAX_SAFE_INTEGER
-        ? parsed
-        : fallback;
-}
-function toolNameEnv(toolName) {
-    return `MCP_TOOL_TIMEOUT_${toolName.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_MS`;
-}
-function toolNameOutputEnv(toolName) {
-    return `MCP_TOOL_MAX_OUTPUT_${toolName.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_BYTES`;
-}
-export function getToolTimeoutPolicy(toolName) {
-    const classification = FAST_TOOLS.has(toolName)
-        ? "fast"
-        : ASYNC_CANDIDATE_TOOLS.has(toolName)
-            ? "async_candidate"
-            : "bounded_slow";
-    let classDefault;
-    switch (classification) {
-        case "fast":
-            classDefault = parsePositiveIntEnv("MCP_TOOL_TIMEOUT_FAST_MS", FAST_TIMEOUT_MS);
-            break;
-        case "async_candidate":
-            classDefault = parsePositiveIntEnv("MCP_TOOL_TIMEOUT_ASYNC_CANDIDATE_MS", ASYNC_CANDIDATE_TIMEOUT_MS);
-            break;
-        default:
-            classDefault = parsePositiveIntEnv("MCP_TOOL_TIMEOUT_BOUNDED_SLOW_MS", BOUNDED_SLOW_TIMEOUT_MS);
-    }
-    const defaultMaxOutputBytes = parsePositiveIntEnv("MCP_TOOL_MAX_OUTPUT_BYTES", DEFAULT_MAX_OUTPUT_BYTES);
-    return {
-        class: classification,
-        timeoutMs: parsePositiveIntEnv(toolNameEnv(toolName), classDefault),
-        maxOutputBytes: parsePositiveIntEnv(toolNameOutputEnv(toolName), defaultMaxOutputBytes),
-    };
-}
-export class ToolRuntimeError extends Error {
-    constructor(code, message, toolName, policy) {
-        super(message);
-        this.code = code;
-        this.toolName = toolName;
-        this.policy = policy;
-        this.name = "ToolRuntimeError";
-    }
-}
-/** Builds the typed timeout/cancellation error shared by the abort race and catch paths. */
-function makeAbortError(timedOut, toolName, policy) {
-    const code = timedOut ? "TOOL_TIMEOUT" : "TOOL_CANCELLED";
-    return new ToolRuntimeError(code, code === "TOOL_TIMEOUT"
-        ? `Tool ${toolName} timed out after ${policy.timeoutMs}ms.`
-        : `Tool ${toolName} was cancelled before it completed.`, toolName, policy);
-}
-function combineSignals(signals) {
-    const controller = new AbortController();
-    const listeners = [];
-    for (const source of signals) {
-        if (!source)
-            continue;
-        if (source.aborted) {
-            controller.abort(source.reason);
-            break;
-        }
-        const onAbort = () => {
-            if (!controller.signal.aborted)
-                controller.abort(source.reason);
-        };
-        source.addEventListener("abort", onAbort, { once: true });
-        listeners.push(() => source.removeEventListener("abort", onAbort));
-    }
-    return {
-        signal: controller.signal,
-        abort: (reason) => {
-            if (!controller.signal.aborted)
-                controller.abort(reason);
-        },
-        cleanup: () => {
-            for (const cleanup of listeners)
-                cleanup();
-        },
-    };
-}
-export async function invokeToolRuntime(input) {
-    return timed(`ToolRuntime.${input.toolName}`, () => invokeToolRuntimeInner(input));
-}
-async function invokeToolRuntimeInner(input) {
-    const basePolicy = getToolTimeoutPolicy(input.toolName);
-    const policy = {
-        ...basePolicy,
-        ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs } : {}),
-        ...(input.maxOutputBytes !== undefined ? { maxOutputBytes: input.maxOutputBytes } : {}),
-    };
-    const inherited = requestContext.getStore();
-    const combined = combineSignals([input.signal, inherited?.abortSignal]);
-    let timedOut = false;
-    const timer = setTimeout(() => {
-        timedOut = true;
-        combined.abort(new Error(`Tool ${input.toolName} timed out after ${policy.timeoutMs}ms`));
-    }, policy.timeoutMs);
-    let removeAbortListener = () => { };
-    const abortPromise = new Promise((_, reject) => {
-        const onAbort = () => {
-            reject(makeAbortError(timedOut, input.toolName, policy));
-        };
-        combined.signal.addEventListener("abort", onAbort, { once: true });
-        removeAbortListener = () => combined.signal.removeEventListener("abort", onAbort);
-    });
-    try {
-        const run = () => input.tool.handler({ context: input.context, query: input.query });
-        const toolPromise = requestContext.run({
-            ...inherited,
-            abortSignal: combined.signal,
-            traceEmitter: input.traceEmitter ?? inherited?.traceEmitter,
-        }, run);
-        const result = await Promise.race([toolPromise, abortPromise]);
-        const outputBytes = new TextEncoder().encode(result).byteLength;
-        if (outputBytes > policy.maxOutputBytes) {
-            throw new ToolRuntimeError("TOOL_OUTPUT_TOO_LARGE", `Tool ${input.toolName} returned ${outputBytes} bytes, exceeding the ${policy.maxOutputBytes} byte limit.`, input.toolName, policy);
-        }
-        return result;
-    }
-    catch (err) {
-        if (err instanceof ToolRuntimeError)
-            throw err;
-        if (combined.signal.aborted) {
-            throw makeAbortError(timedOut, input.toolName, policy);
-        }
-        throw err;
-    }
-    finally {
-        clearTimeout(timer);
-        removeAbortListener();
-        combined.cleanup();
-    }
-}
-export function toolRuntimeErrorToResult(err) {
-    if (!(err instanceof ToolRuntimeError))
-        return null;
-    return JSON.stringify({
-        success: false,
-        code: err.code,
-        error: err.message,
-        data: {
-            tool: err.toolName,
-            timeoutClass: err.policy.class,
-            timeoutMs: err.policy.timeoutMs,
-            maxOutputBytes: err.policy.maxOutputBytes,
-        },
-    });
-}

package/dist/shared/agent/tool.scope.d.ts

@@ -1,44 +0,0 @@
-/**
- * Request scope primitives for protocol tools.
- *
- * `scopeType`/`scopeId` describe the user's focused scope, not the full set of
- * networks a caller may read or write. Helper functions derive concrete network
- * id sets from the focused scope plus the caller's memberships.
- */
-export type ToolScopeType = 'network' | 'intent';
-export interface ToolScopeEnvelope {
-    scopeType?: ToolScopeType;
-    scopeId?: string;
-}
-export interface ScopeMembership {
-    networkId: string;
-    isPersonal?: boolean | null;
-}
-export interface DeriveNetworkScopeInput extends ToolScopeEnvelope {
-    memberships: ScopeMembership[];
-}
-export declare function scopeFromNetworkId(networkId: string | null | undefined): ToolScopeEnvelope;
-export declare function scopeFromIntentId(intentId: string | null | undefined): ToolScopeEnvelope;
-export declare function hasNetworkScope(scope: ToolScopeEnvelope): scope is {
-    scopeType: 'network';
-    scopeId: string;
-};
-export declare function hasIntentScope(scope: ToolScopeEnvelope): scope is {
-    scopeType: 'intent';
-    scopeId: string;
-};
-/**
- * Returns the focused network id from the canonical scope envelope.
- *
- * This intentionally does not inspect legacy `networkId` fields; callers that
- * still need a transition fallback should pass `scopeFromNetworkId(networkId)`
- * at the boundary so tool logic remains envelope-driven.
- */
-export declare function focusedNetworkId(scope: ToolScopeEnvelope): string | undefined;
-export declare function focusedIntentId(scope: ToolScopeEnvelope): string | undefined;
-/** Human-readable label for a focused scope, used in scope-restriction notes. */
-export declare function focusedNetworkLabel(scope: ToolScopeEnvelope & {
-    indexName?: string;
-}): string;
-export declare function deriveAllowedNetworkIds(input: DeriveNetworkScopeInput): string[];
-export declare function deriveDiscoveryNetworkIds(input: DeriveNetworkScopeInput): string[];

package/dist/shared/agent/tool.scope.js

@@ -1,50 +0,0 @@
-function uniqueNetworkIds(ids) {
-    return [...new Set(ids.map((id) => id.trim()).filter(Boolean))];
-}
-export function scopeFromNetworkId(networkId) {
-    const scopeId = networkId?.trim();
-    return scopeId ? { scopeType: 'network', scopeId } : {};
-}
-export function scopeFromIntentId(intentId) {
-    const scopeId = intentId?.trim();
-    return scopeId ? { scopeType: 'intent', scopeId } : {};
-}
-export function hasNetworkScope(scope) {
-    return scope.scopeType === 'network' && typeof scope.scopeId === 'string' && scope.scopeId.trim().length > 0;
-}
-export function hasIntentScope(scope) {
-    return scope.scopeType === 'intent' && typeof scope.scopeId === 'string' && scope.scopeId.trim().length > 0;
-}
-/**
- * Returns the focused network id from the canonical scope envelope.
- *
- * This intentionally does not inspect legacy `networkId` fields; callers that
- * still need a transition fallback should pass `scopeFromNetworkId(networkId)`
- * at the boundary so tool logic remains envelope-driven.
- */
-export function focusedNetworkId(scope) {
-    return hasNetworkScope(scope) ? scope.scopeId.trim() : undefined;
-}
-export function focusedIntentId(scope) {
-    return hasIntentScope(scope) ? scope.scopeId.trim() : undefined;
-}
-/** Human-readable label for a focused scope, used in scope-restriction notes. */
-export function focusedNetworkLabel(scope) {
-    return scope.indexName ?? focusedNetworkId(scope) ?? 'this network';
-}
-export function deriveAllowedNetworkIds(input) {
-    if (!hasNetworkScope(input)) {
-        return uniqueNetworkIds(input.memberships.map((membership) => membership.networkId));
-    }
-    return uniqueNetworkIds(input.memberships
-        .filter((membership) => membership.networkId === input.scopeId || membership.isPersonal === true)
-        .map((membership) => membership.networkId));
-}
-export function deriveDiscoveryNetworkIds(input) {
-    if (!hasNetworkScope(input)) {
-        return uniqueNetworkIds(input.memberships.map((membership) => membership.networkId));
-    }
-    return input.memberships.some((membership) => membership.networkId === input.scopeId)
-        ? [input.scopeId]
-        : [];
-}

package/dist/shared/agent/utility.tools.d.ts

@@ -1,15 +0,0 @@
-import type { DefineTool, ToolRegistryCompositionDeps } from "./tool.helpers.js";
-/** Host capabilities consumed by URL and profile utility tools. */
-type UtilityToolDeps = Pick<ToolRegistryCompositionDeps, "scraper" | "userDb">;
-/**
- * Tool-surface profile. The restricted `'mcp'` surface omits `scrape_url`
- * (IND-597) and sanitizes `read_docs` guidance so it never advertises the
- * contact/Gmail workflows removed from MCP (IND-596). The default `'rest'`
- * surface (direct HTTP Tool API + chat) retains full behavior.
- */
-export type ToolSurface = "mcp" | "rest";
-export interface CreateUtilityToolsOptions {
-    surface?: ToolSurface;
-}
-export declare function createUtilityTools(defineTool: DefineTool, deps: UtilityToolDeps, options?: CreateUtilityToolsOptions): any[];
-export {};