@minded-ai/mindedjs 1.0.19 → 1.0.21

package/test/checkpoint-saver/minded-checkpoint-saver-list.test.ts

@@ -0,0 +1,138 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import * as sinon from 'sinon';
+import { MindedCheckpointSaver } from '../../src/platform/mindedCheckpointSaver';
+import * as mindedRequestModule from '../../src/platform/mindedRequest';
+import { Checkpoint, CheckpointTuple, CheckpointMetadata, emptyCheckpoint, CheckpointListOptions } from '@langchain/langgraph-checkpoint';
+import { RunnableConfig } from '@langchain/core/runnables';
+import { HumanMessage, AIMessage, SystemMessage } from '@langchain/core/messages';
+
+describe('MindedCheckpointSaver - List Method', function () {
+  let checkpointSaver: MindedCheckpointSaver;
+  let mindedRequestStub: sinon.SinonStub;
+  const testToken = 'test-token-456';
+
+  beforeEach(() => {
+    checkpointSaver = new MindedCheckpointSaver(testToken);
+    mindedRequestStub = sinon.stub(mindedRequestModule, 'mindedRequest');
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('list', () => {
+    it('should deserialize multiple checkpoints with different message types', async () => {
+      // Create original checkpoints with proper class instances
+      const checkpoint1: Checkpoint = {
+        ...emptyCheckpoint(),
+        id: 'checkpoint-1',
+        channel_values: {
+          messages: [new HumanMessage('First message')],
+        },
+      };
+
+      const checkpoint2: Checkpoint = {
+        ...emptyCheckpoint(),
+        id: 'checkpoint-2',
+        channel_values: {
+          messages: [new SystemMessage('System prompt'), new AIMessage('AI response')],
+        },
+      };
+
+      const metadata1: CheckpointMetadata = {
+        source: 'input',
+        step: 1,
+        writes: {},
+        parents: {},
+      };
+
+      const metadata2: CheckpointMetadata = {
+        source: 'loop',
+        step: 2,
+        writes: {},
+        parents: {},
+      };
+
+      // Simulate JSON serialization (what happens during HTTP transport)
+      const jsonCheckpoint1 = JSON.parse(JSON.stringify(checkpoint1));
+      const jsonCheckpoint2 = JSON.parse(JSON.stringify(checkpoint2));
+      const jsonMetadata1 = JSON.parse(JSON.stringify(metadata1));
+      const jsonMetadata2 = JSON.parse(JSON.stringify(metadata2));
+
+      const mockServerResponse = {
+        checkpoints: [
+          {
+            config: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } },
+            checkpoint: jsonCheckpoint1,
+            metadata: jsonMetadata1,
+            parentConfig: undefined,
+          },
+          {
+            config: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-2' } },
+            checkpoint: jsonCheckpoint2,
+            metadata: jsonMetadata2,
+            parentConfig: { configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } },
+          },
+        ],
+      };
+
+      // Mock the HTTP response with JSON-serialized objects (no class info)
+      mindedRequestStub.resolves(mockServerResponse);
+
+      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
+      const options: CheckpointListOptions = { limit: 10 };
+
+      const results: CheckpointTuple[] = [];
+      for await (const tuple of checkpointSaver.list(config, options)) {
+        results.push(tuple);
+      }
+
+      // Verify the request was made correctly
+      expect(mindedRequestStub.calledOnce).to.equal(true);
+      expect(mindedRequestStub.firstCall.args[0]).to.deep.include({
+        path: '/sdk-checkpoints/list',
+        method: 'POST',
+        body: { config, options },
+        token: testToken,
+      });
+
+      // Verify we got the correct number of results
+      expect(results).to.have.length(2);
+
+      // Verify first checkpoint - JSON objects should be restored to proper classes
+      const result1 = results[0];
+      expect(result1.checkpoint.id).to.equal('checkpoint-1');
+      expect(result1.metadata?.source).to.equal('input');
+      const messages1 = result1.checkpoint.channel_values.messages as any[];
+      expect(messages1).to.have.length(1);
+      expect(messages1[0]).to.be.instanceOf(HumanMessage);
+      expect(messages1[0].content).to.equal('First message');
+
+      // Verify second checkpoint - JSON objects should be restored to proper classes
+      const result2 = results[1];
+      expect(result2.checkpoint.id).to.equal('checkpoint-2');
+      expect(result2.metadata?.source).to.equal('loop');
+      expect(result2.parentConfig).to.deep.equal({ configurable: { thread_id: 'test-thread', checkpoint_id: 'checkpoint-1' } });
+      const messages2 = result2.checkpoint.channel_values.messages as any[];
+      expect(messages2).to.have.length(2);
+      expect(messages2[0]).to.be.instanceOf(SystemMessage);
+      expect(messages2[1]).to.be.instanceOf(AIMessage);
+      expect(messages2[0].content).to.equal('System prompt');
+      expect(messages2[1].content).to.equal('AI response');
+    });
+
+    it('should handle empty checkpoint list', async () => {
+      mindedRequestStub.resolves({ checkpoints: [] });
+
+      const config: RunnableConfig = { configurable: { thread_id: 'empty-thread' } };
+
+      const results: CheckpointTuple[] = [];
+      for await (const tuple of checkpointSaver.list(config)) {
+        results.push(tuple);
+      }
+
+      expect(results).to.have.length(0);
+    });
+  });
+});

