@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/tool-decision-anchors.js

@@ -0,0 +1,56 @@
+import { APPROVAL_REQUESTED_EVENT_NAME, TOOL_EXECUTION_REQUESTED_EVENT_NAME, } from "../contract/events.js";
+import { MEMBER_ANSWERABLE_KINDS } from "./execution-kinds.js";
+export const EMPTY_TOOL_DECISION_ANCHORS = new Set();
+export function toolDecisionAnchorOf(name, value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const record = value;
+    const toolCallId = typeof record.tool_call_id === "string" && record.tool_call_id !== ""
+        ? record.tool_call_id
+        : null;
+    if (toolCallId === null) {
+        return null;
+    }
+    if (name === APPROVAL_REQUESTED_EVENT_NAME) {
+        return toolCallId;
+    }
+    if (name === TOOL_EXECUTION_REQUESTED_EVENT_NAME) {
+        const request = record.request;
+        if (typeof request !== "object" || request === null) {
+            return null;
+        }
+        const kind = request.kind;
+        return typeof kind === "string" && MEMBER_ANSWERABLE_KINDS.has(kind)
+            ? toolCallId
+            : null;
+    }
+    return null;
+}
+export function withToolDecisionAnchored(previous, toolCallId) {
+    if (previous.has(toolCallId)) {
+        return previous;
+    }
+    const next = new Set(previous);
+    next.add(toolCallId);
+    return next;
+}
+export function wellFormedToolDecisionAnchorsOf(stored) {
+    const seeded = new Set();
+    for (const toolCallId of stored) {
+        if (typeof toolCallId === "string") {
+            seeded.add(toolCallId);
+        }
+    }
+    return seeded;
+}
+export function toolDecisionRecorder(onDecisionAnchored) {
+    return {
+        onCustomEvent({ event }) {
+            const toolCallId = toolDecisionAnchorOf(event.name, event.value);
+            if (toolCallId !== null) {
+                onDecisionAnchored(toolCallId);
+            }
+        },
+    };
+}

package/dist/core/tool-denial-anchors.d.ts

@@ -0,0 +1,19 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface ToolDenialLedger {
+    asks: ReadonlyMap<string, string>;
+    denied: ReadonlySet<string>;
+}
+export declare const EMPTY_TOOL_DENIAL_LEDGER: ToolDenialLedger;
+export declare const EMPTY_TOOL_DENIAL_ANCHORS: ReadonlySet<string>;
+export type ToolDenialMarker = {
+    kind: "ask";
+    interruptId: string;
+    toolCallId: string;
+} | {
+    kind: "denied";
+    interruptId: string;
+};
+export declare function toolDenialMarkerOf(name: string, value: unknown): ToolDenialMarker | null;
+export declare function withToolDenialMarkerFolded(ledger: ToolDenialLedger, marker: ToolDenialMarker): ToolDenialLedger;
+export declare function wellFormedToolDenialAnchorsOf(stored: ReadonlySet<string>): ReadonlySet<string>;
+export declare function toolDenialRecorder(onMarker: (marker: ToolDenialMarker) => void): AgentSubscriber;

package/dist/core/tool-denial-anchors.js

