@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/chunk-XP2EPEBM.mjs

@@ -0,0 +1,966 @@
+import { A_FrameSchema, A_FrameSchemaFeatures } from './chunk-GRNVK7DW.mjs';
+import { A_FrameDynamicContent, A_FrameDynamicContentFeatures, A_FrameDynamicContentOperation } from './chunk-5PYIATGT.mjs';
+import { A_FrameDynamicStructure, A_FrameDynamicStructureFeatures, A_FrameDynamicStructureOperation } from './chunk-IP6DFAO7.mjs';
+import { A_FrameEnv } from './chunk-CNU3CRTR.mjs';
+import { A_FrameIndex } from './chunk-2UI7RJ4Q.mjs';
+import { A_FrameNamespace, A_FrameNamespaceFeatures } from './chunk-AMMQ76RJ.mjs';
+import { A_FrameCompletion, A_FrameCompletionFeatures } from './chunk-OK7I5OQ3.mjs';
+import { A_FrameSegment, A_FrameSegmentFeatures } from './chunk-ALFFUJ2J.mjs';
+import { A_FrameDefinition, A_FrameDefinitionFeatures } from './chunk-RWLKISZQ.mjs';
+import { A_FrameVector } from './chunk-IAL2NK2V.mjs';
+import { __decorateClass, __decorateParam } from './chunk-OI76LHVT.mjs';
+import { A_Inject, A_Feature, A_Caller, A_Error, A_Entity, A_Context, A_Scope, A_Fragment, A_Component } from '@adaas/a-concept';
+import * as http from 'http';
+import * as https from 'https';
+
+// src/lib/A-FrameChannel/A-FrameChannel.constants.ts
+var A_FrameFeatures = {
+  Request: "_A_FRAME_REQUEST",
+  Socket: "_A_FRAME_SOCKET",
+  Stream: "_A_FRAME_STREAM",
+  Send: "_A_FRAME_SEND"
+};
+var A_FrameChannelStreamStatuses = {
+  Open: "open",
+  Closed: "closed"
+};
+var A_FrameChannelStreamFeatures = {
+  open: "_A_FRAME_CHANNEL_STREAM_OPEN",
+  send: "_A_FRAME_CHANNEL_STREAM_SEND",
+  onEvent: "_A_FRAME_CHANNEL_STREAM_ON_EVENT",
+  onError: "_A_FRAME_CHANNEL_STREAM_ON_ERROR",
+  onComplete: "_A_FRAME_CHANNEL_STREAM_ON_COMPLETE",
+  onClose: "_A_FRAME_CHANNEL_STREAM_ON_CLOSE"
+};
+var A_FrameChannelSocketStatuses = {
+  Connecting: "connecting",
+  Open: "open",
+  Closed: "closed"
+};
+var A_FrameChannelSocketFeatures = {
+  onEvent: "_A_FRAME_CHANNEL_SOCKET_ON_EVENT",
+  onError: "_A_FRAME_CHANNEL_SOCKET_ON_ERROR",
+  onOpen: "_A_FRAME_CHANNEL_SOCKET_ON_OPEN",
+  onClose: "_A_FRAME_CHANNEL_SOCKET_ON_CLOSE"
+};
+var A_FrameChannelRequest = class extends A_Fragment {
+  constructor(method, path, body) {
+    super({ name: "a-frame-channel-request" });
+    this.method = method;
+    this.path = path;
+    this.body = body;
+  }
+  complete(response) {
+    this._response = response;
+  }
+  fail(error) {
+    this._error = error;
+  }
+  get response() {
+    return this._response;
+  }
+  get error() {
+    return this._error;
+  }
+};
+var A_FrameChannelError = class extends A_Error {
+};
+A_FrameChannelError.InvalidRequest = "InvalidRequest";
+A_FrameChannelError.Timeout = "Timeout";
+A_FrameChannelError.RequestFailed = "RequestFailed";
+var A_FrameChannelEvent = class extends A_Fragment {
+  constructor(name, data) {
+    super({ name: "a-frame-channel-event-" + name });
+    this._data = data;
+    this._eventName = name;
+  }
+  get name() {
+    return this._eventName;
+  }
+  get data() {
+    return this._data;
+  }
+};
+var A_FrameChannelStream = class extends A_Entity {
+  static onEvent(name) {
+    const eventName = (name || "all") + A_FrameChannelStreamFeatures.onEvent;
+    return (target, propertyKey, descriptor) => {
+      return A_Feature.Extend({
+        name: eventName,
+        scope: [target.constructor]
+      })(target, propertyKey, descriptor);
+    };
+  }
+  /**
+   * The scope of the session, Will be destroyed after the session is closed.
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+    }
+    return this._scope;
+  }
+  get method() {
+    return this._method;
+  }
+  get path() {
+    return this._path;
+  }
+  get body() {
+    return this._body;
+  }
+  get status() {
+    return this._status;
+  }
+  get error() {
+    return this._error;
+  }
+  get initDate() {
+    return new Date(this._initDate);
+  }
+  complete() {
+    this._status = A_FrameChannelStreamStatuses.Closed;
+  }
+  fail(error) {
+    this._status = A_FrameChannelStreamStatuses.Closed;
+    this._error = error;
+  }
+  destroy() {
+    this.scope.destroy();
+  }
+  async open() {
+    await this.call(A_FrameChannelStreamFeatures.open);
+  }
+  async send() {
+    await this.call(A_FrameChannelStreamFeatures.send);
+  }
+  async propagate(name, data) {
+    const request = new A_FrameChannelEvent(name, data);
+    const executionScope = new A_Scope({
+      name: "A_FrameChannelStream.propagate",
+      fragments: [request]
+    }).inherit(this.scope);
+    try {
+      const callName = (name || "all") + A_FrameChannelStreamFeatures.onEvent;
+      await this.call(callName, executionScope);
+      executionScope.destroy();
+    } catch {
+      executionScope.destroy();
+    }
+  }
+  fromNew(newEntity) {
+    this.aseid = this.generateASEID();
+    this._method = newEntity.method;
+    this._path = newEntity.path;
+    this._body = newEntity.body;
+    this._initDate = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  fromJSON(serialized) {
+    this._method = serialized.method;
+    this._path = serialized.path;
+    this._body = serialized.body;
+    this._initDate = serialized.initDate;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      initDate: this._initDate,
+      status: this._status,
+      error: this._error ? this._error.toJSON() : void 0,
+      method: this._method,
+      path: this._path,
+      body: this._body
+    };
+  }
+};
+
+// src/lib/A-FrameDynamicSession/A-FrameDynamicSession.constants.ts
+var A_FrameDynamicSessionFeatures = {
+  Init: "_A_FRAME_DYNAMIC_SESSION_INIT",
+  Question: "_A_FRAME_DYNAMIC_SESSION_QUESTION",
+  Answer: "_A_FRAME_DYNAMIC_SESSION_ANSWER",
+  Destroy: "_A_FRAME_DYNAMIC_SESSION_DESTROY"
+};
+
+// src/lib/A-FrameDynamicSession/A-FrameDynamicSession.entity.ts
+var A_FrameDynamicSession = class extends A_Entity {
+  static get concept() {
+    return "a-frame";
+  }
+  /**
+   * 
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+    }
+    return this._scope;
+  }
+  get currentTurn() {
+    return this._currentTurn;
+  }
+  get initDate() {
+    return new Date(this._initDate);
+  }
+  static onQuestion() {
+    return;
+  }
+  static onAnswer() {
+    return;
+  }
+  fromNew(newEntity) {
+    this._turnsCount = newEntity.turnsCount || 5;
+    this._currentTurn = 0;
+    this._initDate = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  fromJSON(serialized) {
+    this._turnsCount = serialized.turnsCount;
+    this._currentTurn = serialized.currentTurn;
+    this._initDate = serialized.initDate;
+  }
+  async init() {
+    await this.call(A_FrameDynamicSessionFeatures.Init);
+  }
+  async destroy(scope) {
+    await this.call(A_FrameDynamicSessionFeatures.Destroy, scope);
+  }
+  async question() {
+    this._currentTurn++;
+    await this.call(A_FrameDynamicSessionFeatures.Question);
+  }
+  async answer() {
+    await this.call(A_FrameDynamicSessionFeatures.Answer);
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      turnsCount: this._turnsCount,
+      currentTurn: this._currentTurn,
+      initDate: this._initDate
+    };
+  }
+};
+var A_FrameChannelDsgStream = class extends A_FrameChannelStream {
+  constructor() {
+    super(...arguments);
+    this._resolvedComponents = [];
+  }
+  // ── Configuration ──────────────────────────────────────────────────────
+  /**
+   * Provide the callback that sends a component-search response back to the
+   * server via HTTP POST.  Must be set before the SSE stream is opened.
+   */
+  setRespondFn(fn) {
+    this._respondFn = fn;
+  }
+  // ── Result accessor ────────────────────────────────────────────────────
+  /**
+   * Contains the resolved components after `structure_complete` is received.
+   * Empty until the server pushes the final structure.
+   */
+  get resolvedComponents() {
+    return this._resolvedComponents;
+  }
+  async onSearchComponent(event) {
+    if (!this._respondFn) return;
+    const { requestId, vector } = event.data;
+    const queryVector = new A_FrameVector(vector ?? []);
+    const results = A_FrameIndex.search(queryVector, { topK: 1 });
+    const top = results[0];
+    await this._respondFn(requestId, {
+      component: top?.record?.name ?? null,
+      score: top?.score ?? 0
+    });
+  }
+  async onStructureComplete(event) {
+    const { components } = event.data;
+    this._resolvedComponents = Array.isArray(components) ? components : [];
+  }
+  async onStructureError(event) {
+    const { message } = event.data ?? {};
+    console.error("[A_FrameChannelDsgStream] Server reported structure error:", message ?? "unknown");
+  }
+};
+__decorateClass([
+  A_FrameChannelStream.onEvent("search_component"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onSearchComponent", 1);
+__decorateClass([
+  A_FrameChannelStream.onEvent("structure_complete"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureComplete", 1);
+__decorateClass([
+  A_FrameChannelStream.onEvent("structure_error"),
+  __decorateParam(0, A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureError", 1);
+
+// src/lib/A-FrameChannel/A-FrameChannel.component.ts
+var A_FrameChannel = class extends A_Component {
+  async generate(prompt) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/completions", { prompt, max_tokens: 512 });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.generate",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to generate completion: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embed(input, options) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/embeddings", {
+      input,
+      ...options?.model && { model: options.model },
+      ...options?.task && { task: options.task }
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embed",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed input: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async getCredentials() {
+    const request = new A_FrameChannelRequest("GET", "/api/v1/credentials/me");
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.getCredentials",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch (err) {
+      executionScope.destroy();
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to get credentials: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async ping() {
+    const request = new A_FrameChannelRequest("GET", "/health");
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.ping",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      executionScope.destroy();
+      return request;
+    } catch {
+      executionScope.destroy();
+      return request;
+    }
+  }
+  async embedDefinition(definition, env) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/definition/embed", {
+      definition: definition.toJSON(),
+      model: definition.requestedModel
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embedDefinition",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      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: `Invalid embedding response for definition "${definition.name}"`
+        });
+      }
+      const vector = new Float32Array(response.data[0].embedding);
+      definition.hydrateFromEmbedding(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,
+        date: response.date,
+        aFrameMeta: response.aFrameMeta
+      });
+    } catch (err) {
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed definition "${definition.name}": ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embedNamespace(namespace, env) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/namespace/embed", {
+      namespace: namespace.toJSON(),
+      model: namespace.requestedModel
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameChannel.embedNamespace",
+      fragments: [request]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameFeatures.Request, executionScope);
+      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: `Invalid embedding response for namespace "${namespace.name}"`
+        });
+      }
+      const vector = new Float32Array(response.data[0].embedding);
+      namespace.hydrateFromEmbedding(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,
+        date: response.date
+      });
+    } catch (err) {
+      throw new A_FrameChannelError({
+        title: A_FrameChannelError.RequestFailed,
+        description: `Failed to embed namespace "${namespace.name}": ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async embedSegment(segment, env) {
+    const request = new A_FrameChannelRequest("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);
+      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)}`
+      });
+    }
+  }
+  async generateDynamicStructure(structure, session, operation) {
+    const openRequest = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/dsg/stream/open"
+    );
+    const openScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:open",
+      fragments: [openRequest]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, openScope);
+    openScope.destroy();
+    const { channelId } = openRequest.response;
+    const channel = this;
+    const dsgStream = new A_FrameChannelDsgStream({
+      method: "GET",
+      path: `/api/v1/dsg/stream/${channelId}`
+    });
+    dsgStream.setRespondFn(async (requestId, data) => {
+      const respondRequest = new A_FrameChannelRequest(
+        "POST",
+        "/api/v1/dsg/stream/respond",
+        { requestId, data }
+      );
+      const respondScope = new A_Scope({
+        name: "A_FrameChannel.generateDynamicStructure:respond",
+        fragments: [respondRequest]
+      }).inherit(A_Context.scope(channel));
+      await channel.call(A_FrameFeatures.Request, respondScope);
+      respondScope.destroy();
+    });
+    const streamScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:stream",
+      entities: [dsgStream]
+    }).inherit(A_Context.scope(this));
+    const streamTask = this.call(A_FrameFeatures.Stream, streamScope);
+    const generateRequest = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/dsg/structure/generate-stream",
+      { channelId, prompt: structure.prompt }
+    );
+    const generateScope = new A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:generate",
+      fragments: [generateRequest]
+    }).inherit(A_Context.scope(this));
+    await this.call(A_FrameFeatures.Request, generateScope);
+    generateScope.destroy();
+    await streamTask;
+    streamScope.destroy();
+    structure.hydrateFromResolved(
+      dsgStream.resolvedComponents,
+      { model: "sse-stream", serverVersion: "0.0.0" }
+    );
+  }
+  async generateDynamicContent(content, operation) {
+    const request = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/content/generate",
+      {
+        prompt: content.prompt,
+        model: content.modelName,
+        ...content.systemPrompt !== void 0 ? { 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;
+    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"
+    });
+  }
+  async patchDynamicContent(content, operation) {
+    const { instruction, segments } = operation.params;
+    const wireIdToAseid = /* @__PURE__ */ new Map();
+    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) : void 0
+      };
+    });
+    const request = new A_FrameChannelRequest(
+      "POST",
+      "/api/v1/content/patch",
+      {
+        prompt: content.prompt,
+        segments: wireSegments,
+        instruction,
+        model: content.modelName,
+        ...content.systemPrompt !== void 0 ? { 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;
+    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"
+      }
+    );
+  }
+  async generateCompletion(completion, env) {
+    const request = new A_FrameChannelRequest(
+      "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)}`
+      });
+    }
+  }
+  async extractSchema(scheme, env) {
+    const request = new A_FrameChannelRequest(
+      "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)}`
+      });
+    }
+  }
+};
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDefinitionFeatures.Embed,
+    scope: [A_FrameDefinition]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedDefinition", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameNamespaceFeatures.Embed,
+    scope: [A_FrameNamespace]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedNamespace", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameSegmentFeatures.Embed,
+    scope: [A_FrameSegment]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "embedSegment", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicStructureFeatures.Generate,
+    scope: [A_FrameDynamicStructure]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicSession)),
+  __decorateParam(2, A_Inject(A_FrameDynamicStructureOperation))
+], A_FrameChannel.prototype, "generateDynamicStructure", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicContentFeatures.Generate,
+    scope: [A_FrameDynamicContent]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "generateDynamicContent", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDynamicContentFeatures.Patch,
+    scope: [A_FrameDynamicContent]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "patchDynamicContent", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameCompletionFeatures.Generate,
+    scope: [A_FrameCompletion]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "generateCompletion", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameSchemaFeatures.Extract,
+    scope: [A_FrameSchema]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameChannel.prototype, "extractSchema", 1);
+var A_FrameNodeChannel = class extends A_FrameChannel {
+  async request(context, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${context.path}`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = context.body !== void 0 ? JSON.stringify(context.body) : void 0;
+    const result = await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: context.method,
+          headers: {
+            ...payload ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) } : {},
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`
+          }
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+          res.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if ((res.statusCode ?? 500) >= 400) {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Request to ${context.path} failed with status ${res.statusCode}`
+                })
+              );
+              return;
+            }
+            if (!raw) {
+              resolve(void 0);
+              return;
+            }
+            try {
+              const parsed = JSON.parse(raw);
+              resolve(parsed);
+            } catch {
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Invalid JSON response from ${context.path}`
+                })
+              );
+            }
+          });
+        }
+      );
+      req.setTimeout(env.A_FRAME_REQUEST_TIMEOUT, () => {
+        console.error(`[A-FrameChannel] TIMEOUT ${context.method} ${url}`);
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Request to ${context.path} timed out after ${env.A_FRAME_REQUEST_TIMEOUT}ms`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      if (payload) req.write(payload);
+      req.end();
+    });
+    context.complete(result);
+  }
+  async stream(stream, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${stream.path}`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = stream.body !== void 0 ? JSON.stringify(stream.body) : void 0;
+    await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: stream.method,
+          headers: {
+            ...payload ? { "Content-Type": "application/json" } : {},
+            Accept: "text/event-stream",
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+            ...payload ? { "Content-Length": Buffer.byteLength(payload) } : {}
+          }
+        },
+        (res) => {
+          if ((res.statusCode ?? 500) >= 400) {
+            console.error(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url}`);
+            reject(
+              new A_FrameChannelError({
+                title: A_FrameChannelError.RequestFailed,
+                description: `Stream request to ${stream.path} failed with status ${res.statusCode}`
+              })
+            );
+            return;
+          }
+          let buffer = "";
+          res.on("data", async (chunk) => {
+            buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.startsWith("data: ")) continue;
+              const data = line.slice(6).trim();
+              if (data === "[DONE]") continue;
+              try {
+                const event = JSON.parse(data);
+                await stream.propagate(event.type, event.data);
+              } catch {
+                console.error(`[A-FrameChannel] Invalid SSE payload from ${stream.path}: ${data}`);
+              }
+            }
+          });
+          res.on("end", () => {
+            resolve();
+          });
+          res.on("error", (err) => reject(err));
+        }
+      );
+      req.setTimeout(3e5, () => {
+        console.error(`[A-FrameChannel] TIMEOUT ${stream.method} ${url}`);
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Stream request to ${stream.path} timed out after 300 seconds`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      if (payload) req.write(payload);
+      req.end();
+    });
+    stream.complete();
+  }
+  async send(stream, event, env) {
+    const url = `${env.A_FRAME_SERVER_URL}${stream.path}/send`;
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const payload = JSON.stringify({ type: event.name, data: event.data });
+    await new Promise((resolve, reject) => {
+      const req = client.request(
+        {
+          protocol: parsedUrl.protocol,
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port,
+          path: `${parsedUrl.pathname}${parsedUrl.search}`,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+            "Content-Length": Buffer.byteLength(payload)
+          }
+        },
+        (res) => {
+          res.resume();
+          res.on("end", () => {
+            if ((res.statusCode ?? 500) >= 400) {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} POST ${url}`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Send event "${event.name}" to ${stream.path} failed with status ${res.statusCode}`
+                })
+              );
+              return;
+            }
+            resolve();
+          });
+        }
+      );
+      req.setTimeout(15e3, () => {
+        req.destroy(
+          new A_FrameChannelError({
+            title: A_FrameChannelError.Timeout,
+            description: `Send event "${event.name}" to ${stream.path} timed out after 15 seconds`
+          })
+        );
+      });
+      req.on("error", (err) => reject(err));
+      req.write(payload);
+      req.end();
+    });
+  }
+};
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Request,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelRequest)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "request", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Stream,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelStream)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "stream", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameFeatures.Send,
+    scope: [A_FrameChannel]
+  }),
+  __decorateParam(0, A_Inject(A_FrameChannelStream)),
+  __decorateParam(1, A_Inject(A_FrameChannelEvent)),
+  __decorateParam(2, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "send", 1);
+
+export { A_FrameChannel, A_FrameChannelError, A_FrameChannelEvent, A_FrameChannelRequest, A_FrameChannelSocketFeatures, A_FrameChannelSocketStatuses, A_FrameChannelStream, A_FrameChannelStreamFeatures, A_FrameChannelStreamStatuses, A_FrameFeatures, A_FrameNodeChannel };
+//# sourceMappingURL=chunk-XP2EPEBM.mjs.map
+//# sourceMappingURL=chunk-XP2EPEBM.mjs.map