@ai-ecoverse/slicc-spectrum 1.1.0 → 1.2.0

package/dist/types/app/app.d.ts

@@ -1,30 +1,23 @@
 import { type TemplateResult } from 'lit';
 import type { SliccDock } from '../components/dock.js';
-import type { ColorScheme, SliccModel } from '../model/types.js';
-import { ModelElement } from './base.js';
-import { type ScreenClass } from './panels.js';
-export type Color = 'light' | 'dark';
-export declare function resolveColor(scheme: ColorScheme, prefersDark: boolean): Color;
-export declare class SliccApp extends ModelElement {
+import type { SliccModel } from '../model/types.js';
+import { ThemedElement } from './base.js';
+import { type DocumentKind, type ScreenClass } from './panels.js';
+export declare class SliccApp extends ThemedElement {
     #private;
     static properties: {
         model: {
             attribute: boolean;
         };
-        prefersDark: {
-            state: boolean;
-        };
         screen: {
             reflect: boolean;
         };
     };
-    prefersDark: boolean;
     screen: ScreenClass;
     storage: Storage | null;
     layoutKey: string;
     constructor();
     static styles: import("lit").CSSResult[];
-    get color(): Color;
     get dock(): SliccDock;
     protected subscribe(model: SliccModel): Array<() => void>;
     connectedCallback(): void;
@@ -35,6 +28,7 @@ export declare class SliccApp extends ModelElement {
     get storageKey(): string;
     resetLayout(): void;
     show(id: string): void;
+    open(kind: DocumentKind, path: string): void;
     toggleColor(): void;
     render(): TemplateResult;
 }

package/dist/types/app/base.d.ts

@@ -1,5 +1,5 @@
 import { LitElement, type PropertyValues, type TemplateResult } from 'lit';
-import type { AgentStatus, SliccModel } from '../model/types.js';
+import type { AgentStatus, ColorScheme, SliccModel } from '../model/types.js';
 export declare class ModelElement extends LitElement {
     #private;
     static properties: {
@@ -11,10 +11,18 @@ export declare class ModelElement extends LitElement {
     model: SliccModel | null;
     constructor();
     protected subscribe(model: SliccModel): Array<() => void>;
+    protected focusOn(selector: string): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
     protected willUpdate(changed: PropertyValues): void;
 }
+export type Color = 'light' | 'dark';
+export declare function resolveColor(scheme: ColorScheme, prefersDark: boolean): Color;
+export declare class ThemedElement extends ModelElement {
+    #private;
+    get color(): Color;
+    protected subscribe(model: SliccModel): Array<() => void>;
+}
 export declare const statusVariant: {
     readonly idle: 'neutral';
     readonly thinking: 'info';

package/dist/types/app/browser.d.ts

@@ -0,0 +1,25 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare function normalize(input: string): string;
+export declare class SliccBrowser extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        shot: {
+            state: boolean;
+        };
+        address: {
+            state: boolean;
+        };
+    };
+    shot: string;
+    address: string;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    render(): TemplateResult;
+}

package/dist/types/app/changes.d.ts

@@ -0,0 +1,24 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ModelElement, ThemedElement } from './base.js';
+export declare class SliccChanges extends ModelElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    render(): TemplateResult;
+}
+export declare class SliccDiffPanel extends ThemedElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        path: {};
+    };
+    path: string;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    render(): TemplateResult;
+}

package/dist/types/app/chat.d.ts

@@ -1,23 +1,11 @@
 import { type TemplateResult } from 'lit';
 import type { SliccModel } from '../model/types.js';
