@walkeros/mcp 4.5.0 → 4.5.1-next-1788726985928

package/README.md

@@ -76,7 +76,7 @@ five run locally:
 
 ## Tools
 
-The server registers 17 tools.
+The server registers 19 tools.
 
 ### Local, no account
 
@@ -103,6 +103,8 @@ The server registers 17 tools.
 | `secret_manage`    | Manage a flow's `$secret.<NAME>` values. Write-mostly, values are never returned          |
 | `observe_session`  | Start, inspect, or stop an Observe session, a time-boxed window on one running flow       |
 | `observe_journeys` | Read the assembled journeys for an observed flow, each event traced across web and server |
+| `hub_manage`       | Read a flow's release history and the reasoning behind it, and add to the discussion      |
+| `frame_manage`     | Read the frames of a measurement plan, the named rectangles and the marks inside them     |
 | `feedback`         | Send feedback about walkerOS                                                              |
 
 ## Resources

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { ListFlowsOptions, ListPreviewsOptions, GetPreviewOptions, CreatePreviewOptions, DeletePreviewOptions, ListSecretsOptions, CreateSecretOptions, UpdateSecretOptions, DeleteSecretOptions, DeployOptions, ListDeploymentsOptions, DeviceCodeResult, PollResult, FeedbackOptions } from '@walkeros/cli';
 import { Journey, JourneyGap, JourneyUnattributed } from '@walkeros/core';
-import { ZodRawShape } from 'zod';
+import { ZodRawShape, z } from 'zod';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { WebStandardStreamableHTTPServerTransportOptions } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
@@ -107,6 +107,237 @@ interface ObserveSessionRef {
     flowId: string;
     sessionId: string;
 }
