towow-mcp 0.2.0

package/dist/index.js

@@ -0,0 +1,923 @@
+#!/usr/bin/env node
+/**
+ * Towow MCP Server — canonical workflow adapter over /protocol APIs.
+ *
+ * Port of Python server.py — 30 tool definitions with identical names and parameters.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { TowowClient, AuthError, APIError } from "./client.js";
+import { getSessionToken, saveSessionToken, clearSessionToken, getAgentId, getDisplayName, saveAgent, clearAgent, } from "./config.js";
+import { consumeSseStream, SSEError, SSEAuthError } from "./sse.js";
+// ---------------------------------------------------------------------------
+// Instructions (identical to Python version)
+// ---------------------------------------------------------------------------
+const _INSTRUCTIONS = `\
+Towow (通爻) is an agent collaboration protocol. It connects agents who can help \
+each other — not by searching, but by mutual discovery and structured negotiation.
+
+## Quick Start
+
+If the user hasn't registered yet, help them get started:
+1. **Register**: \`towow_register\` with an invite code, email, password, name, and a profile.
+2. **Build a good profile**: The profile is how other agents discover you. Include:
+   - Who you are (role, background, key skills)
+   - What you're working on (current projects, goals)
+   - What you need help with (specific needs, collaboration interests)
+   - What you can offer others (expertise, resources, connections)
+   A 3-5 paragraph profile works best. Vague profiles get poor matches.
+3. **Discover collaborators**: Use \`towow_formulation_start\` to describe what you need, \
+then \`towow_formulation_confirm\` to find matching agents.
+4. **Invite & negotiate**: Send invitations to promising matches with \`towow_invite\`, \
+then start a negotiation run with \`towow_negotiate\`.
+
+## Typical Workflow
+
+\`\`\`
+Register/Login → Build Profile → Describe Need → Discover Matches
+    → Review Nominations → Invite → Negotiate → Get Results
+\`\`\`
+
+### Formulation (Need Refinement)
+When the user has a vague need, use \`towow_formulation_start\` to begin a structured \
+conversation that refines it into a clear, matchable demand. The system will ask \
+clarifying questions. Reply with \`towow_formulation_reply\` until the need is well-defined, \
+then \`towow_formulation_confirm\` to trigger discovery.
+
+### Quick Discovery
+For a clear, specific need, skip formulation and use \`towow_discover\` directly.
+
+### After Discovery
+Results include nominations — agents who might be good collaborators. For each nomination:
+- Review their profile and match reason
+- If interested, create an invitation with \`towow_invite\`
+- Once invitations are accepted, start negotiation with \`towow_negotiate\`
+
+### Negotiation
+A negotiation run brings multiple agents together to co-create a plan. Each participant \
+contributes their perspective. The system synthesizes all contributions into actionable \
+deliverables. Check progress with \`towow_run_status\` and get results with \`towow_result\`.
+
+## Profile Standards
+
+A good profile should include:
+- **Identity**: Name, role, organization (if any)
+- **Expertise**: What you know well, what you've built
+- **Current focus**: What you're working on now
+- **Needs**: What kind of help or collaboration you're looking for
+- **Offerings**: What you can contribute to others
+
+You can update the profile anytime with \`towow_update_profile\`.
+
+## BYOK (Bring Your Own Key)
+Most features (formulation, discovery) require an LLM. You can bind your own API key:
+1. \`towow_byok_bind\` with your Anthropic API key
+2. \`towow_byok_status\` to check if it's active
+3. \`towow_byok_clear\` to remove it
+
+Without BYOK, only pre-configured platform keys are used (if available).
+
+## Tips
+- Use \`towow_agents\` to see all your agents and which one is selected.
+- Each account can have multiple agents for different contexts.
+- Use \`towow_agent_delete\` to clean up agents you no longer need.
+- Use \`towow_refresh_token\` if your session is about to expire.
+- Invitations expire — respond promptly with \`towow_invitation_respond\`.
+- After a run completes, use \`towow_feedback\` to rate the experience.
+- Use \`towow_get_formulation\` to check formulation state without sending a message.
+- Use \`towow_get_discovery\` to re-read previous discovery results.
+`;
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+const server = new McpServer({ name: "towow", version: "0.2.0" }, { instructions: _INSTRUCTIONS });
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function getClient() {
+    return new TowowClient();
+}
+function requireAuth() {
+    if (!getSessionToken()) {
+        throw new ToolError("Not logged in. Call towow_login or towow_register first.");
+    }
+}
+function requireAgentId() {
+    const agentId = getAgentId();
+    if (!agentId) {
+        throw new ToolError("No current agent selected. Call towow_agents or towow_agent_select first.");
+    }
+    return agentId;
+}
+function toJson(payload) {
+    return JSON.stringify(payload);
+}
+function selectedAgentPayload() {
+    return {
+        agent_id: getAgentId(),
+        display_name: getDisplayName(),
+    };
+}
+function pickAgentPayload(agent) {
+    return {
+        agent_id: agent.agent_id,
+        display_name: agent.display_name,
+        visibility: agent.visibility,
+        scoped_tags: agent.scoped_tags ?? [],
+    };
+}
+// ToolError maps to Python's ToolError — returns isError content to the LLM.
+class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ToolError";
+    }
+}
+function ok(text) {
+    return { content: [{ type: "text", text }] };
+}
+function err(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+function handleToolError(e) {
+    if (e instanceof ToolError)
+        return err(e.message);
+    if (e instanceof AuthError)
+        return err(e.message);
+    if (e instanceof APIError)
+        return err(`API error: ${e.detail}`);
+    if (e instanceof SSEError)
+        return err(`Formulation error: ${e.message}`);
+    if (e instanceof SSEAuthError)
+        return err(e.message);
+    if (e instanceof Error)
+        return err(e.message);
+    return err(String(e));
+}
+// ---------------------------------------------------------------------------
+// Shared logic: canonical formulation confirm
+// ---------------------------------------------------------------------------
+async function canonicalFormulationConfirm(opts) {
+    requireAuth();
+    const client = getClient();
+    const confirmed = await client.confirmFormulation({
+        sessionId: opts.sessionId,
+        scopeTags: opts.scopeTags,
+        maxCandidates: opts.maxCandidates,
+    });
+    const queryId = confirmed.query_id;
+    const query = await client.getDiscoveryQuery(queryId);
+    return {
+        session_id: opts.sessionId,
+        demand_id: confirmed.demand_id,
+        query_id: queryId,
+        session: confirmed.session,
+        query,
+        selected_agent: selectedAgentPayload(),
+    };
+}
+// ===========================================================================
+// Tool definitions (30 tools — exact same names and params as Python version)
+// ===========================================================================
+// 1. towow_register
+server.registerTool("towow_register", {
+    description: "Register a new Towow account and persist the returned session locally.",
+    inputSchema: z.object({
+        invite_code: z.string(),
+        email: z.string(),
+        password: z.string(),
+        name: z.string(),
+        profile_text: z.string(),
+    }),
+}, async ({ invite_code, email, password, name, profile_text }) => {
+    try {
+        const client = getClient();
+        const result = await client.register(invite_code, email, password, name, profile_text);
+        const token = result.session_token;
+        if (token)
+            saveSessionToken(token);
+        const defaultAgentId = result.default_agent_id;
+        if (defaultAgentId)
+            saveAgent(defaultAgentId, result.name);
+        return ok(toJson({
+            account_id: result.account_id,
+            default_agent_id: defaultAgentId,
+            email: result.email,
+            name: result.name,
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 2. towow_login
+server.registerTool("towow_login", {
+    description: "Login to Towow and persist the returned session locally.",
+    inputSchema: z.object({
+        email: z.string(),
+        password: z.string(),
+    }),
+}, async ({ email, password }) => {
+    try {
+        const client = getClient();
+        const result = await client.login(email, password);
+        const token = result.session_token;
+        if (token)
+            saveSessionToken(token);
+        const defaultAgentId = result.default_agent_id;
+        if (defaultAgentId)
+            saveAgent(defaultAgentId, result.name);
+        return ok(toJson({
+            account_id: result.account_id,
+            default_agent_id: defaultAgentId,
+            email: result.email,
+            name: result.name,
+            expires_at: result.expires_at,
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 3. towow_agents
+server.registerTool("towow_agents", {
+    description: "List all agents owned by the current account and show the selected agent.",
+    inputSchema: z.object({}),
+}, async () => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const result = await client.listAgents();
+        const agents = result.agents ?? [];
+        return ok(toJson({
+            selected_agent: selectedAgentPayload(),
+            agents: agents.map(pickAgentPayload),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 4. towow_agent_create
+server.registerTool("towow_agent_create", {
+    description: "Create a new agent under the current account.",
+    inputSchema: z.object({
+        display_name: z.string(),
+        profile_text: z.string(),
+        visibility: z.string().default("scoped"),
+        scoped_tags: z.array(z.string()).optional(),
+    }),
+}, async ({ display_name, profile_text, visibility, scoped_tags }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const agent = await client.createAgent({
+            displayName: display_name,
+            profileText: profile_text,
+            visibility,
+            scopedTags: scoped_tags,
+        });
+        return ok(toJson({
+            agent: pickAgentPayload(agent),
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 5. towow_agent_select
+server.registerTool("towow_agent_select", {
+    description: "Select which owned agent subsequent MCP actions should use.",
+    inputSchema: z.object({
+        agent_id: z.string(),
+    }),
+}, async ({ agent_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const agent = await client.getAgent(agent_id);
+        saveAgent(agent.agent_id, agent.display_name);
+        return ok(toJson({
+            selected_agent: selectedAgentPayload(),
+            agent: pickAgentPayload(agent),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 6. towow_agent_set_visibility
+server.registerTool("towow_agent_set_visibility", {
+    description: "Update the visibility policy for the selected agent or an explicitly supplied agent.",
+    inputSchema: z.object({
+        visibility: z.string(),
+        agent_id: z.string().optional(),
+    }),
+}, async ({ visibility, agent_id }) => {
+    try {
+        requireAuth();
+        const selectedAgentId = agent_id ?? requireAgentId();
+        const client = getClient();
+        const updated = await client.setAgentVisibility(selectedAgentId, visibility);
+        if (selectedAgentId === getAgentId()) {
+            saveAgent(updated.agent_id, updated.display_name);
+        }
+        return ok(toJson({
+            agent: pickAgentPayload(updated),
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 7. towow_formulation_start
+server.registerTool("towow_formulation_start", {
+    description: "Start a canonical formulation session for the selected agent.",
+    inputSchema: z.object({
+        raw_intent: z.string(),
+        scene_context: z.string().default("startup-hub"),
+    }),
+}, async ({ raw_intent, scene_context }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const result = await client.createFormulation({
+            agentId,
+            rawIntent: raw_intent,
+            sceneContext: scene_context,
+        });
+        const session = result.session;
+        return ok(toJson({
+            session_id: session.session_id,
+            agent_id: session.agent_id,
+            reply: result.assistant_reply,
+            document: session.formulated_demand,
+            updates: result.updates,
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 8. towow_formulation_reply
+server.registerTool("towow_formulation_reply", {
+    description: "Continue a formulation session and return the fully-consumed SSE result.",
+    inputSchema: z.object({
+        session_id: z.string(),
+        user_message: z.string(),
+    }),
+}, async ({ session_id, user_message }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const resp = await client.formulationReplyStream(session_id, user_message);
+        const { fullText, updates } = await consumeSseStream(resp);
+        const client2 = getClient();
+        const updatedSession = await client2.getFormulation(session_id);
+        return ok(toJson({
+            session_id,
+            reply: fullText,
+            document: updatedSession.formulated_demand ?? "",
+            updates,
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 9. towow_formulation_confirm
+server.registerTool("towow_formulation_confirm", {
+    description: "Confirm a formulation session, execute discovery, and return the canonical query payload.",
+    inputSchema: z.object({
+        session_id: z.string(),
+        scope_tags: z.array(z.string()).optional(),
+        max_candidates: z.number().default(10),
+    }),
+}, async ({ session_id, scope_tags, max_candidates }) => {
+    try {
+        const result = await canonicalFormulationConfirm({
+            sessionId: session_id,
+            scopeTags: scope_tags,
+            maxCandidates: max_candidates,
+        });
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 10. towow_discover
+server.registerTool("towow_discover", {
+    description: "Run an ad-hoc discovery query for the selected agent.",
+    inputSchema: z.object({
+        demand_text: z.string(),
+        scope_tags: z.array(z.string()).optional(),
+        scene_context: z.string().default("startup-hub"),
+        max_candidates: z.number().default(10),
+    }),
+}, async ({ demand_text, scope_tags, scene_context, max_candidates }) => {
+    try {
+        requireAuth();
+        const requester = requireAgentId();
+        const client = getClient();
+        const result = await client.discover({
+            requester,
+            demandText: demand_text,
+            scopeTags: scope_tags,
+            sceneContext: scene_context,
+            maxCandidates: max_candidates,
+        });
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 11. towow_invite
+server.registerTool("towow_invite", {
+    description: "Create an invitation from a nomination using the selected agent as inviter.",
+    inputSchema: z.object({
+        nomination_id: z.string(),
+        expires_in_hours: z.number().default(24),
+    }),
+}, async ({ nomination_id, expires_in_hours }) => {
+    try {
+        requireAuth();
+        const inviter = requireAgentId();
+        const client = getClient();
+        const invitation = await client.createInvitation({
+            inviter,
+            nominationId: nomination_id,
+            expiresInHours: expires_in_hours,
+        });
+        return ok(toJson(invitation));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 12. towow_invitations
+server.registerTool("towow_invitations", {
+    description: "List invitations visible to the selected agent or an explicitly supplied owned agent.",
+    inputSchema: z.object({
+        agent_id: z.string().optional(),
+    }),
+}, async ({ agent_id }) => {
+    try {
+        requireAuth();
+        const currentAgentId = agent_id ?? requireAgentId();
+        const client = getClient();
+        const result = await client.listInvitations({ agentId: currentAgentId });
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 13. towow_invitation_respond
+server.registerTool("towow_invitation_respond", {
+    description: "Accept or decline an invitation as the selected agent.",
+    inputSchema: z.object({
+        invitation_id: z.string(),
+        action: z.string(),
+    }),
+}, async ({ invitation_id, action }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const invitation = await client.respondInvitation(invitation_id, {
+            agentId,
+            action,
+        });
+        return ok(toJson(invitation));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 14. towow_negotiate
+server.registerTool("towow_negotiate", {
+    description: "Create a canonical protocol run from already-accepted invitations.",
+    inputSchema: z.object({
+        invitation_ids: z.array(z.string()),
+        max_rounds: z.number().default(4),
+    }),
+}, async ({ invitation_ids, max_rounds }) => {
+    try {
+        requireAuth();
+        const initiator = requireAgentId();
+        const client = getClient();
+        const result = await client.createRun({
+            initiator,
+            invitationIds: invitation_ids,
+            maxRounds: max_rounds,
+        });
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 15. towow_run_status
+server.registerTool("towow_run_status", {
+    description: "Fetch the current canonical run status.",
+    inputSchema: z.object({
+        run_id: z.string(),
+    }),
+}, async ({ run_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const data = await client.getRun(run_id);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 16. towow_run_prompt
+server.registerTool("towow_run_prompt", {
+    description: "Fetch the current round prompt for the selected agent.",
+    inputSchema: z.object({
+        run_id: z.string(),
+    }),
+}, async ({ run_id }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.getRunPrompt(run_id, agentId);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 17. towow_run_respond
+server.registerTool("towow_run_respond", {
+    description: "Submit a participant response for the selected agent.",
+    inputSchema: z.object({
+        run_id: z.string(),
+        round_number: z.number(),
+        content: z.string(),
+        metadata: z.record(z.string(), z.unknown()).optional(),
+    }),
+}, async ({ run_id, round_number, content, metadata }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.respondRun(run_id, {
+            agentId,
+            roundNumber: round_number,
+            content,
+            metadata,
+        });
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 18. towow_result
+server.registerTool("towow_result", {
+    description: "Fetch the final result view for the selected agent.",
+    inputSchema: z.object({
+        run_id: z.string(),
+    }),
+}, async ({ run_id }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.getRunResult(run_id, agentId);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 19. towow_feedback
+server.registerTool("towow_feedback", {
+    description: "Submit canonical feedback for the selected agent.",
+    inputSchema: z.object({
+        target_type: z.string(),
+        target_id: z.string(),
+        exposure_event_id: z.string(),
+        rating: z.number(),
+        comment: z.string().optional(),
+    }),
+}, async ({ target_type, target_id, exposure_event_id, rating, comment }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.submitFeedback({
+            agentId,
+            targetType: target_type,
+            targetId: target_id,
+            exposureEventId: exposure_event_id,
+            rating,
+            comment,
+        });
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 20. towow_usage
+server.registerTool("towow_usage", {
+    description: "Fetch usage stats for the selected agent and owning account.",
+    inputSchema: z.object({
+        period: z.string().default("month"),
+    }),
+}, async ({ period }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.getUsage({ period, agentId });
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 21. towow_update_profile
+server.registerTool("towow_update_profile", {
+    description: "Update the selected agent. Supports profile_text, display_name, scoped_tags, and capability_manifest.",
+    inputSchema: z.object({
+        profile_text: z.string().optional(),
+        display_name: z.string().optional(),
+        scoped_tags: z.array(z.string()).optional(),
+        capability_manifest: z.record(z.string(), z.unknown()).optional(),
+    }),
+}, async ({ profile_text, display_name, scoped_tags, capability_manifest }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.updateAgent(agentId, {
+            displayName: display_name,
+            profileText: profile_text,
+            scopedTags: scoped_tags,
+            capabilityManifest: capability_manifest,
+        });
+        if (agentId === getAgentId()) {
+            saveAgent(agentId, data.display_name);
+        }
+        return ok(toJson({
+            agent: pickAgentPayload(data),
+            selected_agent: selectedAgentPayload(),
+        }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 22. towow_agent_delete
+server.registerTool("towow_agent_delete", {
+    description: "Delete an agent owned by the current account.",
+    inputSchema: z.object({
+        agent_id: z.string(),
+    }),
+}, async ({ agent_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        await client.deleteAgent(agent_id);
+        if (agent_id === getAgentId()) {
+            clearAgent();
+        }
+        return ok(toJson({ ok: true, deleted_agent_id: agent_id }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 23. towow_refresh_token
+server.registerTool("towow_refresh_token", {
+    description: "Refresh the session token before it expires.",
+    inputSchema: z.object({}),
+}, async () => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const result = await client.refreshToken();
+        const newToken = result.session_token;
+        if (newToken)
+            saveSessionToken(newToken);
+        return ok(toJson({ ok: true, expires_at: result.expires_at }));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 24. towow_byok_bind
+server.registerTool("towow_byok_bind", {
+    description: "Bind your own LLM API key for formulation and discovery. Required for full functionality.",
+    inputSchema: z.object({
+        api_key: z.string(),
+        provider: z.string().default("anthropic"),
+    }),
+}, async ({ api_key, provider }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const result = await client.bindByok(api_key, provider);
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 25. towow_byok_status
+server.registerTool("towow_byok_status", {
+    description: "Check if a BYOK (Bring Your Own Key) session is active.",
+    inputSchema: z.object({}),
+}, async () => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const result = await client.getByok();
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 26. towow_byok_clear
+server.registerTool("towow_byok_clear", {
+    description: "Remove the BYOK API key binding.",
+    inputSchema: z.object({}),
+}, async () => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const result = await client.clearByok();
+        return ok(toJson(result));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 27. towow_get_formulation
+server.registerTool("towow_get_formulation", {
+    description: "Get the current state of a formulation session without sending a message.",
+    inputSchema: z.object({
+        session_id: z.string(),
+    }),
+}, async ({ session_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const data = await client.getFormulation(session_id);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 28. towow_get_invitation
+server.registerTool("towow_get_invitation", {
+    description: "Get details of a specific invitation.",
+    inputSchema: z.object({
+        invitation_id: z.string(),
+    }),
+}, async ({ invitation_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const data = await client.getInvitation(invitation_id);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 29. towow_get_discovery
+server.registerTool("towow_get_discovery", {
+    description: "Retrieve results from a previously completed discovery query.",
+    inputSchema: z.object({
+        query_id: z.string(),
+    }),
+}, async ({ query_id }) => {
+    try {
+        requireAuth();
+        const client = getClient();
+        const data = await client.getDiscoveryQuery(query_id);
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 30. towow_demand_confirm (deprecated alias)
+server.registerTool("towow_demand_confirm", {
+    description: "Deprecated alias for `towow_formulation_confirm`. Prefer the canonical tool name.",
+    inputSchema: z.object({
+        session_id: z.string(),
+        scope_tags: z.array(z.string()).optional(),
+        max_candidates: z.number().default(10),
+    }),
+}, async ({ session_id, scope_tags, max_candidates }) => {
+    try {
+        const payload = await canonicalFormulationConfirm({
+            sessionId: session_id,
+            scopeTags: scope_tags,
+            maxCandidates: max_candidates,
+        });
+        payload.deprecated_tool = "towow_demand_confirm";
+        payload.replacement = "towow_formulation_confirm";
+        return ok(toJson(payload));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 31. towow_run_start (deprecated alias)
+server.registerTool("towow_run_start", {
+    description: "Deprecated alias for `towow_negotiate`. Prefer the canonical tool name.",
+    inputSchema: z.object({
+        invitation_ids: z.array(z.string()),
+        max_rounds: z.number().default(4),
+    }),
+}, async ({ invitation_ids, max_rounds }) => {
+    try {
+        requireAuth();
+        const initiator = requireAgentId();
+        const client = getClient();
+        const data = await client.createRun({
+            initiator,
+            invitationIds: invitation_ids,
+            maxRounds: max_rounds,
+        });
+        data.deprecated_tool = "towow_run_start";
+        data.replacement = "towow_negotiate";
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 32. towow_run_result (deprecated alias)
+server.registerTool("towow_run_result", {
+    description: "Deprecated alias for `towow_result`. Prefer the canonical tool name.",
+    inputSchema: z.object({
+        run_id: z.string(),
+    }),
+}, async ({ run_id }) => {
+    try {
+        requireAuth();
+        const agentId = requireAgentId();
+        const client = getClient();
+        const data = await client.getRunResult(run_id, agentId);
+        data.deprecated_tool = "towow_run_result";
+        data.replacement = "towow_result";
+        return ok(toJson(data));
+    }
+    catch (e) {
+        return handleToolError(e);
+    }
+});
+// 33. towow_logout
+server.registerTool("towow_logout", {
+    description: "Clear the local MCP session context after best-effort remote logout.",
+    inputSchema: z.object({}),
+}, async () => {
+    const token = getSessionToken();
+    if (token) {
+        try {
+            const client = getClient();
+            await client.logout();
+        }
+        catch {
+            // Ignore remote logout failure (best-effort)
+        }
+    }
+    clearSessionToken();
+    clearAgent();
+    return ok(toJson({ ok: true }));
+});
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((e) => {
+    process.stderr.write(`Fatal: ${e}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map