feat(dsh): add bailian-cli-dsh plugin bundle for DeepSeek Harness

Expose Bailian capabilities to dsh through its service seams as one
package with six subpath plugin entries and a `dsh.bundle` patch:

- TokenPlan as an LLM provider
- bailian_vision_describe / bailian_image_generate tools over `bl`
- knowledge-base retrieval as a WebSearchProvider (`bailian-kb`)
- cross-session memory: tools, pre-step recall, turn-close persist
- managed-agent as a SubagentProvider

TokenPlan configures the base bundle's existing pi-ai row rather than
mounting a second `dsh-llm-pi-ai` instance. A second instance cannot
work: pi-ai re-declares its entire built-in provider catalog to
`registerConfigurableProviders`, and that directory is global, so boot
fails with a duplicate on `amazon-bedrock`.

Routes and vision support were probed against the live gateway.
qwen3.8-max, qwen3.7-plus, qwen3.6-flash and glm-5.2 read images;
qwen3.7-max rejects them with HTTP 400; the DeepSeek routes accept image
content without erroring yet stay blind. The DeepSeek entries therefore
do not declare image input — claiming it would turn a clean refusal into
a silently wrong answer — and `bailian_vision_describe` serves them by
returning text instead.

Also fix `bl memory` against the v2 API, each verified live:

- `profile get` used /profiles, which returns HTTP 500. The documented
  and working endpoint is /user_profile.
- `add` read `response.memory_ids`, which the service never returns. It
  returns `memory_nodes`, so text output always printed "IDs: none".
- `MemoryNode.created_at`/`updated_at` are unix seconds, not strings, and
  `UserProfileResponse.profile` did not match the wire shape.
- Add the missing request parameters: --meta-data, --project-id,
  --project-ids, --min-score, --enable-rerank, --plan-version,
  --enable-judge, --enable-rewrite, --timestamp.
- Add `memory profile list|detail|update|delete`, covering the four v2
  profile-schema operations the CLI was missing.

`plan_version: lite` is ignored by the service and still bills pro;
`enable_rerank: false` is what actually selects lite, which is ~50x
cheaper per search. The CLI flag and the memory plugin both send the
parameter that works.

Disable pnpm's autoInstallPeers: the @deepseek-ai/dsh-* rc line peers on
three packages that were never published to npm, which 404s the whole
workspace install. Verified the existing packages still build.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: lishengzxc

.gitignore

@@ -52,3 +52,6 @@ packages/cli/scene/**/outputs/
 
 # Local scratch / plan drafts (never commit)
 .scratch/
+
+# pnpm pack output
+*.tgz

packages/cli/src/commands.ts

