@adaas/a-frame 0.0.21 → 0.0.23

package/dist/node/chunk-DMY44VUG.mjs

@@ -0,0 +1,655 @@
+import { A_FrameEnv } from './chunk-F4UCOZW5.mjs';
+import { A_FrameNamespace, A_FrameNamespaceFeatures } from './chunk-APRYHBEF.mjs';
+import { A_FrameDefinition, A_FrameDefinitionFeatures } from './chunk-B7BXP7K4.mjs';
+import { __decorateClass, __decorateParam } from './chunk-OI76LHVT.mjs';
+import { A_Feature, A_Inject, A_Caller, A_Error, A_Component, A_Scope, A_Context, A_Entity, A_Fragment } 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"
+};
+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";
+
+// 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_FrameDynamicStructureOperation = class extends A_Fragment {
+  constructor(params = {}) {
+    super({ name: "a-frame-dynamic-structure-operation-context" });
+    this._meta = /* @__PURE__ */ new Map();
+    this._meta.set("params", params);
+  }
+  get params() {
+    return this._meta.get("params");
+  }
+  get(key) {
+    return this._meta.get(key);
+  }
+  set(key, value) {
+    this._meta.set(key, value);
+  }
+};
+
+// 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/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) {
+    const request = new A_FrameChannelRequest("POST", "/api/embeddings", { input });
+    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/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()
+    });
+    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
+      });
+    } 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()
+    });
+    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 generateDynamicStructure(structure, session, operation) {
+  }
+  // /**
+  //  * Open a bidirectional WebSocket connection to the server.
+  //  *
+  //  * The method resolves once the connection is closed (server close frame or
+  //  * transport end).  While it is pending, call `socket.send(event)` to push
+  //  * frames to the server.  Incoming frames are dispatched automatically to
+  //  * any `@A_FrameChannelSocket.onEvent()` handlers registered on `socket`.
+  //  *
+  //  * @param socket - Pre-configured socket entity (optionally a subclass with
+  //  *                 event handlers pre-registered via `@onEvent` decorators).
+  //  */
+  // async connect(socket: A_FrameChannelSocket): Promise<void> {
+  //     const executionScope = new A_Scope({
+  //         name: 'A_FrameChannel.connect',
+  //         entities: [socket],
+  //     }).inherit(A_Context.scope(this));
+  //     try {
+  //         await this.call(A_FrameFeatures.Socket, executionScope);
+  //         executionScope.destroy();
+  //     } catch (err) {
+  //         executionScope.destroy();
+  //         throw new A_FrameChannelError({
+  //             title: A_FrameChannelError.RequestFailed,
+  //             description: `WebSocket connection to ${socket.path} failed: ${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([
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameDynamicSession)),
+  __decorateParam(2, A_Inject(A_FrameDynamicStructureOperation))
+], A_FrameChannel.prototype, "generateDynamicStructure", 1);
+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._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
+    };
+  }
+};
+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: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+            ...payload ? { "Content-Length": Buffer.byteLength(payload) } : {}
+          }
+        },
+        (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) {
+              console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (empty)`);
+              resolve(void 0);
+              return;
+            }
+            try {
+              const parsed = JSON.parse(raw);
+              console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+              resolve(parsed);
+            } catch {
+              console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (invalid JSON)`);
+              reject(
+                new A_FrameChannelError({
+                  title: A_FrameChannelError.RequestFailed,
+                  description: `Invalid JSON response from ${context.path}`
+                })
+              );
+            }
+          });
+        }
+      );
+      req.setTimeout(15e3, () => {
+        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 15 seconds`
+          })
+        );
+      });
+      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: {
+            "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", () => {
+            console.log(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url} (stream complete)`);
+            resolve();
+          });
+          res.on("error", (err) => reject(err));
+        }
+      );
+      req.setTimeout(6e4, () => {
+        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 60 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;
+            }
+            console.log(`[A-FrameChannel] --> ${res.statusCode} POST ${url} (event: ${event.name})`);
+            resolve();
+          });
+        }
+      );
+      req.setTimeout(15e3, () => {
+        console.error(`[A-FrameChannel] TIMEOUT POST ${url}`);
+        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([
+  __decorateParam(0, A_Inject(A_FrameChannelStream)),
+  __decorateParam(1, A_Inject(A_FrameEnv))
+], A_FrameNodeChannel.prototype, "stream", 1);
+__decorateClass([
+  __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-DMY44VUG.mjs.map
+//# sourceMappingURL=chunk-DMY44VUG.mjs.map