@agentshouse/app-bridge 0.1.0-ca4ec913df08d → 0.1.0-ca559eade7c19

package/dist/mdmodel/types.d.ts

@@ -0,0 +1,143 @@
+import type { Definition } from './definition.js';
+export type Library = Readonly<Record<string, string>>;
+export type VerifiedModel = {
+    readonly types: Readonly<Record<string, Definition>>;
+};
+export type ModelVerification = {
+    readonly verdict: 'accept';
+    readonly model: VerifiedModel;
+} | {
+    readonly verdict: 'refuse';
+    readonly rule: string;
+    readonly location?: string;
+};
+export type ValidationContext = {
+    readonly binaryTargets: readonly string[];
+};
+export type ProjectionContext = {
+    readonly documentTargets: readonly string[];
+    readonly definition?: Definition;
+};
+export type DivisionContext = ProjectionContext & {
+    readonly budget: number;
+};
+export type Extent = {
+    readonly start: number;
+    readonly end: number;
+};
+export type Span = Extent & {
+    readonly text: string;
+};
+export type Frontmatter = {
+    readonly content: string;
+    readonly type: string | undefined;
+    readonly fields: Readonly<Record<string, unknown>>;
+};
+export type Document = Frontmatter & {
+    readonly preamble: string;
+    readonly sections: Readonly<Record<string, string>>;
+};
+export type Refusal = {
+    readonly file: string;
+    readonly rule: string;
+    readonly location?: string;
+    readonly referrers?: readonly string[];
+};
+export type Reached = {
+    readonly target: string | null;
+    readonly to: readonly string[];
+};
+export type DocumentCheck = {
+    readonly ok: false;
+} | {
+    readonly ok: true;
+    readonly type: string;
+    readonly typed: boolean;
+    readonly references: readonly Reached[];
+};
+export type Validation = {
+    readonly verdict: 'accept';
+} | ({
+    readonly verdict: 'refuse';
+} & Refusal);
+export type Projection = {
+    readonly ok: true;
+    readonly text: string;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type Division = {
+    readonly ok: true;
+    readonly spans: readonly Span[];
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type FrontmatterResult = {
+    readonly ok: true;
+    readonly frontmatter: Frontmatter;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type ParseResult = {
+    readonly ok: true;
+    readonly document: Document;
+} | {
+    readonly ok: false;
+    readonly refusal: Refusal;
+};
+export type Link = {
+    readonly href: string;
+    readonly target: string;
+};
+export type LinkOccurrence = Link & {
+    readonly start: number;
+};
+export type Reference = {
+    readonly pointer: string;
+    readonly value: string;
+    readonly to: readonly string[];
+};
+export type Change = {
+    readonly kind: 'field';
+    readonly name: string;
+    readonly value: unknown;
+    readonly prior: unknown;
+} | {
+    readonly kind: 'section';
+    readonly name: string;
+    readonly value: string;
+    readonly prior: string;
+} | {
+    readonly kind: 'preamble';
+    readonly value: string;
+    readonly prior: string;
+} | {
+    readonly kind: 'link';
+    readonly href: string;
+    readonly to: string;
+} | {
+    readonly kind: 'reference';
+    readonly pointer: string;
+    readonly value: string;
+    readonly prior: string;
+};
+export type ApplyResult = {
+    readonly outcome: 'applied';
+    readonly document: Document;
+} | {
+    readonly outcome: 'stale';
+    readonly document: Document;
+} | {
+    readonly outcome: 'refuse';
+    readonly refusal: Refusal;
+};
+export type BodyResult = {
+    readonly outcome: 'applied';
+    readonly body: string;
+} | {
+    readonly outcome: 'refuse';
+    readonly refusal: Refusal;
+};

package/dist/mdmodel/validate.d.ts

@@ -0,0 +1,7 @@
+import { type Definition } from './definition.js';
+import type { DocumentCheck, Library, ModelVerification, Reached, Validation, ValidationContext, VerifiedModel } from './types.js';
+export declare function resolves(reference: Reached, typeOf: (path: string) => string | undefined, binary: (path: string) => boolean): boolean;
+export declare function verify(schema: string): ModelVerification;
+export declare function checkDocument(file: string, content: string, model: VerifiedModel): DocumentCheck;
+export declare function sectionReferences(file: string, content: string, definition: Definition): readonly Reached[];
+export declare function validate(library: Library, context?: ValidationContext, model?: VerifiedModel): Validation;

package/dist/mdmodel/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.1.0-alpha.19";

package/dist/mdmodel/yaml.d.ts

@@ -0,0 +1,55 @@
+export declare class YamlError extends Error {
+    readonly offset: number;
+    constructor(offset: number);
+}
+export type YamlScalar = {
+    readonly kind: 'scalar';
+    readonly value: string | number | boolean | null;
+    readonly start: number;
+    readonly end: number;
+};
+export type YamlSeq = {
+    readonly kind: 'seq';
+    readonly items: readonly YamlNode[];
+    readonly start: number;
+    readonly end: number;
+};
+export type YamlEntry = {
+    readonly key: string;
+    readonly after: number;
+    readonly value: YamlNode;
+};
+export type YamlMap = {
+    readonly kind: 'map';
+    readonly entries: readonly YamlEntry[];
+    readonly start: number;
+    readonly end: number;
+};
+export type YamlNode = YamlScalar | YamlSeq | YamlMap;
+export declare function interpretPlain(text: string): string | number | boolean | null;
+export declare function parseYamlMapping(text: string, start: number, end: number): YamlMap;
+export declare function jsValue(node: YamlNode): unknown;
+export declare function mapEntry(map: YamlMap, key: string): YamlEntry | undefined;
+export declare function isPlainSafe(text: string): boolean;
+export type FrontmatterValue = string | number | boolean | null | readonly FrontmatterValue[] | {
+    readonly [name: string]: FrontmatterValue;
+};
+export declare function plain(value: unknown): value is Record<string, unknown>;
+export declare function frontmatterValue(value: unknown): value is FrontmatterValue;
+export declare function serializeJs(value: FrontmatterValue): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function serializeKey(name: string): string;
+export declare function bodyStartAfterYaml(content: string, yamlEnd: number): number;
+export declare function bodyStartOf(content: string): number;
+export declare function bodyAfterFrontmatter(content: string): string;
+export declare function extractFrontmatter(content: string): {
+    kind: 'none';
+} | {
+    kind: 'unclosed';
+} | {
+    kind: 'ok';
+    yamlStart: number;
+    yamlEnd: number;
+};
+export declare function equalValue(left: unknown, right: unknown): boolean;
+export declare function lineEnding(content: string): '\n' | '\r\n';

package/dist/mdruntime/acquisition.d.ts

@@ -0,0 +1,13 @@
+export type RuntimeDemand = {
+    readonly whole: boolean;
+    readonly rooms: readonly string[];
+    readonly handles: readonly string[];
+    readonly conversations: boolean;
+};
+export declare const WHOLE_DEMAND: RuntimeDemand;
+export declare function demanded(demand: RuntimeDemand, room: {
+    readonly locator: string;
+    readonly handle: string;
+}): boolean;
+export declare function wider(next: RuntimeDemand, current: RuntimeDemand): boolean;
+export declare function narrower(next: RuntimeDemand, current: RuntimeDemand): boolean;

package/dist/mdruntime/adapter.d.ts

@@ -0,0 +1,479 @@
+import type { ModelResult } from './model.js';
+import type { Open } from './open.js';
+import type { ChangeBatch } from './change.js';
+export type Authorization = object;
+export type MdModelIdentity = {
+    identity: string;
+    version: string;
+};
+export type TypedSelection = {
+    roots: readonly string[];
+};
+export type OperationScopes = {
+    read: readonly string[];
+    sync: readonly string[];
+    write: readonly string[];
+    delete: readonly string[];
+};
+export type ReplicaAdmission = {
+    selection: string;
+    admission: Open<'admitted' | 'unavailable'>;
+};
+export type DiscoveredRoom = {
+    name: string;
+    locator: string;
+    handle: string;
+    roomVersion: string;
+    operations: OperationScopes;
+    replica: ReplicaAdmission;
+    typedSelection?: TypedSelection;
+    providerOwnedPaths: readonly string[];
+};
+export type Capability = {
+    name: string;
+    limits?: readonly ProviderLimit[];
+    actions?: readonly ActionDeclaration[];
+    conversationAgents?: ConversationAgents;
+};
+export type ConversationAgents = {
+    locator: string;
+    type: string;
+    identity: string;
+    name: string;
+    retired?: string;
+};
+export type ListedConversation = {
+    conversation: string;
+    agent: string;
+    name: string;
+    created: string;
+    finished: string | null;
+    outcome: string | null;
+};
+export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
+export type ConversationMessage = {
+    identity: string;
+    turn: string;
+    text: string;
+    message: unknown;
+};
+export type AcceptedMessage = ConversationMessage & {
+    position: string;
+};
+export type ConversationHistoryRequest = {
+    conversations: readonly {
+        conversation: string;
+        after?: string;
+    }[];
+};
+export type ConversationHistoryPage = {
+    conversation: string;
+    messages: readonly AcceptedMessage[];
+    next?: string;
+};
+export type ConversationHistories = {
+    histories: readonly ConversationHistoryPage[];
+};
+export type TurnContext = {
+    used: number;
+    window: number;
+};
+export type TurnOperation = {
+    op: 'begin';
+    at: string;
+} | {
+    op: 'start';
+    index: number;
+    part: unknown;
+} | {
+    op: 'append';
+    index: number;
+    text: string;
+} | {
+    op: 'status';
+    index: number;
+    status: string;
+    result: unknown;
+} | {
+    op: 'count';
+    index: number;
+    count: number;
+} | {
+    op: 'plan';
+    index: number;
+    entries: readonly unknown[];
+} | ({
+    op: 'context';
+} & TurnContext);
+export type ProcessCommand = {
+    [field: string]: unknown;
+    name: string;
+    description: string;
+    input?: {
+        [field: string]: unknown;
+        hint: string;
+    } | null;
+};
+type SelectValue = {
+    [field: string]: unknown;
+    value: string;
+    name: string;
+    description?: string | null;
+};
+type SelectGroup = {
+    [field: string]: unknown;
+    group: string;
+    name: string;
+    options: readonly SelectValue[];
+};
+type SessionOptionNaming = {
+    [field: string]: unknown;
+    id: string;
+    name: string;
+    description?: string | null;
+    category?: string | null;
+};
+export type SessionOption = (SessionOptionNaming & {
+    type: 'select';
+    currentValue: string;
+    options: readonly SelectValue[] | readonly SelectGroup[];
+}) | (SessionOptionNaming & {
+    type: 'boolean';
+    currentValue: boolean;
+});
+export type ConversationEvent = {
+    kind: 'turn';
+    conversation: string;
+    turn: string;
+    operation: TurnOperation;
+} | {
+    kind: 'questions';
+    conversation: string;
+    questions: readonly unknown[];
+} | {
+    kind: 'process';
+    conversation: string;
+    running: boolean;
+} | {
+    kind: 'commands';
+    conversation: string;
+    commands: readonly ProcessCommand[];
+} | {
+    kind: 'options';
+    conversation: string;
+    options: readonly SessionOption[];
+} | {
+    kind: 'accepted-message';
+    conversation: string;
+    message: AcceptedMessage;
+} | {
+    kind: 'gap';
+    conversation: string;
+} | {
+    kind: 'list';
+    entries: readonly ListedConversation[];
+} | {
+    kind: 'listed';
+    entry: ListedConversation;
+} | {
+    kind: 'unlisted';
+    conversation: string;
+};
+export type ConversationStream = {
+    replicate(conversations: readonly string[]): void;
+    observe(notify: (event: ConversationEvent) => void): () => void;
+};
+export type ActionDeclaration = {
+    name: string;
+    inputShape: unknown;
+    resultKind: unknown;
+};
+export type ProviderLimit = {
+    name: string;
+    value?: number | string;
+};
+export type HistoryRetention = {
+    kind: 'duration';
+    seconds: number;
+} | {
+    kind: 'no-declared-time-bound';
+};
+export type Retention = {
+    history: HistoryRetention;
+    outcome: number;
+    refreshHorizon: number;
+};
+export type Discovery = {
+    kind: 'discovery';
+    rooms: readonly DiscoveredRoom[];
+    capabilities: readonly Capability[];
+    providerLimits: readonly ProviderLimit[];
+    retention: Retention;
+    member?: Member;
+};
+export type TransportUncertainty = {
+    kind: 'transport-uncertainty';
+};
+export type RoomNotReadable = {
+    kind: 'room-not-readable';
+    locator: string;
+};
+export type RevokedAuthorization = {
+    kind: 'revoked-authorization';
+};
+export type ProviderRefusal = {
+    code: string;
+    fields: Readonly<Record<string, unknown>>;
+    retryable: boolean;
+};
+export type ScopedRefusal = ProviderRefusal & {
+    kind: 'scoped-refusal';
+    locator: string;
+    scope: Open<'content' | 'sync' | 'model' | 'operation' | 'undisclosed'>;
+};
+export type AdapterFailure = TransportUncertainty | RoomNotReadable | RevokedAuthorization | ScopedRefusal;
+export type ContractUnavailable = ProviderRefusal & {
+    kind: 'contract-unavailable';
+};
+export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
+export type PageToken = string;
+export type ChangeAuthor = {
+    kind: Open<'user' | 'site'>;
+    id: string;
+    name: string;
+};
+export type Member = {
+    kind: Open<'user'>;
+    id: string;
+    name: string;
+};
+export type HeadChange = {
+    author: ChangeAuthor | null;
+    time: string;
+};
+export type BinaryFile = {
+    fileRef: string;
+    byteLength: number;
+    mediaType: string;
+    sha256: string;
+};
+export type HeldContent = {
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+};
+export type BootstrapRequest = {
+    locator: string;
+    selection: string;
+    pageToken?: PageToken;
+    held?: HeldContent;
+};
+export type RoomModels = {
+    collection?: ModelResult;
+    selection?: ModelResult;
+};
+export type BootstrapPage = {
+    kind: 'bootstrap';
+    roomVersion: string;
+    models?: RoomModels;
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+    binaryFiles: Readonly<Record<string, BinaryFile>>;
+    pageToken?: PageToken;
+};
+export type BootstrapResult = BootstrapPage | {
+    kind: 'beyond-horizon';
+} | AdapterFailure;
+export type RefreshRequest = {
+    locator: string;
+    selection: string;
+    fromRoomVersion: string;
+    pageToken?: PageToken;
+};
+export type RefreshPage = {
+    kind: 'net-advancement';
+    roomVersion: string;
+    models?: RoomModels;
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+    binaryFiles: Readonly<Record<string, BinaryFile>>;
+    removals: readonly string[];
+    pageToken?: PageToken;
+};
+export type RefreshResult = {
+    kind: 'still-current';
+} | RefreshPage | {
+    kind: 'beyond-horizon';
+} | RetryableRefusal | AdapterFailure;
+export type MutationRequest = {
+    locator: string;
+    changeBatch: ChangeBatch;
+    upload?: unknown;
+};
+export type RetryableRefusal = ProviderRefusal & {
+    kind: 'retryable-refusal';
+    reset?: string;
+};
+export type ServiceMode = Open<'open' | 'write-halted'>;
+export type ServiceModeSignal = {
+    observe(notify: (mode: ServiceMode) => void): () => void;
+};
+export type MutationResult = {
+    kind: 'accepted';
+    roomVersion: string;
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
+    changes: Readonly<Record<string, HeadChange>>;
+    removals: readonly string[];
+    binaryFiles?: Readonly<Record<string, BinaryFile>>;
+    author?: string;
+    time?: string;
+} | (ProviderRefusal & {
+    kind: 'conflicted';
+    roomVersion?: string;
+    affected: Readonly<Record<string, string>>;
+}) | (ProviderRefusal & {
+    kind: 'rejected';
+    affected: Readonly<Record<string, string>>;
+}) | RetryableRefusal | {
+    kind: 'write-halted';
+} | {
+    kind: 'expired';
+    restored?: true;
+} | AdapterFailure;
+export type HistoryAuthor = {
+    kind: 'user';
+    id: string;
+} | {
+    kind: 'site';
+    id: string;
+    name: string;
+};
+export type HistoryRevision = {
+    revision: string;
+    author: HistoryAuthor;
+    time: string;
+    binaryFile?: BinaryFile;
+};
+export type HistoryRequest = {
+    locator: string;
+    path: string;
+    revision?: string;
+    pageToken?: PageToken;
+};
+export type HistoryResult = {
+    kind: 'history';
+    revisions: readonly HistoryRevision[];
+    pageToken?: PageToken;
+    deleted?: true;
+} | {
+    kind: 'revision';
+    content: string;
+} | {
+    kind: 'no-history';
+} | AdapterFailure;
+export type BinaryRequest = {
+    kind: 'path';
+    locator: string;
+    path: string;
+    revision: string;
+    fileRef?: string;
+} | {
+    kind: 'reference';
+    fileRef: string;
+    referrer: unknown;
+};
+export type ReferrerScope = {
+    kind: 'room';
+    locator: string;
+    path?: string;
+} | {
+    kind: 'conversations';
+};
+export type BinaryResult = {
+    kind: 'binary';
+    blob: Blob;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type ActionRequest = {
+    name: string;
+    input: unknown;
+};
+export type RoomVersionAt = {
+    locator: string;
+    roomVersion: string;
+};
+export type ActionResult = {
+    kind: 'action';
+    result: unknown;
+    at?: RoomVersionAt;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type HeldRoom = {
+    locator: string;
+    roomVersion: string;
+    documents: Readonly<Record<string, string>>;
+    revisions: Readonly<Record<string, string>>;
+};
+export type RoomStreamEvent = {
+    kind: 'opened';
+} | {
+    kind: 'closed';
+    revoked: boolean;
+    lost: boolean;
+} | {
+    kind: 'opening';
+    expired: readonly string[];
+} | {
+    kind: 'room-version';
+    locator: string;
+    roomVersion: string;
+};
+export type KeptReceipt = {
+    key: string;
+    head: unknown;
+};
+export type StreamReceipts = {
+    heads(): Promise<readonly KeptReceipt[]>;
+    parts(key: string, count: number): Promise<readonly unknown[]>;
+    keep(key: string, head: unknown, part?: {
+        index: number;
+        value: unknown;
+    }): Promise<void>;
+    drop(keys: readonly string[]): Promise<void>;
+};
+export type AcquiredDemand = {
+    rooms: readonly string[];
+    conversations: boolean;
+};
+export type RoomStream = {
+    hold(rooms: readonly HeldRoom[], demand: AcquiredDemand | null): void;
+    reopen(): void;
+    published(locator: string, roomVersion: string): void;
+    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts): () => void;
+};
+export type Adapter = {
+    readonly localSaves?: true;
+    readonly exhaustiveDiscovery?: true;
+    authorize(): Promise<Authorization>;
+    discover(authorization: Authorization): Promise<DiscoverResult>;
+    bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
+    refresh(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
+    mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
+    history(authorization: Authorization, request: HistoryRequest): Promise<HistoryResult>;
+    binary(authorization: Authorization, request: BinaryRequest): Promise<BinaryResult>;
+    referrerScope(referrer: unknown): ReferrerScope | null;
+    action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
+    reached(locator: string, roomVersion: string, target: string): boolean;
+    follows(locator: string, roomVersion: string, next: string): boolean;
+    roomStream?: RoomStream;
+    conversations?: ConversationStream;
+    serviceMode?: ServiceModeSignal;
+};
+export {};