@@ -0,0 +1,68 @@
+import { APPROVAL_REQUESTED_EVENT_NAME, APPROVAL_RESOLVED_EVENT_NAME, } from "../contract/events.js";
+import { approvalResolvedPayloadOf } from "./approval-resolved.js";
+export const EMPTY_TOOL_DENIAL_LEDGER = {
+    asks: new Map(),
+    denied: new Set(),
+};
+export const EMPTY_TOOL_DENIAL_ANCHORS = EMPTY_TOOL_DENIAL_LEDGER.denied;
+export function toolDenialMarkerOf(name, value) {
+    if (name === APPROVAL_REQUESTED_EVENT_NAME) {
+        if (typeof value !== "object" || value === null) {
+            return null;
+        }
+        const record = value;
+        const interruptId = record.interrupt_id;
+        const toolCallId = record.tool_call_id;
+        if (typeof interruptId !== "string" ||
+            interruptId === "" ||
+            typeof toolCallId !== "string" ||
+            toolCallId === "") {
+            return null;
+        }
+        return { kind: "ask", interruptId, toolCallId };
+    }
+    if (name === APPROVAL_RESOLVED_EVENT_NAME) {
+        const resolved = approvalResolvedPayloadOf(value);
+        if (resolved === null || resolved.approved) {
+            return null;
+        }
+        return { kind: "denied", interruptId: resolved.interruptId };
+    }
+    return null;
+}
+export function withToolDenialMarkerFolded(ledger, marker) {
+    if (marker.kind === "ask") {
+        if (ledger.asks.has(marker.interruptId)) {
+            return ledger;
+        }
+        const asks = new Map(ledger.asks);
+        asks.set(marker.interruptId, marker.toolCallId);
+        return { asks, denied: ledger.denied };
+    }
+    const toolCallId = ledger.asks.get(marker.interruptId);
+    if (toolCallId === undefined || ledger.denied.has(toolCallId)) {
+        return ledger;
+    }
+    const denied = new Set(ledger.denied);
+    denied.add(toolCallId);
+    return { asks: ledger.asks, denied };
+}
+export function wellFormedToolDenialAnchorsOf(stored) {
+    const seeded = new Set();
+    for (const toolCallId of stored) {
+        if (typeof toolCallId === "string") {
+            seeded.add(toolCallId);
+        }
+    }
+    return seeded;
+}
+export function toolDenialRecorder(onMarker) {
+    return {
+        onCustomEvent({ event }) {
+            const marker = toolDenialMarkerOf(event.name, event.value);
+            if (marker !== null) {
+                onMarker(marker);
+            }
+        },
+    };
+}

package/dist/core/tool-error-anchors.d.ts

