@adaas/a-frame 0.0.23 → 0.1.2

package/src/lib/A-FrameChannel/A-FrameChannel.component.ts

@@ -1,5 +1,5 @@
 import { A_Caller, A_Component, A_Context, A_Feature, A_Inject, A_Scope } from "@adaas/a-concept";
-import { IA_Frame_Channel, A_Frame_EmbedResponse, A_Frame_GenerateResponse, A_Frame_CredentialResponse } from "./A-FrameChannel.types";
+import { IA_Frame_Channel, A_Frame_EmbedResponse, A_Frame_GenerateResponse, A_Frame_CredentialResponse, A_FrameEmbedOptions } from "./A-FrameChannel.types";
 import { A_FrameEnv } from "../A-FrameEnv/A-FrameEnv.fragment.env-node";
 import { A_FrameFeatures } from "./A-FrameChannel.constants";
 import { A_FrameChannelRequest } from "./A-FrameChannelRequest.context";
@@ -9,9 +9,27 @@ import { A_FrameDefinitionFeatures } from "../A-FrameDefinition/A-FrameDefinitio
 import { A_FrameNamespaceFeatures } from "../A-FrameNamespace/A-FrameNamespace.constants";
 import { A_FrameNamespace } from "../A-FrameNamespace";
 import { A_FrameDynamicStructure } from "../A-FrameDynamicStructure/A-FrameDynamicStructure.entity";
-import { A_FrameDynamicSession } from "../A-FrameDynamicSession/A-FrameDynamicSession.entity";
 import { A_FrameDynamicStructureOperation } from "../A-FrameDynamicStructure/A-FrameDynamicStructureOperation.context";
+import { A_FrameDynamicStructureFeatures } from "../A-FrameDynamicStructure/A-FrameDynamicStructure.constants";
+import { A_FrameStructureGenerateResponse, A_FrameStructurePatchResponse, A_FrameDynamicStructureDefinition, A_FrameDynamicStructureDefinitionEntity } from "../A-FrameDynamicStructure/A-FrameDynamicStructure.types";
 import { A_FrameChannelSocket } from "./A-FrameChannelSocket.entity";
