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

package/dist/chat/chat.title.generator.js

@@ -1,66 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { log } from "../shared/observability/log.js";
-import { Timed } from "../shared/observability/performance.js";
-import { createResilientModel } from "../shared/agent/model.config.js";
-import { invokeWithAbortSignal } from "../shared/agent/model-signal.js";
-const logger = log.lib.from("ChatTitleGenerator");
-const SYSTEM_PROMPT = `You suggest a very short title for a chat conversation.
-
-Rules:
-- Reply with ONLY the title, no quotes or punctuation.
-- Maximum 6 words.
-- If the conversation is just greetings (hi, hello, hey, thanks) or has no clear topic yet, reply with exactly: New chat
-- Otherwise summarize the main topic or intent in a few words.`;
-/**
- * Generates a short, descriptive title for a chat session using the first exchange.
- * Only meaningful when there is at least one user message and one assistant message.
- */
-export class ChatTitleGenerator {
-    constructor() {
-        this.model = createResilientModel("chatTitleGenerator");
-    }
-    /**
-     * Suggests a title from the conversation excerpt.
-     * Call only when there is at least one user and one assistant message.
-     */
-    async invoke(input) {
-        const { messages } = input;
-        if (messages.length === 0)
-            return "New chat";
-        const excerpt = messages
-            .slice(0, 6)
-            .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content.slice(0, 200)}`)
-            .join("\n");
-        try {
-            const response = await invokeWithAbortSignal(this.model, [
-                new SystemMessage(SYSTEM_PROMPT),
-                new HumanMessage(`Conversation:\n${excerpt}\n\nSuggested title:`),
-            ]);
-            const text = typeof response.content === "string" ? response.content : String(response.content ?? "").trim();
-            const title = text.slice(0, 80).trim() || "New chat";
-            logger.verbose("Title generated", { titleLength: title.length });
-            return title;
-        }
-        catch (error) {
-            logger.warn("Failed to generate title", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return "New chat";
-        }
-    }
-}
-__decorate([
-    Timed(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], ChatTitleGenerator.prototype, "invoke", null);

package/dist/chat/chat.tools.d.ts

@@ -1,5 +0,0 @@
-import type { DefineTool, ToolDeps } from "../shared/agent/tool.helpers.js";
-export declare function createChatTools(defineTool: DefineTool, deps: ToolDeps): {
-    listConversations: any;
-    getConversation: any;
-};

package/dist/chat/chat.tools.js

@@ -1,62 +0,0 @@
-import { z } from "zod";
-import { success, error, UUID_REGEX } from "../shared/agent/tool.helpers.js";
-export function createChatTools(defineTool, deps) {
-    const { chatSession } = deps;
-    if (!chatSession) {
-        throw new Error("createChatTools requires `chatSession` in deps");
-    }
-    const listConversations = defineTool({
-        name: "list_conversations",
-        description: "Lists the authenticated user's past H2A chat conversations (direct chats with the Index agent), " +
-            "most-recently-active first. Use when the user asks about their prior chats, wants to resume a " +
-            "conversation, or is orienting themselves in their own history. Only returns H2A sessions the caller " +
-            "participates in. Human-to-human (H2H) DMs are NEVER exposed through this tool, and A2A negotiation " +
-            "chats are only available via `list_negotiations` / `get_negotiation`.\n\n" +
-            "**Returns:** `conversations: [{ sessionId, title, messageCount, lastMessageAt, createdAt }]`. Use " +
-            "`sessionId` with `get_conversation` to read the full thread.",
-        querySchema: z.object({
-            limit: z
-                .number()
-                .int()
-                .positive()
-                .max(100)
-                .optional()
-                .describe("Maximum conversations to return (default 25, max 100)."),
-        }),
-        handler: async ({ context, query }) => {
-            const sessions = await chatSession.listSessions(context.userId, query.limit ?? 25);
-            return success({ conversations: sessions });
-        },
-    });
-    const getConversation = defineTool({
-        name: "get_conversation",
-        description: "Fetches a single H2A chat conversation (a direct chat with the Index agent) belonging to the " +
-            "authenticated user, including its messages. Use after `list_conversations` has yielded a specific " +
-            "`sessionId` — for example when the user asks you to pick up a prior thread by topic or title. Returns " +
-            "an error if the session does not exist, the caller is not a participant, or the session is not an H2A " +
-            "chat: human-to-human (H2H) DMs are NEVER exposed through this tool, and A2A negotiation transcripts " +
-            "are only available via `get_negotiation`.\n\n" +
-            "**Returns:** `{ sessionId, title, messageCount, lastMessageAt, createdAt, messages: [{ role, content, createdAt }] }`.",
-        querySchema: z.object({
-            sessionId: z.string().describe("Session UUID from list_conversations."),
-            messageLimit: z
-                .number()
-                .int()
-                .positive()
-                .max(500)
-                .optional()
-                .describe("Maximum messages to include (default 50, max 500)."),
-        }),
-        handler: async ({ context, query }) => {
-            if (!UUID_REGEX.test(query.sessionId)) {
-                return error("Invalid session ID format. Pass a sessionId returned by list_conversations.");
-            }
-            const session = await chatSession.getSession(context.userId, query.sessionId, query.messageLimit ?? 50);
-            if (!session) {
-                return error("Conversation not found or you are not a participant.");
-            }
-            return success(session);
-        },
-    });
-    return { listConversations, getConversation };
-}

package/dist/chat/chat.utils.d.ts

@@ -1,41 +0,0 @@
-/**
- * Token utilities for context window management.
- * Estimates token counts and truncates message arrays to fit within model limits.
- * Uses a simple heuristic (~4 chars per token for English).
- */
-import { BaseMessage } from "@langchain/core/messages";
-/**
- * Default maximum tokens to allow for context.
- * Reserves space for system prompt and response generation.
- */
-export declare const MAX_CONTEXT_TOKENS = 8000;
-/**
- * Estimate token count for a string using a simple heuristic.
- *
- * This uses a rough estimate of ~4 characters per token, which works
- * reasonably well for English text. For more accuracy with specific
- * models, use tiktoken or the model's native tokenizer.
- *
- * @param text - The text to estimate tokens for
- * @returns Estimated token count
- */
-export declare function estimateTokenCount(text: string): number;
-/**
- * Estimate token count for a message, including role overhead.
- *
- * @param message - The LangChain message to estimate
- * @returns Estimated token count including message overhead
- */
-export declare function estimateMessageTokens(message: BaseMessage): number;
-/**
- * Truncate messages to fit within token limit, keeping most recent messages.
- *
- * Messages are processed from newest to oldest, accumulating until the
- * token limit is reached. The first message (usually system) is always
- * kept if present.
- *
- * @param messages - Array of messages to truncate
- * @param maxTokens - Maximum total tokens allowed (default: MAX_CONTEXT_TOKENS)
- * @returns Array of messages that fit within the token limit
- */
-export declare function truncateToTokenLimit(messages: BaseMessage[], maxTokens?: number): BaseMessage[];

package/dist/chat/chat.utils.js

@@ -1,88 +0,0 @@
-/**
- * Token utilities for context window management.
- * Estimates token counts and truncates message arrays to fit within model limits.
- * Uses a simple heuristic (~4 chars per token for English).
- */
-/**
- * Default maximum tokens to allow for context.
- * Reserves space for system prompt and response generation.
- */
-export const MAX_CONTEXT_TOKENS = 8000;
-/** Minimum tokens to reserve for the model's response (internal use in truncateToTokenLimit). */
-const RESERVED_RESPONSE_TOKENS = 2000;
-/**
- * Estimate token count for a string using a simple heuristic.
- *
- * This uses a rough estimate of ~4 characters per token, which works
- * reasonably well for English text. For more accuracy with specific
- * models, use tiktoken or the model's native tokenizer.
- *
- * @param text - The text to estimate tokens for
- * @returns Estimated token count
- */
-export function estimateTokenCount(text) {
-    if (!text)
-        return 0;
-    // Rough estimate: ~4 characters per token for English
-    // This tends to slightly overestimate, which is safer for truncation
-    return Math.ceil(text.length / 4);
-}
-/**
- * Estimate token count for a message, including role overhead.
- *
- * @param message - The LangChain message to estimate
- * @returns Estimated token count including message overhead
- */
-export function estimateMessageTokens(message) {
-    const content = typeof message.content === "string"
-        ? message.content
-        : JSON.stringify(message.content);
-    // Add ~4 tokens overhead per message for role and formatting
-    return estimateTokenCount(content) + 4;
-}
-/**
- * Truncate messages to fit within token limit, keeping most recent messages.
- *
- * Messages are processed from newest to oldest, accumulating until the
- * token limit is reached. The first message (usually system) is always
- * kept if present.
- *
- * @param messages - Array of messages to truncate
- * @param maxTokens - Maximum total tokens allowed (default: MAX_CONTEXT_TOKENS)
- * @returns Array of messages that fit within the token limit
- */
-export function truncateToTokenLimit(messages, maxTokens = MAX_CONTEXT_TOKENS) {
-    if (messages.length === 0)
-        return [];
-    // Calculate available tokens (reserve space for response)
-    const availableTokens = maxTokens - RESERVED_RESPONSE_TOKENS;
-    // If only one message, return it (truncation within message not supported)
-    if (messages.length === 1) {
-        return messages;
-    }
-    let totalTokens = 0;
-    const result = [];
-    // Check if first message is a system message (should always be kept)
-    const firstMessage = messages[0];
-    const hasSystemMessage = firstMessage._getType() === "system";
-    if (hasSystemMessage) {
-        const systemTokens = estimateMessageTokens(firstMessage);
-        totalTokens += systemTokens;
-        result.push(firstMessage);
-    }
-    // Process remaining messages from newest to oldest
-    const remainingMessages = hasSystemMessage ? messages.slice(1) : messages;
-    const recentMessages = [];
-    for (let i = remainingMessages.length - 1; i >= 0; i--) {
-        const msg = remainingMessages[i];
-        const msgTokens = estimateMessageTokens(msg);
-        if (totalTokens + msgTokens > availableTokens) {
-            // Stop adding more messages
-            break;
-        }
-        recentMessages.unshift(msg);
-        totalTokens += msgTokens;
-    }
-    // Combine system message (if any) with recent messages
-    return hasSystemMessage ? [firstMessage, ...recentMessages] : recentMessages;
-}

package/dist/chat/negotiator.persona.d.ts

@@ -1,74 +0,0 @@
-import { type ChatTools, type ToolContext, type ResolvedToolContext } from "../shared/agent/tool.factory.js";
-import { type ToolScopeEnvelope } from "../shared/agent/tool.scope.js";
-import type { ChatPersonaConfig } from "./chat.persona.js";
-import { type NegotiatorPromptOptions } from "./negotiator.prompt.js";
-/**
- * Persona id for the user's personal negotiator. Matches the
- * `conversations.persona` column value for negotiator DM sessions.
- */
-export declare const NEGOTIATOR_PERSONA_ID = "negotiator";
-/**
- * Client-scoped tool allowlist for the negotiator persona.
- *
- * P4.5 (IND-413) expanded this from the read-mostly P4.1 set: with direct
- * opportunity discovery retiring alongside the orchestrator, discovery is
- * purely signal-based — so the negotiator (the surviving personal-agent chat
- * surface) manages the client's signals, profile knowledge, memberships, and
- * contacts.
- *
- * Still deliberately excluded:
- * - discovery runs (`discover_opportunities`, `get/cancel_discovery_run`) —
- *   retired capability; matching happens in the background from signals,
- * - whole-network administration (`create/update/delete_network`) — a
- *   human/UI act for now (joins/leaves are allowed),
- * - onboarding plumbing (`complete_onboarding`),
- * - agent management (`register/update/delete_agent`, permission grants),
- * - `confirm_opportunity_delivery` (OpenClaw ledger write, never chat).
- */
-export declare const NEGOTIATOR_TOOL_NAMES: readonly ["list_negotiations", "get_negotiation", "respond_to_negotiation", "list_opportunities", "update_opportunity", "read_intents", "create_intent", "update_intent", "delete_intent", "search_intents", "read_intent_indexes", "create_intent_index", "delete_intent_index", "read_user_contexts", "create_user_context", "update_user_context", "confirm_user_context", "preview_user_context", "read_premises", "create_premise", "update_premise", "retract_premise", "read_networks", "read_network_memberships", "create_network_membership", "delete_network_membership", "list_contacts", "search_contacts", "remove_contact", "scrape_url"];
-/**
- * Filters a full chat-tool registry down to the negotiator allowlist.
- * Exported separately so the scoping rule is unit-testable without
- * constructing the full tool factory dependency graph.
- */
-export declare function filterNegotiatorTools<T extends {
-    name: string;
-}>(tools: T[]): T[];
-/**
- * Applies negotiator tool availability rules that depend on the focused scope.
- * Intent-pinned chats use the adjacent Radar for opportunity listing, while all
- * other negotiator-specific capabilities remain available. Shared intent tool
- * filtering independently removes create_intent from every intent-scoped chat.
- */
-export declare function filterNegotiatorToolsForContext<T extends {
-    name: string;
-}>(tools: T[], context: ToolScopeEnvelope): T[];
-/**
- * Creates the negotiator persona's client-scoped toolset.
- *
- * Reuses the standard chat tool factory (so context resolution, scope
- * derivation, logging, and error handling stay identical) and filters the
- * registry to the allowlist. The negotiation tools are already context-bound
- * to `context.userId`, so every tool in this set can only read or act on the
- * calling client's own data.
- */
-export declare function createNegotiatorTools(deps: ToolContext, preResolvedContext?: ResolvedToolContext): Promise<ChatTools>;
-/**
- * Creates a negotiator `ChatPersonaConfig` bound to the client's personal
- * negotiator agent row identity.
- *
- * Loop behaviors (P4.5):
- * - `hallucinationRecovery: true` — with `create_intent` in the toolset the
- *   model can legitimately produce ```intent_proposal blocks, so unbacked
- *   blocks must be detected/auto-invoked/stripped. The auto-invoke path is
- *   confirm-safe: `create_intent` returns a proposal card that persists
- *   nothing until the client approves it in the UI. A hallucinated
- *   ```opportunity block maps to `discover_opportunities`, which is absent
- *   from this toolset — the loop falls back to a correction message and the
- *   final-response strip still removes the unbacked block.
- * - `createIntentCallback: false` — discovery-coupled (fires only off
- *   `discover_opportunities` results); retired along with direct discovery.
- *
- * @param opts - Identity from the user's `type='personal'` agent row
- */
-export declare function createNegotiatorPersona(opts: NegotiatorPromptOptions): ChatPersonaConfig;

package/dist/chat/negotiator.persona.js

@@ -1,154 +0,0 @@
-import { createChatTools } from "../shared/agent/tool.factory.js";
-import { focusedIntentId } from "../shared/agent/tool.scope.js";
-import { buildNegotiatorSystemContent } from "./negotiator.prompt.js";
-import { createNegotiatorMemoryTools } from "./negotiator.tools.js";
-// ═══════════════════════════════════════════════════════════════════════════════
-// NEGOTIATOR PERSONA (P4.1)
-// ═══════════════════════════════════════════════════════════════════════════════
-//
-// A pure persona addition on the P4.0 persona-neutral chat runtime: advocate
-// prompt, client-scoped toolset, and all orchestrator loop behaviors OFF.
-// Unlike the orchestrator (a static singleton), the negotiator persona is
-// created per session because its identity comes from the user's
-// `type='personal'` agent row (name/description).
-/**
- * Persona id for the user's personal negotiator. Matches the
- * `conversations.persona` column value for negotiator DM sessions.
- */
-export const NEGOTIATOR_PERSONA_ID = "negotiator";
-/**
- * Client-scoped tool allowlist for the negotiator persona.
- *
- * P4.5 (IND-413) expanded this from the read-mostly P4.1 set: with direct
- * opportunity discovery retiring alongside the orchestrator, discovery is
- * purely signal-based — so the negotiator (the surviving personal-agent chat
- * surface) manages the client's signals, profile knowledge, memberships, and
- * contacts.
- *
- * Still deliberately excluded:
- * - discovery runs (`discover_opportunities`, `get/cancel_discovery_run`) —
- *   retired capability; matching happens in the background from signals,
- * - whole-network administration (`create/update/delete_network`) — a
- *   human/UI act for now (joins/leaves are allowed),
- * - onboarding plumbing (`complete_onboarding`),
- * - agent management (`register/update/delete_agent`, permission grants),
- * - `confirm_opportunity_delivery` (OpenClaw ledger write, never chat).
- */
-export const NEGOTIATOR_TOOL_NAMES = [
-    // Negotiation record — the advocate core (P4.1)
-    "list_negotiations",
-    "get_negotiation",
-    "respond_to_negotiation",
-    "list_opportunities",
-    "update_opportunity",
-    // Signals — the input surface of signal-based discovery (P4.5)
-    "read_intents",
-    "create_intent",
-    "update_intent",
-    "delete_intent",
-    "search_intents",
-    "read_intent_indexes",
-    "create_intent_index",
-    "delete_intent_index",
-    // Profile knowledge (P4.5)
-    "read_user_contexts",
-    "create_user_context",
-    "update_user_context",
-    "confirm_user_context",
-    "preview_user_context",
-    // Premises (P4.5; read was already in P4.1)
-    "read_premises",
-    "create_premise",
-    "update_premise",
-    "retract_premise",
-    // Networks — joins/leaves only, no network administration (P4.5)
-    "read_networks",
-    "read_network_memberships",
-    "create_network_membership",
-    "delete_network_membership",
-    // Contacts — read/remove only; contacts arise from accepted opportunities
-    "list_contacts",
-    "search_contacts",
-    "remove_contact",
-    // Utility — create_intent's own contract instructs scraping pasted URLs
-    // before synthesizing a signal description (P4.5)
-    "scrape_url",
-];
-const NEGOTIATOR_TOOL_ALLOWLIST = new Set(NEGOTIATOR_TOOL_NAMES);
-/**
- * Filters a full chat-tool registry down to the negotiator allowlist.
- * Exported separately so the scoping rule is unit-testable without
- * constructing the full tool factory dependency graph.
- */
-export function filterNegotiatorTools(tools) {
-    return tools.filter((t) => NEGOTIATOR_TOOL_ALLOWLIST.has(t.name));
-}
-/**
- * Applies negotiator tool availability rules that depend on the focused scope.
- * Intent-pinned chats use the adjacent Radar for opportunity listing, while all
- * other negotiator-specific capabilities remain available. Shared intent tool
- * filtering independently removes create_intent from every intent-scoped chat.
- */
-export function filterNegotiatorToolsForContext(tools, context) {
-    return focusedIntentId(context)
-        ? tools.filter((tool) => tool.name !== "list_opportunities")
-        : tools;
-}
-/**
- * Creates the negotiator persona's client-scoped toolset.
- *
- * Reuses the standard chat tool factory (so context resolution, scope
- * derivation, logging, and error handling stay identical) and filters the
- * registry to the allowlist. The negotiation tools are already context-bound
- * to `context.userId`, so every tool in this set can only read or act on the
- * calling client's own data.
- */
-export async function createNegotiatorTools(deps, preResolvedContext) {
-    const tools = await createChatTools(deps, preResolvedContext);
-    const filtered = filterNegotiatorTools(tools);
-    // A supplied resolved context is authoritative. Direct callers without one
-    // still get the canonical explicit scope envelope from ToolContext.
-    const toolScope = preResolvedContext ?? { scopeType: deps.scopeType, scopeId: deps.scopeId };
-    const contextFiltered = filterNegotiatorToolsForContext(filtered, toolScope);
-    // P5.4 (IND-408): `remember`/`forget` are negotiator-exclusive — appended
-    // AFTER the allowlist filter, and only when the composition root injected
-    // the host bridge (i.e. negotiator memory writes are enabled). They never
-    // enter the shared registry, so the orchestrator cannot see them.
-    if (deps.negotiatorMemoryTools) {
-        const memoryTools = createNegotiatorMemoryTools({
-            host: deps.negotiatorMemoryTools,
-            userId: deps.userId,
-            ...(deps.sessionId ? { sessionId: deps.sessionId } : {}),
-        });
-        return [...contextFiltered, ...memoryTools];
-    }
-    return contextFiltered;
-}
-/**
- * Creates a negotiator `ChatPersonaConfig` bound to the client's personal
- * negotiator agent row identity.
- *
- * Loop behaviors (P4.5):
- * - `hallucinationRecovery: true` — with `create_intent` in the toolset the
- *   model can legitimately produce ```intent_proposal blocks, so unbacked
- *   blocks must be detected/auto-invoked/stripped. The auto-invoke path is
- *   confirm-safe: `create_intent` returns a proposal card that persists
- *   nothing until the client approves it in the UI. A hallucinated
- *   ```opportunity block maps to `discover_opportunities`, which is absent
- *   from this toolset — the loop falls back to a correction message and the
- *   final-response strip still removes the unbacked block.
- * - `createIntentCallback: false` — discovery-coupled (fires only off
- *   `discover_opportunities` results); retired along with direct discovery.
- *
- * @param opts - Identity from the user's `type='personal'` agent row
- */
-export function createNegotiatorPersona(opts) {
-    return {
-        id: NEGOTIATOR_PERSONA_ID,
-        buildSystemContent: (ctx, iterCtx) => buildNegotiatorSystemContent(ctx, opts, iterCtx),
-        createTools: (deps, preResolvedContext) => createNegotiatorTools(deps, preResolvedContext),
-        loopBehaviors: {
-            hallucinationRecovery: true,
-        },
-    };
-}

package/dist/chat/negotiator.prompt.d.ts

@@ -1,45 +0,0 @@
-import type { ResolvedToolContext } from "../shared/agent/tool.factory.js";
-import { type NegotiatorMemoryEntry } from "../negotiations/negotiation.module.js";
-import type { IterationContext } from "./chat.prompt.modules.js";
-/** Identity options resolved from the user's personal negotiator agent row. */
-export interface NegotiatorPromptOptions {
-    /** The negotiator agent's display name (e.g. "Ada's Negotiator"). */
-    agentName: string;
-    /** The negotiator agent's description, when set on the agent row. */
-    agentDescription?: string;
-    /**
-     * Human-readable label for the pinned signal when the session is
-     * intent-scoped (P4.2/IND-403). The pin itself comes from the resolved
-     * context's scope envelope; this label just saves a tool round-trip for
-     * naming it. Ignored when the session has no intent scope.
-     */
-    pinnedIntentLabel?: string;
-    /**
-     * The client's negotiator memories (P5.3 read path) — accumulated notes
-     * from negotiations and prior chats, rendered as a prompt section. The
-     * audience is the client themself, so entries are shared context, not
-     * secrets. Absent/empty → the prompt is byte-identical to before.
-     */
-    memory?: NegotiatorMemoryEntry[];
-    /**
-     * True when the `remember`/`forget` memory tools are registered for this
-     * session (P5.4 — the composition root injects them only while negotiator
-     * memory writes are enabled). Adds the memory-tool guidance section and
-     * tool-reference rows; false/absent → prompt unchanged.
-     */
-    memoryToolsEnabled?: boolean;
-}
-/**
- * Builds the system prompt for the negotiator chat persona.
- *
- * Grounded in the client's preloaded user/profile context; everything else
- * (negotiations, opportunities, signals, premises) must be fetched through
- * the client-scoped toolset each turn.
- *
- * @param ctx - Resolved tool context for the current session
- * @param opts - Identity from the client's personal negotiator agent row
- * @param _iterCtx - Iteration context (unused — the negotiator prompt has no
- *                   dynamic modules; the nudge is injected by the agent loop)
- * @returns The complete system prompt string
- */
-export declare function buildNegotiatorSystemContent(ctx: ResolvedToolContext, opts: NegotiatorPromptOptions, _iterCtx?: IterationContext): string;