-import { ModelElement } from './base.js';
-export declare class SliccChat extends ModelElement {
+import { ThemedElement } from './base.js';
+export declare class SliccChat extends ThemedElement {
     #private;
-    static properties: {
-        model: {
-            attribute: boolean;
-        };
-        draft: {
-            state: boolean;
-        };
-    };
-    draft: string;
-    constructor();
     static styles: import("lit").CSSResult[];
     protected subscribe(model: SliccModel): Array<() => void>;
     protected firstUpdated(): void;
     focus(): void;
-    send(): void;
-    stop(): void;
     render(): TemplateResult;
 }

package/dist/types/app/composer.d.ts

@@ -0,0 +1,69 @@
+import { type TemplateResult } from 'lit';
+import type { Attachment, SendMode, SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare const limit: number;
+export interface Choice {
+    value: string;
+    label: string;
+    detail: string;
+}
+export interface Command {
+    name: string;
+    detail: string;
+    args?(model: SliccModel): Choice[];
+    run(model: SliccModel, agentId: string, arg: string): void;
+}
+export declare const commands: Command[];
+export type PopupKind = 'command' | 'argument' | 'mention' | 'file' | 'secret';
+export interface Popup {
+    kind: PopupKind;
+    start: number;
+    query: string;
+    items: Choice[];
+    index: number;
+}
+export declare function readFile(file: Blob): Promise<string>;
+export declare function filter(items: Choice[], query: string): Choice[];
+export declare function trigger(text: string, caret: number): {
+    kind: PopupKind;
+    start: number;
+    query: string;
+} | null;
+export declare class SliccComposer extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        value: {
+            state: boolean;
+        };
+        attachments: {
+            state: boolean;
+        };
+        popup: {
+            state: boolean;
+        };
+        dictating: {
+            state: boolean;
+        };
+    };
+    value: string;
+    attachments: Attachment[];
+    popup: Popup | null;
+    dictating: boolean;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    send(mode?: SendMode): void;
+    addFiles(files: readonly File[]): Promise<void>;
+    detach(id: string): void;
+    screenshot(): Promise<void>;
+    attachPath(path: string): Promise<void>;
+    shareSecret(name: string): void;
+    openPopup(kind: 'file' | 'secret'): void;
+    pick(choice: Choice): void;
+    dictate(): void;
+    render(): TemplateResult;
+}

package/dist/types/app/files.d.ts

@@ -0,0 +1,56 @@
+import { type TemplateResult } from 'lit';
+import type { GitStatusEntry } from '../components/file-tree.js';
+import type { Change, FileEntry, SliccModel } from '../model/types.js';
+import { ModelElement, ThemedElement } from './base.js';
+export declare function relative(path: string): string;
+export declare function basename(path: string): string;
+export declare function treePaths(entries: readonly FileEntry[]): string[];
+export declare function treeStatus(changes: readonly Change[]): GitStatusEntry[];
+export declare function ancestors(paths: readonly string[]): string[];
+export declare function agentName(model: SliccModel | null, id: string | null): string;
+export declare function request(target: EventTarget, type: 'open-file' | 'open-diff', path: string): void;
+export declare const panelCss: import("lit").CSSResult;
+export declare const letters: {
+    readonly added: 'A';
+    readonly modified: 'M';
+    readonly deleted: 'D';
+};
+export declare class SliccFiles extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        count: {
+            state: boolean;
+        };
+    };
+    count: number;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    render(): TemplateResult;
+}
+export declare class SliccFileView extends ThemedElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        path: {};
+        text: {
+            state: boolean;
+        };
+        missing: {
+            state: boolean;
+        };
+    };
+    path: string;
+    text: string | null;
+    missing: boolean;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    render(): TemplateResult;
+}

package/dist/types/app/freezer.d.ts

@@ -0,0 +1,11 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare function ago(at: number, now?: number): string;
+export declare class SliccFreezer extends ModelElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    render(): TemplateResult;
+}

package/dist/types/app/markdown.d.ts

@@ -1,5 +1,10 @@
 import { type TemplateResult } from 'lit';