+import { A_FrameDynamicContent } from "../A-FrameDynamicContent/A-FrameDynamicContent.entity";
+import { A_FrameDynamicContentOperation } from "../A-FrameDynamicContent/A-FrameDynamicContentOperation.context";
+import { A_FrameDynamicContentFeatures } from "../A-FrameDynamicContent/A-FrameDynamicContent.constants";
+import { A_FrameContentGenerateResponse, A_FrameContentPatchResponse } from "../A-FrameDynamicContent/A-FrameDynamicContent.types";
+import { A_Frame_CompletionResponse } from "./A-FrameChannel.types";
+import { A_FrameSegment, A_FrameSegmentFeatures } from "../A-FrameSegment";
+import { A_FrameCompletion, A_FrameCompletionFeatures } from "../A-FrameCompletion";
+import { A_FrameSchema, A_FrameSchemaFeatures } from "../A-FrameSchema";
+import { A_Frame_SchemaResponse } from "./A-FrameChannel.types";
+import { A_FrameDynamicFeature } from "../A-FrameDynamicFeature/A-FrameDynamicFeature.entity";
+import { A_FrameDynamicFeatureOperation } from "../A-FrameDynamicFeature/A-FrameDynamicFeatureOperation.context";
+import { A_FrameDynamicFeatureFeatures } from "../A-FrameDynamicFeature/A-FrameDynamicFeature.constants";
+import {
+    A_FrameDynamicFeatureDefinition,
+    A_FrameFeatureGenerateResponse,
+    A_FrameFeaturePatchResponse,
+} from "../A-FrameDynamicFeature/A-FrameDynamicFeature.types";
 
 /**
  * A_FrameChannel — Node.js environment
@@ -25,7 +43,7 @@ import { A_FrameChannelSocket } from "./A-FrameChannelSocket.entity";
 export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
 
     async generate(prompt: string): Promise<A_FrameChannelRequest<A_Frame_GenerateResponse>> {
-        const request = new A_FrameChannelRequest<A_Frame_GenerateResponse>('POST', '/api/completions', { prompt, max_tokens: 512 });
+        const request = new A_FrameChannelRequest<A_Frame_GenerateResponse>('POST', '/api/v1/completions', { prompt, max_tokens: 512 });
 
         const executionScope = new A_Scope({
             name: 'A_FrameChannel.generate',
@@ -48,8 +66,12 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
         }
     }
 
-    async embed(input: string | string[]): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>> {
-        const request = new A_FrameChannelRequest<A_Frame_EmbedResponse>('POST', '/api/embeddings', { input });
+    async embed(input: string | string[], options?: A_FrameEmbedOptions): Promise<A_FrameChannelRequest<A_Frame_EmbedResponse>> {
+        const request = new A_FrameChannelRequest<A_Frame_EmbedResponse>('POST', '/api/v1/embeddings', {
+            input,
+            ...(options?.model && { model: options.model }),
+            ...(options?.task  && { task:  options.task  }),
+        });
 
         const executionScope = new A_Scope({
             name: 'A_FrameChannel.embed',
@@ -72,7 +94,7 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
     }
 
     async getCredentials(): Promise<A_FrameChannelRequest<A_Frame_CredentialResponse>> {
-        const request = new A_FrameChannelRequest<A_Frame_CredentialResponse>('GET', '/api/credentials/me');
+        const request = new A_FrameChannelRequest<A_Frame_CredentialResponse>('GET', '/api/v1/credentials/me');
 
         const executionScope = new A_Scope({
             name: 'A_FrameChannel.getCredentials',
@@ -129,6 +151,7 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
     ) {
         const request = new A_FrameChannelRequest<A_Frame_EmbedResponse>('POST', '/api/v1/definition/embed', {
             definition: definition.toJSON(),
+            model: definition.requestedModel,
         });
 
         const executionScope = new A_Scope({
@@ -159,6 +182,7 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
                 aFrameVersion: env.A_FRAME_VERSION!,
                 credentialId: response.meta.credential_id!,
                 date: response.date,
+                aFrameMeta: response.aFrameMeta,
             });
         } catch (err) {
             throw new A_FrameChannelError({
@@ -182,6 +206,7 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
 
         const request = new A_FrameChannelRequest<A_Frame_EmbedResponse>('POST', '/api/v1/namespace/embed', {
             namespace: namespace.toJSON(),
+            model: namespace.requestedModel,
         });
 
         const executionScope = new A_Scope({
@@ -224,16 +249,283 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
     }
 
 
+    @A_Feature.Extend({
+        name: A_FrameSegmentFeatures.Embed,
+        scope: [A_FrameSegment],
+    })
+    async embedSegment(
+        @A_Inject(A_Caller) segment: A_FrameSegment,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+
+        const request = new A_FrameChannelRequest<A_Frame_EmbedResponse>('POST', '/api/v1/segment/embed', {
+            segment: segment.toJSON(),
+            task: segment.options?.task,
+            model: segment.options?.model,
+        });
+
+        const executionScope = new A_Scope({
+            name: 'A_FrameChannel.embedNamespace',
+            fragments: [request]
+        })
+            .inherit(A_Context.scope(this));
+
+
+        try {
+            await this.call(A_FrameFeatures.Request, executionScope) as A_Frame_EmbedResponse;
+            executionScope.destroy();
+
+            const response = request.response!;
+            if (!response.data || !response.data[0] || !response.data[0].embedding) {
+                throw new A_FrameChannelError({
+                    title: A_FrameChannelError.InvalidRequest,
+                    description: `Error during embed a segment: ${segment.content}`
+                });
+            }
+
+            const vector = new Float32Array(response.data[0].embedding);
+
+            segment.fromJSON({
+                aseid: segment.aseid.toString(),
+                content: segment.content,
+                hash: segment.hash,
+                embedding: vector,
+                model: response.model,
+                // dimensions: response.meta.dimensions,
+                // inputCount: response.meta.input_count,
+                aFrameServerVersion: response.meta.server_version!,
+                aFrameVersion: env.A_FRAME_VERSION!,
+                credentialId: response.meta.credential_id!,
+                embeddedAt: response.date,
+            });
+        } catch (err) {
+            throw new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Failed to embed segment with content "${segment.content}": ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
 
+    }
 
 
 
+    /**
+     * Feature implementation for A_FrameDynamicStructure.generate().
+     *
+     * Calls POST /api/v1/structure/generate — the server returns element
+     * descriptions with embeddings.  The raw definition (embeddings included) is
+     * stored on the entity so the separate `map()` phase can use them later.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicStructureFeatures.Generate,
+        scope: [A_FrameDynamicStructure],
+    })
     async generateDynamicStructure(
         @A_Inject(A_Caller) structure: A_FrameDynamicStructure,
-        @A_Inject(A_FrameDynamicSession) session: A_FrameDynamicSession,
         @A_Inject(A_FrameDynamicStructureOperation) operation: A_FrameDynamicStructureOperation,
     ) {
+        const request = new A_FrameChannelRequest<A_FrameStructureGenerateResponse>(
+            'POST',
+            '/api/v1/structure/generate',
+            {
+                prompt:            structure.prompt,
+                model:             structure.modelName,
+                context:           structure.contextHint,
+                metaHint:          structure.metaHintValue,
+                includeBases:      structure.includedBases,
+                excludeBases:      structure.excludedBases,
+                enabledComponents: structure.enabledComponentsList,
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.generateDynamicStructure',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
 
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+
+        structure.hydrateFromGeneration(resp.definition, {
+            model:         resp.model,
+            serverVersion: resp.meta?.server_version ?? '0.0.0',
+        });
+    }
+
+    /**
+     * Feature implementation for A_FrameDynamicStructure.patch().
+     *
+     * Calls POST /api/v1/structure/patch — the server returns an updated
+     * definition with fresh embeddings.  The raw definition is stored on the
+     * entity; run `map()` afterwards to update the component-mapping result.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicStructureFeatures.Patch,
+        scope: [A_FrameDynamicStructure],
+    })
+    async patchDynamicStructure(
+        @A_Inject(A_Caller) structure: A_FrameDynamicStructure,
+        @A_Inject(A_FrameDynamicStructureOperation) operation: A_FrameDynamicStructureOperation,
+    ) {
+        const { instruction } = operation.params as { instruction: string };
+
+        const request = new A_FrameChannelRequest<A_FrameStructurePatchResponse>(
+            'POST',
+            '/api/v1/structure/patch',
+            {
+                originalPrompt:    structure.prompt,
+                definition:        this._stripStructureEmbeddings(structure.definition ?? { containers: [], components: [], fragments: [], entities: [] }),
+                patchInstruction:  instruction,
+                model:             structure.modelName,
+                context:           structure.contextHint,
+                metaHint:          structure.metaHintValue,
+                includeBases:      structure.includedBases,
+                excludeBases:      structure.excludedBases,
+                enabledComponents: structure.enabledComponentsList,
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.patchDynamicStructure',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+
+        structure.hydrateFromPatch(resp.definition, resp.patchSummary, {
+            model:         resp.model,
+            serverVersion: resp.meta?.server_version ?? '0.0.0',
+        });
+    }
+
+    // ─── Structure helpers ─────────────────────────────────────────────────────
+
+    /**
+     * Strip embedding arrays and any client-side match fields from a definition
+     * before sending it to the server (the server does not need embeddings back).
+     */
+    private _stripStructureEmbeddings(def: A_FrameDynamicStructureDefinition): A_FrameDynamicStructureDefinition {
+        const strip = (el: A_FrameDynamicStructureDefinitionEntity): A_FrameDynamicStructureDefinitionEntity => {
+            const { embedding, ...rest } = el as any;
+            return rest as A_FrameDynamicStructureDefinitionEntity;
+        };
+
+        return {
+            containers: def.containers.map(c => ({
+                ...strip(c),
+                components: (c.components ?? []).map(strip),
+                fragments:  (c.fragments  ?? []).map(strip),
+                entities:   (c.entities   ?? []).map(strip),
+            })),
+            components: def.components.map(strip),
+            fragments:  def.fragments.map(strip),
+            entities:   def.entities.map(strip),
+        };
+    }
+
+    // ─── DynamicFeature channel extensions ────────────────────────────────────
+
+    /**
+     * Feature implementation for A_FrameDynamicFeature.generate().
+     *
+     * Calls POST /api/v1/feature/generate — the server decomposes the prompt
+     * into an ordered workflow: title, description, steps (with embeddings),
+     * and supporting components/fragments/entities.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicFeatureFeatures.Generate,
+        scope: [A_FrameDynamicFeature],
+    })
+    async generateDynamicFeature(
+        @A_Inject(A_Caller) feature: A_FrameDynamicFeature,
+        @A_Inject(A_FrameDynamicFeatureOperation) operation: A_FrameDynamicFeatureOperation,
+    ) {
+        const request = new A_FrameChannelRequest<A_FrameFeatureGenerateResponse>(
+            'POST',
+            '/api/v1/feature/generate',
+            {
+                prompt:  feature.prompt,
+                model:   feature.modelName,
+                context: feature.contextHint,
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.generateDynamicFeature',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+        feature.hydrateFromGeneration(resp.definition, {
+            model:         resp.model,
+            serverVersion: resp.meta?.server_version ?? '0.0.0',
+        });
+    }
+
+    /**
+     * Feature implementation for A_FrameDynamicFeature.patch().
+     *
+     * Calls POST /api/v1/feature/patch — the server returns an updated workflow
+     * definition with fresh embeddings on all steps and elements.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicFeatureFeatures.Patch,
+        scope: [A_FrameDynamicFeature],
+    })
+    async patchDynamicFeature(
+        @A_Inject(A_Caller) feature: A_FrameDynamicFeature,
+        @A_Inject(A_FrameDynamicFeatureOperation) operation: A_FrameDynamicFeatureOperation,
+    ) {
+        const { instruction } = operation.params as { instruction: string };
+
+        const request = new A_FrameChannelRequest<A_FrameFeaturePatchResponse>(
+            'POST',
+            '/api/v1/feature/patch',
+            {
+                originalPrompt:   feature.prompt,
+                definition:       this._stripFeatureEmbeddings(
+                    feature.definition ?? {
+                        title: '', description: '', steps: [], components: [], fragments: [], entities: []
+                    }
+                ),
+                patchInstruction: instruction,
+                model:            feature.modelName,
+                context:          feature.contextHint,
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.patchDynamicFeature',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+        feature.hydrateFromPatch(resp.definition, resp.patchSummary, {
+            model:         resp.model,
+            serverVersion: resp.meta?.server_version ?? '0.0.0',
+        });
+    }
+
+    private _stripFeatureEmbeddings(def: A_FrameDynamicFeatureDefinition): A_FrameDynamicFeatureDefinition {
+        const strip = (el: any): any => { const { embedding, ...rest } = el; return rest; };
+        return {
+            ...def,
+            steps:      def.steps.map(strip),
+            components: def.components.map(strip),
+            fragments:  def.fragments.map(strip),
+            entities:   def.entities.map(strip),
+        };
     }
 
 
@@ -266,6 +558,249 @@ export class A_FrameChannel extends A_Component implements IA_Frame_Channel {
     //     }
     // }
 
+
+    // ─── Dynamic Content ──────────────────────────────────────────────────────
+
+    /**
+     * 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.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicContentFeatures.Generate,
+        scope: [A_FrameDynamicContent],
+    })
+    async generateDynamicContent(
+        @A_Inject(A_Caller) content: A_FrameDynamicContent,
+        @A_Inject(A_FrameDynamicContentOperation) operation: A_FrameDynamicContentOperation,
+    ) {
+        const request = new A_FrameChannelRequest<A_FrameContentGenerateResponse>(
+            'POST',
+            '/api/v1/content/generate',
+            {
+                prompt: content.prompt,
+                model: content.modelName,
+                ...(content.systemPrompt !== undefined ? { system: content.systemPrompt } : {}),
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.generateDynamicContent',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+
+        // Convert wire segments to proper A_FrameSegment domain objects.
+        // The channel is the adapter layer — it never passes raw serialized
+        // objects into the domain; it always constructs instances.
+        const segments = (resp.segments ?? []).map(w => {
+            const seg = new A_FrameSegment({ content: w.content, options: { task: 'document' } });
+            if (w.embedding?.length) {
+                seg.hydrateFromEmbedding(new Float32Array(w.embedding));
+            }
+            return seg;
+        });
+
+        content.hydrateFromGeneration(segments, {
+            model: resp.model,
+            serverVersion: resp.meta?.server_version ?? '0.0.0',
+        });
+    }
+
+    /**
+     * 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.
+     */
+    @A_Feature.Extend({
+        name: A_FrameDynamicContentFeatures.Patch,
+        scope: [A_FrameDynamicContent],
+    })
+    async patchDynamicContent(
+        @A_Inject(A_Caller) content: A_FrameDynamicContent,
+        @A_Inject(A_FrameDynamicContentOperation) operation: A_FrameDynamicContentOperation,
+    ) {
+        const { instruction, segments } = operation.params as { instruction: string; segments: A_FrameSegment[] };
+
+        // Use short positional wire IDs (s0, s1, …) to maximise LLM reliability
+        // when the model echoes them back as targetId values.
+        // We keep a reverse map to translate back to the real ASEID ids.
+        const wireIdToAseid = new Map<string, string>();
+        const wireSegments = segments.map((s, idx) => {
+            const wireId = `s${idx}`;
+            wireIdToAseid.set(wireId, String(s.id));
+            return {
+                id: wireId,
+                index: idx,
+                text: s.content,
+                vector: s.vector ? Array.from(s.vector.values) : undefined,
+            };
+        });
+
+        const request = new A_FrameChannelRequest<A_FrameContentPatchResponse>(
+            'POST',
+            '/api/v1/content/patch',
+            {
+                prompt: content.prompt,
+                segments: wireSegments,
+                instruction,
+                model: content.modelName,
+                ...(content.systemPrompt !== undefined ? { system: content.systemPrompt } : {}),
+            },
+        );
+
+        const requestScope = new A_Scope({
+            name: 'A_FrameChannel.patchDynamicContent',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        await this.call(A_FrameFeatures.Request, requestScope);
+        requestScope.destroy();
+
+        const resp = request.response!;
+
+        // Translate wire ids (s0, s1, …) in targetId back to real ASEID ids
+        // so that applyOperation can look them up in the index.
+        const translatedOperations = resp.operations.map(op => ({
+            ...op,
+            targetId: op.targetId
+                ? (wireIdToAseid.get(op.targetId) ?? op.targetId)
+                : op.targetId,
+        }));
+
+        content.hydrateFromPatch(
+            { ...resp, operations: translatedOperations },
+            {
+                model: resp.model,
+                serverVersion: resp.meta?.server_version ?? '0.0.0',
+            },
+        );
+    }
+
+
+    // ─── Completion ───────────────────────────────────────────────────────────
+
+    /**
+     * 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.
+     */
+    @A_Feature.Extend({
+        name: A_FrameCompletionFeatures.Generate,
+        scope: [A_FrameCompletion],
+    })
+    async generateCompletion(
+        @A_Inject(A_Caller) completion: A_FrameCompletion,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const request = new A_FrameChannelRequest<A_Frame_CompletionResponse>(
+            'POST',
+            '/api/v1/completions/generate',
+            {
+                prompt: completion.prompt,
+                options: completion.options,
+            },
+        );
+
+        const executionScope = new A_Scope({
+            name: 'A_FrameChannel.generateCompletion',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        try {
+            await this.call(A_FrameFeatures.Request, executionScope);
+            executionScope.destroy();
+
+            const response = request.response!;
+
+            if (!response.text) {
+                throw new A_FrameChannelError({
+                    title: A_FrameChannelError.InvalidRequest,
+                    description: `Invalid completion response for prompt "${completion.prompt}"`,
+                });
+            }
+
+            completion.hydrateFromGeneration({
+                text: response.text,
+                embedding: new Float32Array(response.embedding),
+                model: response.model,
+                date: response.date,
+                aFrameVersion: env.A_FRAME_VERSION!,
+                aFrameServerVersion: response.meta.server_version,
+            });
+        } catch (err) {
+            throw new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Failed to generate completion for prompt "${completion.prompt}": ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+
+    /**
+     * 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.
+     */
+    @A_Feature.Extend({
+        name: A_FrameSchemaFeatures.Extract,
+        scope: [A_FrameSchema],
+    })
+    async extractSchema<T extends Record<string, unknown>>(
+        @A_Inject(A_Caller) scheme: A_FrameSchema<T>,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const request = new A_FrameChannelRequest<A_Frame_SchemaResponse<T>>(
+            'POST',
+            '/api/v1/schema/extract',
+            {
+                prompt: scheme.prompt,
+                schema: scheme.schema,
+                options: scheme.options,
+            },
+        );
+
+        const executionScope = new A_Scope({
+            name: 'A_FrameChannel.extractSchema',
+            fragments: [request],
+        }).inherit(A_Context.scope(this));
+
+        try {
+            await this.call(A_FrameFeatures.Request, executionScope);
+            executionScope.destroy();
+
+            const response = request.response!;
+
+            if (!response.data) {
+                throw new A_FrameChannelError({
+                    title: A_FrameChannelError.InvalidRequest,
+                    description: `Invalid scheme extraction response for prompt "${scheme.prompt}"`,
+                });
+            }
+
+            scheme.hydrateFromExtraction(response.data, {
+                model: response.model,
+                date: response.date,
+                aFrameVersion: env.A_FRAME_VERSION!,
+                aFrameServerVersion: response.meta.server_version,
+            });
+        } catch (err) {
+            throw new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Failed to extract scheme for prompt "${scheme.prompt}": ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+
 }
 
 

package/src/lib/A-FrameChannel/A-FrameChannel.constants.ts

@@ -3,6 +3,8 @@
 export const A_FrameFeatures = {
     Request: '_A_FRAME_REQUEST',
     Socket:  '_A_FRAME_SOCKET',
+    Stream:  '_A_FRAME_STREAM',
+    Send:    '_A_FRAME_SEND',
 } as const;