package/test/checkpoint-saver/minded-checkpoint-saver.test.ts

@@ -0,0 +1,99 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import * as sinon from 'sinon';
+import { MindedCheckpointSaver } from '../../src/platform/mindedCheckpointSaver';
+import * as mindedRequestModule from '../../src/platform/mindedRequest';
+import { Checkpoint, CheckpointMetadata, emptyCheckpoint } from '@langchain/langgraph-checkpoint';
+import { RunnableConfig } from '@langchain/core/runnables';
+import { HumanMessage, AIMessage } from '@langchain/core/messages';
+
+describe('MindedCheckpointSaver', function () {
+  let checkpointSaver: MindedCheckpointSaver;
+  let mindedRequestStub: sinon.SinonStub;
+  const testToken = 'test-token-123';
+
+  beforeEach(() => {
+    checkpointSaver = new MindedCheckpointSaver(testToken);
+    mindedRequestStub = sinon.stub(mindedRequestModule, 'mindedRequest');
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('getTuple', () => {
+    it('should deserialize checkpoint and metadata correctly', async () => {
+      // First, let's create proper objects and see what the serializer produces
+      const originalHumanMessage = new HumanMessage('Hello');
+      const originalAIMessage = new AIMessage('Hi there!');
+
+      // Create a checkpoint with these messages
+      const originalCheckpoint: Checkpoint = {
+        ...emptyCheckpoint(),
+        id: 'test-checkpoint-id',
+        channel_values: {
+          messages: [originalHumanMessage, originalAIMessage],
+        },
+      };
+
+      const originalMetadata: CheckpointMetadata = {
+        source: 'input',
+        step: 1,
+        writes: {},
+        parents: {},
+      };
+
+      // Simulate what happens when these objects go through JSON serialization (HTTP transport)
+      // This is what the server would actually return - plain JSON objects without class info
+      const jsonSerializedCheckpoint = JSON.parse(JSON.stringify(originalCheckpoint));
+      const jsonSerializedMetadata = JSON.parse(JSON.stringify(originalMetadata));
+
+      const mockServerResponse = {
+        tuple: {
+          config: { configurable: { thread_id: 'test-thread' } },
+          checkpoint: jsonSerializedCheckpoint,
+          metadata: jsonSerializedMetadata,
+          parentConfig: undefined,
+          pendingWrites: [],
+        },
+      };
+
+      // Mock the HTTP response with JSON-serialized objects (no class info)
+      mindedRequestStub.resolves(mockServerResponse);
+
+      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
+      const result = await checkpointSaver.getTuple(config);
+
+      // Verify the request was made correctly
+      expect(mindedRequestStub.calledOnce).to.equal(true);
+      expect(mindedRequestStub.firstCall.args[0]).to.deep.include({
+        path: '/sdk-checkpoints/getTuple',
+        method: 'POST',
+        body: { config },
+        token: testToken,
+      });
+
+      // Verify the result structure
+      expect(result).to.not.equal(undefined);
+      expect(result!.config).to.deep.equal(mockServerResponse.tuple.config);
+      expect(result!.checkpoint.id).to.equal('test-checkpoint-id');
+
+      // This is the key test - the JSON objects should be restored to proper classes
+      const messages = result!.checkpoint.channel_values.messages as any[];
+      expect(messages).to.have.length(2);
+      expect(messages[0]).to.be.instanceOf(HumanMessage);
+      expect(messages[1]).to.be.instanceOf(AIMessage);
+      expect(messages[0].content).to.equal('Hello');
+      expect(messages[1].content).to.equal('Hi there!');
+    });
+
+    it('should return undefined when server returns no tuple', async () => {
+      mindedRequestStub.resolves({ tuple: undefined });
+
+      const config: RunnableConfig = { configurable: { thread_id: 'test-thread' } };
+      const result = await checkpointSaver.getTuple(config);
+
+      expect(result).to.equal(undefined);
+    });
+  });
+});

package/dist/analytics.d.ts

@@ -1,6 +0,0 @@
-export declare const analyticsFactory: ({ token, sessionId }: {
-    token: string;
-    sessionId: string;
-}) => {
-    track: <T>(event: string, data: T) => Promise<void>;
-};

package/dist/analytics.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyticsFactory = void 0;
-const mindedRequest_1 = require("./infrastructure.ts/mindedRequest");
-const track = async ({ event, data, token, sessionId }) => {
-    await (0, mindedRequest_1.mindedRequest)({
-        path: '/analytics/events',
-        method: 'POST',
-        body: { event, data, sessionId },
-        token
-    });
-};
-const analyticsFactory = ({ token, sessionId }) => {
-    return {
-        track: (event, data) => track({ event, data, token, sessionId })
-    };
-};
-exports.analyticsFactory = analyticsFactory;
-//# sourceMappingURL=analytics.js.map

package/dist/analytics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"analytics.js","sourceRoot":"","sources":["../src/analytics.ts"],"names":[],"mappings":";;;AAAA,qEAAkE;AAElE,MAAM,KAAK,GAAG,KAAK,EAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAgE,EAAE,EAAE;IACzH,MAAM,IAAA,6BAAa,EAAC;QAClB,IAAI,EAAE,mBAAmB;QACzB,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE;QAChC,KAAK;KACN,CAAC,CAAC;AACL,CAAC,CAAA;AAEM,MAAM,gBAAgB,GAAG,CAAC,EAAE,KAAK,EAAE,SAAS,EAAwC,EAAE,EAAE;IAC7F,OAAO;QACL,KAAK,EAAE,CAAI,KAAa,EAAE,IAAO,EAAE,EAAE,CAAC,KAAK,CAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;KAClF,CAAA;AACH,CAAC,CAAA;AAJY,QAAA,gBAAgB,oBAI5B"}

package/dist/infrastructure.ts/mindedRequest.d.ts

@@ -1,8 +0,0 @@
-type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-export declare const mindedRequest: <Response, Request = object>({ path, method, body, token }: {
-    path: string;
-    method: Method;
-    body: Request;
-    token: string;
-}) => Promise<Response>;
-export {};

package/dist/infrastructure.ts/mindedRequest.js

@@ -1,22 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mindedRequest = void 0;
-const axios_1 = __importDefault(require("axios"));
-const baseUrl = 'https://api.minded.com/sdk';
-const mindedRequest = async ({ path, method, body, token }) => {
-    const response = await (0, axios_1.default)({
-        method,
-        url: `${baseUrl}${path}`,
-        data: body,
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${token}`
-        }
-    });
-    return response.data;
-};
-exports.mindedRequest = mindedRequest;
-//# sourceMappingURL=mindedRequest.js.map

package/dist/infrastructure.ts/mindedRequest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mindedRequest.js","sourceRoot":"","sources":["../../src/infrastructure.ts/mindedRequest.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAC1B,MAAM,OAAO,GAAG,4BAA4B,CAAA;AAIrC,MAAM,aAAa,GAAG,KAAK,EAA8B,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAkE,EAAqB,EAAE;IAClL,MAAM,QAAQ,GAAG,MAAM,IAAA,eAAK,EAAC;QAC3B,MAAM;QACN,GAAG,EAAE,GAAG,OAAO,GAAG,IAAI,EAAE;QACxB,IAAI,EAAE,IAAI;QACV,OAAO,EAAE;YACP,cAAc,EAAE,kBAAkB;YAClC,eAAe,EAAE,UAAU,KAAK,EAAE;SACnC;KACF,CAAC,CAAC;IAEH,OAAO,QAAQ,CAAC,IAAI,CAAC;AACvB,CAAC,CAAA;AAZY,QAAA,aAAa,iBAYzB"}