@decocms/bindings 1.0.0 → 1.0.1-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/bindings",
-  "version": "1.0.0",
+  "version": "1.0.1-alpha.4",
   "type": "module",
   "scripts": {
     "test": "vitest run",
@@ -19,6 +19,7 @@
     "./llm": "./src/well-known/language-model.ts",
     "./connection": "./src/core/connection.ts",
     "./client": "./src/core/client/index.ts",
+    "./mcp": "./src/well-known/mcp.ts",
     "./agent": "./src/well-known/agent.ts"
   },
   "devDependencies": {

package/src/core/binder.ts

@@ -16,8 +16,7 @@ type JsonSchema = Record<string, unknown>;
 /**
  * Checks if a value is a Zod schema by looking for the _def property
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isZodSchema(value: unknown): value is ZodType<any> {
+function isZodSchema(value: unknown): value is ZodType<unknown> {
   return (
     value !== null &&
     typeof value === "object" &&
@@ -34,15 +33,15 @@ function isZodSchema(value: unknown): value is ZodType<any> {
  * @returns The JSON schema representation, or null if input is null/undefined
  */
 export function normalizeToJsonSchema(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  schema: ZodType<any> | JsonSchema | null | undefined,
+  schema: ZodType<unknown> | JsonSchema | null | undefined,
 ): JsonSchema | null {
   if (schema == null) {
     return null;
   }
 
   if (isZodSchema(schema)) {
-    return zodToJsonSchema(schema) as JsonSchema;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return zodToJsonSchema(schema as any) as JsonSchema;
   }
 
   // Already a JSON schema

package/src/well-known/collections.ts

@@ -261,45 +261,71 @@ export function createCollectionBindings<
   const upperName = collectionName.toUpperCase() as Uppercase<TName>;
   const readOnly = options?.readOnly ?? false;
 
-  const bindings: CollectionBinding<TEntitySchema, Uppercase<TName>>[number][] =
-    [
-      {
-        name: `COLLECTION_${upperName}_LIST` as const,
-        inputSchema: CollectionListInputSchema,
-        outputSchema: createCollectionListOutputSchema(entitySchema),
-      },
-      {
-        name: `COLLECTION_${upperName}_GET` as const,
-        inputSchema: CollectionGetInputSchema,
-        outputSchema: createCollectionGetOutputSchema(entitySchema),
-      },
-    ];
+  const bindings: ToolBinder[] = [
+    {
+      name: `COLLECTION_${upperName}_LIST` as const,
+      inputSchema: CollectionListInputSchema,
+      outputSchema: createCollectionListOutputSchema(entitySchema) as z.ZodType<
+        CollectionListOutput<z.infer<TEntitySchema>>
+      >,
+    },
+    {
+      name: `COLLECTION_${upperName}_GET` as const,
+      inputSchema: CollectionGetInputSchema,
+      outputSchema: createCollectionGetOutputSchema(entitySchema) as z.ZodType<
+        CollectionGetOutput<z.infer<TEntitySchema>>
+      >,
+    },
+  ];
 
   // Only include mutation operations if not read-only
   if (!readOnly) {
     bindings.push(
       {
         name: `COLLECTION_${upperName}_CREATE` as const,
-        inputSchema: createCollectionInsertInputSchema(entitySchema),
-        outputSchema: createCollectionInsertOutputSchema(entitySchema),
+        inputSchema: createCollectionInsertInputSchema(
+          entitySchema,
+        ) as unknown as z.ZodType<
+          CollectionInsertInput<z.infer<TEntitySchema>>
+        >,
+        outputSchema: createCollectionInsertOutputSchema(
+          entitySchema,
+        ) as unknown as z.ZodType<
+          CollectionInsertOutput<z.infer<TEntitySchema>>
+        >,
         opt: true,
       },
       {
         name: `COLLECTION_${upperName}_UPDATE` as const,
-        inputSchema: createCollectionUpdateInputSchema(entitySchema),
-        outputSchema: createCollectionUpdateOutputSchema(entitySchema),
+        inputSchema: createCollectionUpdateInputSchema(
+          entitySchema,
+        ) as unknown as z.ZodType<
+          CollectionUpdateInput<z.infer<TEntitySchema>>
+        >,
+        outputSchema: createCollectionUpdateOutputSchema(
+          entitySchema,
+        ) as unknown as z.ZodType<
+          CollectionUpdateOutput<z.infer<TEntitySchema>>
+        >,
         opt: true,
       },
       {
         name: `COLLECTION_${upperName}_DELETE` as const,
         inputSchema: CollectionDeleteInputSchema,
-        outputSchema: createCollectionDeleteOutputSchema(entitySchema),
+        outputSchema: createCollectionDeleteOutputSchema(
+          entitySchema,
+        ) as unknown as z.ZodType<
+          CollectionDeleteOutput<z.infer<TEntitySchema>>
+        >,
         opt: true,
       },
     );
   }
 
-  return bindings satisfies readonly ToolBinder[];
+  return bindings as unknown as readonly CollectionBinding<
+    TEntitySchema,
+    Uppercase<TName>
+  >[number][];
 }
 
 export type ReadOnlyCollectionBinding<
@@ -309,16 +335,12 @@ export type ReadOnlyCollectionBinding<
   {
     name: `COLLECTION_${TUpperName}_LIST`;
     inputSchema: typeof CollectionListInputSchema;
-    outputSchema: ReturnType<
-      typeof createCollectionListOutputSchema<TEntitySchema>
-    >;
+    outputSchema: z.ZodType<CollectionListOutput<z.infer<TEntitySchema>>>;
   },
   {
     name: `COLLECTION_${TUpperName}_GET`;
     inputSchema: typeof CollectionGetInputSchema;
-    outputSchema: ReturnType<
-      typeof createCollectionGetOutputSchema<TEntitySchema>
-    >;
+    outputSchema: z.ZodType<CollectionGetOutput<z.infer<TEntitySchema>>>;
   },
 ];
 /**
@@ -328,33 +350,32 @@ export type CollectionBinding<
   TEntitySchema extends BaseCollectionEntitySchemaType,
   TUpperName extends Uppercase<string> = Uppercase<string>,
 > = [
-  ...ReadOnlyCollectionBinding<TEntitySchema, TUpperName>,
+  {
+    name: `COLLECTION_${TUpperName}_LIST`;
+    inputSchema: typeof CollectionListInputSchema;
+    outputSchema: z.ZodType<CollectionListOutput<z.infer<TEntitySchema>>>;
+  },
+  {
+    name: `COLLECTION_${TUpperName}_GET`;
+    inputSchema: typeof CollectionGetInputSchema;
+    outputSchema: z.ZodType<CollectionGetOutput<z.infer<TEntitySchema>>>;
+  },
   {
     name: `COLLECTION_${TUpperName}_CREATE`;
-    inputSchema: ReturnType<
-      typeof createCollectionInsertInputSchema<TEntitySchema>
-    >;
-    outputSchema: ReturnType<
-      typeof createCollectionInsertOutputSchema<TEntitySchema>
-    >;
+    inputSchema: z.ZodType<CollectionInsertInput<z.infer<TEntitySchema>>>;
+    outputSchema: z.ZodType<CollectionInsertOutput<z.infer<TEntitySchema>>>;
     opt: true;
   },
   {
     name: `COLLECTION_${TUpperName}_UPDATE`;
-    inputSchema: ReturnType<
-      typeof createCollectionUpdateInputSchema<TEntitySchema>
-    >;
-    outputSchema: ReturnType<
-      typeof createCollectionUpdateOutputSchema<TEntitySchema>
-    >;
+    inputSchema: z.ZodType<CollectionUpdateInput<z.infer<TEntitySchema>>>;
+    outputSchema: z.ZodType<CollectionUpdateOutput<z.infer<TEntitySchema>>>;
     opt: true;
   },
   {
     name: `COLLECTION_${TUpperName}_DELETE`;
     inputSchema: typeof CollectionDeleteInputSchema;
-    outputSchema: ReturnType<
-      typeof createCollectionDeleteOutputSchema<TEntitySchema>
-    >;
+    outputSchema: z.ZodType<CollectionDeleteOutput<z.infer<TEntitySchema>>>;
     opt: true;
   },
 ];
@@ -373,6 +394,21 @@ export type CollectionGetInput = z.infer<typeof CollectionGetInputSchema>;
 export type CollectionDeleteInput = z.infer<typeof CollectionDeleteInputSchema>;
 export type OrderByExpression = z.infer<typeof OrderByExpressionSchema>;
 
+/**
+ * Type helper for insert input with generic item type
+ */
+export type CollectionInsertInput<T> = {
+  data: T;
+};
+
+/**
+ * Type helper for update input with generic item type
+ */
+export type CollectionUpdateInput<T> = {
+  id: string;
+  data: Partial<T>;
+};
+
 /**
  * Type helper for list output with generic item type
  */