-type Block = {
+export interface ListItem {
+    text: string;
+    task: boolean | null;
+    children: Block | null;
+}
+export type Block = {
     type: 'code';
     lang: string;
     text: string;
@@ -10,10 +15,15 @@ type Block = {
 } | {
     type: 'list';
     ordered: boolean;
-    items: string[];
+    items: ListItem[];
 } | {
     type: 'table';
     rows: string[][];
+} | {
+    type: 'quote';
+    text: string;
+} | {
+    type: 'rule';
 } | {
     type: 'paragraph';
     text: string;
@@ -21,4 +31,3 @@ type Block = {
 export declare function inline(text: string): TemplateResult[];
 export declare function parse(text: string): Block[];
 export declare function markdown(text: string): TemplateResult;
-export {};

package/dist/types/app/memory.d.ts

@@ -0,0 +1,39 @@
+import { type TemplateResult } from 'lit';
+import type { Memory, MemoryTag, SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export type TagFilter = MemoryTag | 'all' | 'untagged';
+export declare function visible(memories: readonly Memory[], scope: string, tag: TagFilter, query: string): Memory[];
+export declare function sections(memories: readonly Memory[]): Array<[string, Memory[]]>;
+export declare class SliccMemory extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        query: {
+            state: boolean;
+        };
+        tag: {
+            state: boolean;
+        };
+        scope: {
+            state: boolean;
+        };
+        open: {
+            state: boolean;
+        };
+        editing: {
+            state: boolean;
+        };
+    };
+    query: string;
+    tag: TagFilter;
+    scope: string;
+    open: string | null;
+    editing: string | null;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    render(): TemplateResult;
+}

package/dist/types/app/messages.d.ts

@@ -0,0 +1,21 @@
+import { nothing, type TemplateResult } from 'lit';
+import type { AssistantMessage, ErrorAction, LickChannel, LickMessage, LickState, MessagePart, SystemMessage, ToolCall, ToolMessage, UserMessage } from '../model/types.js';
+export interface Handlers {
+    color: 'light' | 'dark';
+    answer(questionId: string, answer: string): void;
+    resolve(messageId: string, state: Exclude<LickState, 'pending'>): void;
+    action(action: ErrorAction): void;
+    open(path: string): void;
+}
+export declare const lickLabels: Record<LickChannel, [string, string]>;
+export declare function time(at: number): string;
+export declare function day(at: number): string;
+export declare function size(bytes: number): string;
+export declare function tool(call: ToolCall): TemplateResult;
+export declare function parts(entries: MessagePart[], handlers: Handlers, showThinking: boolean, streaming: boolean): Array<TemplateResult | typeof nothing>;
+export declare function user(message: UserMessage): TemplateResult;
+export declare function assistant(message: AssistantMessage, name: string, model: string, handlers: Handlers, showThinking: boolean): TemplateResult;
+export declare function toolMessage(message: ToolMessage): TemplateResult;
+export declare function system(message: SystemMessage, handlers: Handlers): TemplateResult;
+export declare function lick(message: LickMessage, handlers: Handlers): TemplateResult;
+export declare const messageCss: import("lit").CSSResult;

package/dist/types/app/monitor.d.ts

@@ -0,0 +1,11 @@
+import { type TemplateResult } from 'lit';
+import type { MonitorSection, MonitorStatus, SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare function sparkline(points: readonly number[], width?: number, height?: number): string;
+export declare function health(section: MonitorSection): MonitorStatus;
+export declare class SliccMonitor extends ModelElement {
+    #private;
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    render(): TemplateResult;
+}

package/dist/types/app/panels.d.ts

@@ -1,5 +1,5 @@
-import type { SliccDock } from '../components/dock.js';
-import type { SliccModel } from '../model/types.js';
+import type { PanelParams, SliccDock } from '../components/dock.js';
+import type { SliccModel, Sprinkle } from '../model/types.js';
 export type Direction = 'left' | 'right' | 'above' | 'below' | 'within';
 export type Side = 'left' | 'center' | 'right';
 export type ScreenClass = 'phone' | 'tablet' | 'desktop';
@@ -22,10 +22,18 @@ export interface Surface {
     width?: number;
 }
 export declare const surfaces: Surface[];
+export type DocumentKind = 'file' | 'diff';
+export declare const documents: Record<DocumentKind, {
+    tag: string;
+    title(path: string): string;
+}>;
 export declare function screenClass(width: number): ScreenClass;
 export declare function surface(id: string): Surface | undefined;
-export declare function create(tag: string, model: SliccModel): HTMLElement;
+export declare function create(tag: string, model: SliccModel, params?: PanelParams): HTMLElement;
 export declare function placement(dock: SliccDock, side: Side, screen: ScreenClass): Placement;
 export declare function openSurface(dock: SliccDock, item: Surface, screen: ScreenClass): void;
+export declare function openDocument(dock: SliccDock, kind: DocumentKind, path: string, screen: ScreenClass): string;
 export declare function defaultLayout(dock: SliccDock, screen: ScreenClass): void;
 export declare function closed(dock: SliccDock): Surface[];
+export declare function sprinkleSurface(sprinkle: Sprinkle): Surface;
+export declare function openSprinkle(dock: SliccDock, sprinkle: Sprinkle, screen: ScreenClass): string;

package/dist/types/app/settings.d.ts

@@ -0,0 +1,21 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare class SliccSettings extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        pending: {
+            state: boolean;
+        };
+    };
+    pending: ReadonlySet<string>;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    connect(id: string): Promise<void>;
+    render(): TemplateResult;
+}

package/dist/types/app/spectrum.d.ts

@@ -3,6 +3,7 @@ import '@spectrum-web-components/theme/spectrum-two/theme-light.js';
 import '@spectrum-web-components/theme/spectrum-two/theme-dark.js';
 import '@spectrum-web-components/theme/spectrum-two/scale-medium.js';
 import '@spectrum-web-components/action-button/sp-action-button.js';
+import '@spectrum-web-components/action-group/sp-action-group.js';
 import '@spectrum-web-components/action-menu/sp-action-menu.js';
 import '@spectrum-web-components/badge/sp-badge.js';
 import '@spectrum-web-components/button/sp-button.js';
@@ -11,9 +12,26 @@ import '@spectrum-web-components/menu/sp-menu-divider.js';
 import '@spectrum-web-components/menu/sp-menu-item.js';
 import '@spectrum-web-components/picker/sp-picker.js';
 import '@spectrum-web-components/progress-circle/sp-progress-circle.js';
+import '@spectrum-web-components/search/sp-search.js';
+import '@spectrum-web-components/switch/sp-switch.js';
 import '@spectrum-web-components/textfield/sp-textfield.js';
 import '@spectrum-web-components/icons-workflow/icons/sp-icon-chat.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-add.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-checkmark.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-compare.js';
 import '@spectrum-web-components/icons-workflow/icons/sp-icon-contrast.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-filter.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-checkmark-circle.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-data.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-history.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-lightbulb.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-globe-grid.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-code.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-folder.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-microphone.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-refresh.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-revert.js';
 import '@spectrum-web-components/icons-workflow/icons/sp-icon-send.js';
 import '@spectrum-web-components/icons-workflow/icons/sp-icon-user-group.js';
+import '@spectrum-web-components/icons-workflow/icons/sp-icon-settings.js';
 import '@spectrum-web-components/icons-workflow/icons/sp-icon-view-grid.js';

package/dist/types/app/sprinkle.d.ts

@@ -0,0 +1,18 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ThemedElement } from './base.js';
+export declare function themed(source: string, color: 'light' | 'dark'): string;
+export declare class SliccSprinkle extends ThemedElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        sprinkle: {};
+    };
+    sprinkle: string;
+    constructor();
+    static styles: import("lit").CSSResult;
+    protected subscribe(model: SliccModel): Array<() => void>;
+    render(): TemplateResult;
+}

