@granular-software/sdk 0.4.16 → 0.4.18

package/dist/index.mjs

@@ -3928,6 +3928,12 @@ var READY_STATE_OPEN = 1;
 var TOKEN_REFRESH_LEEWAY_MS = 2 * 60 * 1e3;
 var TOKEN_REFRESH_RETRY_MS = 30 * 1e3;
 var MAX_TIMER_DELAY_MS = 2147483647;
+var DEBUG_WS = process.env.GRANULAR_DEBUG_WS === "1";
+function debugWs(...args) {
+  if (DEBUG_WS) {
+    console.log(...args);
+  }
+}
 var WSClient = class {
   ws = null;
   url;
@@ -4227,7 +4233,7 @@ var WSClient = class {
   }
   handleMessage(message) {
     if (typeof message !== "object" || message === null) return;
-    console.log("[Granular DEBUG] Received message:", JSON.stringify(message).slice(0, 500));
+    debugWs("[Granular DEBUG] Received message:", JSON.stringify(message).slice(0, 500));
     if ("type" in message && message.type === "sync") {
       const syncMessage = message;
       let bytes;
@@ -4247,7 +4253,7 @@ var WSClient = class {
         } else {
           return;
         }
-        console.log("[Granular DEBUG] Applying sync bytes:", bytes.length);
+        debugWs("[Granular DEBUG] Applying sync bytes:", bytes.length);
         const [newDoc, newSyncState] = Automerge.receiveSyncMessage(
           this.doc,
           this.syncState,
@@ -4257,19 +4263,19 @@ var WSClient = class {
         this.syncState = newSyncState;
         const docAny = this.doc;
         if (docAny.catalog) {
-          console.log("[Granular DEBUG] Doc catalog sync applied. Keys in catalog:", Object.keys(docAny.catalog || {}));
-          console.log("[Granular DEBUG] RawToolCatalogs:", Object.keys(docAny.catalog.rawToolCatalogs || {}));
+          debugWs("[Granular DEBUG] Doc catalog sync applied. Keys in catalog:", Object.keys(docAny.catalog || {}));
+          debugWs("[Granular DEBUG] RawToolCatalogs:", Object.keys(docAny.catalog.rawToolCatalogs || {}));
         } else {
-          console.log("[Granular DEBUG] Doc synced but no catalog yet. Keys in doc:", Object.keys(docAny));
+          debugWs("[Granular DEBUG] Doc synced but no catalog yet. Keys in doc:", Object.keys(docAny));
         }
         this.emit("sync", this.doc);
       } catch (e) {
         try {
-          console.log("[Granular DEBUG] receiveSyncMessage failed, trying applyChanges...");
+          debugWs("[Granular DEBUG] receiveSyncMessage failed, trying applyChanges...");
           const [newDoc] = Automerge.applyChanges(this.doc, [bytes]);
           this.doc = newDoc;
           this.emit("sync", this.doc);
-          console.log("[Granular DEBUG] applyChanges succeeded. Doc:", JSON.stringify(Automerge.toJS(this.doc)));
+          debugWs("[Granular DEBUG] applyChanges succeeded. Doc:", JSON.stringify(Automerge.toJS(this.doc)));
         } catch (applyError) {
           console.warn("[Granular] Failed to apply sync message (both sync & applyChanges)", e, applyError);
         }
@@ -4280,10 +4286,10 @@ var WSClient = class {
       const snapshotMessage = message;
       try {
         const bytes = new Uint8Array(snapshotMessage.data);
-        console.log("[Granular DEBUG] Loading Automerge session snapshot bytes:", bytes.length);
+        debugWs("[Granular DEBUG] Loading Automerge session snapshot bytes:", bytes.length);
         this.doc = Automerge.load(bytes);
         this.emit("sync", this.doc);
-        console.log("[Granular DEBUG] Automerge session snapshot loaded. Doc:", JSON.stringify(Automerge.toJS(this.doc)));
+        debugWs("[Granular DEBUG] Automerge session snapshot loaded. Doc:", JSON.stringify(Automerge.toJS(this.doc)));
       } catch (e) {
         console.warn("[Granular] Failed to load snapshot message", e);
       }
@@ -11321,6 +11327,7 @@ var Environment = class extends Session {
       headers: {
         "Authorization": `Bearer ${this._apiKey}`,
         "Content-Type": "application/json",
+        "Connection": "close",
         ...options.headers
       }
     });
@@ -11355,7 +11362,8 @@ var Environment = class extends Session {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
-              "Authorization": `Bearer ${this._apiKey}`
+              "Authorization": `Bearer ${this._apiKey}`,
+              "Connection": "close"
             },
             body: JSON.stringify({
               reason: "sdk_disconnect_http_fallback",
@@ -11815,6 +11823,70 @@ var Environment = class extends Session {
       await this._runGraphql(mutation.query, mutation.label);
     }
   }
+  async _ensureWorkspaceStreamsRoot() {
+    await this._runGraphql(
+      `mutation { create_model(path: "workspace", label: "workspace") { model { path } } }`,
+      "ensure workspace"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    await this._runGraphql(
+      `mutation { at(path: "workspace") { create_submodel(subpath: "streams", label: "Streams") { model { path } } } }`,
+      "ensure workspace:streams"
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+  }
+  async _applyEventStreamDeclaration(stream) {
+    await this._ensureWorkspaceStreamsRoot();
+    const streamPath = `workspace:streams:${stream.name}`;
+    await this._runGraphql(
+      `mutation { at(path: "workspace:streams") { create_submodel(subpath: ${JSON.stringify(stream.name)}, label: ${JSON.stringify(stream.name)}) { model { path } } } }`,
+      `create stream ${stream.name}`
+    ).catch((error) => {
+      if (!error.message.includes("already exists")) throw error;
+    });
+    if (stream.description) {
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(streamPath)}) { set_description(description: ${JSON.stringify(stream.description)}) { done } } }`,
+        `set stream description on ${streamPath}`
+      );
+    }
+    for (const eventType of stream.eventTypes) {
+      const typePath = `${streamPath}:${eventType.name}`;
+      await this._runGraphql(
+        `mutation { at(path: ${JSON.stringify(streamPath)}) { create_submodel(subpath: ${JSON.stringify(eventType.name)}, label: ${JSON.stringify(eventType.name)}) { model { path } } } }`,
+        `create event type ${eventType.name} on ${streamPath}`
+      ).catch((error) => {
+        if (!error.message.includes("already exists")) throw error;
+      });
+      if (eventType.description) {
+        await this._runGraphql(
+          `mutation { at(path: ${JSON.stringify(typePath)}) { set_description(description: ${JSON.stringify(eventType.description)}) { done } } }`,
+          `set event type description on ${typePath}`
+        );
+      }
+      if (eventType.payloadSchema?.properties) {
+        const fieldSpecs = {};
+        for (const [propName, propSchema] of Object.entries(eventType.payloadSchema.properties)) {
+          const schema = propSchema;
+          fieldSpecs[propName] = {
+            type: schema.type ?? "string",
+            description: schema.description
+          };
+        }
+        await this._applyFields(typePath, fieldSpecs);
+      }
+      if (eventType.payloadSchema?.required?.length) {
+        await this._runGraphql(
+          `mutation { at(path: ${JSON.stringify(typePath)}) { create_submodel(subpath: "required", label: "required") { set_string_value(value: ${JSON.stringify(JSON.stringify(eventType.payloadSchema.required))}) { done } } } }`,
+          `store required fields on ${typePath}`
+        ).catch((error) => {
+          if (!error.message.includes("already exists")) throw error;
+        });
+      }
+    }
+  }
   async _applyEffectDeclaration(effect, aliasMap) {
     let containerPath = "workspace:tools:declared";
     if (effect.attachedClass) {
@@ -11902,6 +11974,9 @@ var Environment = class extends Session {
     if (op.withEffect) {
       await this._applyEffectDeclaration(op.withEffect, aliasMap);
     }
+    if (op.defineEventStream) {
+      await this._applyEventStreamDeclaration(op.defineEventStream);
+    }
   }
   /**
    * Apply field definitions (has) to a model via GraphQL
@@ -12151,6 +12226,7 @@ var Granular = class _Granular {
   WebSocketCtor;
   onUnexpectedClose;
   onReconnectError;
+  debugHttp = process.env.GRANULAR_DEBUG_HTTP === "1";
   /** Sandbox-level effect registry: sandboxId → (effectKey → ToolWithHandler) */
   sandboxEffects = /* @__PURE__ */ new Map();
   /** Live sandbox-scoped effect hosts keyed by sandboxId */
@@ -12874,6 +12950,107 @@ var Granular = class _Granular {
       }
     };
   }
+  /**
+   * Event stream operations: query, subscribe, and acknowledge stream events
+   */
+  get streams() {
+    return {
+      getEvents: async (params) => {
+        const sandbox = await this._resolveSandboxId(params.ontology);
+        const query = new URLSearchParams({ sandboxId: sandbox });
+        if (params.environment) query.set("environmentId", params.environment);
+        if (params.session) query.set("sessionId", params.session);
+        if (params.stream) query.set("streamName", params.stream);
+        if (params.eventTypes && params.eventTypes.length > 0) {
+          query.set("eventTypes", params.eventTypes.join(","));
+        }
+        if (params.since) query.set("since", params.since.toISOString());
+        if (params.until) query.set("until", params.until.toISOString());
+        if (params.isAcked !== void 0) query.set("isAcked", params.isAcked ? "1" : "0");
+        if (params.limit) query.set("limit", String(params.limit));
+        if (params.offset) query.set("offset", String(params.offset));
+        const result = await this.request(`/control/stream-events?${query.toString()}`);
+        return (result.items || []).map((row) => ({
+          eventId: row.event_id,
+          streamName: row.stream_name,
+          eventType: row.event_type,
+          payload: typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload,
+          environmentId: row.environment_id,
+          sessionId: row.session_id,
+          subjectId: row.subject_id,
+          source: row.source,
+          isAcked: Boolean(row.is_acked),
+          createdAt: row.created_at
+        }));
+      },
+      subscribe: (params) => {
+        const interval = params.pollIntervalMs ?? 5e3;
+        let cursor = params.since || /* @__PURE__ */ new Date();
+        let running = true;
+        const seenEventIds = /* @__PURE__ */ new Set();
+        const poll = async () => {
+          while (running) {
+            try {
+              const events = await this.streams.getEvents({
+                ontology: params.ontology,
+                stream: params.stream,
+                environment: params.environment,
+                session: params.session,
+                eventTypes: params.eventTypes,
+                since: cursor,
+                limit: 100
+              });
+              const orderedEvents = [...events].sort((a, b) => a.createdAt - b.createdAt);
+              for (const event of orderedEvents) {
+                if (seenEventIds.has(event.eventId)) {
+                  continue;
+                }
+                seenEventIds.add(event.eventId);
+                const eventTime = new Date(event.createdAt * 1e3);
+                if (eventTime > cursor) {
+                  cursor = eventTime;
+                }
+                params.onEvent(event);
+              }
+            } catch (err) {
+              params.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            await new Promise((resolve) => setTimeout(resolve, interval));
+          }
+        };
+        poll();
+        return { unsubscribe: () => {
+          running = false;
+        } };
+      },
+      ack: async (eventId) => {
+        await this.request("/control/stream-events/ack", {
+          method: "POST",
+          body: JSON.stringify({ eventIds: [eventId] })
+        });
+      },
+      ackBatch: async (eventIds) => {
+        await this.request("/control/stream-events/ack", {
+          method: "POST",
+          body: JSON.stringify({ eventIds })
+        });
+      },
+      getStats: async (params) => {
+        const sandbox = await this._resolveSandboxId(params.ontology);
+        const query = new URLSearchParams({ sandboxId: sandbox });
+        if (params.environment) query.set("environmentId", params.environment);
+        const result = await this.request(`/control/stream-events/stats?${query.toString()}`);
+        return (result.items || []).map((row) => ({
+          streamName: row.stream_name,
+          eventType: row.event_type,
+          total: Number(row.total),
+          last1h: Number(row.last_1h),
+          last24h: Number(row.last_24h),
+          unacked: Number(row.unacked)
+        }));
+      }
+    };
+  }
   /**
    * Subject management
    */
@@ -12907,17 +13084,26 @@ var Granular = class _Granular {
       }
     };
   }
+  async _resolveSandboxId(ontologyNameOrId) {
+    if (ontologyNameOrId.startsWith("sbx_")) return ontologyNameOrId;
+    const result = await this.request(`/control/sandboxes?name=${encodeURIComponent(ontologyNameOrId)}`);
+    if (result.items.length === 0) throw new Error(`Ontology not found: ${ontologyNameOrId}`);
+    return result.items[0].sandboxId;
+  }
   /**
    * Make an authenticated API request
    */
   async request(path, options = {}) {
     const url = `${this.httpUrl}${path}`;
-    console.log(`[SDK] Requesting: ${url}`);
+    if (this.debugHttp) {
+      console.log(`[SDK] Requesting: ${url}`);
+    }
     const response = await fetch(url, {
       ...options,
       headers: {
         "Authorization": `Bearer ${this.apiKey}`,
         "Content-Type": "application/json",
+        "Connection": "close",
         ...options.headers
       }
     });