@@ -0,0 +1,5 @@
+export declare const EMPTY_TOOL_ERROR_ANCHORS: ReadonlyMap<string, string>;
+export declare const toolCallErrorOf: (event: unknown) => string | null;
+export declare const withToolErrorAnchored: (previous: ReadonlyMap<string, string>, toolCallId: string, sentence: string) => ReadonlyMap<string, string>;
+export declare const wellFormedToolErrorAnchorsOf: (stored: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
+export declare const toolErrorRecorder: (onAnchored: (toolCallId: string, sentence: string) => void) => import("@ag-ui/client").AgentSubscriber;

package/dist/core/tool-error-anchors.js

@@ -0,0 +1,7 @@
+import { toolSentenceAnchorsOf } from "./tool-sentence-anchors.js";
+const anchors = toolSentenceAnchorsOf("error", { acceptEmpty: true });
+export const EMPTY_TOOL_ERROR_ANCHORS = anchors.empty;
+export const toolCallErrorOf = anchors.sentenceOf;
+export const withToolErrorAnchored = anchors.withAnchored;
+export const wellFormedToolErrorAnchorsOf = anchors.wellFormedOf;
+export const toolErrorRecorder = anchors.recorderOf;

package/dist/core/tool-flag-anchors.d.ts

@@ -0,0 +1,9 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface ToolFlagAnchors {
+    empty: ReadonlySet<string>;
+    flagOf: (event: unknown) => boolean;
+    withAnchored: (previous: ReadonlySet<string>, toolCallId: string) => ReadonlySet<string>;
+    wellFormedOf: (stored: ReadonlySet<string>) => ReadonlySet<string>;
+    recorderOf: (onAnchored: (toolCallId: string) => void) => AgentSubscriber;
+}
+export declare function toolFlagAnchorsOf(field: "cancelled" | "offloaded" | "truncated"): ToolFlagAnchors;

package/dist/core/tool-flag-anchors.js

@@ -0,0 +1,37 @@
+import { toolOutcomeOf } from "./tool-outcome.js";
+export function toolFlagAnchorsOf(field) {
+    function flagOf(event) {
+        return toolOutcomeOf(event)[field] === true;
+    }
+    return {
+        empty: new Set(),
+        flagOf,
+        withAnchored: (previous, toolCallId) => {
+            if (previous.has(toolCallId)) {
+                return previous;
+            }
+            const next = new Set(previous);
+            next.add(toolCallId);
+            return next;
+        },
+        wellFormedOf: (stored) => {
+            const seeded = new Set();
+            const entries = stored;
+            for (const toolCallId of entries) {
+                if (typeof toolCallId === "string") {
+                    seeded.add(toolCallId);
+                }
+            }
+            return seeded;
+        },
+        recorderOf: (onAnchored) => {
+            return {
+                onToolCallResultEvent({ event }) {
+                    if (flagOf(event)) {
+                        onAnchored(event.toolCallId);
+                    }
+                },
+            };
+        },
+    };
+}

package/dist/core/tool-offload-anchors.d.ts

@@ -0,0 +1,5 @@
+export declare const EMPTY_TOOL_OFFLOAD_ANCHORS: ReadonlySet<string>;
+export declare const toolCallOffloadedOf: (event: unknown) => boolean;
+export declare const withToolOffloadAnchored: (previous: ReadonlySet<string>, toolCallId: string) => ReadonlySet<string>;
+export declare const wellFormedToolOffloadAnchorsOf: (stored: ReadonlySet<string>) => ReadonlySet<string>;
+export declare const toolOffloadRecorder: (onAnchored: (toolCallId: string) => void) => import("@ag-ui/client").AgentSubscriber;

package/dist/core/tool-offload-anchors.js

@@ -0,0 +1,7 @@
+import { toolFlagAnchorsOf } from "./tool-flag-anchors.js";
+const anchors = toolFlagAnchorsOf("offloaded");
+export const EMPTY_TOOL_OFFLOAD_ANCHORS = anchors.empty;
+export const toolCallOffloadedOf = anchors.flagOf;
+export const withToolOffloadAnchored = anchors.withAnchored;
+export const wellFormedToolOffloadAnchorsOf = anchors.wellFormedOf;
+export const toolOffloadRecorder = anchors.recorderOf;

package/dist/core/tool-outcome.d.ts

@@ -0,0 +1,9 @@
+import type { BaseEvent } from "@ag-ui/core";
+import { type Observable } from "rxjs";
+declare const TOOL_OUTCOME_FIELDS: readonly ["error", "refused", "cancelled", "truncated", "offloaded"];
+type ToolOutcomeField = (typeof TOOL_OUTCOME_FIELDS)[number];
+export type ToolOutcome = Partial<Record<ToolOutcomeField, unknown>>;
+export declare function withToolOutcomeLifted(event: BaseEvent): BaseEvent;
+export declare function toolOutcomeOf(event: unknown): ToolOutcome;
+export declare function liftToolOutcome(events$: Observable<BaseEvent>): Observable<BaseEvent>;
+export {};

package/dist/core/tool-outcome.js

@@ -0,0 +1,72 @@
+import { EventType } from "@ag-ui/core";
+import { map } from "rxjs";
+const TOOL_OUTCOME_FIELDS = [
+    "error",
+    "refused",
+    "cancelled",
+    "truncated",
+    "offloaded",
+];
+const NAMESPACE = "teaflask";
+const OUTCOME_KEY = "toolOutcome";
+function _record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function withToolOutcomeLifted(event) {
+    if (event.type !== EventType.TOOL_CALL_RESULT) {
+        return event;
+    }
+    const source = event;
+    const lifted = {};
+    for (const field of TOOL_OUTCOME_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(source, field)) {
+            lifted[field] = source[field];
+        }
+    }
+    if (Object.keys(lifted).length === 0) {
+        return event;
+    }
+    const rest = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (!TOOL_OUTCOME_FIELDS.includes(key)) {
+            rest[key] = value;
+        }
+    }
+    const metadata = source.metadata === undefined ? {} : _record(source.metadata);
+    if (metadata === null) {
+        return event;
+    }
+    const namespace = _record(metadata[NAMESPACE]) ?? {};
+    const outcome = _record(namespace[OUTCOME_KEY]) ?? {};
+    rest.metadata = {
+        ...metadata,
+        [NAMESPACE]: {
+            ...namespace,
+            [OUTCOME_KEY]: { ...outcome, ...lifted },
+        },
+    };
+    return rest;
+}
+export function toolOutcomeOf(event) {
+    const source = _record(event);
+    if (source === null) {
+        return {};
+    }
+    const namespace = _record(_record(source.metadata)?.[NAMESPACE]);
+    const outcome = _record(namespace?.[OUTCOME_KEY]);
+    if (outcome === null) {
+        return {};
+    }
+    const result = {};
+    for (const field of TOOL_OUTCOME_FIELDS) {
+        if (Object.prototype.hasOwnProperty.call(outcome, field)) {
+            result[field] = outcome[field];
+        }
+    }
+    return result;
+}
+export function liftToolOutcome(events$) {
+    return events$.pipe(map(withToolOutcomeLifted));
+}