package/dist/types/app/terminals.d.ts

@@ -0,0 +1,25 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel } from '../model/types.js';
+import { ThemedElement } from './base.js';
+export declare function deepActive(root: Document | ShadowRoot): HTMLElement | null;
+export declare class SliccTerminals extends ThemedElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        active: {
+            state: boolean;
+        };
+    };
+    active: string;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    focus(): void;
+    select(id: string): void;
+    add(): void;
+    close(id: string): void;
+    protected updated(): void;
+    render(): TemplateResult;
+}

package/dist/types/app/tray.d.ts

@@ -0,0 +1,25 @@
+import { type TemplateResult } from 'lit';
+import type { SliccModel, TrayConnection } from '../model/types.js';
+import { ModelElement } from './base.js';
+export declare const connectionVariant: Record<TrayConnection, string>;
+export declare class SliccTray extends ModelElement {
+    #private;
+    static properties: {
+        model: {
+            attribute: boolean;
+        };
+        open: {
+            state: boolean;
+        };
+        copied: {
+            state: boolean;
+        };
+    };
+    open: boolean;
+    copied: boolean;
+    constructor();
+    static styles: import("lit").CSSResult[];
+    protected subscribe(model: SliccModel): Array<() => void>;
+    copy(): Promise<void>;
+    render(): TemplateResult;
+}

package/dist/types/components/code-view.d.ts