package/src/well-known/mcp.ts

@@ -0,0 +1,35 @@
+/**
+ * MCP Well-Known Binding
+ *
+ * Defines the interface for retrieving MCP configuration.
+ */
+
+import { z } from "zod/v3";
+import type { Binder } from "../core/binder";
+
+/**
+ * MCP Configuration Output Schema
+ */
+export const McpConfigurationOutputSchema = z.object({
+  scopes: z.array(z.string()).describe("List of scopes available"),
+  stateSchema: z
+    .record(z.string(), z.unknown())
+    .describe("JSON Schema (draft-07) defining the state structure"),
+});
+
+export type McpConfigurationOutput = z.infer<
+  typeof McpConfigurationOutputSchema
+>;
+
+/**
+ * MCP Binding
+ *
+ * Tool to retrieve the MCP configuration including scopes and state schema.
+ */
+export const MCP_BINDING = [
+  {
+    name: "MCP_CONFIGURATION",
+    inputSchema: z.object({}),
+    outputSchema: McpConfigurationOutputSchema,
+  },
+] as const satisfies Binder;

package/test/mcp.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import {
+  MCP_BINDING,
+  McpConfigurationOutputSchema,
+} from "../src/well-known/mcp";
+
+describe("MCP Binding", () => {
+  it("should match the expected structure", () => {
+    expect(MCP_BINDING).toHaveLength(1);
+    const tool = MCP_BINDING[0];
+    expect(tool.name).toBe("MCP_CONFIGURATION");
+    expect(tool.inputSchema).toBeDefined();
+    expect(tool.outputSchema).toBeDefined();
+  });
+
+  it("should validate correct output", () => {
+    const validOutput = {
+      scopes: ["scope1", "scope2"],
+      stateSchema: {
+        type: "object",
+        properties: {
+          foo: { type: "string" },
+        },
+      },
+    };
+
+    const result = McpConfigurationOutputSchema.safeParse(validOutput);
+    expect(result.success).toBe(true);
+  });
+
+  it("should fail on invalid output", () => {
+    const invalidOutput = {
+      scopes: "not-an-array", // Invalid
+      stateSchema: { type: "object" },
+    };
+
+    const result = McpConfigurationOutputSchema.safeParse(invalidOutput);
+    expect(result.success).toBe(false);
+  });
+});