fix: align getDiscovery capabilities with DiscoverySchema hierarchical format

The DiscoverySchema.capabilities expects Record<string, { enabled: boolean }>
(hierarchical format), but ObjectStackProtocolImplementation.getDiscovery()
was returning WellKnownCapabilities (flat booleans), causing TS2416.

- Convert flat WellKnownCapabilities booleans to { enabled: boolean } objects
  in protocol.ts getDiscovery()
- Update discovery tests to expect hierarchical format
- Update client capabilities getter to normalize both hierarchical and flat
  formats back to WellKnownCapabilities for backward compatibility

Agent-Logs-Url: https://github.com/objectstack-ai/spec/sessions/069cea55-358d-4b17-b1b8-505aaa03ccb6

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/client/src/index.ts

@@ -312,9 +312,20 @@ export class ObjectStackClient {
    * Well-known capability flags discovered from the server.
    * Returns undefined if the client has not yet connected or the server
    * did not include capabilities in its discovery response.
+   *
+   * The server may return capabilities in hierarchical format
+   * `{ key: { enabled: boolean } }` or flat boolean format `{ key: boolean }`.
+   * This getter normalizes both to flat `WellKnownCapabilities`.
    */
   get capabilities(): WellKnownCapabilities | undefined {
-    return this.discoveryInfo?.capabilities;
+    const raw = this.discoveryInfo?.capabilities;
+    if (!raw) return undefined;
+    // Normalize: hierarchical { enabled: boolean } → flat boolean
+    const result: Record<string, boolean> = {};
+    for (const [key, value] of Object.entries(raw)) {
+      result[key] = typeof value === 'object' && value !== null ? !!(value as any).enabled : !!value;
+    }
+    return result as unknown as WellKnownCapabilities;
   }
 
   /**

packages/objectql/src/protocol-discovery.test.ts

@@ -148,28 +148,28 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     expect(discovery.capabilities).toBeDefined();
     // workflow is registered but doesn't map to a well-known capability directly
     expect(discovery.services.workflow.enabled).toBe(true);
-    // All well-known capabilities should be false since workflow doesn't map to any
-    expect(discovery.capabilities!.feed).toBe(false);
-    expect(discovery.capabilities!.comments).toBe(false);
-    expect(discovery.capabilities!.automation).toBe(false);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(false);
-    expect(discovery.capabilities!.export).toBe(false);
-    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+    // All well-known capabilities should be disabled since workflow doesn't map to any
+    expect(discovery.capabilities!.feed).toEqual({ enabled: false });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: false });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: false });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: false });
+    expect(discovery.capabilities!.export).toEqual({ enabled: false });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: false });
   });
 
   it('should set all capabilities to false when no services are registered', async () => {
     protocol = new ObjectStackProtocolImplementation(engine);
     const discovery = await protocol.getDiscovery();
 
     expect(discovery.capabilities).toBeDefined();
-    expect(discovery.capabilities!.feed).toBe(false);
-    expect(discovery.capabilities!.comments).toBe(false);
-    expect(discovery.capabilities!.automation).toBe(false);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(false);
-    expect(discovery.capabilities!.export).toBe(false);
-    expect(discovery.capabilities!.chunkedUpload).toBe(false);
+    expect(discovery.capabilities!.feed).toEqual({ enabled: false });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: false });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: false });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: false });
+    expect(discovery.capabilities!.export).toEqual({ enabled: false });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: false });
   });
 
   it('should dynamically set capabilities based on registered services', async () => {
@@ -182,13 +182,13 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.feed).toBe(true);
-    expect(discovery.capabilities!.comments).toBe(true);
-    expect(discovery.capabilities!.automation).toBe(true);
-    expect(discovery.capabilities!.cron).toBe(false);
-    expect(discovery.capabilities!.search).toBe(true);
-    expect(discovery.capabilities!.export).toBe(true);
-    expect(discovery.capabilities!.chunkedUpload).toBe(true);
+    expect(discovery.capabilities!.feed).toEqual({ enabled: true });
+    expect(discovery.capabilities!.comments).toEqual({ enabled: true });
+    expect(discovery.capabilities!.automation).toEqual({ enabled: true });
+    expect(discovery.capabilities!.cron).toEqual({ enabled: false });
+    expect(discovery.capabilities!.search).toEqual({ enabled: true });
+    expect(discovery.capabilities!.export).toEqual({ enabled: true });
+    expect(discovery.capabilities!.chunkedUpload).toEqual({ enabled: true });
   });
 
   it('should enable cron capability when job service is registered', async () => {
@@ -198,7 +198,7 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.cron).toBe(true);
+    expect(discovery.capabilities!.cron).toEqual({ enabled: true });
   });
 
   it('should enable export capability when queue service is registered', async () => {
@@ -208,6 +208,6 @@ describe('ObjectStackProtocolImplementation - Dynamic Service Discovery', () =>
     protocol = new ObjectStackProtocolImplementation(engine, () => mockServices);
     const discovery = await protocol.getDiscovery();
 
-    expect(discovery.capabilities!.export).toBe(true);
+    expect(discovery.capabilities!.export).toEqual({ enabled: true });
   });
 });

packages/objectql/src/protocol.ts

@@ -151,8 +151,10 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             ...optionalRoutes,
         };
 
-        // Build well-known capabilities from registered services
-        const capabilities: WellKnownCapabilities = {
+        // Build well-known capabilities from registered services.
+        // DiscoverySchema defines capabilities as Record<string, { enabled, features?, description? }>
+        // (hierarchical format). We also keep a flat WellKnownCapabilities for backward compat.
+        const wellKnown: WellKnownCapabilities = {
             feed: registeredServices.has('feed'),
             comments: registeredServices.has('feed'),
             automation: registeredServices.has('automation'),
@@ -162,6 +164,12 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             chunkedUpload: registeredServices.has('file-storage'),
         };
 
+        // Convert flat booleans → hierarchical capability objects
+        const capabilities: Record<string, { enabled: boolean; description?: string }> = {};
+        for (const [key, enabled] of Object.entries(wellKnown)) {
+            capabilities[key] = { enabled };
+        }
+
         return {
             version: '1.0',
             apiName: 'ObjectStack API',