@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/A-FrameChannel.component-DYV8omYR.d.ts

@@ -0,0 +1,379 @@
+import { A_TYPES__Entity_Serialized, A_Entity, A_Scope, A_Fragment, A_Component } from '@adaas/a-concept';
+import { I as IA_Frame_Channel, c as A_FrameChannelRequest, p as A_Frame_GenerateResponse, o as A_Frame_EmbedResponse, n as A_Frame_CredentialResponse } from './A-FrameChannel.types-C-gxXl8m.js';
+import { A_FrameEnv } from './env.js';
+import { A as A_FrameDefinition } from './A-FrameDefinition.entity-Bt9ua6cn.js';
+import { A as A_FrameNamespace } from './A-FrameNamespace.entity-D3fZBGDx.js';
+import { m as A_FrameDynamicPatch_Serialized, n as A_FrameDynamicPatch, A as A_FrameDynamicStructure, o as A_FrameDynamicStructureOperation } from './A-FrameDynamicStructure.entity-DxkPP9mR.js';
+import { A_FrameVector } from './vector.js';
+
+type A_FrameDynamicSession_Init = {
+    turnsCount: number;
+};
+type A_FrameDynamicSession_Serialized = {
+    turnsCount: number;
+    currentTurn: number;
+    initDate: string;
+} & A_TYPES__Entity_Serialized;
+
+declare class A_FrameDynamicSession extends A_Entity<A_FrameDynamicSession_Init, A_FrameDynamicSession_Serialized> {
+    static get concept(): string;
+    /**
+     *
+     */
+    protected _scope: A_Scope;
+    protected _turnsCount: number;
+    protected _currentTurn: number;
+    protected _initDate: string;
+    /**
+     *
+     */
+    get scope(): A_Scope;
+    get currentTurn(): number;
+    get initDate(): Date;
+    static onQuestion(): void;
+    static onAnswer(): void;
+    fromNew(newEntity: A_FrameDynamicSession_Init): void;
+    fromJSON(serialized: A_FrameDynamicSession_Serialized): void;
+    init(): Promise<void>;
+    destroy(scope?: A_Scope): Promise<void>;
+    question(): Promise<void>;
+    answer(): Promise<void>;
+    toJSON(): A_FrameDynamicSession_Serialized;
+}
+
+/**
+ * Lightweight segment representation used over the HTTP wire.
+ * `embedding` is always `number[]` (JSON-serialised), never `Float32Array`.
+ * The channel layer converts this to/from `A_FrameSegment` domain objects.
+ */
+interface A_FrameContentSegmentWire {
+    /** Text content of the segment */
+    content: string;
+    /** Embedding vector as plain number array */
+    embedding?: number[];
+    /** Name of the model that produced the embedding */
+    model?: string;
+}
+type A_FrameDynamicContentOptions = {
+    /** Which AI model to use */
+    model: string;
+    /**
+     * The maximum number of pieces to include in a patch request. This limits the scope of changes and helps control costs.
+     * The server will select the most relevant pieces based on the instruction and this limit.
+     * If not specified, defaults to A_FrameDynamicContentIndex.PATCH_PIECE_LIMIT.
+     */
+    patchPieceLimit: number;
+};
+type A_FrameDynamicContent_Init = {
+    /** The generation prompt */
+    prompt: string;
+    /**
+     * Optional configuration parameters for generation and patching behavior. This can include model selection, patch piece limits, and other options that influence how the content is generated and modified.
+     */
+    options?: Partial<A_FrameDynamicContentOptions>;
+};
+type A_FrameDynamicContent_Serialized = {
+    prompt: string;
+    description?: string;
+    metadata?: Record<string, any>;
+    history: Array<A_FrameDynamicPatch_Serialized>;
+} & A_TYPES__Entity_Serialized;
+/** How a patch operation positions new or replacement text relative to a target */
+type A_FrameContentPatchPosition = 'before' | 'after' | 'replace' | 'append';
+/** A single patch action returned by the server */
+interface A_FrameContentPatchOperation {
+    /** 'add' inserts a new segment, 'replace' swaps an existing one, 'remove' deletes it */
+    action: 'add' | 'replace' | 'remove';
+    /** Target segment id (required for replace / remove; optional for add) */
+    targetId?: string;
+    /** Placement relative to target for 'add'; defaults to 'after' */
+    position?: A_FrameContentPatchPosition;
+    /** New segment data (required for add / replace) */
+    segment?: A_FrameContentSegmentWire;
+}
+interface A_FrameContentPatchResponse {
+    patchSummary: string;
+    operations: A_FrameContentPatchOperation[];
+    model: string;
+    date: string;
+    meta: {
+        server_version: string;
+    };
+}
+
+type A_FrameSegmentOptions = {
+    /**
+     * model: Optional name of the embedding model to associate with this segment (e.g. "text-embedding-3-small"). If not provided, the server will attempt to infer the model based on the vector dimensions or other available metadata.
+     */
+    model: string;
+};
+type A_FrameSegment_Init = {
+    /** Unique identifier / slug for the namespace (e.g. "math", "finance/options") */
+    content: string;
+    metadata?: Record<string, any>;
+    options?: Partial<A_FrameSegmentOptions>;
+};
+type A_FrameSegment_Serialized = {
+    hash: string;
+    content: string;
+    embedding?: Float32Array;
+    embeddedAt: string;
+    model?: string;
+    credentialId?: string;
+    aFrameVersion?: string;
+    aFrameServerVersion?: string;
+} & A_TYPES__Entity_Serialized;
+type A_FrameSegment_Record = {
+    /** SHA-256 hex of the namespace name — acts as stable identity key */
+    hash: string;
+    /** Segment name / slug */
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    embedding: Float32Array;
+    embeddedAt: string;
+    /** Name of the embedding model used to produce the vector */
+    embeddingModel?: string;
+    /** ID of the server credential (API key) used during embedding */
+    credentialId?: string;
+    /** Version of @adaas/a-frame that produced this record */
+    aFrameVersion?: string;
+    /** Version of adaas-a-frame-mcp that produced the vector */
+    aFrameServerVersion?: string;
+};
+
+declare class A_FrameSegment extends A_Entity<A_FrameSegment_Init, A_FrameSegment_Serialized> {
+    static get concept(): string;
+    protected _content: string;
+    protected _hash: string;
+    protected _vector?: A_FrameVector;
+    protected _embeddedAt?: string;
+    protected _model?: string;
+    protected _credentialId?: string;
+    protected _aFrameVersion?: string;
+    protected _aFrameServerVersion?: string;
+    get id(): string;
+    get content(): string;
+    get hash(): string;
+    get vector(): A_FrameVector | undefined;
+    get embedding(): Float32Array | null;
+    get aFrameServerVersion(): string | undefined;
+    get aFrameVersion(): string | undefined;
+    get isEmbed(): boolean;
+    /**
+      * Saves Segment to storage. The actual implementation of saving is handled by the A_FrameSegmentFeatures.Save feature, which can be implemented by the environment to persist the definition to a database, file system, or other storage mechanism.
+      *
+      * @param scope
+      * @returns
+      */
+    save(scope?: A_Scope): Promise<void> | void;
+    /**
+     * Deletes the namespace from storage. The actual implementation of deletion is handled by the A_FrameSegmentFeatures.Destroy feature, which can be implemented by the environment to remove the namespace from the database, file system, or other storage mechanism.
+     *
+     * @param scope
+     * @returns
+     */
+    destroy(scope?: A_Scope): Promise<void> | void;
+    /**
+     * Loads the namespace from storage. The actual implementation of loading is handled by the A_FrameSegmentFeatures.Load feature, which can be implemented by the environment to retrieve the namespace from the database, file system, or other storage mechanism and populate the entity's properties accordingly.
+     *
+     * @param scope
+     * @returns
+     */
+    load(scope?: A_Scope): Promise<void>;
+    /**
+     * Updates the definition's properties. This can be used to modify the source code, description, metadata, or namespace of the definition. After updating, you may want to call `embed()` again to refresh the embedding based on the new content.
+     *
+     * @param updates
+     */
+    update(updates: Partial<Pick<A_FrameSegment, 'content'>>): void;
+    /**
+     * Generates an embedding vector for the namespace using the A_FrameSegmentFeatures.Embed feature. This typically involves sending the namespace's content (name + description) to an embedding model and storing the resulting vector in the entity. Once embedded, the namespace can be searched using its vector representation.
+     *
+     * @param scope
+     * @returns
+     */
+    embed(scope?: A_Scope): Promise<void> | void;
+    fromNew(init: A_FrameSegment_Init): void;
+    fromJSON(serialized: A_FrameSegment_Serialized): void;
+    toJSON(): A_FrameSegment_Serialized;
+    hydrateFromRecord(record: A_FrameSegment_Record): void;
+    /**
+     * Populate the embedding vector directly from a raw `Float32Array`.
+     * Use this when the vector is obtained externally (e.g. from a server
+     * response) without going through the full `embed()` feature pipeline.
+     */
+    hydrateFromEmbedding(embedding: Float32Array): void;
+    /**
+     * Build the text string sent to the embedding model.
+     * Uses content so the vector captures semantic intent.
+     */
+    toString(): string;
+}
+
+interface A_FrameDynamicContentIndex_SearchResult {
+    segment: A_FrameSegment;
+    score: number;
+}
+declare class A_FrameDynamicContentIndex extends A_Fragment {
+    /** Maximum segments forwarded to the server in a single patch request. */
+    static readonly PATCH_PIECE_LIMIT = 5;
+    /** Ordered list of segment IDs — defines the canonical reading order. */
+    private _order;
+    /** O(1) lookup by id. */
+    private _map;
+    get count(): number;
+    get size(): number;
+    /** Append one or more segments to the end. */
+    add(...segments: A_FrameSegment[]): void;
+    /** Replace the content of an existing segment in-place (position unchanged). */
+    update(segment: A_FrameSegment): void;
+    /** Remove a segment by id. */
+    remove(id: string): void;
+    /** Remove all segments. */
+    clear(): void;
+    /** Insert `segment` immediately before the segment with `targetId`. */
+    insertBefore(targetId: string, segment: A_FrameSegment): void;
+    /** Insert `segment` immediately after the segment with `targetId`. */
+    insertAfter(targetId: string, segment: A_FrameSegment): void;
+    /** Swap the content of `targetId` with `segment`, keeping the same position. */
+    replace(targetId: string, segment: A_FrameSegment): void;
+    /** Move the segment with `id` to absolute zero-based `newPosition`. */
+    moveTo(id: string, newPosition: number): void;
+    /** Move `id` to directly before `targetId`. */
+    moveBefore(id: string, targetId: string): void;
+    /** Move `id` to directly after `targetId`. */
+    moveAfter(id: string, targetId: string): void;
+    /**
+     * Apply a single `A_FrameContentPatchOperation` to the index.
+     * For `add` and `replace` the caller must supply the resolved `segment`.
+     * For `remove` only the `op` is needed.
+     */
+    applyOperation(op: A_FrameContentPatchOperation, segment?: A_FrameSegment): void;
+    get(id: string): A_FrameSegment | undefined;
+    /** Returns all segments in their current canonical order. */
+    list(): A_FrameSegment[];
+    /**
+     * Rank all embedded segments by cosine similarity to the query vector.
+     */
+    search(vector: A_FrameVector, topK?: number): A_FrameDynamicContentIndex_SearchResult[];
+    /**
+     * Rank segments by how many instruction keywords appear in their content.
+     * Words shorter than 4 characters are ignored.
+     */
+    searchByKeywords(instruction: string, topK?: number): A_FrameDynamicContentIndex_SearchResult[];
+    /**
+     * Select at most `limit` segments most relevant to a patch instruction.
+     *
+     * Priority:
+     *   1. Vector search  — when `vector` is provided and segments carry embeddings.
+     *   2. Keyword search — fallback when embeddings are absent or vector is null.
+     *   3. Identity       — first N segments when neither search finds candidates.
+     */
+    selectForPatch(vector: A_FrameVector | null, instruction: string, limit?: number): A_FrameSegment[];
+    cosineSimilarity(a: A_FrameVector, b?: A_FrameVector): number;
+}
+
+declare class A_FrameDynamicContent extends A_Entity<A_FrameDynamicContent_Init, A_FrameDynamicContent_Serialized> {
+    static get concept(): string;
+    prompt: string;
+    createdAt: number;
+    private model;
+    private _history;
+    private _version;
+    private _patchPieceLimit;
+    /**
+     * The scope of the current Content stores all related data to it
+     */
+    protected _scope: A_Scope;
+    /**
+     *
+     */
+    get scope(): A_Scope;
+    get index(): A_FrameDynamicContentIndex;
+    fromNew(options: A_FrameDynamicContent_Init): void;
+    /** Ordered list of content pieces (output of the last generate or patch). */
+    get segments(): ReadonlyArray<A_FrameSegment>;
+    /** Full content reconstructed from all segments in index order. */
+    get content(): string;
+    /** Alias for `content` — kept for backward compatibility. */
+    get text(): string;
+    /** Immutable patch history. */
+    get history(): ReadonlyArray<A_FrameDynamicPatch>;
+    /** Current content version (increments with each patch). */
+    get version(): number;
+    /** The AI model name to use for generation / patching. */
+    get modelName(): string;
+    /**
+     * Generate content from the entity's prompt.
+     * Populates `pieces` and creates the first history entry.
+     */
+    generate(): Promise<void>;
+    /**
+     * Apply a natural-language patch instruction to the current pieces.
+     * The server identifies which pieces to add, replace, or remove using
+     * semantic search over piece embeddings.
+     */
+    patch(instruction: string): Promise<void>;
+    /**
+     * Populate index from the segments created by the channel after a generate response.
+     * Creates the first history entry.
+     */
+    hydrateFromGeneration(segments: A_FrameSegment[], meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    /**
+     * Apply a patch diff returned by the server to the current piece list.
+     * Increments the version and records a history entry.
+     */
+    hydrateFromPatch(patchResult: A_FrameContentPatchResponse, meta: {
+        model: string;
+        serverVersion: string;
+    }): void;
+    toJSON(): A_FrameDynamicContent_Serialized;
+}
+
+declare class A_FrameDynamicContentOperation<_InputParams = any> extends A_Fragment {
+    protected _meta: Map<string, any>;
+    constructor(params?: _InputParams);
+    get params(): _InputParams;
+    get(key: string): any;
+    set(key: string, value: any): void;
+}
+
+/**
+ * A_FrameChannel — Node.js environment
+ *
+ * HTTP client for the embed-server API.
+ * Configuration is resolved from process.env via A_FrameEnv injected at
+ * feature execution time — no state is stored on the component itself.
+ *
+ * Uses the global fetch (available in Node 18+; no extra dependency needed).
+ */
+declare class A_FrameChannel extends A_Component implements IA_Frame_Channel {
+    generate(prompt: string): Promise<A_FrameChannelRequest<A_Frame_GenerateResponse>>;
+    embed(input: string | string[]): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>>;
+    getCredentials(): Promise<A_FrameChannelRequest<A_Frame_CredentialResponse>>;
+    ping(): Promise<A_FrameChannelRequest<boolean>>;
+    embedDefinition(definition: A_FrameDefinition, env: A_FrameEnv): Promise<void>;
+    embedNamespace(namespace: A_FrameNamespace, env: A_FrameEnv): Promise<void>;
+    embedSegment(segment: A_FrameSegment, env: A_FrameEnv): Promise<void>;
+    generateDynamicStructure(structure: A_FrameDynamicStructure, session: A_FrameDynamicSession, operation: A_FrameDynamicStructureOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicContent.generate().
+     *
+     * Calls POST /api/v1/content/generate on the server and hydrates the
+     * content entity from the returned piece list.
+     */
+    generateDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicContent.patch().
+     *
+     * Sends the current piece list and a patch instruction to the server,
+     * then applies the returned operations to the content entity.
+     */
+    patchDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+}
+
+export { A_FrameChannel as A };

package/dist/node/A-FrameChannel.component-DwgYNfFn.d.mts

@@ -0,0 +1,97 @@
+import { A_TYPES__Entity_Serialized, A_Entity, A_Scope, A_Component } from '@adaas/a-concept';
+import { I as IA_Frame_Channel, A as A_FrameChannelRequest, a as A_Frame_GenerateResponse, b as A_FrameEmbedOptions, c as A_Frame_EmbedResponse, d as A_Frame_CredentialResponse } from './A-FrameChannel.types-DYMgRiCF.mjs';
+import { A_FrameEnv } from './env.mjs';
+import { A as A_FrameDefinition } from './A-FrameDefinition.entity-C1aK-gdl.mjs';
+import { A as A_FrameNamespace } from './A-FrameNamespace.entity-BDg1FUgo.mjs';
+import { A as A_FrameDynamicStructure, m as A_FrameDynamicStructureOperation } from './A-FrameDynamicStructure.entity-DMvI_EPT.mjs';
+import { f as A_FrameDynamicContent, i as A_FrameDynamicContentOperation } from './A-FrameDynamicContentOperation.context-Dd7Lb7X2.mjs';
+import { A as A_FrameSegment } from './A-FrameSegment.entity-D7Aj39Wh.mjs';
+import { A as A_FrameCompletion } from './A-FrameCompletion.entity-Dzy9sIa8.mjs';
+import { A as A_FrameSchema } from './A-FrameSchema.entity-DjYIhsoj.mjs';
+
+type A_FrameDynamicSession_Init = {
+    turnsCount: number;
+};
+type A_FrameDynamicSession_Serialized = {
+    turnsCount: number;
+    currentTurn: number;
+    initDate: string;
+} & A_TYPES__Entity_Serialized;
+
+declare class A_FrameDynamicSession extends A_Entity<A_FrameDynamicSession_Init, A_FrameDynamicSession_Serialized> {
+    static get concept(): string;
+    /**
+     *
+     */
+    protected _scope: A_Scope;
+    protected _turnsCount: number;
+    protected _currentTurn: number;
+    protected _initDate: string;
+    /**
+     *
+     */
+    get scope(): A_Scope;
+    get currentTurn(): number;
+    get initDate(): Date;
+    static onQuestion(): void;
+    static onAnswer(): void;
+    fromNew(newEntity: A_FrameDynamicSession_Init): void;
+    fromJSON(serialized: A_FrameDynamicSession_Serialized): void;
+    init(): Promise<void>;
+    destroy(scope?: A_Scope): Promise<void>;
+    question(): Promise<void>;
+    answer(): Promise<void>;
+    toJSON(): A_FrameDynamicSession_Serialized;
+}
+
+/**
+ * A_FrameChannel — Node.js environment
+ *
+ * HTTP client for the embed-server API.
+ * Configuration is resolved from process.env via A_FrameEnv injected at
+ * feature execution time — no state is stored on the component itself.
+ *
+ * Uses the global fetch (available in Node 18+; no extra dependency needed).
+ */
+declare class A_FrameChannel extends A_Component implements IA_Frame_Channel {
+    generate(prompt: string): Promise<A_FrameChannelRequest<A_Frame_GenerateResponse>>;
+    embed(input: string | string[], options?: A_FrameEmbedOptions): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>>;
+    getCredentials(): Promise<A_FrameChannelRequest<A_Frame_CredentialResponse>>;
+    ping(): Promise<A_FrameChannelRequest<boolean>>;
+    embedDefinition(definition: A_FrameDefinition, env: A_FrameEnv): Promise<void>;
+    embedNamespace(namespace: A_FrameNamespace, env: A_FrameEnv): Promise<void>;
+    embedSegment(segment: A_FrameSegment, env: A_FrameEnv): Promise<void>;
+    generateDynamicStructure(structure: A_FrameDynamicStructure, session: A_FrameDynamicSession, operation: A_FrameDynamicStructureOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicContent.generate().
+     *
+     * Calls POST /api/v1/content/generate on the server and hydrates the
+     * content entity from the returned piece list.
+     */
+    generateDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameDynamicContent.patch().
+     *
+     * Sends the current piece list and a patch instruction to the server,
+     * then applies the returned operations to the content entity.
+     */
+    patchDynamicContent(content: A_FrameDynamicContent, operation: A_FrameDynamicContentOperation): Promise<void>;
+    /**
+     * Feature implementation for A_FrameCompletion.generate().
+     *
+     * Calls POST /api/v1/completions/generate on the server, which performs a
+     * text completion followed by an embedding of the result in a single
+     * round-trip, then hydrates the entity with both values.
+     */
+    generateCompletion(completion: A_FrameCompletion, env: A_FrameEnv): Promise<void>;
+    /**
+     * Calls POST /api/v1/schema/extract on the server.
+     *
+     * Sends the prompt and schema descriptor to the Nova model, which returns
+     * a structured JSON object matching the schema.  Hydrates the entity with
+     * the extracted data and provenance metadata.
+     */
+    extractSchema<T extends Record<string, unknown>>(scheme: A_FrameSchema<T>, env: A_FrameEnv): Promise<void>;
+}
+
+export { A_FrameChannel as A };

package/dist/node/A-FrameChannel.types-B3_xWKEO.d.mts

@@ -0,0 +1,151 @@
+import { A_Fragment, A_Error, A_TYPES__Error_Serialized, A_TYPES__Entity_Serialized } from '@adaas/a-concept';
+import { D as DefinitionExtractedMeta } from './A-FrameDefinition.entity-CKPXsarS.mjs';
+
+declare class A_FrameChannelRequest<_Response = any> extends A_Fragment {
+    method: string;
+    path: string;
+    body?: unknown;
+    protected _response?: _Response;
+    protected _error?: A_Error;
+    constructor(method: string, path: string, body?: unknown);
+    complete(response: _Response): void;
+    fail(error: A_Error): void;
+    get response(): _Response | undefined;
+    get error(): A_Error | undefined;
+}
+
+declare const A_FrameFeatures: {
+    readonly Request: "_A_FRAME_REQUEST";
+    readonly Socket: "_A_FRAME_SOCKET";
+    readonly Stream: "_A_FRAME_STREAM";
+    readonly Send: "_A_FRAME_SEND";
+};
+declare const A_FrameChannelStreamStatuses: {
+    readonly Open: "open";
+    readonly Closed: "closed";
+};
+declare const A_FrameChannelStreamFeatures: {
+    readonly open: "_A_FRAME_CHANNEL_STREAM_OPEN";
+    readonly send: "_A_FRAME_CHANNEL_STREAM_SEND";
+    readonly onEvent: "_A_FRAME_CHANNEL_STREAM_ON_EVENT";
+    readonly onError: "_A_FRAME_CHANNEL_STREAM_ON_ERROR";
+    readonly onComplete: "_A_FRAME_CHANNEL_STREAM_ON_COMPLETE";
+    readonly onClose: "_A_FRAME_CHANNEL_STREAM_ON_CLOSE";
+};
+declare const A_FrameChannelSocketStatuses: {
+    readonly Connecting: "connecting";
+    readonly Open: "open";
+    readonly Closed: "closed";
+};
+declare const A_FrameChannelSocketFeatures: {
+    readonly onEvent: "_A_FRAME_CHANNEL_SOCKET_ON_EVENT";
+    readonly onError: "_A_FRAME_CHANNEL_SOCKET_ON_ERROR";
+    readonly onOpen: "_A_FRAME_CHANNEL_SOCKET_ON_OPEN";
+    readonly onClose: "_A_FRAME_CHANNEL_SOCKET_ON_CLOSE";
+};
+
+interface A_Frame_EmbedResponse {
+    data: Array<{
+        embedding: number[];
+        index: number;
+    }>;
+    model: string;
+    /**
+     * Execution backend reported by the server ("local" | "remote" | …)
+     */
+    backend?: string;
+    /**
+     * ISO timestamp of when the embedding was generated, as reported by the server. Useful for cache validation and staleness checks.
+     */
+    date: string;
+    meta: {
+        dimensions: number;
+        input_count: number;
+        /** Embed-server (a-frame-mcp) package version */
+        server_version: string;
+        /** ID of the credential (API key) used for this request */
+        credential_id: string | null;
+    };
+    /** Structural metadata extracted from the source by the server */
+    aFrameMeta?: DefinitionExtractedMeta;
+}
+interface A_Frame_GenerateResponse {
+    data: {
+        text: string;
+    };
+    model: string;
+    /**
+     * Execution backend reported by the server ("local" | "remote" | …)
+     */
+    backend?: string;
+    /**
+     * ISO timestamp of when the embedding was generated, as reported by the server. Useful for cache validation and staleness checks.
+     */
+    date: string;
+    meta: {
+        /** Embed-server (a-frame-mcp) package version */
+        server_version: string;
+        /** ID of the credential (API key) used for this request */
+        credential_id: string | null;
+    };
+}
+interface A_Frame_CredentialResponse {
+    /** Unique identifier for the credential */
+    id: string;
+    /** Name of the credential */
+    name: string;
+    /** Optional description of the credential */
+    description: string | null;
+    /** The encryption key in base64 format */
+    encryption_key: string;
+    /** Encryption algorithm used (e.g., "AES-256-GCM") */
+    algorithm: string;
+    /** Encoding format of the encryption key (e.g., "base64") */
+    key_encoding: string;
+    /** Usage instructions for the encryption key */
+    usage_note: string;
+    /** Version of the a-frame-mcp server */
+    server_version: string;
+}
+interface IA_Frame_Channel {
+    generate(prompt: string): Promise<A_FrameChannelRequest<A_Frame_GenerateResponse>>;
+    /** Embed one or more raw text strings and return the server response */
+    embed(inputs: string | string[]): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>>;
+    /** Fetch credential details (incl. encryption key) for the authenticated API key */
+    getCredentials(): Promise<A_FrameChannelRequest<A_Frame_CredentialResponse>>;
+    /** Returns true if the embed server is reachable */
+    ping(): Promise<A_FrameChannelRequest<boolean>>;
+}
+type A_FrameChannelStreamStatusNames = typeof A_FrameChannelStreamStatuses[keyof typeof A_FrameChannelStreamStatuses];
+type A_FrameChannelStreamFeatureNames = typeof A_FrameChannelStreamFeatures[keyof typeof A_FrameChannelStreamFeatures];
+type A_FrameChannelStream_Init<T extends Record<string, any> = Record<string, any>> = {
+    method: string;
+    path: string;
+    body?: T;
+};
+type A_FrameChannelStream_Serialized<T extends Record<string, any> = Record<string, any>> = {
+    method: string;
+    path: string;
+    body?: T;
+    initDate: string;
+    status: A_FrameChannelStreamStatusNames;
+    error?: A_TYPES__Error_Serialized;
+} & A_TYPES__Entity_Serialized;
+type A_FrameChannelSocketStatusNames = typeof A_FrameChannelSocketStatuses[keyof typeof A_FrameChannelSocketStatuses];
+type A_FrameChannelSocketFeatureNames = typeof A_FrameChannelSocketFeatures[keyof typeof A_FrameChannelSocketFeatures];
+type A_FrameChannelSocket_Init<T extends Record<string, any> = Record<string, any>> = {
+    method: string;
+    path: string;
+    /** Optional JSON body sent as the X-A-Frame-Init header during the upgrade request. */
+    body?: T;
+};
+type A_FrameChannelSocket_Serialized<T extends Record<string, any> = Record<string, any>> = {
+    method: string;
+    path: string;
+    body?: T;
+    initDate: string;
+    status: A_FrameChannelSocketStatusNames;
+    error?: A_TYPES__Error_Serialized;
+} & A_TYPES__Entity_Serialized;
+
+export { type A_FrameChannelStream_Init as A, type IA_Frame_Channel as I, type A_FrameChannelStream_Serialized as a, type A_FrameChannelStreamStatusNames as b, A_FrameChannelRequest as c, type A_FrameChannelSocketFeatureNames as d, A_FrameChannelSocketFeatures as e, type A_FrameChannelSocketStatusNames as f, A_FrameChannelSocketStatuses as g, type A_FrameChannelSocket_Init as h, type A_FrameChannelSocket_Serialized as i, type A_FrameChannelStreamFeatureNames as j, A_FrameChannelStreamFeatures as k, A_FrameChannelStreamStatuses as l, A_FrameFeatures as m, type A_Frame_CredentialResponse as n, type A_Frame_EmbedResponse as o, type A_Frame_GenerateResponse as p };