package/dist/core/tool-refusal-anchors.d.ts

@@ -0,0 +1,5 @@
+export declare const EMPTY_TOOL_REFUSAL_ANCHORS: ReadonlyMap<string, string>;
+export declare const toolCallRefusalOf: (event: unknown) => string | null;
+export declare const withToolRefusalAnchored: (previous: ReadonlyMap<string, string>, toolCallId: string, sentence: string) => ReadonlyMap<string, string>;
+export declare const wellFormedToolRefusalAnchorsOf: (stored: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
+export declare const toolRefusalRecorder: (onAnchored: (toolCallId: string, sentence: string) => void) => import("@ag-ui/client").AgentSubscriber;

package/dist/core/tool-refusal-anchors.js

@@ -0,0 +1,7 @@
+import { toolSentenceAnchorsOf } from "./tool-sentence-anchors.js";
+const anchors = toolSentenceAnchorsOf("refused", { acceptEmpty: false });
+export const EMPTY_TOOL_REFUSAL_ANCHORS = anchors.empty;
+export const toolCallRefusalOf = anchors.sentenceOf;
+export const withToolRefusalAnchored = anchors.withAnchored;
+export const wellFormedToolRefusalAnchorsOf = anchors.wellFormedOf;
+export const toolRefusalRecorder = anchors.recorderOf;

package/dist/core/tool-result-envelope.d.ts

@@ -0,0 +1,3 @@
+export declare function toolResultEnvelopePayloadOf(parsed: unknown): {
+    payload: unknown;
+} | null;

package/dist/core/tool-result-envelope.js

@@ -0,0 +1,28 @@
+export function toolResultEnvelopePayloadOf(parsed) {
+    if (!_isRecord(parsed)) {
+        return { payload: parsed };
+    }
+    const keys = Object.keys(parsed);
+    const envelopeShaped = keys.length === 2 &&
+        _hasOwn(parsed, "ok") &&
+        _hasOwn(parsed, "result") &&
+        parsed.ok === true &&
+        _isRecord(parsed.result);
+    if (!envelopeShaped) {
+        return { payload: parsed };
+    }
+    const result = parsed.result;
+    if (result.truncated === true) {
+        return null;
+    }
+    if (typeof result.status === "number" && _hasOwn(result, "body")) {
+        return { payload: result.body };
+    }
+    return { payload: result };
+}
+function _hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function _isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/core/tool-schema-anchors.d.ts

@@ -0,0 +1,18 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+import type { JsonSchema } from "./tool-view.js";
+export interface ToolCallSchemas {
+    argsSchema?: JsonSchema;
+    resultSchema?: JsonSchema;
+}
+export declare const EMPTY_TOOL_SCHEMA_ANCHORS: ReadonlyMap<string, ToolCallSchemas>;
+export declare function toolSchemaAnchorOf(value: unknown): {
+    toolCallId: string;
+    schemas: ToolCallSchemas;
+} | null;
+export declare function withToolSchemasAnchored(previous: ReadonlyMap<string, ToolCallSchemas>, toolCallId: string, schemas: ToolCallSchemas): ReadonlyMap<string, ToolCallSchemas>;
+export declare function wellFormedToolSchemaAnchorsOf(stored: ReadonlyMap<string, ToolCallSchemas>): ReadonlyMap<string, ToolCallSchemas>;
+export declare function toolSchemaRecorder(onSchemasAnchored: (toolCallId: string, schemas: ToolCallSchemas) => void): AgentSubscriber;
+export declare function approvalCardSchemasOf(card: {
+    toolInputSchema: Record<string, unknown> | null;
+    toolOutputSchema: Record<string, unknown> | null;
+}): ToolCallSchemas | null;

package/dist/core/tool-schema-anchors.js

@@ -0,0 +1,101 @@
+import { TOOL_CALL_ANNOTATED_EVENT_NAME } from "../contract/events.js";
+export const EMPTY_TOOL_SCHEMA_ANCHORS = new Map();
+export function toolSchemaAnchorOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const { tool_call_id: toolCallId, tool_input_schema, tool_output_schema, } = value;
+    if (typeof toolCallId !== "string" || toolCallId === "") {
+        return null;
+    }
+    const schemas = {};
+    const argsSchema = _schemaOf(tool_input_schema);
+    if (argsSchema !== undefined) {
+        schemas.argsSchema = argsSchema;
+    }
+    const resultSchema = _schemaOf(tool_output_schema);
+    if (resultSchema !== undefined) {
+        schemas.resultSchema = resultSchema;
+    }
+    if (schemas.argsSchema === undefined && schemas.resultSchema === undefined) {
+        return null;
+    }
+    return { toolCallId, schemas };
+}
+export function withToolSchemasAnchored(previous, toolCallId, schemas) {
+    const existing = previous.get(toolCallId);
+    if (existing === undefined) {
+        const next = new Map(previous);
+        next.set(toolCallId, schemas);
+        return next;
+    }
+    if ((existing.argsSchema !== undefined || schemas.argsSchema === undefined) &&
+        (existing.resultSchema !== undefined || schemas.resultSchema === undefined)) {
+        return previous;
+    }
+    const merged = {};
+    const argsSchema = existing.argsSchema ?? schemas.argsSchema;
+    if (argsSchema !== undefined) {
+        merged.argsSchema = argsSchema;
+    }
+    const resultSchema = existing.resultSchema ?? schemas.resultSchema;
+    if (resultSchema !== undefined) {
+        merged.resultSchema = resultSchema;
+    }
+    const next = new Map(previous);
+    next.set(toolCallId, merged);
+    return next;
+}
+export function wellFormedToolSchemaAnchorsOf(stored) {
+    const seeded = new Map();
+    const entries = stored;
+    for (const [toolCallId, schemas] of entries) {
+        if (typeof toolCallId !== "string" || !_isWellFormedSchemas(schemas)) {
+            continue;
+        }
+        seeded.set(toolCallId, schemas);
+    }
+    return seeded;
+}
+export function toolSchemaRecorder(onSchemasAnchored) {
+    return {
+        onCustomEvent({ event }) {
+            if (event.name !== TOOL_CALL_ANNOTATED_EVENT_NAME) {
+                return;
+            }
+            const anchor = toolSchemaAnchorOf(event.value);
+            if (anchor !== null) {
+                onSchemasAnchored(anchor.toolCallId, anchor.schemas);
+            }
+        },
+    };
+}
+export function approvalCardSchemasOf(card) {
+    if (card.toolInputSchema === null && card.toolOutputSchema === null) {
+        return null;
+    }
+    const schemas = {};
+    if (card.toolInputSchema !== null) {
+        schemas.argsSchema = card.toolInputSchema;
+    }
+    if (card.toolOutputSchema !== null) {
+        schemas.resultSchema = card.toolOutputSchema;
+    }
+    return schemas;
+}
+function _schemaOf(schema) {
+    if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+        return undefined;
+    }
+    return schema;
+}
+function _isWellFormedSchemas(schemas) {
+    if (typeof schemas !== "object" || schemas === null) {
+        return false;
+    }
+    const { argsSchema, resultSchema } = schemas;
+    const fieldsAreWellTypedOrAbsent = (argsSchema === undefined || _schemaOf(argsSchema) !== undefined) &&
+        (resultSchema === undefined || _schemaOf(resultSchema) !== undefined);
+    return (fieldsAreWellTypedOrAbsent &&
+        (argsSchema !== undefined || resultSchema !== undefined));
+}

