fix(channels): manage DingTalk interactive card config

docs/developers/qwen-serve-protocol.md

@@ -776,6 +776,11 @@ The catalog marks the types supported by this management API with
 presence metadata, startup state, and runtime state; literal secrets are never
 returned. Channel snapshots use `Cache-Control: no-store`.
 
+Field descriptors can expose nested object metadata through `properties`.
+Numeric descriptors can use `exclusiveMinimum` for open lower bounds. Clients
+that do not render an advertised field kind must preserve its existing config
+value instead of coercing or deleting it.
+
 Configuration writes use optimistic concurrency and the strict bearer-token
 gate:
 

packages/channels/base/src/types.ts

@@ -386,7 +386,8 @@ export type ChannelConfigFieldKind =
   | 'number'
   | 'enum'
   | 'string-list'
-  | 'record';
+  | 'record'
+  | 'object';
 
 export interface ChannelConfigFieldDescriptor {
   key: string;
@@ -396,6 +397,8 @@ export interface ChannelConfigFieldDescriptor {
   envResolvable?: boolean;
   options?: ReadonlyArray<{ value: string; label: string }>;
   default?: string;
+  properties?: readonly ChannelConfigFieldDescriptor[];
+  exclusiveMinimum?: number;
   description?: string;
 }
 

packages/channels/dingtalk/src/index.ts

@@ -24,6 +24,48 @@ export const plugin: ChannelPlugin = {
         required: true,
         envResolvable: true,
       },
+      {
+        key: 'interactiveCards',
+        label: 'Interactive Cards',
+        kind: 'object',
+        properties: [
+          {
+            key: 'enabled',
+            label: 'Enabled',
+            kind: 'boolean',
+          },
+          {
+            key: 'statusCard',
+            label: 'Status Card',
+            kind: 'object',
+            properties: [
+              {
+                key: 'enabled',
+                label: 'Enabled',
+                kind: 'boolean',
+              },
+            ],
+          },
+          {
+            key: 'questionCard',
+            label: 'Question Card',
+            kind: 'object',
+            properties: [
+              {
+                key: 'enabled',
+                label: 'Enabled',
+                kind: 'boolean',
+              },
+              {
+                key: 'timeoutMs',
+                label: 'Timeout (ms)',
+                kind: 'number',
+                exclusiveMinimum: 0,
+              },
+            ],
+          },
+        ],
+      },
     ],
   },
   createChannel: (name, config, bridge, options) =>

packages/cli/src/commands/channel/channel-registry.test.ts

@@ -56,6 +56,19 @@ describe('channel registry', () => {
         }),
       );
     }
+    expect(
+      catalog.find((entry) => entry.type === 'dingtalk')?.fields,
+    ).toContainEqual(
+      expect.objectContaining({
+        key: 'interactiveCards',
+        kind: 'object',
+        properties: expect.arrayContaining([
+          expect.objectContaining({ key: 'enabled', kind: 'boolean' }),
+          expect.objectContaining({ key: 'statusCard', kind: 'object' }),
+          expect.objectContaining({ key: 'questionCard', kind: 'object' }),
+        ]),
+      }),
+    );
     expect(JSON.stringify(catalog)).not.toContain('createChannel');
   });
 });

packages/cli/src/serve/channel-settings-store.test.ts

@@ -485,6 +485,85 @@ describe('WorkspaceChannelSettingsStore', () => {
     });
   });
 
