@holokai/harbor-sdk 0.3.0

package/dist/contract.d.ts

@@ -0,0 +1,613 @@
+/**
+ * THE PUBLIC WIRE of harbor's extension to MCP Apps — spelled once, here, with
+ * ZERO imports. Harbor's gate imports this module for runtime validation and
+ * the SDK client imports it for its types, so the two cannot drift.
+ *
+ * Everything here is a PROJECTION of harbor, never harbor's internals: no
+ * `RunView`, no `FusionEventMap`, no IPC `*View` — each public shape names
+ * what it keeps, and a field a hosted app needs that is not here becomes a
+ * new public field, never an import (ADR-HARBOR-012, decision 5).
+ *
+ * Versioning: `HARBOR_EXTENSION_VERSION` rides the handshake; methods and
+ * events are additive within a major.
+ */
+/** The key under `hostCapabilities.experimental` (and under a tool's `_meta`). */
+export declare const HARBOR_EXTENSION_ID = "ai.holokai/harbor";
+/** The page reader's tool name, and the `reads` mark under `_meta[HARBOR_EXTENSION_ID]` that names it. */
+export declare const HARBOR_PAGE_READER: {
+    readonly tool: "read_page";
+    readonly reads: "page";
+};
+/** The extension's own version — independent of the MCP Apps protocol version. */
+export declare const HARBOR_EXTENSION_VERSION = "0.2";
+/** The MCP Apps protocol revision harbor speaks. */
+export declare const MCP_APPS_PROTOCOL_VERSION = "2026-01-26";
+export declare const HARBOR_METHODS: {
+    readonly workflowsList: "harbor/workflows/list";
+    readonly workflowsSubmit: "harbor/workflows/submit";
+    readonly workflowsGet: "harbor/workflows/get";
+    readonly capabilitiesList: "harbor/capabilities/list";
+    readonly eventsSubscribe: "harbor/events/subscribe";
+    readonly eventsUnsubscribe: "harbor/events/unsubscribe";
+    readonly filesOpen: "harbor/files/open";
+    readonly filesAdd: "harbor/files/add";
+    readonly filesLink: "harbor/files/link";
+    readonly browserOpen: "harbor/browser/open";
+    readonly barSet: "harbor/bar/set";
+    readonly viewsOpen: "harbor/views/open";
+    readonly viewStatus: "harbor/view/status";
+};
+export type HarborMethod = (typeof HARBOR_METHODS)[keyof typeof HARBOR_METHODS];
+/** The host → view notification that carries subscribed events. */
+export declare const HARBOR_EVENT_NOTIFICATION = "harbor/notifications/event";
+/** The host → view notification that carries what the person typed or chose in the window bar. */
+export declare const HARBOR_BAR_NOTIFICATION = "harbor/notifications/bar";
+/**
+ * A run's public status. The contract's OWN union, mapped exhaustively from
+ * harbor's internal vocabulary with `unknown` as the registered fallback.
+ */
+export type WorkflowStatus = 'running' | 'held' | 'done' | 'done_with_errors' | 'failed' | 'cancelled' | 'unknown';
+/** What harbor says about one run. `title` is CONTENT (the user's goal text) and rides its own grant. */
+export interface WorkflowSummary {
+    id: string;
+    chatId: string;
+    /** Empty when the `workflows.content` grant is absent — never a placeholder. */
+    title: string;
+    status: WorkflowStatus;
+    stepCount: number;
+    startedAtMs: number | null;
+    endedAtMs: number | null;
+}
+export interface WorkflowsListParams {
+    /** 1..50, default 20. Newest first. */
+    limit?: number;
+}
+export interface WorkflowsListResult {
+    workflows: WorkflowSummary[];
+}
+export declare const WORKFLOWS_LIST_LIMIT: {
+    readonly min: 1;
+    readonly max: 50;
+    readonly default: 20;
+};
+/**
+ * One capability a DAG may name: the same four fields harbor pins for its
+ * own planner, plus whether it is the calling app's OWN tool
+ * (`mcp/<this instance>/<tool>`). Harbor's built-ins (`desktop/*`), Holo
+ * applications (`holo/<slug>`) and other connectors' tools all appear here;
+ * nothing that is disabled at the global scope does.
+ */
+export interface CapabilityEntry {
+    type: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    own: boolean;
+}
+export interface CapabilitiesListResult {
+    capabilities: CapabilityEntry[];
+}
+/**
+ * One task of a submitted DAG. `capability` must be a type from
+ * `harbor/capabilities/list`. `inputMappings` binds a dot-path INTO `input`
+ * (`messages.0.content`) to a dot-path into an upstream task's result
+ * (`results.<taskId>.data.text`) — the same convention harbor's own planner
+ * emits; the mapped slot in `input` is a `null` placeholder that the
+ * dispatcher overwrites. A mapping implies a dependency; `dependsOn` adds
+ * ordering-only edges. Every task's output is the ONE capability envelope
+ * (`{ok, version, data | error}`), so result paths start at `results.<id>.data`.
+ */
+export interface WorkflowTaskSpec {
+    id: string;
+    capability: string;
+    description?: string;
+    input?: Record<string, unknown>;
+    dependsOn?: string[];
+    inputMappings?: Record<string, string>;
+}
+export interface WorkflowsSubmitParams {
+    name: string;
+    description?: string;
+    tasks: WorkflowTaskSpec[];
+}
+export interface WorkflowsSubmitResult {
+    workflowId: string;
+    /** Task ids dispatched by the start — the DAG's roots. */
+    dispatched: string[];
+}
+export declare const WORKFLOW_TASKS_MAX = 50;
+/** A task's public state. Mapped exhaustively from harbor's internal vocabulary. */
+export type WorkflowTaskState = 'pending' | 'running' | 'done' | 'failed' | 'skipped' | 'cancelled' | 'unknown';
+export interface WorkflowTaskView {
+    id: string;
+    capability: string;
+    state: WorkflowTaskState;
+    /** The task's result envelope once it has one, else null. CONTENT: an app sees only its own workflows'. */
+    output: unknown;
+    error: {
+        code: string | null;
+        message: string | null;
+    } | null;
+}
+export interface WorkflowsGetParams {
+    workflowId: string;
+}
+export interface WorkflowsGetResult {
+    workflowId: string;
+    name: string;
+    status: WorkflowStatus;
+    tasks: WorkflowTaskView[];
+}
+/**
+ * Ask harbor to open a file this app identifies. Harbor calls `tool` on the
+ * app's OWN server with `arguments`; the tool answers a `CallToolResult` whose
+ * content holds exactly one `{type: 'resource', resource: {uri, mimeType?, blob}}`
+ * with the file's bytes base64 in `blob`. Harbor keeps its own read-only copy
+ * named `name` (a bare file name, no folders) and opens it in its editor.
+ */
+export interface FilesOpenParams {
+    name: string;
+    tool: string;
+    arguments?: Record<string, unknown>;
+}
+export interface FilesOpenResult {
+    /** The file name harbor opened the copy under. */
+    name: string;
+}
+/**
+ * Ask harbor to add a file this app identifies to the workspace the person
+ * opened this page to pick for. The same call as `harbor/files/open`: harbor
+ * calls `tool` on the app's OWN server with `arguments` for the bytes. The
+ * page never names the workspace; harbor decided it when it opened the page.
+ * Offered only to a page opened to pick files.
+ */
+export type FilesAddParams = FilesOpenParams;
+export interface FilesAddResult {
+    /** The name it was added under: a file's in the workspace, which may differ from the one asked for, or a linked folder's. */
+    name: string;
+    /** True when the workspace already had it, so nothing changed. */
+    alreadyAdded?: boolean;
+}
+/**
+ * Ask harbor to link a folder or a single file this app identifies to the
+ * workspace the person opened this page to pick for: the workspace's chats then
+ * read it, read-only, through this app's own tools, and nothing is copied.
+ * Harbor asks the app's `get_session` for the account signed in and its
+ * `item_parents` for the item, and keeps only the app, the item's id, whether
+ * it is a folder or a file, and that account. Offered only to a first-party
+ * file app's page opened to pick files.
+ */
+export interface FilesLinkParams {
+    /** A folder or file id this app's own tools gave. */
+    id: string;
+    /** The folder's address on its provider's own site, kept only when the folder is picked as a workspace's file location. */
+    url?: string;
+}
+/**
+ * Ask harbor to open a URL in the person's own browser. A view's frame is
+ * sandboxed without `allow-popups`, so a link of its own goes nowhere; this
+ * is the one way out of the frame, and the URL leaves harbor for the
+ * operating system.
+ *
+ * HTTPS ONLY, and harbor decides that on the PARSED url, not this type: a
+ * page's own check is a convenience. Anything else — `http:`, `file:`,
+ * `javascript:`, an application's own scheme, an address that does not parse
+ * — is refused with `-32602`.
+ */
+export interface BrowserOpenParams {
+    url: string;
+}
+export interface BrowserOpenResult {
+    /** The URL harbor handed over, as it parsed it. */
+    url: string;
+}
+/**
+ * A page hands harbor its search field and account menu, and harbor draws
+ * them in the window bar. Plain values only: harbor never runs page code or
+ * loads page markup there. Each call replaces the whole bar, and an absent or
+ * null field leaves that slot empty.
+ */
+export interface BarSearch {
+    placeholder: string;
+    /** The field's accessible label. */
+    label: string;
+    /** The current text: the person's own words. */
+    value: string;
+}
+export interface BarMenuItem {
+    id: string;
+    label: string;
+}
+export interface BarAccount {
+    /** Who is signed in, shown at the top of the menu. */
+    name: string;
+    items: BarMenuItem[];
+}
+export interface BarSetParams {
+    search?: BarSearch | null;
+    account?: BarAccount | null;
+}
+/** An empty object. */
+export type BarSetResult = Record<string, never>;
+/**
+ * The `harbor/notifications/bar` params: text typed in the bar's search, the
+ * id of a chosen menu item, or the id of a trail step the person pressed in
+ * harbor's window bar. A crumb's id is one the page reported in its view
+ * names' `trail`, and the page alone knows what going there means.
+ */
+export type BarInput = {
+    kind: 'search';
+    value: string;
+} | {
+    kind: 'action';
+    id: string;
+} | {
+    kind: 'crumb';
+    id: string;
+};
+/** The caps on page-supplied bar words, in characters, and on the menu's length. Harbor's gate is the one place they are enforced. */
+export declare const BAR_LIMITS: {
+    readonly placeholderChars: 60;
+    readonly labelChars: 60;
+    readonly valueChars: 500;
+    readonly nameChars: 80;
+    readonly items: 8;
+    readonly itemLabelChars: 60;
+    readonly itemIdChars: 40;
+};
+/**
+ * What a page's tray button shows about the work behind the page: harbor's
+ * own tray vocabulary, chosen by the page. `running` draws the loader in
+ * place of the extension's icon, `waiting` a dot that says the work needs
+ * the person, `completed` and `failed` a mark on the corner, and `idle` the
+ * icon alone. The button is the extension's, so the status is shared by every
+ * view of it, and the last report wins. Harbor puts it back to `idle` when
+ * the extension's last view closes.
+ */
+export declare const VIEW_STATUSES: readonly ["idle", "running", "waiting", "completed", "failed"];
+export type ViewStatus = (typeof VIEW_STATUSES)[number];
+export interface ViewStatusParams {
+    status: ViewStatus;
+}
+/** An empty object. */
+export type ViewStatusResult = Record<string, never>;
+/**
+ * Ask harbor to open THIS SAME page — the same app, the same server, the same
+ * `ui://` document — in a new window beside the one asking, booted with
+ * `view` as its saved view. That is the whole reach of the method: the params
+ * carry no app, no tool and no address, so a page can open only itself.
+ *
+ * `view` is a {@link HarborViewState}, held to {@link validateViewState}: the
+ * new page reads it back through `savedView` exactly as it would a view it
+ * reported itself, so it shows the item `view.item` names. `title` is what the
+ * new window is called until its page reports names of its own: a noun, held to
+ * {@link HARBOR_VIEW_NAME_LIMITS} like the names a page reports, and kept in
+ * memory only.
+ *
+ * The new window is the person's like any other: resized, arranged and closed
+ * by harbor, never by the page.
+ */
+export interface ViewsOpenParams {
+    title: string;
+    view: HarborViewState;
+}
+/** An empty object: the new window is harbor's, and the page is told nothing about it. */
+export type ViewsOpenResult = Record<string, never>;
+/**
+ * The five facts a page reports about its own view, spelled ONCE for every
+ * page that has a view. Mail and the file browser say the same things under
+ * different nouns — a place and an item, how the list is narrowed, what was
+ * typed, how wide the panes are — and naming them twice is how the two drift.
+ *
+ *     place   a mail place id      ·  a folder id
+ *     item    the open message id  ·  the selected entry id
+ *     filter  Unread / Flagged     ·  All / Folders / Documents
+ *     query   the search box text  ·  the search box text
+ *     panes   list + places widths ·  details width
+ *
+ * Every field is optional: a page reports what it has. `panes` is the one
+ * bag, because harbor cannot know what a page calls its panes; its keys are
+ * validated by pattern and its values are finite numbers.
+ *
+ * This is the WHOLE view, never a patch — the slot it rides is
+ * last-write-wins, so an omitted field is an erased field.
+ */
+export interface HarborViewState {
+    place?: string;
+    item?: string;
+    filter?: string;
+    query?: string;
+    panes?: Record<string, number>;
+}
+/** The caps a reported view is held to. Strings are capped; the bag is bounded both ways. */
+export declare const HARBOR_VIEW_STATE_LIMITS: {
+    /** Longest a `place`, `item`, `filter` or `query` may be. */
+    readonly valueChars: 256;
+    /** Most entries `panes` may carry. */
+    readonly paneEntries: 8;
+    /** Longest a pane name may be. */
+    readonly paneNameChars: 32;
+};
+/** The view state's capped string fields, in one list: the validator's loop and the size a saved view is held to. */
+export declare const HARBOR_VIEW_STATE_STRING_KEYS: readonly ["place", "item", "filter", "query"];
+export type HarborViewStateVerdict = {
+    ok: true;
+    value: HarborViewState;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Grade one reported view: unknown top-level keys are refused, strings are
+ * capped, and the pane bag is checked key by key. The schema IS the allowlist,
+ * so nothing undeclared survives.
+ */
+export declare function validateViewState(value: unknown): HarborViewStateVerdict;
+/**
+ * One step of the trail outside what a page has open: its name for the bar,
+ * and the page's own id for it. The id is opaque to harbor: it is handed back
+ * unchanged in a `crumb` bar input when the person presses the step, and the
+ * page resolves it against its own state.
+ */
+export interface HarborTrailStep {
+    id: string;
+    name: string;
+}
+/**
+ * The nouns a page offers for a sentence about it: what it has open, where
+ * that sits, and the steps outside it. The person's own content, so they ride
+ * the CONTENT grant and the live rail — held in memory for as long as the view
+ * is mounted and written nowhere. The view state's `item` and `place` are the
+ * first two as ids, and those are what harbor remembers.
+ *
+ * Nouns, never clauses: the host spells every other word of the sentence
+ * these appear in.
+ */
+export interface HarborViewNames {
+    /** What the page has open — a message's subject, a file's name. */
+    item?: string;
+    /** Where that sits — a mail place, a folder. */
+    place?: string;
+    /**
+     * Every step outside `item`, outermost first, each with an id the page
+     * answers to. Harbor draws them as the pressable part of its trail; a
+     * page that gives none has `place` drawn as text. A first step named for
+     * the application is its root, and makes the application's own crumb
+     * pressable.
+     */
+    trail?: HarborTrailStep[];
+}
+/** The key the nouns ride under `structuredContent`, beside the view state's own. */
+export declare const HARBOR_VIEW_NAMES_ID = "ai.holokai/harbor/names";
+/** The caps a noun is held to. Short: it goes in a sentence, not a document. */
+export declare const HARBOR_VIEW_NAME_LIMITS: {
+    /** Longest an `item`, `place` or step name may be; a longer one is not kept. */
+    readonly nameChars: 120;
+    /** Most steps a trail may hold; past it, the first step and the innermost ones are kept. */
+    readonly trailSteps: 12;
+    /** Longest a step's id may be; a step with a longer one, or one holding a control character, is not kept. */
+    readonly stepIdChars: 256;
+};
+export type HarborViewNamesVerdict = {
+    ok: true;
+    value: HarborViewNames;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Grade the nouns: unknown keys are refused and a wrong type is refused, but
+ * a name that is too long — or empty once its control characters are gone —
+ * is simply not kept, so one unusable noun never costs the report the other.
+ * A trail keeps its first steps up to the cap, and drops a step whose name or
+ * id is unusable; a trail with no usable step is not kept.
+ */
+export declare function validateViewNames(value: unknown): HarborViewNamesVerdict;
+/**
+ * The params of `ui/update-model-context`, the spec's own method for telling
+ * the host what the view is showing. Harbor accepts it under the two `view.*`
+ * grants: the `structuredContent` half carries the view state under
+ * {@link HARBOR_EXTENSION_ID} and the nouns under {@link HARBOR_VIEW_NAMES_ID},
+ * the `content` half carries text for the model. Harbor advertises the
+ * modalities it takes, so a page feature-detects rather than probing.
+ */
+export declare const UPDATE_MODEL_CONTEXT_PARAMS_SCHEMA: JsonSchemaObject;
+/** What harbor hands a booting page back under {@link HARBOR_EXTENSION_ID} in `hostContext`. */
+export interface HarborHostContext {
+    /** The view harbor saved for this page, or null when it has none. */
+    viewState: HarborViewState | null;
+}
+/**
+ * Every public event, with the payload a view receives. Each is a projection
+ * of one harbor-internal event; the projection (which fields survive) lives
+ * in harbor, and the view only ever sees these shapes.
+ */
+export interface HarborEventMap {
+    /** Harbor's liveness tick — diagnostic, ungated. */
+    'harbor.heartbeat': {
+        count: number;
+    };
+    /** A run was created or changed. An INVALIDATION signal: re-read on a `seq` gap. */
+    'run.changed': {
+        workflow: WorkflowSummary;
+    };
+    /** A task of a workflow THIS app submitted moved. Progress is numbers only. */
+    'workflow.task': {
+        workflowId: string;
+        taskId: string;
+        state: WorkflowTaskState;
+        progress?: {
+            percent?: number;
+            outputTokens?: number;
+            reasoningTokens?: number;
+        };
+    };
+    /** A workflow this app submitted started or ended. On a terminal status, read it back. */
+    'workflow.changed': {
+        workflowId: string;
+        status: WorkflowStatus;
+    };
+    /**
+     * The app's own server told its open views something, named by the server. Delivered as sent,
+     * not a projection of anything harbor holds; on a `seq` gap the view re-reads from its server.
+     */
+    'server.notification': {
+        name: string;
+        params: Record<string, unknown>;
+    };
+}
+export type HarborEventName = keyof HarborEventMap;
+/** The closed set, as data, for runtime checks. */
+export declare const HARBOR_EVENT_NAMES: readonly HarborEventName[];
+export interface EventsSubscribeParams {
+    events: HarborEventName[];
+}
+export interface EventsSubscribeResult {
+    subscriptionId: string;
+    events: HarborEventName[];
+}
+export interface EventsUnsubscribeParams {
+    subscriptionId: string;
+}
+/** An empty object — JSON-RPC results are objects, never bare scalars. */
+export type EventsUnsubscribeResult = Record<string, never>;
+/**
+ * The `harbor/notifications/event` params. `seq` is PER SUBSCRIPTION, starts
+ * at 1 and increments by one per delivered event; a skipped number means an
+ * event was lost and the view re-reads its snapshot. There is no replay.
+ */
+export interface HarborEventNotificationParams<K extends HarborEventName = HarborEventName> {
+    subscriptionId: string;
+    seq: number;
+    event: K;
+    payload: HarborEventMap[K];
+}
+/** Method → its params and result, for typed clients and typed gates alike. */
+export interface HarborMethodMap {
+    'harbor/workflows/list': {
+        params: WorkflowsListParams;
+        result: WorkflowsListResult;
+    };
+    'harbor/workflows/submit': {
+        params: WorkflowsSubmitParams;
+        result: WorkflowsSubmitResult;
+    };
+    'harbor/workflows/get': {
+        params: WorkflowsGetParams;
+        result: WorkflowsGetResult;
+    };
+    'harbor/capabilities/list': {
+        params: Record<string, never>;
+        result: CapabilitiesListResult;
+    };
+    'harbor/events/subscribe': {
+        params: EventsSubscribeParams;
+        result: EventsSubscribeResult;
+    };
+    'harbor/events/unsubscribe': {
+        params: EventsUnsubscribeParams;
+        result: EventsUnsubscribeResult;
+    };
+    'harbor/files/open': {
+        params: FilesOpenParams;
+        result: FilesOpenResult;
+    };
+    'harbor/files/add': {
+        params: FilesAddParams;
+        result: FilesAddResult;
+    };
+    'harbor/files/link': {
+        params: FilesLinkParams;
+        result: FilesAddResult;
+    };
+    'harbor/browser/open': {
+        params: BrowserOpenParams;
+        result: BrowserOpenResult;
+    };
+    'harbor/bar/set': {
+        params: BarSetParams;
+        result: BarSetResult;
+    };
+    'harbor/views/open': {
+        params: ViewsOpenParams;
+        result: ViewsOpenResult;
+    };
+    'harbor/view/status': {
+        params: ViewStatusParams;
+        result: ViewStatusResult;
+    };
+}
+/**
+ * The JSON Schema subset the wire is validated against: top-level `type`,
+ * `properties`, `required`, and per-property `type` / `enum`. Undeclared
+ * fields are refused — the schema IS the allowlist. Nested shapes are checked
+ * by the handler, which is why `events` names its closed set again in
+ * `HARBOR_EVENT_NAMES`, and why the bar's caps (`BAR_LIMITS`) are enforced by
+ * harbor's gate and nowhere here.
+ */
+export interface JsonSchemaObject {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        enum?: readonly string[];
+        description?: string;
+    }>;
+    required?: readonly string[];
+}
+export declare const HARBOR_METHOD_PARAMS_SCHEMA: Record<HarborMethod, JsonSchemaObject>;
+/**
+ * The closed grant vocabulary. Content (a run's title) and metadata (its
+ * status, timestamps) are DIFFERENT grants from day one, and a reported view
+ * splits the same way: `view.state` lets harbor remember the structured view
+ * and hand it back, `view.content` lets what a page says it is showing — its
+ * words and the names of what it has open — reach the window's report.
+ * `bar.set` lets a page hand its search field and account menu to the window
+ * bar, and receive what the person types or chooses there. `views.open` lets
+ * a page open itself again in a new window beside its own. `files.add` lets a
+ * page opened to pick files add one to the workspace it was opened for, or
+ * link a folder to it. `view.state` also admits `harbor/view/status`: the
+ * standing a page gives its own tray button is part of the view harbor keeps
+ * for it, and carries none of the page's words.
+ */
+export type HarborGrant = 'workflows.read' | 'workflows.content' | 'workflows.submit' | 'capabilities.read' | 'server.tools' | 'server.resources' | 'events.runs' | 'events.diagnostic' | 'files.open' | 'files.add' | 'browser.open' | 'view.state' | 'view.content' | 'bar.set' | 'views.open';
+/**
+ * The grants an extension must declare in its manifest to be given: harbor
+ * gives one to no extension that does not name it, whatever else it is given.
+ */
+export type DeclaredGrant = Extract<HarborGrant, 'files.add'>;
+/**
+ * Every method and every event, tied to its grant — exhaustive, so a new
+ * name cannot ship ungated. `by-params` is an explicit row, not an omission:
+ * the method itself is open, and the grant check runs against the names its
+ * params carry (a subscribe is gated per event).
+ */
+export declare const HARBOR_GRANT_OF: Record<HarborMethod | HarborEventName, HarborGrant | 'by-params'>;
+/**
+ * The grants behind the STANDARD MCP Apps methods harbor answers, which are
+ * not `harbor/*` names and so live outside `HARBOR_GRANT_OF`'s key set.
+ * Spelled here so the vocabulary stays one table.
+ *
+ * A LIST means any one of them admits the method, and each half of its params
+ * is then gated on its own: withholding one grant leaves the other half
+ * working, and withholding both makes the method absent like any other
+ * ungranted one.
+ */
+export declare const STANDARD_METHOD_GRANT_OF: {
+    readonly 'tools/call': "server.tools";
+    readonly 'resources/list': "server.resources";
+    readonly 'resources/read': "server.resources";
+    readonly 'ui/update-model-context': readonly ["view.state", "view.content"];
+};
+/** The grant a field inside a result needs, beyond the method's own. */
+export declare const WORKFLOW_TITLE_GRANT: HarborGrant;
+/**
+ * What harbor advertises under `hostCapabilities.experimental[HARBOR_EXTENSION_ID]`
+ * in the `ui/initialize` result: ONLY what this view is granted. The list is
+ * therefore the permission disclosure too, and a client feature-detects per
+ * method. An ungranted method answers `-32601` like an absent one.
+ */
+export interface HarborHostExtension {
+    version: string;
+    methods: HarborMethod[];
+    events: HarborEventName[];
+}

package/dist/contract.js

@@ -0,0 +1,51 @@
+import {createRequire as __harborCreateRequire} from 'node:module'; const require = __harborCreateRequire(import.meta.url);
+import {
+  BAR_LIMITS,
+  HARBOR_BAR_NOTIFICATION,
+  HARBOR_EVENT_NAMES,
+  HARBOR_EVENT_NOTIFICATION,
+  HARBOR_EXTENSION_ID,
+  HARBOR_EXTENSION_VERSION,
+  HARBOR_GRANT_OF,
+  HARBOR_METHODS,
+  HARBOR_METHOD_PARAMS_SCHEMA,
+  HARBOR_PAGE_READER,
+  HARBOR_VIEW_NAMES_ID,
+  HARBOR_VIEW_NAME_LIMITS,
+  HARBOR_VIEW_STATE_LIMITS,
+  HARBOR_VIEW_STATE_STRING_KEYS,
+  MCP_APPS_PROTOCOL_VERSION,
+  STANDARD_METHOD_GRANT_OF,
+  UPDATE_MODEL_CONTEXT_PARAMS_SCHEMA,
+  VIEW_STATUSES,
+  WORKFLOWS_LIST_LIMIT,
+  WORKFLOW_TASKS_MAX,
+  WORKFLOW_TITLE_GRANT,
+  validateViewNames,
+  validateViewState
+} from "./chunks/chunk-G4KJ2OCU.js";
+export {
+  BAR_LIMITS,
+  HARBOR_BAR_NOTIFICATION,
+  HARBOR_EVENT_NAMES,
+  HARBOR_EVENT_NOTIFICATION,
+  HARBOR_EXTENSION_ID,
+  HARBOR_EXTENSION_VERSION,
+  HARBOR_GRANT_OF,
+  HARBOR_METHODS,
+  HARBOR_METHOD_PARAMS_SCHEMA,
+  HARBOR_PAGE_READER,
+  HARBOR_VIEW_NAMES_ID,
+  HARBOR_VIEW_NAME_LIMITS,
+  HARBOR_VIEW_STATE_LIMITS,
+  HARBOR_VIEW_STATE_STRING_KEYS,
+  MCP_APPS_PROTOCOL_VERSION,
+  STANDARD_METHOD_GRANT_OF,
+  UPDATE_MODEL_CONTEXT_PARAMS_SCHEMA,
+  VIEW_STATUSES,
+  WORKFLOWS_LIST_LIMIT,
+  WORKFLOW_TASKS_MAX,
+  WORKFLOW_TITLE_GRANT,
+  validateViewNames,
+  validateViewState
+};

package/dist/holokai-logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The Holokai logo, the holokai.ai website's PNG (566 by 566 pixels), as a data URI, so a page
+ * shows it with no file beside it and no request.
+ */
+export declare const HOLOKAI_LOGO_PNG = "data:image/png;base64,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";