@optimizely-opal/opal-tools-sdk 0.1.6-dev → 0.1.8-dev

package/tests/integration.test.ts

@@ -7,7 +7,14 @@ import request from "supertest";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { z } from "zod/v4";
 
-import { Block, ParameterType, registerTool, tool, ToolsService } from "../src";
+import {
+  ParameterType,
+  registerResource,
+  registerTool,
+  tool,
+  ToolsService,
+  UI,
+} from "../src";
 import { registry } from "../src/registry";
 
 // Clear registry before each test
@@ -49,63 +56,6 @@ describe("Integration Tests", () => {
     expect(response.body).toBe("Hello, Alice!");
   });
 
-  test("block tool endpoint correctly serializes all fields", async () => {
-    const app = express();
-    app.use(express.json());
-    new ToolsService(app);
-
-    registerTool(
-      "create_task",
-      {
-        description: "Create a task",
-        inputSchema: {
-          name: z.string().describe("Task name"),
-        },
-        type: "block",
-      },
-      async (params) => {
-        return {
-          artifact: {
-            data: { name: params.name },
-            id: "task-123",
-            type: "task",
-          },
-          content: Block.Document({
-            children: Block.Text({ children: `Created task: ${params.name}` }),
-          }),
-          data: { created_at: "2024-01-01T00:00:00Z" },
-          rollback: {
-            config: { endpoint: "/api/tasks/task-123", method: "DELETE" },
-            label: "Delete Task",
-            type: "endpoint",
-          },
-        };
-      },
-    );
-
-    const response = await request(app)
-      .post("/tools/create-task")
-      .send({ parameters: { name: "My Task" } });
-
-    expect(response.status).toBe(200);
-    expect(response.headers["content-type"]).toBe(
-      "application/vnd.opal.block+json; charset=utf-8",
-    );
-    expect(response.body).toEqual({
-      artifact: { data: { name: "My Task" }, id: "task-123", type: "task" },
-      content: {
-        $type: "Block.Document",
-        children: { $type: "Block.Text", children: "Created task: My Task" },
-      },
-      data: { created_at: "2024-01-01T00:00:00Z" },
-      rollback: {
-        config: { endpoint: "/api/tasks/task-123", method: "DELETE" },
-        label: "Delete Task",
-        type: "endpoint",
-      },
-    });
-  });
-
   test("environment parameter is correctly passed to tool", async () => {
     const app = express();
     app.use(express.json());
@@ -210,12 +160,13 @@ describe("Integration Tests", () => {
         inputSchema: {
           title: z.string().describe("Task title"),
         },
-        type: "block",
       },
       async (params) => {
         return {
-          content: Block.Document({
-            children: Block.Text({ children: `Task: ${params.title}` }),
+          content: UI.Document({
+            appName: "Task Manager",
+            body: UI.Text({ children: `Task: ${params.title}` }),
+            title: "Create Task",
           }),
         };
       },
@@ -286,33 +237,261 @@ describe("Integration Tests", () => {
     });
   });
 
-  test("block tool without BlockResponse throws error", async () => {
+  test("resource endpoint returns correct content via POST /resources/read", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    registerResource(
+      "test-form",
+      {
+        description: "A test form",
+        mimeType: "application/vnd.opal.proteus+json",
+        uri: "ui://test-app/form",
+      },
+      async () => {
+        return JSON.stringify({
+          fields: [{ name: "title", type: "text" }],
+          type: "form",
+        });
+      },
+    );
+
+    // Call the POST /resources/read endpoint
+    const response = await request(app)
+      .post("/resources/read")
+      .send({ uri: "ui://test-app/form" });
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      mimeType: "application/vnd.opal.proteus+json",
+      text: JSON.stringify({
+        fields: [{ name: "title", type: "text" }],
+        type: "form",
+      }),
+      uri: "ui://test-app/form",
+    });
+  });
+
+  test("tool with uiResource reference", async () => {
     const app = express();
     app.use(express.json());
     new ToolsService(app);
 
-    // @ts-expect-error - Testing runtime validation of invalid block tool return type
+    registerResource(
+      "create-form",
+      {
+        description: "Form for creating items",
+        mimeType: "application/vnd.opal.proteus+json",
+        uri: "ui://test-app/create-form",
+      },
+      async () => {
+        return "{}";
+      },
+    );
+
     registerTool(
-      "invalid_block",
+      "create_item",
       {
-        description: "Block tool that returns wrong type",
+        description: "Create a new item",
         inputSchema: {
-          name: z.string().describe("Name"),
+          title: z.string().describe("The title"),
         },
-        type: "block",
+        uiResource: "ui://test-app/create-form",
       },
       async (params) => {
-        // This should fail - block tools must return BlockResponse
-        return `This should fail: ${params.name}`;
+        return { id: "item-123", title: params.title };
       },
     );
 
+    // Call discovery endpoint
+    const response = await request(app).get("/discovery");
+
+    expect(response.status).toBe(200);
+    expect(response.body).toEqual({
+      functions: [
+        {
+          description: "Create a new item",
+          endpoint: "/tools/create-item",
+          http_method: "POST",
+          name: "create_item",
+          parameters: [
+            {
+              description: "The title",
+              name: "title",
+              required: true,
+              type: "string",
+            },
+          ],
+          ui_resource: "ui://test-app/create-form",
+        },
+      ],
+    });
+  });
+
+  test("POST /resources/read with missing URI returns 400", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    registerResource(
+      "minimal-resource",
+      {
+        uri: "ui://test-app/minimal",
+      },
+      async () => {
+        return "minimal";
+      },
+    );
+
+    // Call without URI
+    const response = await request(app).post("/resources/read").send({});
+
+    expect(response.status).toBe(400);
+    expect(response.body.error).toBe("Missing required field: uri");
+  });
+
+  test("POST /resources/read with unknown URI returns 404", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    // Call with unknown URI
     const response = await request(app)
-      .post("/tools/invalid-block")
-      .send({ parameters: { name: "Test" } });
+      .post("/resources/read")
+      .send({ uri: "ui://unknown/resource" });
+
+    expect(response.status).toBe(404);
+    expect(response.body.error).toBe(
+      "Resource not found: ui://unknown/resource",
+    );
+  });
+
+  test("POST /resources/read with non-string handler result returns 500", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    registerResource(
+      "invalid-resource",
+      {
+        uri: "ui://test-app/invalid",
+      },
+      // @ts-expect-error - intentionally returning wrong type for test
+      async () => {
+        return { invalid: "object" };
+      },
+    );
+
+    // Call the resource
+    const response = await request(app)
+      .post("/resources/read")
+      .send({ uri: "ui://test-app/invalid" });
 
-    // Should return 500 error because block tools must return BlockResponse
     expect(response.status).toBe(500);
-    expect(response.body.error).toContain("must return a BlockResponse object");
+    expect(response.body.error).toContain(
+      "Resource handler for 'ui://test-app/invalid' must return a string or ProteusDocument",
+    );
+    expect(response.body.error).toContain("but returned object");
+  });
+
+  test("resource with ProteusDocument return is auto-serialized", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    registerResource(
+      "dynamic-form",
+      {
+        description: "A dynamic form using UI.Document",
+        uri: "ui://test-app/dynamic-form",
+      },
+      async () => {
+        return UI.Document({
+          actions: [
+            UI.Action({ appearance: "primary", children: "Save" }),
+            UI.CancelAction({ children: "Cancel" }),
+          ],
+          appName: "Item Manager",
+          body: [
+            UI.Heading({ children: "Create Item" }),
+            UI.Field({
+              children: UI.Input({
+                name: "item_name",
+                placeholder: "Enter item name",
+              }),
+              label: "Item Name",
+            }),
+            UI.Field({
+              children: UI.Textarea({
+                name: "description",
+                placeholder: "Enter description",
+              }),
+              label: "Description",
+            }),
+          ],
+          title: "Create New Item",
+        });
+      },
+    );
+
+    // Call the resource endpoint
+    const response = await request(app)
+      .post("/resources/read")
+      .send({ uri: "ui://test-app/dynamic-form" });
+
+    expect(response.status).toBe(200);
+
+    // Verify URI
+    expect(response.body.uri).toBe("ui://test-app/dynamic-form");
+
+    // Verify MIME type was auto-set
+    expect(response.body.mimeType).toBe("application/vnd.opal.proteus+json");
+
+    // Verify the text is a serialized ProteusDocument
+    const parsedDoc = JSON.parse(response.body.text);
+    expect(parsedDoc.$type).toBe("Document");
+    expect(parsedDoc.appName).toBe("Item Manager");
+    expect(parsedDoc.title).toBe("Create New Item");
+    expect(parsedDoc.body).toHaveLength(3);
+    expect(parsedDoc.body[0].$type).toBe("Heading");
+    expect(parsedDoc.body[0].children).toBe("Create Item");
+    expect(parsedDoc.body[1].$type).toBe("Field");
+    expect(parsedDoc.body[1].label).toBe("Item Name");
+    expect(parsedDoc.actions).toHaveLength(2);
+    expect(parsedDoc.actions[0].$type).toBe("Action");
+    expect(parsedDoc.actions[1].$type).toBe("CancelAction");
+  });
+
+  test("resource with ProteusDocument and explicit MIME type preserves MIME type", async () => {
+    const app = express();
+    app.use(express.json());
+    new ToolsService(app);
+
+    registerResource(
+      "custom-mime",
+      {
+        description: "ProteusDocument with custom MIME type",
+        mimeType: "application/custom+json",
+        uri: "ui://test-app/custom-mime",
+      },
+      async () => {
+        return UI.Document({
+          appName: "Test App",
+          body: [UI.Text({ children: "Test" })],
+          title: "Test Document",
+        });
+      },
+    );
+
+    // Call the resource endpoint
+    const response = await request(app)
+      .post("/resources/read")
+      .send({ uri: "ui://test-app/custom-mime" });
+
+    expect(response.status).toBe(200);
+
+    // Verify explicit MIME type is preserved (not auto-set)
+    expect(response.body.mimeType).toBe("application/custom+json");
   });
 });