@@ -30,6 +30,10 @@ import {
   memoryDelete,
   memoryProfileCreate,
   memoryProfileGet,
+  memoryProfileList,
+  memoryProfileDetail,
+  memoryProfileUpdate,
+  memoryProfileDelete,
   knowledgeRetrieve,
   knowledgeSearch,
   knowledgeChat,
@@ -149,6 +153,10 @@ export const commands: Record<string, AnyCommand> = {
   "memory delete": memoryDelete,
   "memory profile create": memoryProfileCreate,
   "memory profile get": memoryProfileGet,
+  "memory profile list": memoryProfileList,
+  "memory profile detail": memoryProfileDetail,
+  "memory profile update": memoryProfileUpdate,
+  "memory profile delete": memoryProfileDelete,
   "knowledge retrieve": knowledgeRetrieve,
   "knowledge search": knowledgeSearch,
   "knowledge chat": knowledgeChat,

packages/commands/src/commands/memory/add.ts

@@ -28,6 +28,16 @@ const ADD_FLAGS = {
     valueHint: "<id>",
     description: "Memory library ID (isolate memory space)",
   },
+  projectId: {
+    type: "string",
+    valueHint: "<id>",
+    description: "Memory extraction rule ID (defaults to the library's default rule)",
+  },
+  metaData: {
+    type: "string",
+    valueHint: "<json>",
+    description: 'Custom metadata JSON object: {"location":"Beijing"}',
+  },
 } satisfies FlagsDef;
 type AddFlags = ParsedFlags<typeof ADD_FLAGS>;
 
@@ -40,6 +50,7 @@ export default defineCommand({
     '--user-id user1 --content "The user likes Python programming"',
     '--user-id user1 --messages \'[{"role":"user","content":"I like traveling"}]\'',
     '--user-id user1 --content "Lives in Beijing" --profile-schema schema_xxx',
+    '--user-id user1 --content "Lives in Beijing" --meta-data \'{"source":"onboarding"}\'',
   ],
   validate: (f: AddFlags) =>
     !f.messages && !f.content ? "Provide --messages or --content." : undefined,
@@ -63,6 +74,15 @@ export default defineCommand({
 
     if (flags.profileSchema) body.profile_schema = flags.profileSchema;
     if (flags.memoryLibraryId) body.memory_library_id = flags.memoryLibraryId;
+    if (flags.projectId) body.project_id = flags.projectId;
+
+    if (flags.metaData) {
+      try {
+        body.meta_data = JSON.parse(flags.metaData);
+      } catch {
+        throw new UsageError("--meta-data must be valid JSON object");
+      }
+    }
 
     const format = detectOutputFormat(settings.output);
 
@@ -78,8 +98,14 @@ export default defineCommand({
     });
 
     if (settings.quiet || format === "text") {
-      const ids = response.memory_ids?.join(", ") || "none";
-      emitBare(`Memory added. IDs: ${ids}`);
+      const nodes = response.memory_nodes ?? [];
+      if (nodes.length === 0) {
+        emitBare("No memory fragments were extracted.");
+      } else {
+        for (const node of nodes) {
+          emitBare(`[${node.event ?? "ADD"}] ${node.memory_node_id} ${node.content}`);
+        }
+      }
     } else {
       emitResult(response, format);
     }

packages/commands/src/commands/memory/list.ts

@@ -24,6 +24,11 @@ export default defineCommand({
     },
     page: { type: "number", valueHint: "<n>", description: "Page number (default: 1)" },
     memoryLibraryId: { type: "string", valueHint: "<id>", description: "Memory library ID" },
+    projectId: {
+      type: "string",
+      valueHint: "<id>",
+      description: "Memory extraction rule ID (defaults to the library's default rule)",
+    },
   },
   exampleArgs: ["--user-id user1", "--user-id user1 --page-size 20 --page 2"],
   async run(ctx) {
@@ -36,6 +41,7 @@ export default defineCommand({
     if (flags.pageSize !== undefined) params.set("page_size", String(flags.pageSize));
     if (flags.page !== undefined) params.set("page_num", String(flags.page));
     if (flags.memoryLibraryId) params.set("memory_library_id", flags.memoryLibraryId);
+    if (flags.projectId) params.set("project_id", flags.projectId);
 
     const path = `${memoryListPath()}?${params.toString()}`;
 

packages/commands/src/commands/memory/profile-delete.ts

@@ -0,0 +1,44 @@
+import { defineCommand, profileSchemaItemPath, detectOutputFormat } from "bailian-cli-core";
+import { emitResult, emitBare } from "bailian-cli-runtime";
+
+export default defineCommand({
+  description: "Delete a profile schema",
+  auth: "apiKey",
+  usageArgs: "--schema-id <id> [flags]",
+  flags: {
+    schemaId: {
+      type: "string",
+      valueHint: "<id>",
+      description: "Profile schema ID (required)",
+      required: true,
+    },
+    memoryLibraryId: { type: "string", valueHint: "<id>", description: "Memory library ID" },
+  },
+  exampleArgs: ["--schema-id schema_xxx"],
+  async run(ctx) {
+    const { settings, flags } = ctx;
+    const format = detectOutputFormat(settings.output);
+
+    const params = new URLSearchParams();
+    if (flags.memoryLibraryId) params.set("memory_library_id", flags.memoryLibraryId);
+    const query = params.toString();
+    const base = profileSchemaItemPath(flags.schemaId);
+    const path = query ? `${base}?${query}` : base;
+
+    if (settings.dryRun) {
+      emitResult({ endpoint: ctx.client.url(path), method: "DELETE" }, format);
+      return;
+    }
+
+    const response = await ctx.client.requestJson<{ request_id: string }>({
+      path,
+      method: "DELETE",
+    });
+
+    if (settings.quiet || format === "text") {
+      emitBare(`Profile schema ${flags.schemaId} deleted.`);
+    } else {
+      emitResult(response, format);
+    }
+  },
+});

packages/commands/src/commands/memory/profile-detail.ts

@@ -0,0 +1,52 @@
+import {
+  defineCommand,
+  profileSchemaItemPath,
+  detectOutputFormat,
+  type ProfileSchemaGetResponse,
+} from "bailian-cli-core";
+import { emitResult, emitBare } from "bailian-cli-runtime";
+
+export default defineCommand({
+  description: "Show a profile schema and its attribute IDs",
+  auth: "apiKey",
+  usageArgs: "--schema-id <id> [flags]",
+  flags: {
+    schemaId: {
+      type: "string",
+      valueHint: "<id>",
+      description: "Profile schema ID (required)",
+      required: true,
+    },
+    memoryLibraryId: { type: "string", valueHint: "<id>", description: "Memory library ID" },
+  },
+  exampleArgs: ["--schema-id schema_xxx"],
+  async run(ctx) {
+    const { settings, flags } = ctx;
+    const format = detectOutputFormat(settings.output);
+
+    const params = new URLSearchParams();
+    if (flags.memoryLibraryId) params.set("memory_library_id", flags.memoryLibraryId);
+    const query = params.toString();
+    const base = profileSchemaItemPath(flags.schemaId);
+    const path = query ? `${base}?${query}` : base;
+
+    if (settings.dryRun) {
+      emitResult({ endpoint: ctx.client.url(path), method: "GET" }, format);
+      return;
+    }
+
+    const response = await ctx.client.requestJson<ProfileSchemaGetResponse>({
+      path,
+      method: "GET",
+    });
+
+    if (settings.quiet || format === "text") {
+      emitBare(`${response.name}${response.description ? ` — ${response.description}` : ""}`);
+      for (const attribute of response.attributes ?? []) {
+        emitBare(`  [${attribute.attribute_id}] ${attribute.name}`);
+      }
+    } else {
+      emitResult(response, format);
+    }
+  },
+});

packages/commands/src/commands/memory/profile-list.ts

@@ -0,0 +1,55 @@
+import {
+  defineCommand,
+  profileSchemaPath,
+  detectOutputFormat,
+  type ProfileSchemaListResponse,
+} from "bailian-cli-core";
+import { emitResult, emitBare } from "bailian-cli-runtime";
+
+export default defineCommand({
+  description: "List profile schemas",
+  auth: "apiKey",
+  usageArgs: "[flags]",
+  flags: {
+    memoryLibraryId: { type: "string", valueHint: "<id>", description: "Memory library ID" },
+    pageSize: { type: "number", valueHint: "<n>", description: "Results per page (default: 10)" },
+    page: { type: "number", valueHint: "<n>", description: "Page number (default: 1)" },
+  },
+  exampleArgs: ["", "--page-size 20 --page 2"],
+  async run(ctx) {
+    const { settings, flags } = ctx;
+    const format = detectOutputFormat(settings.output);
+
+    const params = new URLSearchParams();
+    if (flags.memoryLibraryId) params.set("memory_library_id", flags.memoryLibraryId);
+    if (flags.pageSize !== undefined) params.set("page_size", String(flags.pageSize));
+    if (flags.page !== undefined) params.set("page_num", String(flags.page));
+
+    const query = params.toString();
+    const path = query ? `${profileSchemaPath()}?${query}` : profileSchemaPath();
+
+    if (settings.dryRun) {
+      emitResult({ endpoint: ctx.client.url(path), method: "GET" }, format);
+      return;
+    }
+
+    const response = await ctx.client.requestJson<ProfileSchemaListResponse>({
+      path,
+      method: "GET",
+    });
+
+    if (settings.quiet || format === "text") {
+      const schemas = response.profile_schemas ?? [];
+      if (schemas.length === 0) {
+        emitBare("No profile schemas found.");
+      } else {
+        for (const schema of schemas) {
+          emitBare(`[${schema.profile_schema_id}] ${schema.name}`);
+        }
+        if (response.total !== undefined) emitBare(`\nTotal: ${response.total}`);
+      }
+    } else {
+      emitResult(response, format);
+    }
+  },
+});

packages/commands/src/commands/memory/profile-update.ts

@@ -0,0 +1,81 @@
+import {
+  defineCommand,
+  UsageError,
+  profileSchemaItemPath,
+  detectOutputFormat,
+  type ProfileSchemaUpdateRequest,
+} from "bailian-cli-core";
+import { emitResult, emitBare } from "bailian-cli-runtime";
+import type { FlagsDef, ParsedFlags } from "bailian-cli-core";
+
+const UPDATE_FLAGS = {
+  schemaId: {
+    type: "string",
+    valueHint: "<id>",
+    description: "Profile schema ID (required)",
+    required: true,
+  },
+  name: { type: "string", valueHint: "<name>", description: "New schema name" },
+  description: { type: "string", valueHint: "<text>", description: "New schema description" },
+  attributeOps: {
+    type: "string",
+    valueHint: "<json>",
+    description:
+      'Attribute operations JSON array: [{"op":"add","name":"plan"},{"op":"delete","attribute_id":"attr_1"}]',
+  },
+  memoryLibraryId: { type: "string", valueHint: "<id>", description: "Memory library ID" },
+} satisfies FlagsDef;
+type UpdateFlags = ParsedFlags<typeof UPDATE_FLAGS>;
+
+export default defineCommand({
+  description: "Update a profile schema's name, description, or attributes",
+  auth: "apiKey",
+  usageArgs: "--schema-id <id> [--name <name>] [--attribute-ops <json>] [flags]",
+  flags: UPDATE_FLAGS,
+  notes: ["Attribute IDs for update/delete operations come from `memory profile detail`."],
+  exampleArgs: [
+    '--schema-id schema_xxx --name "user_basic_v2"',
+    '--schema-id schema_xxx --attribute-ops \'[{"op":"add","name":"plan","description":"subscription plan"}]\'',
+    '--schema-id schema_xxx --attribute-ops \'[{"op":"delete","attribute_id":"attr_1"}]\'',
+  ],
+  validate: (f: UpdateFlags) =>
+    !f.name && !f.description && !f.attributeOps
+      ? "Provide --name, --description, or --attribute-ops."
+      : undefined,
+  async run(ctx) {
+    const { settings, flags } = ctx;
+    const format = detectOutputFormat(settings.output);
+
+    const body: ProfileSchemaUpdateRequest = {};
+    if (flags.name) body.name = flags.name;
+    if (flags.description) body.description = flags.description;
+    if (flags.memoryLibraryId) body.memory_library_id = flags.memoryLibraryId;
+
+    if (flags.attributeOps) {
+      try {
+        body.attributes_operations = JSON.parse(flags.attributeOps);
+      } catch {
+        throw new UsageError("--attribute-ops must be valid JSON array");
+      }
+    }
+
+    const path = profileSchemaItemPath(flags.schemaId);
+
+    if (settings.dryRun) {
+      emitResult({ endpoint: ctx.client.url(path), method: "PATCH", request: body }, format);
+      return;
+    }
+
+    const response = await ctx.client.requestJson<{ request_id: string }>({
+      path,
+      method: "PATCH",
+      body,
+    });
+
+    if (settings.quiet || format === "text") {
+      emitBare(`Profile schema ${flags.schemaId} updated.`);
+    } else {
+      emitResult(response, format);
+    }
+  },
+});