package/dist/core/tool-sentence-anchors.d.ts

@@ -0,0 +1,11 @@
+import type { AgentSubscriber } from "@ag-ui/client";
+export interface ToolSentenceAnchors {
+    empty: ReadonlyMap<string, string>;
+    sentenceOf: (event: unknown) => string | null;
+    withAnchored: (previous: ReadonlyMap<string, string>, toolCallId: string, sentence: string) => ReadonlyMap<string, string>;
+    wellFormedOf: (stored: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
+    recorderOf: (onAnchored: (toolCallId: string, sentence: string) => void) => AgentSubscriber;
+}
+export declare function toolSentenceAnchorsOf(field: "error" | "refused", options: {
+    acceptEmpty: boolean;
+}): ToolSentenceAnchors;

package/dist/core/tool-sentence-anchors.js

@@ -0,0 +1,46 @@
+import { toolOutcomeOf } from "./tool-outcome.js";
+import { WIRE_SENTENCE_MAX_CHARS } from "./wire-sentence-cap.js";
+export function toolSentenceAnchorsOf(field, options) {
+    function sentenceOf(event) {
+        const value = toolOutcomeOf(event)[field];
+        if (typeof value !== "string") {
+            return null;
+        }
+        if (value === "" && !options.acceptEmpty) {
+            return null;
+        }
+        return value.slice(0, WIRE_SENTENCE_MAX_CHARS);
+    }
+    return {
+        empty: new Map(),
+        sentenceOf,
+        withAnchored: (previous, toolCallId, sentence) => {
+            if (previous.has(toolCallId)) {
+                return previous;
+            }
+            const next = new Map(previous);
+            next.set(toolCallId, sentence);
+            return next;
+        },
+        wellFormedOf: (stored) => {
+            const seeded = new Map();
+            const entries = stored;
+            for (const [toolCallId, sentence] of entries) {
+                if (typeof toolCallId === "string" && typeof sentence === "string") {
+                    seeded.set(toolCallId, sentence);
+                }
+            }
+            return seeded;
+        },
+        recorderOf: (onAnchored) => {
+            return {
+                onToolCallResultEvent({ event }) {
+                    const sentence = sentenceOf(event);
+                    if (sentence !== null) {
+                        onAnchored(event.toolCallId, sentence);
+                    }
+                },
+            };
+        },
+    };
+}

package/dist/core/tool-view.d.ts

@@ -0,0 +1,66 @@
+import type { ToolCallState } from "./tool-call-display.js";
+export type ToolViewThemeMode = "light" | "dark";
+export type JsonSchema = Record<string, unknown>;
+export interface ToolViewCall<TArgs = Record<string, unknown>, TResult = unknown> {
+    toolName: string;
+    toolCallId: string;
+    status: ToolCallState;
+    awaitingDecision: boolean;
+    args: TArgs;
+    result?: TResult;
+    resultText?: string;
+    truncated?: boolean;
+    offloaded?: boolean;
+    errorText?: string;
+    refusalText?: string;
+    argsSchema?: JsonSchema;
+    resultSchema?: JsonSchema;
+}
+export interface ToolViewProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    call: ToolViewCall<TArgs, TResult>;
+    context: {
+        themeMode: ToolViewThemeMode;
+    };
+}
+export interface ToolViewInstance<TArgs = Record<string, unknown>, TResult = unknown> {
+    update(props: ToolViewProps<TArgs, TResult>): void;
+    destroy(): void;
+}
+export interface ToolViewAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
+}
+export interface IconAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
+}
+export interface ToolViewRegistration {
+    version: number;
+    view?: ToolViewAdapter;
+    icon?: IconAdapter;
+}
+export type ToolViewRegistry = Readonly<Record<string, ToolViewRegistration>>;
+export declare function isReservedToolViewKey(key: string): boolean;
+export declare const PACKAGE_TOOL_VIEWS: ToolViewRegistry;
+export declare function actionToolName(slug: string): string;
+export declare function actionToolViews(bySlug: Readonly<Record<string, ToolViewRegistration>>): ToolViewRegistry;
+export interface ResolvedToolView {
+    rung: 1 | 2 | 3;
+    key: string;
+    adapter: ToolViewAdapter;
+}
+export interface ResolvedToolViewIcon {
+    rung: 1 | 2 | 3;
+    key: string;
+    adapter: IconAdapter;
+}
+export interface ToolViewResolution {
+    views: readonly ResolvedToolView[];
+    icons: readonly ResolvedToolViewIcon[];
+    call: ToolViewCall;
+}
+export declare function resolvedToolViewsOf(ref: {
+    key: string;
+    version: number;
+} | undefined, toolName: string, registry: ToolViewRegistry | undefined, builtIns?: ToolViewRegistry): {
+    views: readonly ResolvedToolView[];
+    icons: readonly ResolvedToolViewIcon[];
+};