@granular-software/sdk 0.4.14 → 0.4.15

package/dist/index.mjs

@@ -5725,7 +5725,8 @@ var Environment = class extends Session {
               "Authorization": `Bearer ${this._apiKey}`
             },
             body: JSON.stringify({
-              reason: "sdk_disconnect_http_fallback"
+              reason: "sdk_disconnect_http_fallback",
+              sessionId: this.client.currentSessionId
             })
           }
         );
@@ -6509,7 +6510,7 @@ var Environment = class extends Session {
     return super.unpublishAllEffects();
   }
 };
-var Granular = class {
+var Granular = class _Granular {
   apiKey;
   apiUrl;
   httpUrl;
@@ -6679,6 +6680,120 @@ var Granular = class {
         initialHeap: options.initialHeap
       })
     });
+    return this.bindWebSocketEnvironment(envData, clientId, session);
+  }
+  /**
+   * List active (open) sessions for an environment — each session is one agent conversation thread.
+   */
+  async listOpenSessions(filters) {
+    return this.listSessionsForEnvironment(filters.environmentId, "active");
+  }
+  /**
+   * List closed sessions for an environment (conversations that have disconnected).
+   */
+  async listClosedSessions(filters) {
+    return this.listSessionsForEnvironment(filters.environmentId, "closed");
+  }
+  async listSessionsForEnvironment(environmentId, status) {
+    const query = new URLSearchParams({ environmentId, status });
+    const res = await this.request(
+      `/control/sessions?${query.toString()}`
+    );
+    const items = Array.isArray(res.items) ? res.items : [];
+    return items.map((row) => this.normalizeConversationSession(row));
+  }
+  normalizeConversationSession(row) {
+    const sessionId = String(row.sessionId ?? row.session_id ?? "");
+    const environmentId = String(row.environmentId ?? row.environment_id ?? "");
+    return {
+      sessionId,
+      tenantId: row.tenantId != null ? String(row.tenantId) : void 0,
+      environmentId,
+      versionId: row.versionId != null ? String(row.versionId) : null,
+      docId: String(row.docId ?? row.doc_id ?? ""),
+      status: row.status || "active",
+      createdAt: _Granular.coerceIsoDate(row.createdAt ?? row.created_at),
+      lastSeenAt: _Granular.coerceIsoDate(row.lastSeenAt ?? row.last_seen_at),
+      summary: row.summary != null ? String(row.summary) : null,
+      summaryUpdatedAt: row.summaryUpdatedAt != null || row.summary_updated_at != null ? _Granular.coerceIsoDate(row.summaryUpdatedAt ?? row.summary_updated_at) : null,
+      subjectId: row.subjectId != null ? String(row.subjectId) : null,
+      jobCount: typeof row.jobCount === "number" ? row.jobCount : void 0,
+      toolCallCount: typeof row.toolCallCount === "number" ? row.toolCallCount : void 0
+    };
+  }
+  static coerceIsoDate(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number") {
+      return new Date(value).toISOString();
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return (/* @__PURE__ */ new Date(0)).toISOString();
+  }
+  /**
+   * Create a new session (conversation) for an existing environment and connect to it.
+   * The runtime graph is shared across all sessions for the same environment.
+   */
+  async createSession(options) {
+    const clientId = options.clientId || `client_${Date.now()}`;
+    await this.activateEnvironment(options.environmentId);
+    const envData = await this.environments.get(options.environmentId);
+    const session = await this.request("/ws/sessions", {
+      method: "POST",
+      body: JSON.stringify({
+        environmentId: options.environmentId,
+        clientId,
+        initialHeap: options.initialHeap
+      })
+    });
+    return this.bindWebSocketEnvironment(envData, clientId, session);
+  }
+  /**
+   * Connect to an existing open session (same conversation thread) using a freshly minted WebSocket token.
+   */
+  async connectSession(options) {
+    const clientId = options.clientId || `client_${Date.now()}`;
+    const minted = await this.request(`/ws/sessions/${encodeURIComponent(options.sessionId)}/token`, {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+    const envData = await this.environments.get(minted.environmentId);
+    return this.bindWebSocketEnvironment(envData, clientId, minted);
+  }
+  /**
+   * Mark a session closed in the control plane. If `environment` is the connected handle for that
+   * `sessionId`, disconnects the WebSocket so the runtime tears down cleanly.
+   */
+  async closeSession(sessionId, environment) {
+    if (environment && environment.sessionId === sessionId) {
+      await environment.disconnect();
+      return;
+    }
+    await this.request(`/control/sessions/${encodeURIComponent(sessionId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        status: "closed",
+        lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    });
+  }
+  /**
+   * Re-open a closed session in the index and connect to its existing runtime document.
+   */
+  async reopenSession(sessionId, options) {
+    await this.request(`/control/sessions/${encodeURIComponent(sessionId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        status: "active",
+        lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    });
+    return this.connectSession({ sessionId, clientId: options?.clientId });
+  }
+  async bindWebSocketEnvironment(envData, clientId, session) {
     const client = new WSClient({
       url: session.wsUrl,
       sessionId: session.sessionId,