WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

packages/dsh-weknora/test/e2e/run-in-dsh.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+/**
+ * End-to-end check inside a real DeepSeek Harness install: install this package
+ * into a throwaway dsh profile with `dsh plugin add`, boot the headless profile
+ * against a fake OpenAI-compatible model and a mock WeKnora backend, and assert
+ * that the harness agent loop actually called the tools and answered from what
+ * they returned.
+ *
+ * Three scenarios run, because all three are documented paths:
+ *   A. the bundle's shipped `cordis.patch.yml`, configured only by environment
+ *      variables — what a user gets straight after `dsh plugin add`.
+ *   B. a profile patch that overrides the row, including a renamed tool prefix,
+ *      which also proves configuration reaches the plugin.
+ *   C. a row with no knowledge base scope, where the plugin resolves the full
+ *      visible set itself — WeKnora refuses an unscoped search.
+ *
+ * Usage:
+ *   node test/e2e/run-in-dsh.mjs                 # installs dsh into a cache dir
+ *   DSH_BIN=/path/to/dsh node test/e2e/run-in-dsh.mjs
+ *   DSH_E2E_LOG=/tmp/transcript.log node test/e2e/run-in-dsh.mjs
+ *
+ * Environment:
+ *   DSH_PACKAGE_SPEC  npm spec for the harness (default `@deepseek-ai/dsh@latest`)
+ *   DSH_INSTALL_DIR   where to keep that install (default `<tmp>/dsh-e2e-install`)
+ *   DSH_E2E_KEEP_HOME keep the throwaway `DSH_HOME` for inspection
+ */
+
+import assert from 'node:assert/strict'
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { startFakeModel } from './fake-model.mjs'
+import { startMockWeknora } from '../helpers/mock-weknora.mjs'
+
+const packageDir = resolve(dirname(fileURLToPath(import.meta.url)), '../..')
+const installDir = process.env.DSH_INSTALL_DIR ?? join(tmpdir(), 'dsh-e2e-install')
+const dshSpec = process.env.DSH_PACKAGE_SPEC ?? '@deepseek-ai/dsh@latest'
+const API_KEY = 'e2e-api-key'
+const QUESTION = 'WeKnora 的默认检索阈值是多少？请查知识库后回答。'
+const transcript = []
+
+function log(line) {
+  transcript.push(line)
+  process.stdout.write(`${line}\n`)
+}
+
+/** Run a command to completion, capturing both streams. */
+function run(command, args, options = {}) {
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd ?? packageDir,
+      env: { ...process.env, ...options.env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', part => {
+      stdout += part
+    })
+    child.stderr.on('data', part => {
+      stderr += part
+    })
+    child.on('error', rejectRun)
+    child.on('close', code => resolveRun({ code, stdout, stderr }))
+  })
+}
+
+/** Resolve a dsh launcher, installing one from npm when none was supplied. */
+async function resolveDsh() {
+  if (process.env.DSH_BIN !== undefined) return process.env.DSH_BIN
+  const binary = join(installDir, 'node_modules', '.bin', 'dsh')
+  if (existsSync(binary)) {
+    log(`# reusing the dsh install at ${installDir}`)
+    return binary
+  }
+  log(`# installing ${dshSpec} into ${installDir} (first run only)`)
+  await mkdir(installDir, { recursive: true })
+  await writeFile(join(installDir, 'package.json'), JSON.stringify({ name: 'dsh-e2e-install', private: true }, null, 2))
+  const install = await run('npm', ['install', '--no-audit', '--no-fund', dshSpec], { cwd: installDir })
+  if (install.code !== 0) throw new Error(`npm install ${dshSpec} failed:\n${install.stderr}`)
+  return binary
+}
+
+/** The two rows that make dsh talk to the fake model instead of DeepSeek. */
+function modelPatchRows(modelUrl) {
+  return [
+    {
+      id: 'agent-default-model',
+      config: { provider: 'weknora-e2e', model: 'weknora-e2e-model' },
+    },
+    {
+      id: 'llm-pi-ai',
+      config: {
+        providers: {
+          'weknora-e2e': {
+            displayName: 'WeKnora e2e gateway',
+            apiKeyEnv: 'WEKNORA_E2E_MODEL_KEY',
+            api: 'openai-completions',
+            baseURL: modelUrl,
+            models: [{
+              id: 'weknora-e2e-model',
+              name: 'WeKnora e2e model',
+              contextWindow: 65536,
+              maxTokens: 4096,
+            }],
+          },
+        },
+      },
+    },
+  ]
+}
+
+/**
+ * Boot the headless profile once and assert the whole path: the harness offered
+ * the tools, the tools reached WeKnora, the retrieved passages reached the
+ * model, and the printed answer is grounded in them.
+ */
+async function scenario(options) {
+  const { label, dsh, home, env, patch, prefix, weknora, autoScope = false } = options
+  const model = await startFakeModel({ searchTool: `${prefix}_search`, readTool: `${prefix}_read_document` })
+  const requestsBefore = weknora.requests.length
+  try {
+    await writeFile(
+      join(home, 'profiles', 'headless', 'cordis.patch.yml'),
+      JSON.stringify([...patch, ...modelPatchRows(model.url)], null, 2),
+    )
+
+    const dump = await run(dsh, ['--profile', 'headless', '--dump-config'], { env })
+    assert.equal(dump.code, 0, `--dump-config must succeed:\n${dump.stderr}`)
+    assert.match(dump.stdout, /name: ["']?@wxg-prc-cpg\/dsh-weknora/, 'the composed tree must mount the plugin')
+
+    log(`\n=== ${label} ===`)
+    log(`$ dsh --profile headless "${QUESTION}"`)
+    const boot = await run(dsh, ['--profile', 'headless', QUESTION], { env })
+    log(`--- stdout ---\n${boot.stdout.trim()}`)
+    if (boot.stderr.trim() !== '') log(`--- stderr ---\n${boot.stderr.trim()}`)
+    assert.equal(boot.code, 0, 'the headless run must exit 0')
+
+    const offered = (model.requests.at(0)?.offeredTools ?? []).filter(name => name.startsWith(`${prefix}_`))
+    log(`# tools offered to the model: ${offered.join(', ')}`)
+    for (const suffix of ['search', 'read_document', 'ask', 'list_knowledge_bases']) {
+      assert.ok(offered.includes(`${prefix}_${suffix}`), `${prefix}_${suffix} must appear in the model's tool schemas`)
+    }
+
+    const calls = weknora.requests.slice(requestsBefore)
+    const paths = calls.map(request => request.path)
+    log(`# WeKnora received: ${paths.join(', ')}`)
+    assert.ok(paths.includes('/api/v1/knowledge-search'), 'search must reach the retrieval endpoint')
+    if (autoScope) {
+      // WeKnora rejects an unscoped retrieval, so with nothing configured the
+      // plugin has to resolve the full visible set itself — the model asked a
+      // plain question and never named a knowledge base.
+      assert.ok(
+        paths.indexOf('/api/v1/knowledge-bases') >= 0
+        && paths.indexOf('/api/v1/knowledge-bases') < paths.indexOf('/api/v1/knowledge-search'),
+        'the plugin must resolve the visible knowledge bases before retrieving',
+      )
+      const search = calls.find(request => request.path === '/api/v1/knowledge-search')
+      assert.deepEqual(
+        search.body.knowledge_base_ids,
+        ['kb-product', 'kb-ops'],
+        'an unconfigured deployment must search every visible knowledge base',
+      )
+    }
+    assert.ok(paths.some(path => path.startsWith('/api/v1/chunks/')), 'read_document must reach the chunk endpoint')
+    assert.equal(
+      weknora.requests.slice(requestsBefore).every(request => request.headers['x-api-key'] === API_KEY),
+      true,
+      'every call must carry the configured API key',
+    )
+
+    const toolResults = model.requests.flatMap(request => request.toolResults).join('\n')
+    assert.match(toolResults, /vector_threshold 是 0\.5/, 'the model must see the retrieved passage verbatim')
+    assert.match(toolResults, /knowledge_id: doc-retrieval-pipeline/, 'search hits must carry a usable knowledge_id')
+    assert.match(boot.stdout, /0\.5/, 'the printed answer must carry the retrieved threshold')
+
+    log(`# PASS (${label}): ${prefix}_search and ${prefix}_read_document ran inside dsh against WeKnora, `
+      + 'and the answer came from the retrieved passages.')
+  } finally {
+    await model.close()
+  }
+}
+
+async function main() {
+  if (!existsSync(join(packageDir, 'dist', 'index.js'))) {
+    throw new Error('build the package first: npm run build')
+  }
+
+  const weknora = await startMockWeknora({ apiKey: API_KEY })
+  const home = await mkdtemp(join(tmpdir(), 'dsh-weknora-home-'))
+  const dsh = await resolveDsh()
+  const env = {
+    DSH_HOME: home,
+    WEKNORA_E2E_MODEL_KEY: 'not-a-real-key',
+    WEKNORA_BASE_URL: weknora.url,
+    WEKNORA_API_KEY: API_KEY,
+    WEKNORA_KNOWLEDGE_BASE_IDS: 'kb-product',
+  }
+
+  log(`# mock WeKnora   ${weknora.url}`)
+  log(`# DSH_HOME       ${home}`)
+  log(`# dsh launcher   ${dsh}`)
+
+  try {
+    // Install this package into a fresh profile exactly as a user would.
+    const install = await run(dsh, ['plugin', '--profile', 'headless', 'add', packageDir], { env })
+    log(`\n$ dsh plugin --profile headless add ${packageDir}\n${install.stdout.trim()}\n${install.stderr.trim()}`)
+    assert.equal(install.code, 0, 'dsh plugin add must succeed')
+
+    const manifest = JSON.parse(await readFile(join(home, 'profiles', 'headless', 'package.json'), 'utf8'))
+    log(`# profile bundles: ${JSON.stringify(manifest.dsh.profile.bundles)}`)
+    assert.ok(
+      manifest.dsh.profile.bundles.includes('@wxg-prc-cpg/dsh-weknora'),
+      'the bundle must join the profile layer list',
+    )
+
+    // A. The shipped bundle patch, configured only by environment variables.
+    await scenario({ label: 'A · shipped bundle defaults from env', dsh, home, env, weknora, patch: [], prefix: 'weknora' })
+
+    // B. A profile override, which also renames the tools.
+    await scenario({
+      label: 'B · profile override with a renamed tool prefix',
+      dsh,
+      home,
+      env,
+      weknora,
+      prefix: 'kb',
+      patch: [{
+        id: 'weknora',
+        config: {
+          baseUrl: weknora.url,
+          apiKey: API_KEY,
+          knowledgeBaseIds: ['kb-product'],
+          toolPrefix: 'kb',
+          maxResults: 3,
+          maxChunkChars: 400,
+        },
+      }],
+    })
+
+    // C. No configured scope at all, which is what the quickstart's optional
+    //    WEKNORA_KNOWLEDGE_BASE_IDS leaves behind.
+    await scenario({
+      label: 'C · no configured scope, resolved by the plugin',
+      dsh,
+      home,
+      env,
+      weknora,
+      prefix: 'weknora',
+      autoScope: true,
+      patch: [{
+        id: 'weknora',
+        config: { baseUrl: weknora.url, apiKey: API_KEY },
+      }],
+    })
+
+    log('\n# ALL SCENARIOS PASSED')
+  } finally {
+    await weknora.close()
+    const logPath = process.env.DSH_E2E_LOG
+    if (logPath !== undefined) await writeFile(logPath, `${transcript.join('\n')}\n`)
+    if (process.env.DSH_E2E_KEEP_HOME === undefined) await rm(home, { recursive: true, force: true })
+  }
+}
+
+await main()