@@ -0,0 +1,47 @@
+export type CodeColor = 'light' | 'dark';
+interface Viewer {
+    cleanUp(): void;
+}
+declare abstract class PierreView extends HTMLElement {
+    #private;
+    static observedAttributes: string[];
+    get path(): string;
+    set path(value: string);
+    get color(): CodeColor;
+    set color(value: CodeColor);
+    protected options(): {
+        theme: {
+            light: string;
+            dark: string;
+        };
+        themeType: CodeColor;
+        overflow: 'scroll';
+        disableFileHeader: boolean;
+    };
+    protected abstract draw(container: HTMLElement): Viewer | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    refresh(): void;
+    protected empty(container: HTMLElement, text: string): null;
+}
+export declare class SliccCodeView extends PierreView {
+    #private;
+    get contents(): string | null;
+    set contents(value: string | null);
+    protected draw(container: HTMLElement): Viewer | null;
+}
+export type DiffStyle = 'unified' | 'split';
+export declare class SliccDiffView extends PierreView {
+    #private;
+    static observedAttributes: string[];
+    get oldText(): string | null;
+    set oldText(value: string | null);
+    get newText(): string | null;
+    set newText(value: string | null);
+    get diffStyle(): DiffStyle;
+    set diffStyle(value: DiffStyle);
+    protected draw(container: HTMLElement): Viewer | null;
+}
+export declare function defineCodeViews(): void;
+export {};

package/dist/types/components/file-tree.d.ts

@@ -0,0 +1,18 @@
+import { FileTree, type GitStatusEntry } from '@pierre/trees';
+export type { GitStatusEntry };
+export declare class SliccFileTree extends HTMLElement {
+    #private;
+    static loaded: boolean;
+    get paths(): readonly string[];
+    set paths(value: readonly string[]);
+    get gitStatus(): readonly GitStatusEntry[];
+    set gitStatus(value: readonly GitStatusEntry[]);
+    get expanded(): readonly string[];
+    set expanded(value: readonly string[]);
+    get tree(): FileTree | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    focus(): void;
+    reveal(path: string, focus?: boolean): void;
+}
+export declare function defineFileTree(): void;

package/dist/types/dummy/agent.d.ts

@@ -1,14 +1,32 @@
 import { Emitter } from '../model/emitter.js';
-import type { Agent, AgentEvents, AgentPort, Message } from '../model/types.js';
+import type { Agent, AgentEvents, AgentPort, FrozenCone, LickChannel, LickState, Message, Outgoing, UserMessage } from '../model/types.js';
 import type { Clock } from './clock.js';
 import { type Effects } from './script.js';
 export declare class DummyAgent extends Emitter<AgentEvents> implements AgentPort {
     #private;
-    constructor(agents: readonly Agent[], conversations: Record<string, readonly Message[]>, effects: Omit<Effects, 'agentId'>, clock: Clock);
+    constructor(agents: readonly Agent[], conversations: Record<string, readonly Message[]>, effects: Omit<Effects, 'agentId'>, clock: Clock, queues?: Record<string, readonly UserMessage[]>, frozen?: ReadonlyArray<{
+        cone: FrozenCone;
+        messages: readonly Message[];
+    }>);
     list(): readonly Agent[];
     active(): string;
     select(id: string): void;
     messages(agentId: string): readonly Message[];
-    send(agentId: string, text: string): Promise<void>;
+    queue(agentId: string): readonly UserMessage[];
+    busy(agentId: string): boolean;
+    suggestion(agentId: string): string | null;
+    unqueue(agentId: string, messageId: string): void;
+    send(agentId: string, input: string | Outgoing): Promise<void>;
     stop(agentId: string): void;
+    answer(agentId: string, questionId: string, answer: string): void;
+    resolveLick(agentId: string, messageId: string, state: Exclude<LickState, 'pending'>): void;
+    compact(agentId: string): void;
+    clear(agentId: string): void;
+    setModel(agentId: string, model: string): void;
+    createScoop(parentId: string, name: string): Agent;
+    lick(agentId: string, channel: LickChannel, title: string, text: string, body?: string): void;
+    frozen(): readonly FrozenCone[];
+    freeze(agentId: string): void;
+    thaw(id: string): Agent | null;
+    discard(id: string): void;
 }

package/dist/types/dummy/extras.d.ts

@@ -0,0 +1,8 @@
+import type { FrozenCone, Memory, Message, Sprinkle, TrayStatus } from '../model/types.js';
+export declare const frozen: Array<{
+    cone: FrozenCone;
+    messages: Message[];
+}>;
+export declare const memories: Memory[];
+export declare const sprinkles: Sprinkle[];
+export declare const tray: TrayStatus;