+type ThreadAnchorType = 'step' | 'entity_action' | 'release' | 'contract' | 'tag';
+type StoredAnchorType = ThreadAnchorType | 'page';
+type ThreadStatus = 'open' | 'resolved';
+type ReleaseRef = {
+    versionId: string;
+} | {
+    versionNumber: number;
+};
+interface ReleaseRationaleSummaryWire {
+    hasHumanText: boolean;
+    hasGeneratedSummary: boolean;
+    firstLine: string | null;
+}
+interface FlowReleaseWire {
+    id: string;
+    deploymentId: string;
+    deploymentSlug: string | null;
+    deploymentType: string | null;
+    versionNumber: number;
+    flowVersionId: string | null;
+    flowVersionNumber: number | null;
+    status: string;
+    source: string;
+    errorCode: string | null;
+    createdAt: string;
+    createdBy: string | null;
+    createdByLabel: string | null;
+    /** Present only on a read that asked for rationale. */
+    rationale?: ReleaseRationaleSummaryWire | null;
+}
+interface ReleaseIndexWire {
+    releases: FlowReleaseWire[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+interface VersionAnnotationWire {
+    versionId: string;
+    humanText: string | null;
+    generatedSummary: string | null;
+    author: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface ReleaseDiffWire {
+    prevVersionId: string;
+    prevVersionNumber: number;
+    text: string;
+    contentIdentical: boolean;
+}
+interface ReleaseDetailWire {
+    versionId: string;
+    versionNumber: number;
+    contentHash: string | null;
+    createdAt: string;
+    createdBy: string;
+    rationale: VersionAnnotationWire | null;
+    diff: ReleaseDiffWire | null;
+}
+interface StepHistoryEntryWire {
+    versionId: string;
+    versionNumber: number;
+    createdAt: string;
+    flow: string | null;
+    change: 'added' | 'removed' | 'changed';
+    humanText: string | null;
+    generatedSummary: string | null;
+}
+interface StepHistoryWire {
+    step: string;
+    flow: string | null;
+    entries: StepHistoryEntryWire[];
+    scanned: number;
+    truncated: boolean;
+    entriesTruncated: boolean;
+    knownSteps?: string[];
+}
+interface HubMessageWire {
+    id: string;
+    author: string;
+    text: string;
+    createdAt: string;
+}
+interface HubThreadWire {
+    id: string;
+    anchorType: ThreadAnchorType;
+    anchorKey: string;
+    anchorLabel: string;
+    status: ThreadStatus;
+    resolvedByVersionId: string | null;
+    resolvedByVersionNumber: number | null;
+    resolvedAt: string | null;
+    resolvedBy: string | null;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+    messages?: HubMessageWire[];
+    hasMoreMessages?: boolean;
+}
+interface ListThreadsWire {
+    threads: HubThreadWire[];
+    hasMoreThreads: boolean;
+}
+type KnowledgeValidityWire = {
+    tier: 'release';
+    versionId: string;
+    versionNumber: number;
+    promoted: boolean;
+} | {
+    tier: 'draft';
+    versionId?: string;
+} | {
+    tier: 'none';
+};
+interface KnowledgeAuthorWire {
+    kind: 'user' | 'preview' | 'agent';
+    id: string | null;
+    label: string;
+}
+interface KnowledgeMessageWire {
+    id: string;
+    author: string;
+    authorLabel: string;
+    text: string;
+    createdAt: string;
+    clientMessageId: string | null;
+}
+interface KnowledgeEntryBaseWire {
+    id: string;
+    anchorKey: string;
+    anchorLabel: string;
+    frameId: string | null;
+    frameName: string | null;
+    flowId: string | null;
+    subjectKey: string | null;
+    /** Opaque DOM anchor plus a fractional point. Never surfaced by a tool. */
+    spatial: {
+        at: {
+            x: number;
+            y: number;
+        };
+        element?: Record<string, unknown>;
+    } | null;
+    validity: KnowledgeValidityWire;
+    freshness: 'current' | 'subject_changed' | 'unknown';
+    author: KnowledgeAuthorWire;
+    source: 'tag_mode' | 'hub' | 'mcp';
+    updatedAt: string;
+}
+interface KnowledgeThreadWire extends KnowledgeEntryBaseWire {
+    kind: 'thread';
+    anchorType: StoredAnchorType;
+    status: ThreadStatus;
+    createdAt: string;
+    messageCount: number;
+    messages?: KnowledgeMessageWire[];
+    hasMoreMessages?: boolean;
+}
+interface KnowledgeDescriptionWire extends KnowledgeEntryBaseWire {
+    kind: 'description';
+    anchorType: 'tag' | 'page';
+    body: string;
+}
+type KnowledgeEntryWire = KnowledgeThreadWire | KnowledgeDescriptionWire;
+interface ListKnowledgeWire {
+    entries: KnowledgeEntryWire[];
+    hasMoreEntries: boolean;
+}
+interface PlanSizeWire {
+    width: number;
+    height: number;
+}
+interface PlanRectWire {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface FramePlacementWire {
+    id: string;
+    rect: PlanRectWire;
+    selector?: string;
+    anchor?: Record<string, unknown>;
+}
+type FrameSourceWire = {
+    kind: 'page';
+    key: string;
+    url: string;
+} | {
+    kind: 'figma';
+    fileKey: string;
+    nodeId: string;
+} | {
+    kind: 'image';
+};
+interface FrameScreenshotWire {
+    assetId: string;
+    capturedAt: string;
+    size: PlanSizeWire;
+    dpr: number;
+    capturedRect: PlanRectWire;
+}
+interface FrameLeanWire {
+    id: string;
+    projectId: string;
+    name: string;
+    parentId: string | null;
+    placements: FramePlacementWire[];
+    size: PlanSizeWire;
+    extends: string | null;
+    source: FrameSourceWire | null;
+    origin: 'drawn' | 'imported' | 'observed';
+    flowId: string | null;
+    screenshot: FrameScreenshotWire | null;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string;
+    updatedBy: string;
+    deletedAt: string | null;
+}
+interface FrameWire extends FrameLeanWire {
+    marks: Record<string, unknown>;
+}
+interface FrameListWire {
+    frames: FrameWire[];
+}
+interface FrameLeanListWire {
+    frames: FrameLeanWire[];
+}
 /**
  * Transport-agnostic client for network-reach MCP tools. The stdio build
  * plugs in HttpToolClient (talks to the walkerOS app over HTTPS via the
@@ -211,6 +442,72 @@ interface ToolClient {
     startObserveSession?(options: StartObserveSessionOptions): Promise<ObserveSessionResult>;
     getObserveSession?(options: ObserveSessionRef): Promise<ObserveSessionResult>;
     endObserveSession?(options: ObserveSessionRef): Promise<void>;
+    listReleases(options: {
+        projectId: string;
+        flowId: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ReleaseIndexWire>;
+    getRelease(options: {
+        projectId: string;
+        flowId: string;
+        ref: ReleaseRef;
+    }): Promise<ReleaseDetailWire>;
+    listStepHistory(options: {
+        projectId: string;
+        flowId: string;
+        step: string;
+        flow?: string;
+        limit?: number;
+    }): Promise<StepHistoryWire>;
+    setReleaseRationale(options: {
+        projectId: string;
+        flowId: string;
+        versionId: string;
+        text: string;
+    }): Promise<VersionAnnotationWire>;
+    listThreads(options: {
+        projectId: string;
+        flowId: string;
+        anchorType?: ThreadAnchorType;
+        anchorKey?: string;
+        status?: ThreadStatus;
+        includeMessages: boolean;
+        limit?: number;
+    }): Promise<ListThreadsWire>;
+    createThread(options: {
+        projectId: string;
+        flowId: string;
+        anchorType: ThreadAnchorType;
+        anchorKey: string;
+        anchorLabel?: string;
+        text: string;
+    }): Promise<HubThreadWire>;
+    addThreadMessage(options: {
+        projectId: string;
+        flowId: string;
+        threadId: string;
+        text: string;
+    }): Promise<HubThreadWire>;
+    listKnowledge(options: {
+        projectId: string;
+        pageKey?: string;
+        frameId?: string;
+        markId?: string;
+        includeMessages: boolean;
+        limit?: number;
+    }): Promise<ListKnowledgeWire>;
+    listFrames(options: {
+        projectId: string;
+    }): Promise<FrameLeanListWire>;
+    listPageFrames(options: {
+        projectId: string;
+        pageKey: string;
+    }): Promise<FrameListWire>;
+    getFrame(options: {
+        projectId: string;
+        frameId: string;
+    }): Promise<FrameWire>;
     requestDeviceCode(): Promise<DeviceCodeResult>;
     pollForToken(deviceCode: string, options?: {
         timeoutMs?: number;
@@ -381,6 +678,72 @@ declare class HttpToolClient implements ToolClient {
     startObserveSession(options: StartObserveSessionOptions): Promise<ObserveSessionResult>;
     getObserveSession(options: ObserveSessionRef): Promise<ObserveSessionResult>;
     endObserveSession(options: ObserveSessionRef): Promise<void>;
+    listReleases(options: {
+        projectId: string;
+        flowId: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ReleaseIndexWire>;
+    getRelease(options: {
+        projectId: string;
+        flowId: string;
+        ref: ReleaseRef;
+    }): Promise<ReleaseDetailWire>;
+    listStepHistory(options: {
+        projectId: string;
+        flowId: string;
+        step: string;
+        flow?: string;
+        limit?: number;
+    }): Promise<StepHistoryWire>;
+    setReleaseRationale(options: {
+        projectId: string;
+        flowId: string;
+        versionId: string;
+        text: string;
+    }): Promise<VersionAnnotationWire>;
+    listThreads(options: {
+        projectId: string;
+        flowId: string;
+        anchorType?: ThreadAnchorType;
+        anchorKey?: string;
+        status?: ThreadStatus;
+        includeMessages: boolean;
+        limit?: number;
+    }): Promise<ListThreadsWire>;
+    createThread(options: {
+        projectId: string;
+        flowId: string;
+        anchorType: ThreadAnchorType;
+        anchorKey: string;
+        anchorLabel?: string;
+        text: string;
+    }): Promise<HubThreadWire>;
+    addThreadMessage(options: {
+        projectId: string;
+        flowId: string;
+        threadId: string;
+        text: string;
+    }): Promise<HubThreadWire>;
+    listKnowledge(options: {
+        projectId: string;
+        pageKey?: string;
+        frameId?: string;
+        markId?: string;
+        includeMessages: boolean;
+        limit?: number;
+    }): Promise<ListKnowledgeWire>;
+    listFrames(options: {
+        projectId: string;
+    }): Promise<FrameLeanListWire>;
+    listPageFrames(options: {
+        projectId: string;
+        pageKey: string;
+    }): Promise<FrameListWire>;
+    getFrame(options: {
+        projectId: string;
+        frameId: string;
+    }): Promise<FrameWire>;
     requestDeviceCode(): Promise<DeviceCodeResult>;
     pollForToken(deviceCode: string, options?: {
         timeoutMs?: number;
@@ -445,6 +808,142 @@ declare const HINT_EMPTY_FEED = "recordsReceived is 0: nothing has reached the f
 declare const HINT_ENDED = "Session ended and both arms detached. Start a new one with observe_session start.";
 declare const HINT_NO_WINDOW = "No Observe session on this flow. Open one with observe_session start.";
 
+/**
+ * Exported so a host asserts parity against this exact string instead of
+ * retyping it.
+ */
+declare const HUB_MANAGE_DESCRIPTION: string;
+/**
+ * One flat schema with an `action` enum and per-action optional fields, the
+ * shape `flow_manage`, `project_manage`, and `secret_manage` already use.
+ * Per-action requirements are enforced in the handler, so later actions add a
+ * field and an enum member without reshaping what callers already send.
+ *
+ * Exported so the declarative registry holds the same object rather than a
+ * second copy of it.
+ */
+declare const HUB_MANAGE_INPUT_SCHEMA: {
+    action: z.ZodEnum<{
+        releases: "releases";
+        release_get: "release_get";
+        step_history: "step_history";
+        rationale_set: "rationale_set";
+        threads: "threads";
+        note_add: "note_add";
+        knowledge: "knowledge";
+    }>;
+    projectId: z.ZodOptional<z.ZodString>;
+    flowId: z.ZodOptional<z.ZodString>;
+    versionId: z.ZodOptional<z.ZodString>;
+    versionNumber: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodString>;
+    flow: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    anchorType: z.ZodOptional<z.ZodEnum<{
+        step: "step";
+        entity_action: "entity_action";
+        release: "release";
+        contract: "contract";
+        tag: "tag";
+    }>>;
+    anchorKey: z.ZodOptional<z.ZodString>;
+    anchorLabel: z.ZodOptional<z.ZodString>;
+    threadId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        resolved: "resolved";
+    }>>;
+    pageKey: z.ZodOptional<z.ZodString>;
+    frameId: z.ZodOptional<z.ZodString>;
+    markId: z.ZodOptional<z.ZodString>;
+};
+/**
+ * Hints carry the verb ladder rather than the description. One constant per
+ * sentence the tool can emit, so the surface fixture pins wording and ordering
+ * by name and a reword fails a test instead of drifting.
+ */
+declare const HUB_HINT_RELEASE_GET = "Use action \"release_get\" with a versionId or versionNumber to read one release in full, with its diff.";
+declare const HUB_HINT_ROWS_ARE_DEPLOYMENTS = "Rows are deployments, not releases: the same versionId on several rows is a redeploy of identical content, so count distinct versionId values, and note that total counts deployments.";
+declare const HUB_HINT_STEP_HISTORY = "Use action \"step_history\" to see which releases touched one step.";
+declare const HUB_HINT_MASKED_ONLY = "The diff is empty because the only changes are inside masked values. Say that the change is not visible here rather than that nothing changed.";
+declare const HUB_HINT_TRACE_STEP = "Use action \"step_history\" to trace one step across releases.";
+declare const HUB_HINT_WRITE_RATIONALE = "This release has no human rationale. Read the diff, then use action \"rationale_set\" to record why it changed.";
+declare const HUB_HINT_SCAN_CAPPED = "The scan stopped at the entry cap, so older releases were not compared. Narrow with \"flow\" to see the whole history of one occurrence.";
+declare const HUB_HINT_NO_MATCH = "No scanned release touched this step. Check the step key against knownSteps, or raise limit to scan further back.";
+declare const HUB_HINT_OPEN_RELEASE = "Use action \"release_get\" on one of these versionIds to read the full diff and rationale.";
+declare const HUB_HINT_RATIONALE_VISIBLE = "The rationale is now visible on this release in the app.";
+declare const HUB_HINT_CONFIRM_INDEX = "Use action \"releases\" to confirm it appears in the index.";
+declare const HUB_HINT_THREADS_PAGE_CAPPED = "More threads match than were returned (the page is capped at 20 when messages are attached). Narrow with anchorType and anchorKey, or with status, rather than treating this as the complete list.";
+declare const HUB_HINT_NOTHING_DISCUSSED = "Nothing is being discussed on this flow. Use action \"note_add\" with a versionId to start a thread on a release.";
+declare const HUB_HINT_NO_THREAD_ON_ANCHOR = "No thread hangs on this anchor yet. Use action \"note_add\" to open one.";
+declare const HUB_HINT_THREADS_INDEX = "This is an index: message bodies are omitted. Pass a versionId, or anchorType with anchorKey, to read one discussion in full.";
+declare const HUB_HINT_MESSAGES_TRUNCATED = "A thread here is marked hasMoreMessages: only its newest messages were returned. Say the discussion is longer than what you read rather than summarizing it as complete.";
+declare const HUB_HINT_REPLY_OR_OPEN = "Use action \"note_add\" with a threadId to reply in one of these threads, or without one to open another.";
+declare const HUB_HINT_RESOLVE_IN_APP = "Resolving a thread into a release is done by a person in the app, not through this tool.";
+declare const HUB_HINT_MESSAGE_VISIBLE = "The message is now visible in this thread in the app.";
+declare const HUB_HINT_STAYS_RESOLVED = "This thread is resolved and stayed resolved: a reply never retracts the release link.";
+declare const HUB_HINT_READ_BACK = "Use action \"threads\" to read the discussion back.";
+declare const HUB_HINT_THREAD_OPEN = "The thread is now open on this anchor in the app.";
+declare const HUB_HINT_KEEP_ONE_THREAD = "Pass its threadId back to action \"note_add\" to keep the conversation in one place instead of opening another thread.";
+declare const HUB_HINT_KNOWLEDGE_PAGE_CAPPED = "More knowledge matches than was returned. Narrow with pageKey, then frameId, then markId, rather than treating this as everything that was written.";
+declare const HUB_HINT_NOTHING_WRITTEN = "Nothing has been written here. Notes are left on the page in Tag Mode, not through this tool.";
+declare const HUB_HINT_KNOWLEDGE_INDEX = "This is an index: message bodies are omitted. Pass markId with frameId to read one mark in full.";
+declare const HUB_HINT_ENTRY_NAMES_FLOW = "An entry names the flow it was written against in flowId, and validity says which release was live at the time.";
+declare const HUB_HINT_KNOWLEDGE_READ_ONLY = "This tool only reads knowledge. Answering a note, and settling it, are done by a person in the app.";
+declare const HUB_HINT_READ_FRAME = "Use frame_manage action \"get\" with the frameId to read the frame and its marks.";
+declare const HUB_NOT_FOUND_HINT = "Use action \"releases\" to find version ids and action \"threads\" to find thread ids.";
+
+/**
+ * Exported so a host asserts parity against this exact string instead of
+ * retyping it.
+ */
+declare const FRAME_MANAGE_DESCRIPTION: string;
+/**
+ * Exported so the declarative registry holds the same object rather than a
+ * second copy of it.
+ */
+declare const FRAME_MANAGE_INPUT_SCHEMA: {
+    action: z.ZodEnum<{
+        page: "page";
+        get: "get";
+        list: "list";
+    }>;
+    projectId: z.ZodOptional<z.ZodString>;
+    pageKey: z.ZodOptional<z.ZodString>;
+    frameId: z.ZodOptional<z.ZodString>;
+};
+/**
+ * Hints carry the verb ladder rather than the description. One constant per
+ * sentence the tool can emit, so the surface fixture pins wording and ordering
+ * by name and a reword fails a test instead of drifting.
+ */
+declare const FRAME_HINT_OPEN_PAGE_OR_GET = "Use action \"page\" with a pageKey (a frame\u2019s source.key) to read a page with marks, or action \"get\" with a frameId.";
+declare const FRAME_HINT_NAMES_ARE_DOCUMENTATION = "Frame names are documentation; the marks inside a frame carry the meaning.";
+declare const FRAME_HINT_NONE_YET = "This project has no frames yet. Frames are drawn in Tag Mode or the app, not through this tool.";
+declare const FRAME_HINT_MARK_SPACE = "Marks are in their frame\u2019s own 0..1 space; a child frame sits inside its parent through placements[].rect.";
+declare const FRAME_HINT_READ_KNOWLEDGE = "Use hub_manage action \"knowledge\" with frameId (and markId) to read what people wrote here. A markId is an id from these marks, and an entity action is addressed by its own id, never by its raw text.";
+declare const FRAME_HINT_NONE_ON_PAGE = "No frames on this page. Check the pageKey against the source.key values from action \"list\".";
+declare const FRAME_HINT_EXTENDS_BASE = "This frame extends another and stores only what it adds; read the base frame (extends) for the rest.";
+declare const FRAME_NOT_FOUND_HINT = "Use action \"list\" or \"page\" to find frame ids.";
+
+/** The code every door answers a plan or project gate with. */
+declare const FEATURE_NOT_AVAILABLE = "FEATURE_NOT_AVAILABLE";
+/** The features a door can refuse a whole tool for. */
+type GatedFeature = 'hub' | 'frames';
+/**
+ * A denial is recognised by its code, never by its wording: the two doors phrase
+ * the refusal differently and only the code is contractual.
+ */
+declare function isFeatureDenial(error: unknown): boolean;
+/**
+ * Names the feature so an agent can tell the person what is missing. Enabling
+ * it is a plan or project entitlement change made in the app, never something
+ * a tool can do, and the hint says so instead of inviting a retry.
+ */
+declare function featureDenialHint(feature: GatedFeature): string;
+
 /**
  * Wraps a user-writable string in `<user_data>…</user_data>` so the chat
  * assistant treats it as data, never as instructions. Inner `</user_data>`
@@ -528,4 +1027,4 @@ declare module '@walkeros/core' {
  */
 declare function createToolHandlers(client: ToolClient, packageVersion?: string): Record<string, ToolSpec>;
 
-export { type CreateServerOptions, type CreateStreamableHttpHandlerOptions, type FlowCanvasPayload, type FlowCanvasToolResult, HINT_EMPTY_FEED, HINT_ENDED, HINT_NO_WINDOW, HINT_PREVIEW_STREAMS, HINT_READ, HINT_SIMULATE_FIRST, HINT_STOP, HttpToolClient, type JourneysResult, type Logger, DESCRIPTION as OBSERVE_SESSION_DESCRIPTION, type RedactOptions, type SuggestionTile, TOOL_DEFINITIONS, type ToolAnnotations, type ToolClient, type ToolDefinition, type ToolSpec, createStreamableHttpHandler, createToolHandlers, createWalkerOSMcpServer, flowCanvasResult, isFlowCanvasResult, redactNestedStrings, wrapUserData };
+export { type CreateServerOptions, type CreateStreamableHttpHandlerOptions, FEATURE_NOT_AVAILABLE, FRAME_HINT_EXTENDS_BASE, FRAME_HINT_MARK_SPACE, FRAME_HINT_NAMES_ARE_DOCUMENTATION, FRAME_HINT_NONE_ON_PAGE, FRAME_HINT_NONE_YET, FRAME_HINT_OPEN_PAGE_OR_GET, FRAME_HINT_READ_KNOWLEDGE, FRAME_MANAGE_DESCRIPTION, FRAME_MANAGE_INPUT_SCHEMA, FRAME_NOT_FOUND_HINT, type FlowCanvasPayload, type FlowCanvasToolResult, type FrameLeanListWire, type FrameLeanWire, type FrameListWire, type FrameWire, type GatedFeature, HINT_EMPTY_FEED, HINT_ENDED, HINT_NO_WINDOW, HINT_PREVIEW_STREAMS, HINT_READ, HINT_SIMULATE_FIRST, HINT_STOP, HUB_HINT_CONFIRM_INDEX, HUB_HINT_ENTRY_NAMES_FLOW, HUB_HINT_KEEP_ONE_THREAD, HUB_HINT_KNOWLEDGE_INDEX, HUB_HINT_KNOWLEDGE_PAGE_CAPPED, HUB_HINT_KNOWLEDGE_READ_ONLY, HUB_HINT_MASKED_ONLY, HUB_HINT_MESSAGES_TRUNCATED, HUB_HINT_MESSAGE_VISIBLE, HUB_HINT_NOTHING_DISCUSSED, HUB_HINT_NOTHING_WRITTEN, HUB_HINT_NO_MATCH, HUB_HINT_NO_THREAD_ON_ANCHOR, HUB_HINT_OPEN_RELEASE, HUB_HINT_RATIONALE_VISIBLE, HUB_HINT_READ_BACK, HUB_HINT_READ_FRAME, HUB_HINT_RELEASE_GET, HUB_HINT_REPLY_OR_OPEN, HUB_HINT_RESOLVE_IN_APP, HUB_HINT_ROWS_ARE_DEPLOYMENTS, HUB_HINT_SCAN_CAPPED, HUB_HINT_STAYS_RESOLVED, HUB_HINT_STEP_HISTORY, HUB_HINT_THREADS_INDEX, HUB_HINT_THREADS_PAGE_CAPPED, HUB_HINT_THREAD_OPEN, HUB_HINT_TRACE_STEP, HUB_HINT_WRITE_RATIONALE, HUB_MANAGE_DESCRIPTION, HUB_MANAGE_INPUT_SCHEMA, HUB_NOT_FOUND_HINT, HttpToolClient, type HubThreadWire, type JourneysResult, type KnowledgeEntryWire, type ListKnowledgeWire, type ListThreadsWire, type Logger, DESCRIPTION as OBSERVE_SESSION_DESCRIPTION, type RedactOptions, type ReleaseDetailWire, type ReleaseIndexWire, type ReleaseRef, type StepHistoryWire, type SuggestionTile, TOOL_DEFINITIONS, type ToolAnnotations, type ToolClient, type ToolDefinition, type ToolSpec, type VersionAnnotationWire, createStreamableHttpHandler, createToolHandlers, createWalkerOSMcpServer, featureDenialHint, flowCanvasResult, isFeatureDenial, isFlowCanvasResult, redactNestedStrings, wrapUserData };