package/tests/proteus.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Tests for Adaptive Proteus components
+ */
+
+import { describe, expect, test } from "vitest";
+
+import { UI } from "../src";
+
+describe("Proteus Components", () => {
+  test("UI.Heading with children", () => {
+    const heading = UI.Heading({ children: "Test Heading" });
+    expect(heading.$type).toBe("Heading");
+
+    const doc = UI.Document({
+      appName: "Test App",
+      body: heading,
+      title: "Test Title",
+    });
+    expect(doc).toEqual({
+      $type: "Document",
+      appName: "Test App",
+      body: { $type: "Heading", children: "Test Heading" },
+      title: "Test Title",
+    });
+  });
+
+  test("UI.Text with children", () => {
+    const text = UI.Text({ children: "Test text content" });
+    expect(text.$type).toBe("Text");
+
+    const doc = UI.Document({
+      appName: "Test App",
+      body: text,
+      title: "Test Title",
+    });
+    expect(doc).toEqual({
+      $type: "Document",
+      appName: "Test App",
+      body: { $type: "Text", children: "Test text content" },
+      title: "Test Title",
+    });
+  });
+
+  test("UI.Heading with additional properties", () => {
+    const heading = UI.Heading({
+      children: "Styled Heading",
+      fontSize: "md",
+      fontWeight: "600",
+      level: "2",
+    });
+
+    const doc = UI.Document({
+      appName: "Test App",
+      body: heading,
+      title: "Test Title",
+    });
+    expect(doc).toEqual({
+      $type: "Document",
+      appName: "Test App",
+      body: {
+        $type: "Heading",
+        children: "Styled Heading",
+        fontSize: "md",
+        fontWeight: "600",
+        level: "2",
+      },
+      title: "Test Title",
+    });
+  });
+
+  test("UI.Group with children array", () => {
+    const group = UI.Group({
+      children: [
+        UI.Text({ children: "First item" }),
+        UI.Text({ children: "Second item" }),
+      ],
+      flexDirection: "column",
+      gap: "16",
+    });
+
+    const doc = UI.Document({
+      appName: "Test App",
+      body: group,
+      title: "Test Title",
+    });
+    expect(doc).toEqual({
+      $type: "Document",
+      appName: "Test App",
+      body: {
+        $type: "Group",
+        children: [
+          { $type: "Text", children: "First item" },
+          { $type: "Text", children: "Second item" },
+        ],
+        flexDirection: "column",
+        gap: "16",
+      },
+      title: "Test Title",
+    });
+  });
+
+  test("UI.Document", () => {
+    const doc = UI.Document({
+      appName: "Test App",
+      body: [
+        UI.Heading({ children: "Title", level: "2" }),
+        UI.Text({ children: "Description" }),
+      ],
+      title: "Test Title",
+    });
+
+    expect(doc).toEqual({
+      $type: "Document",
+      appName: "Test App",
+      body: [
+        { $type: "Heading", children: "Title", level: "2" },
+        { $type: "Text", children: "Description" },
+      ],
+      title: "Test Title",
+    });
+  });
+});