+  it('persists DingTalk interactive card configuration through management metadata', async () => {
+    writeWorkspaceSettings(`{
+  "$version": 4,
+  "channels": { "bot": {
+    "type": "dingtalk",
+    "clientId": "client-id",
+    "clientSecret": "existing-secret"
+  } }
+}\n`);
+    const store = new WorkspaceChannelSettingsStore(workspace);
+
+    const next = await store.upsert('bot', {
+      expectedRevision: store.snapshot().revision,
+      config: {
+        type: 'dingtalk',
+        clientId: 'client-id',
+        interactiveCards: {
+          enabled: true,
+          statusCard: { enabled: true },
+          questionCard: { enabled: true, timeoutMs: 270_000 },
+        },
+      },
+      secrets: { clientSecret: { operation: 'preserve' } },
+    });
+
+    expect(next.channels['bot']?.['interactiveCards']).toEqual({
+      enabled: true,
+      statusCard: { enabled: true },
+      questionCard: { enabled: true, timeoutMs: 270_000 },
+    });
+  });
+
+  it.each([
+    {
+      label: 'string enabled flag',
+      interactiveCards: { enabled: 'true' },
+    },
+    {
+      label: 'invalid nested enabled flag',
+      interactiveCards: { statusCard: { enabled: 'true' } },
+    },
+    {
+      label: 'non-positive question timeout',
+      interactiveCards: { questionCard: { timeoutMs: 0 } },
+    },
+    {
+      label: 'unknown nested field',
+      interactiveCards: { unexpected: true },
+    },
+  ])(
+    'rejects DingTalk interactive card configuration with $label',
+    async ({ interactiveCards }) => {
+      writeWorkspaceSettings(`{
+  "$version": 4,
+  "channels": { "bot": {
+    "type": "dingtalk",
+    "clientId": "client-id",
+    "clientSecret": "existing-secret"
+  } }
+}\n`);
+      const store = new WorkspaceChannelSettingsStore(workspace);
+      const before = fs.readFileSync(settingsPath, 'utf8');
+
+      await expect(
+        store.upsert('bot', {
+          expectedRevision: store.snapshot().revision,
+          config: {
+            type: 'dingtalk',
+            clientId: 'client-id',
+            interactiveCards,
+          },
+          secrets: { clientSecret: { operation: 'preserve' } },
+        }),
+      ).rejects.toMatchObject({ code: 'channel_settings_invalid_config' });
+
+      expect(fs.readFileSync(settingsPath, 'utf8')).toBe(before);
+    },
+  );
+
   it('rejects clearing an existing required secret without writing', async () => {
     writeWorkspaceSettings(`{
   "$version": 4,

packages/cli/src/serve/channel-settings-store.ts

@@ -210,7 +210,39 @@ function assertSharedField(key: string, value: unknown): boolean {
 function assertDescriptorValue(
   field: ChannelConfigFieldDescriptor,
   value: unknown,
+  path = field.key,
 ): void {
+  if (field.kind === 'object') {
+    if (!isRecord(value)) {
+      throw invalidConfig(`Channel field "${path}" has an invalid value.`);
+    }
+    const properties = new Map(
+      (field.properties ?? []).map((property) => [property.key, property]),
+    );
+    for (const [key, nestedValue] of Object.entries(value)) {
+      const property = properties.get(key);
+      if (!property) {
+        throw invalidConfig(
+          `Channel field "${path}.${key}" is not manageable.`,
+        );
+      }
+      assertDescriptorValue(property, nestedValue, `${path}.${key}`);
+    }
+    for (const property of field.properties ?? []) {
+      if (!property.required) continue;
+      const nestedValue = value[property.key];
+      if (
+        nestedValue === undefined ||
+        nestedValue === null ||
+        nestedValue === ''
+      ) {
+        throw invalidConfig(
+          `Channel field "${path}.${property.key}" is required.`,
+        );
+      }
+    }
+    return;
+  }
   const invalidEnvironment =
     typeof value === 'string' &&
     isEnvironmentReference(value) &&
@@ -227,7 +259,9 @@ function assertDescriptorValue(
     (field.kind === 'boolean' && typeof value === 'boolean') ||
     (field.kind === 'number' &&
       typeof value === 'number' &&
-      Number.isFinite(value)) ||
+      Number.isFinite(value) &&
+      (field.exclusiveMinimum === undefined ||
+        value > field.exclusiveMinimum)) ||
     (field.kind === 'enum' &&
       typeof value === 'string' &&
       field.options?.some((option) => option.value === value) === true) ||
@@ -238,7 +272,7 @@ function assertDescriptorValue(
       isRecord(value) &&
       Object.values(value).every((v) => typeof v === 'string'));
   if (!valid) {
-    throw invalidConfig(`Channel field "${field.key}" has an invalid value.`);
+    throw invalidConfig(`Channel field "${path}" has an invalid value.`);
   }
 }
 

packages/sdk-typescript/src/daemon/types.ts

@@ -2988,7 +2988,8 @@ export type DaemonChannelConfigFieldKind =
   | 'number'
   | 'enum'
   | 'string-list'
-  | 'record';
+  | 'record'
+  | 'object';
 
 export interface DaemonChannelConfigFieldDescriptor {
   key: string;
@@ -2998,6 +2999,8 @@ export interface DaemonChannelConfigFieldDescriptor {
   envResolvable?: boolean;
   options?: ReadonlyArray<{ value: string; label: string }>;
   default?: string;
+  properties?: readonly DaemonChannelConfigFieldDescriptor[];
+  exclusiveMinimum?: number;
   description?: string;
 }
 

packages/web-shell/client/components/channels/ChannelEditorDialog.test.tsx

@@ -33,6 +33,11 @@ const DINGTALK: DaemonChannelTypeDescriptor = {
       kind: 'secret',
       required: true,
     },
+    {
+      key: 'interactiveCards',
+      label: 'Interactive Cards',
+      kind: 'object',
+    },
   ],
 };
 
@@ -125,6 +130,12 @@ afterEach(() => {
 });
 
 describe('ChannelEditorDialog', () => {
+  it('does not render object metadata as a text field', async () => {
+    await renderDialog();
+
+    expect(inputByLabel('Interactive Cards')).toBeNull();
+  });
+
   it('preserves a stored secret until Replace is explicitly selected', async () => {
     await renderDialog({ instance: INSTANCE });
 

packages/web-shell/client/components/channels/ChannelEditorDialog.tsx

@@ -383,6 +383,7 @@ export function ChannelEditorDialog({
   };
 
   const renderField = (field: DaemonChannelConfigFieldDescriptor) => {
+    if (field.kind === 'object') return null;
     if (field.kind === 'secret') return renderSecret(field);
     const id = `${formId}-${field.key}`;
     const value = draft.values[field.key];

packages/web-shell/client/components/channels/channel-editor-state.test.ts

@@ -34,6 +34,11 @@ const DINGTALK: DaemonChannelTypeDescriptor = {
       required: true,
       envResolvable: true,
     },
+    {
+      key: 'interactiveCards',
+      label: 'Interactive Cards',
+      kind: 'object',
+    },
   ],
 };
 
@@ -46,6 +51,10 @@ function configuredInstance(): DaemonChannelInstanceSnapshot {
       senderPolicy: 'open',
       sessionScope: 'thread',
       model: 'qwen3-coder-plus',
+      interactiveCards: {
+        enabled: true,
+        statusCard: { enabled: true },
+      },
     },
     secrets: {
       clientSecret: { present: true, source: 'environment' },
@@ -96,6 +105,10 @@ describe('Channel editor state', () => {
         senderPolicy: 'open',
         sessionScope: 'thread',
         model: 'qwen3-coder-plus',
+        interactiveCards: {
+          enabled: true,
+          statusCard: { enabled: true },
+        },
       },
       secrets: {
         clientSecret: { operation: 'preserve' },

packages/web-shell/client/components/channels/channel-editor-state.ts

@@ -83,6 +83,7 @@ export function createChannelEditorDraft(
   const values: Record<string, string | boolean> = {};
   const secrets: Record<string, ChannelSecretDraft> = {};
   for (const field of descriptor.fields) {
+    if (field.kind === 'object') continue;
     if (field.kind === 'secret') {
       secrets[field.key] = instance?.secrets[field.key]?.present
         ? { operation: 'preserve' }
@@ -239,6 +240,7 @@ export function buildChannelUpsertRequest(
   };
   const secrets: Record<string, DaemonChannelSecretUpdate> = {};
   for (const field of descriptor.fields) {
+    if (field.kind === 'object') continue;
     if (field.kind === 'secret') {
       const secret = draft.secrets[field.key] ?? { operation: 'preserve' };
       secrets[field.key] =