@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/chunk-JHZGTVYF.cjs

@@ -0,0 +1,999 @@
+'use strict';
+
+var chunkWTBRJXFG_cjs = require('./chunk-WTBRJXFG.cjs');
+var chunk2KXGI2E5_cjs = require('./chunk-2KXGI2E5.cjs');
+var chunkAY6UMDWD_cjs = require('./chunk-AY6UMDWD.cjs');
+var chunkNWOUVAIS_cjs = require('./chunk-NWOUVAIS.cjs');
+var chunkD2HTYEJZ_cjs = require('./chunk-D2HTYEJZ.cjs');
+var chunk7SEZMRLI_cjs = require('./chunk-7SEZMRLI.cjs');
+var chunk3ZDHQOIU_cjs = require('./chunk-3ZDHQOIU.cjs');
+var chunkM6DJYGDO_cjs = require('./chunk-M6DJYGDO.cjs');
+var chunkMVAWR76Q_cjs = require('./chunk-MVAWR76Q.cjs');
+var chunkHAORARSB_cjs = require('./chunk-HAORARSB.cjs');
+var chunkQFHZIG7Y_cjs = require('./chunk-QFHZIG7Y.cjs');
+var aConcept = require('@adaas/a-concept');
+var http = require('http');
+var https = require('https');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var http__namespace = /*#__PURE__*/_interopNamespace(http);
+var https__namespace = /*#__PURE__*/_interopNamespace(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 aConcept.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 aConcept.A_Error {
+};
+A_FrameChannelError.InvalidRequest = "InvalidRequest";
+A_FrameChannelError.Timeout = "Timeout";
+A_FrameChannelError.RequestFailed = "RequestFailed";
+var A_FrameChannelEvent = class extends aConcept.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 aConcept.A_Entity {
+  static onEvent(name) {
+    const eventName = (name || "all") + A_FrameChannelStreamFeatures.onEvent;
+    return (target, propertyKey, descriptor) => {
+      return aConcept.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 = aConcept.A_Context.allocate(this, new aConcept.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 aConcept.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 aConcept.A_Entity {
+  static get concept() {
+    return "a-frame";
+  }
+  /**
+   * 
+   */
+  get scope() {
+    if (!this._scope) {
+      this._scope = aConcept.A_Context.allocate(this, new aConcept.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 chunkHAORARSB_cjs.A_FrameVector(vector ?? []);
+    const results = chunkD2HTYEJZ_cjs.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");
+  }
+};
+chunkQFHZIG7Y_cjs.__decorateClass([
+  A_FrameChannelStream.onEvent("search_component"),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onSearchComponent", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  A_FrameChannelStream.onEvent("structure_complete"),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureComplete", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  A_FrameChannelStream.onEvent("structure_error"),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelEvent))
+], A_FrameChannelDsgStream.prototype, "onStructureError", 1);
+
+// src/lib/A-FrameChannel/A-FrameChannel.component.ts
+var A_FrameChannel = class extends aConcept.A_Component {
+  async generate(prompt) {
+    const request = new A_FrameChannelRequest("POST", "/api/v1/completions", { prompt, max_tokens: 512 });
+    const executionScope = new aConcept.A_Scope({
+      name: "A_FrameChannel.generate",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.embed",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.getCredentials",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.ping",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.embedDefinition",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.embedNamespace",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.embedNamespace",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:open",
+      fragments: [openRequest]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+        name: "A_FrameChannel.generateDynamicStructure:respond",
+        fragments: [respondRequest]
+      }).inherit(aConcept.A_Context.scope(channel));
+      await channel.call(A_FrameFeatures.Request, respondScope);
+      respondScope.destroy();
+    });
+    const streamScope = new aConcept.A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:stream",
+      entities: [dsgStream]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.generateDynamicStructure:generate",
+      fragments: [generateRequest]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.generateDynamicContent",
+      fragments: [request]
+    }).inherit(aConcept.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 chunkM6DJYGDO_cjs.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 aConcept.A_Scope({
+      name: "A_FrameChannel.patchDynamicContent",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.generateCompletion",
+      fragments: [request]
+    }).inherit(aConcept.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 aConcept.A_Scope({
+      name: "A_FrameChannel.extractSchema",
+      fragments: [request]
+    }).inherit(aConcept.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)}`
+      });
+    }
+  }
+};
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunkMVAWR76Q_cjs.A_FrameDefinitionFeatures.Embed,
+    scope: [chunkMVAWR76Q_cjs.A_FrameDefinition]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameChannel.prototype, "embedDefinition", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunk7SEZMRLI_cjs.A_FrameNamespaceFeatures.Embed,
+    scope: [chunk7SEZMRLI_cjs.A_FrameNamespace]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameChannel.prototype, "embedNamespace", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunkM6DJYGDO_cjs.A_FrameSegmentFeatures.Embed,
+    scope: [chunkM6DJYGDO_cjs.A_FrameSegment]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameChannel.prototype, "embedSegment", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunkAY6UMDWD_cjs.A_FrameDynamicStructureFeatures.Generate,
+    scope: [chunkAY6UMDWD_cjs.A_FrameDynamicStructure]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(A_FrameDynamicSession)),
+  chunkQFHZIG7Y_cjs.__decorateParam(2, aConcept.A_Inject(chunkAY6UMDWD_cjs.A_FrameDynamicStructureOperation))
+], A_FrameChannel.prototype, "generateDynamicStructure", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunk2KXGI2E5_cjs.A_FrameDynamicContentFeatures.Generate,
+    scope: [chunk2KXGI2E5_cjs.A_FrameDynamicContent]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunk2KXGI2E5_cjs.A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "generateDynamicContent", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunk2KXGI2E5_cjs.A_FrameDynamicContentFeatures.Patch,
+    scope: [chunk2KXGI2E5_cjs.A_FrameDynamicContent]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunk2KXGI2E5_cjs.A_FrameDynamicContentOperation))
+], A_FrameChannel.prototype, "patchDynamicContent", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunk3ZDHQOIU_cjs.A_FrameCompletionFeatures.Generate,
+    scope: [chunk3ZDHQOIU_cjs.A_FrameCompletion]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameChannel.prototype, "generateCompletion", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: chunkWTBRJXFG_cjs.A_FrameSchemaFeatures.Extract,
+    scope: [chunkWTBRJXFG_cjs.A_FrameSchema]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(aConcept.A_Caller)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.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__namespace : http__namespace;
+    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__namespace : http__namespace;
+    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__namespace : http__namespace;
+    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();
+    });
+  }
+};
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: A_FrameFeatures.Request,
+    scope: [A_FrameChannel]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelRequest)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameNodeChannel.prototype, "request", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: A_FrameFeatures.Stream,
+    scope: [A_FrameChannel]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelStream)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameNodeChannel.prototype, "stream", 1);
+chunkQFHZIG7Y_cjs.__decorateClass([
+  aConcept.A_Feature.Extend({
+    name: A_FrameFeatures.Send,
+    scope: [A_FrameChannel]
+  }),
+  chunkQFHZIG7Y_cjs.__decorateParam(0, aConcept.A_Inject(A_FrameChannelStream)),
+  chunkQFHZIG7Y_cjs.__decorateParam(1, aConcept.A_Inject(A_FrameChannelEvent)),
+  chunkQFHZIG7Y_cjs.__decorateParam(2, aConcept.A_Inject(chunkNWOUVAIS_cjs.A_FrameEnv))
+], A_FrameNodeChannel.prototype, "send", 1);
+
+exports.A_FrameChannel = A_FrameChannel;
+exports.A_FrameChannelError = A_FrameChannelError;
+exports.A_FrameChannelEvent = A_FrameChannelEvent;
+exports.A_FrameChannelRequest = A_FrameChannelRequest;
+exports.A_FrameChannelSocketFeatures = A_FrameChannelSocketFeatures;
+exports.A_FrameChannelSocketStatuses = A_FrameChannelSocketStatuses;
+exports.A_FrameChannelStream = A_FrameChannelStream;
+exports.A_FrameChannelStreamFeatures = A_FrameChannelStreamFeatures;
+exports.A_FrameChannelStreamStatuses = A_FrameChannelStreamStatuses;
+exports.A_FrameFeatures = A_FrameFeatures;
+exports.A_FrameNodeChannel = A_FrameNodeChannel;
+//# sourceMappingURL=chunk-JHZGTVYF.cjs.map
+//# sourceMappingURL=chunk-JHZGTVYF.cjs.map