dsh-router-core 0.4.1 → 0.4.2

package/README.md

@@ -14,13 +14,13 @@
   <a href="#快速安装">快速安装</a> ·
   <a href="#面板设置--路由">面板</a> ·
   <a href="#agent-team-支持">Agent Team</a> ·
-  <a href="#api-端点openai-兼容3080v1">API 端点</a> ·
+  <a href="#api-端点openai-兼容v1">API 端点</a> ·
   <a href="docs/suppliers.md">供应商开发</a> ·
   <a href="docs/ext.md">扩展开发</a>
 </p>
 
 **插件版的 9router** —— 不是另开一个网关服务,而是直接作为 DSH 插件嵌进 DSH web,
-在 `http://localhost:3080/v1` 上原生暴露 OpenAI 兼容端点,把请求路由到内部供应商。
+在宿主 Web 服务的 `/v1` 上原生暴露 OpenAI 兼容端点(`http://127.0.0.1:<宿主页端口>/v1`;`dsh web` 默认 3080,面板「端点与密钥」页显示的是实际地址),把请求路由到内部供应商。
 管理界面在**设置 → 路由**(官方设置页座位,不是自己开的页面)。装好即用,
 不用多开一个 9router、不用维护第二个端口、不用在网关和 DSH 之间搬配置。
 
@@ -160,11 +160,15 @@ team 测试就是多个会话交错发请求。dsh-router 原生适配这个场
   为 DSH 模型目录里的 `router` provider 选项(设置 → 模型直接选组合名即可用),请求
   按组合策略命中其中一个供应商模型;
 - **端点与密钥** — 端点核心(无隧道/Tailscale):
-  - API 端点 URL(`http://localhost:3080/v1`,可复制);
+  - API 端点 URL(面板按当前页面 origin 显示,可复制;端口跟着宿主走,`dsh web` 默认 3080);
   - 鉴权设置 `requireApiKey` 开关;
   - API Keys 管理:创建 / 启用切换 / 显示 / 复制 / 删除(持久化到 `data/keys.json`)。
 
-## API 端点(OpenAI 兼容,`:3080/v1`)
+## API 端点(OpenAI 兼容,`/v1`)
+
+> 端口 = **宿主 Web 服务实际监听的端口**:`dsh web` 默认 3080,桌面端等通道由宿主
+> 分配(不一定还是 3080)。下面按 3080 写;换通道时把端口换成面板「端点与密钥」
+> 页里显示的那个即可。
 
 ```bash
 # 模型列表
@@ -177,7 +181,7 @@ curl -X POST http://localhost:3080/v1/chat/completions \
 ```
 
 任何支持 OpenAI 兼容 API 的工具(Claude Code、Cline、DSH 设置-模型 等)都可以把
-`baseURL` 指向 `http://localhost:3080/v1`。
+`baseURL` 指向面板「端点与密钥」页里显示的那个端点(`dsh web` 下即 `http://localhost:3080/v1`)。
 
 **鉴权**:默认 `requireApiKey=false`,`/v1/*` 不要求鉴权(本地使用,与 9router 一致)。
 在「端点与密钥」页开启「要求 API Key」后,请求必须带

package/docs/ext.md

@@ -223,7 +223,7 @@ tools.get('bash')              // ❌ 只查全局视图,查不到 → 静默走
 
 ```bash
 # 1) 看 API:扩展器 enabled / ready 是否都为 true
-curl -s http://127.0.0.1:3080/router/api/ext
+curl -s http://127.0.0.1:3080/router/api/ext   # 端口 = 宿主页端口(面板可见),非 3080 的通道要换
 
 # 2) 跑一条有等价改写的命令,看输出是否变成压缩格式
 ls                 # 被改写时是 rtk 树形格式,不是原生列表

package/lib/index.js

@@ -3160,6 +3160,11 @@ const ROUTER_REASONING_EFFORTS = [
 	}
 ];
 var RouterAdapter = class RouterAdapter extends LlmAdapter {
+	/**
+	* 网关端点。**函数形态 = 每次请求现算**：端口要等宿主 listen 完才有值的场景
+	* 必须传函数（写死 3080 在桌面端等非 3080 宿主上全线 `fetch failed`，
+	* issue #9），见 `host-base-url.ts`。
+	*/
 	baseURL;
 	source;
 	resolveAttachments;
@@ -3232,7 +3237,8 @@ var RouterAdapter = class RouterAdapter extends LlmAdapter {
 		options.signal?.addEventListener("abort", onAbort, { once: true });
 		let resp;
 		try {
-			resp = await fetch(`${this.baseURL}/chat/completions`, {
+			const base = typeof this.baseURL === "function" ? this.baseURL() : this.baseURL;
+			resp = await fetch(`${base}/chat/completions`, {
 				method: "POST",
 				headers: {
 					...attributionHeaders(),
@@ -4565,6 +4571,47 @@ function dshHome() {
 	return resolve(value);
 }
 //#endregion
+//#region src/host-base-url.ts
+/**
+* 网关端点地址（`http://127.0.0.1:<宿主端口>/v1`）的解析。
+*
+* ## 为什么端口不能写死
+*
+* dsh-router **自己不开端口**：`/v1/*` 是注册在**宿主** web server 上的路由
+* （见 `index.ts` 的 `ctx.webServer.register`）。所以端点地址里的端口由启动通道
+* 决定，而不是插件决定 —— `dsh web` 默认 3080，桌面端官方通道、以及配置
+* `port: 0`（让 OS 分配）时都**不是** 3080。之前 adapter 把
+* `http://localhost:3080/v1` 写死在构造参数里，于是非 3080 的宿主上 Router
+* 的每一轮对话都是 `dsh-router upstream call failed: fetch failed`（issue #9）。
+*
+* ## 为什么返回函数而不是字符串
+*
+* `webServer.port` 是**监听之后**才有值的 getter（listen 前是 `undefined`），
+* 且宿主重启/换端口后它会变。所以这里返回函数、**每次请求现算**，不在注册时
+* 算一次 —— 注册发生在启动早期，那时算只会把「拿不到端口」固化成常量。
+*
+* ## 拿不到端口时为什么抛，而不是回退 3080
+*
+* 回退等于把同一个 bug 换种写法：端口读不到时宿主的路由也没在服务，回退到 3080
+* 只会重新得到一句无从查证的 `fetch failed`。这里抛明确的话，让它出现在
+* `LlmError` 消息里（adapter 在 fetch 同一个 try 里调它），报错自带原因。
+*/
+/** 回环地址：宿主即使监听 `0.0.0.0`（LAN 模式），走 127.0.0.1 也通。 */
+const LOOPBACK_HOST = "127.0.0.1";
+/**
+* 造一个「每次调用现读宿主端口」的端点解析器。
+*
+* @param readPort 读宿主监听端口（`webServer.port`）。取不到时抛错而不是猜。
+* @param path 端点路径前缀，默认 `/v1`。
+*/
+function loopbackBaseURL(readPort, path = "/v1") {
+	return () => {
+		const port = readPort();
+		if (port === void 0) throw new Error("dsh-router: 宿主 webServer 端口未就绪（webServer.port 读不到），无法定位 /v1 端点");
+		return `http://${LOOPBACK_HOST}:${String(port)}${path}`;
+	};
+}
+//#endregion
 //#region src/host-version.ts
 /**
 * 宿主 DSH 版本探测 —— **0.1.5 / 0.1.7 兼容分叉的唯一判据来源**。
@@ -5353,7 +5400,7 @@ function apply(rawContext) {
 			});
 			log(`Router settings section registered (${settingsNs})`);
 		});
-		disposers.push(ctx.llm.registerAdapter(["router"], new RouterAdapter("http://localhost:3080/v1", { comboModels: async () => (await router.combos()).map((c) => {
+		disposers.push(ctx.llm.registerAdapter(["router"], new RouterAdapter(loopbackBaseURL(() => ctx.webServer?.port), { comboModels: async () => (await router.combos()).map((c) => {
 			const w = router.comboContextWindow(c);
 			return {
 				id: c.name,

package/lib/types/host-base-url.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 网关端点地址（`http://127.0.0.1:<宿主端口>/v1`）的解析。
+ *
+ * ## 为什么端口不能写死
+ *
+ * dsh-router **自己不开端口**：`/v1/*` 是注册在**宿主** web server 上的路由
+ * （见 `index.ts` 的 `ctx.webServer.register`）。所以端点地址里的端口由启动通道
+ * 决定，而不是插件决定 —— `dsh web` 默认 3080，桌面端官方通道、以及配置
+ * `port: 0`（让 OS 分配）时都**不是** 3080。之前 adapter 把
+ * `http://localhost:3080/v1` 写死在构造参数里，于是非 3080 的宿主上 Router
+ * 的每一轮对话都是 `dsh-router upstream call failed: fetch failed`（issue #9）。
+ *
+ * ## 为什么返回函数而不是字符串
+ *
+ * `webServer.port` 是**监听之后**才有值的 getter（listen 前是 `undefined`），
+ * 且宿主重启/换端口后它会变。所以这里返回函数、**每次请求现算**，不在注册时
+ * 算一次 —— 注册发生在启动早期，那时算只会把「拿不到端口」固化成常量。
+ *
+ * ## 拿不到端口时为什么抛，而不是回退 3080
+ *
+ * 回退等于把同一个 bug 换种写法：端口读不到时宿主的路由也没在服务，回退到 3080
+ * 只会重新得到一句无从查证的 `fetch failed`。这里抛明确的话，让它出现在
+ * `LlmError` 消息里（adapter 在 fetch 同一个 try 里调它），报错自带原因。
+ */
+/**
+ * 造一个「每次调用现读宿主端口」的端点解析器。
+ *
+ * @param readPort 读宿主监听端口（`webServer.port`）。取不到时抛错而不是猜。
+ * @param path 端点路径前缀，默认 `/v1`。
+ */
+export declare function loopbackBaseURL(readPort: () => number | undefined, path?: string): () => string;

package/lib/types/llm/adapter.d.ts

@@ -82,6 +82,11 @@ export interface RouterAdapterSource {
  */
 export declare function translateSse(payloads: AsyncIterable<string> | Iterable<string>): AsyncGenerator<StreamChunk>;
 export declare class RouterAdapter extends LlmAdapter {
+    /**
+     * 网关端点。**函数形态 = 每次请求现算**：端口要等宿主 listen 完才有值的场景
+     * 必须传函数（写死 3080 在桌面端等非 3080 宿主上全线 `fetch failed`，
+     * issue #9），见 `host-base-url.ts`。
+     */
     private readonly baseURL;
     private readonly source;
     private readonly resolveAttachments;
@@ -95,7 +100,7 @@ export declare class RouterAdapter extends LlmAdapter {
      * @param log 降级诊断出口。图片读不到时会降级成占位文本，原因走这里 ——
      *   曾经那条路径是个空 `catch`，出问题跨版本都没人发现（issue #8）。
      */
-    constructor(baseURL: string, source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined, idleTimeoutMs?: number, log?: (msg: string) => void);
+    constructor(baseURL: string | (() => string), source: RouterAdapterSource, resolveAttachments?: () => RouterAttachmentStore | undefined, idleTimeoutMs?: number, log?: (msg: string) => void);
     providerInfo(provider: string): {
         id: string;
         name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-router-core",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "DSH plugin: a simplified 9router (AI routing gateway). Adds a 路由系统 (Routing System) sidebar entry beside 记忆系统; the panel shows suppliers, account pool, combos, and endpoint/API keys.",
   "type": "module",
   "repository": {

package/src/host-base-url.test.ts

@@ -0,0 +1,129 @@
+/**
+ * 网关端点按**宿主实际监听端口**解析 —— issue #9 的闸门。
+ *
+ * ## 这条闸门拦的是什么
+ *
+ * `/v1/*` 是注册在**宿主** webServer 上的路由，端口由启动通道给：`dsh web` 默认
+ * 3080，桌面端官方通道、以及 `port: 0`（OS 分配）都不是。adapter 曾把
+ * `http://localhost:3080/v1` 写死，于是那些宿主上 Router 每一轮对话都是
+ * `dsh-router upstream call failed: fetch failed`，而 `/v1` 明明就在本机跑着。
+ *
+ * 判据刻意用**真服务器 + OS 分配端口**而不是打桩 fetch：打桩只能证明字符串拼对了，
+ * 证明不了「非 3080 端口上请求真的落得到」（这正是当初漏掉这条 bug 的原因）。
+ * `listen(0)` 拿到的端口几乎不可能是 3080，于是「用 3080 也能过」的假修法在这条
+ * 闸门下会当场变红。
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { readdirSync, readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { RouterAdapter } from './llm/adapter.ts'
+import { loopbackBaseURL } from './host-base-url.ts'
+
+/** 起一个只回一条最小 SSE 的真服务器，回报 OS 分配的端口与收到的路径。 */
+async function serveSse(): Promise<{ port: number; hits: string[]; close: () => Promise<void> }> {
+  const hits: string[] = []
+  const server = createServer((req, res) => {
+    hits.push(req.url ?? '')
+    res.writeHead(200, { 'content-type': 'text/event-stream' })
+    res.end(`data: ${JSON.stringify({ choices: [{ delta: { content: 'ok' } }] })}\n\ndata: [DONE]\n\n`)
+  })
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+  const { port } = server.address() as AddressInfo
+  return { port, hits, close: () => new Promise<void>((resolve) => server.close(() => resolve())) }
+}
+
+/** 跑完一次 adapter 流，返回收到的块类型。 */
+async function drain(adapter: RouterAdapter): Promise<string[]> {
+  const types: string[] = []
+  for await (const c of adapter.stream({ model: 'm', messages: [], signal: AbortSignal.timeout(5000) } as never)) {
+    types.push(c.type)
+  }
+  return types
+}
+
+test('端点：宿主端口不是 3080 时，请求照样落得到（issue #9 的原始现场）', async () => {
+  const up = await serveSse()
+  try {
+    assert.notEqual(up.port, 3080, '这条用例的判据就是「端口不是 3080」')
+    const adapter = new RouterAdapter(loopbackBaseURL(() => up.port), { comboModels: async () => [] })
+    const types = await drain(adapter)
+    assert.deepEqual(up.hits, ['/v1/chat/completions'], `请求应打到宿主 /v1，实际打到：${JSON.stringify(up.hits)}`)
+    assert.ok(types.includes('text-delta'), `应真的收到上游内容，实际块类型：${JSON.stringify(types)}`)
+  } finally {
+    await up.close()
+  }
+})
+
+test('端点：端口每次请求现算（listen 前读不到、宿主重启换端口都不缓存）', async () => {
+  const first = await serveSse()
+  const second = await serveSse()
+  try {
+    let port: number | undefined = first.port
+    let reads = 0
+    const adapter = new RouterAdapter(
+      loopbackBaseURL(() => {
+        reads += 1
+        return port
+      }),
+      { comboModels: async () => [] },
+    )
+    await drain(adapter)
+    port = second.port // 宿主换了端口（重启 / 重新 listen）
+    await drain(adapter)
+    assert.deepEqual(first.hits, ['/v1/chat/completions'], '第一次应打在第一个端口')
+    assert.deepEqual(second.hits, ['/v1/chat/completions'], '端口变了之后应改打新端口（不能缓存第一次的值）')
+    assert.ok(reads >= 2, `端口应每请求现读，实际只读了 ${reads} 次`)
+  } finally {
+    await first.close()
+    await second.close()
+  }
+})
+
+test('端点：端口读不到时报出原因，不回退 3080 硬猜', async () => {
+  const adapter = new RouterAdapter(loopbackBaseURL(() => undefined), { comboModels: async () => [] })
+  await assert.rejects(
+    () => drain(adapter),
+    (err: Error) => {
+      assert.match(err.message, /webServer/, `报错必须带原因，实际：${err.message}`)
+      assert.equal((err as { code?: string }).code, 'TRANSPORT', '应是可重试的传输类错误')
+      return true
+    },
+  )
+})
+
+test('端点：常量形态的 baseURL 仍然可用（测试与显式传入的老调用方）', () => {
+  assert.equal(loopbackBaseURL(() => 19387)(), 'http://127.0.0.1:19387/v1')
+})
+
+test('源码：非测试代码里不得再出现写死的 3080 端点', () => {
+  // 防复发闸门：这次的根因就是一行写死的字符串，只靠「端口现算」的实现测试拦不住
+  // 将来有人在别处再写一遍。判据只看**代码**（先剥掉注释）——注释里可以、也应该
+  // 写明「当年就是这里写死了 3080」。
+  const root = fileURLToPath(new URL('.', import.meta.url))
+  const offenders: string[] = []
+  for (const file of walk(root)) {
+    if (/(?:localhost|127\.0\.0\.1):3080/.test(stripComments(readFileSync(file, 'utf8')))) {
+      offenders.push(file.slice(root.length))
+    }
+  }
+  assert.deepEqual(offenders, [], `这些文件里还有写死的 3080 端点（宿主端口随启动通道变）：${offenders.join(', ')}`)
+})
+
+/** 去掉块注释与行注释，只留可执行代码。 */
+function stripComments(text: string): string {
+  return text.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '')
+}
+
+/** 递归列出 src 下的 .ts 文件（跳过测试自身：测试里出现端口字面量是合法的）。 */
+function walk(dir: string): string[] {
+  const out: string[] = []
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = `${dir}${entry.name}`
+    if (entry.isDirectory()) out.push(...walk(`${path}/`))
+    else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts')) out.push(path)
+  }
+  return out
+}

package/src/host-base-url.ts

@@ -0,0 +1,43 @@
+/**
+ * 网关端点地址（`http://127.0.0.1:<宿主端口>/v1`）的解析。
+ *
+ * ## 为什么端口不能写死
+ *
+ * dsh-router **自己不开端口**：`/v1/*` 是注册在**宿主** web server 上的路由
+ * （见 `index.ts` 的 `ctx.webServer.register`）。所以端点地址里的端口由启动通道
+ * 决定，而不是插件决定 —— `dsh web` 默认 3080，桌面端官方通道、以及配置
+ * `port: 0`（让 OS 分配）时都**不是** 3080。之前 adapter 把
+ * `http://localhost:3080/v1` 写死在构造参数里，于是非 3080 的宿主上 Router
+ * 的每一轮对话都是 `dsh-router upstream call failed: fetch failed`（issue #9）。
+ *
+ * ## 为什么返回函数而不是字符串
+ *
+ * `webServer.port` 是**监听之后**才有值的 getter（listen 前是 `undefined`），
+ * 且宿主重启/换端口后它会变。所以这里返回函数、**每次请求现算**，不在注册时
+ * 算一次 —— 注册发生在启动早期，那时算只会把「拿不到端口」固化成常量。
+ *
+ * ## 拿不到端口时为什么抛，而不是回退 3080
+ *
+ * 回退等于把同一个 bug 换种写法：端口读不到时宿主的路由也没在服务，回退到 3080
+ * 只会重新得到一句无从查证的 `fetch failed`。这里抛明确的话，让它出现在
+ * `LlmError` 消息里（adapter 在 fetch 同一个 try 里调它），报错自带原因。
+ */
+
+/** 回环地址：宿主即使监听 `0.0.0.0`（LAN 模式），走 127.0.0.1 也通。 */
+const LOOPBACK_HOST = '127.0.0.1'
+
+/**
+ * 造一个「每次调用现读宿主端口」的端点解析器。
+ *
+ * @param readPort 读宿主监听端口（`webServer.port`）。取不到时抛错而不是猜。
+ * @param path 端点路径前缀，默认 `/v1`。
+ */
+export function loopbackBaseURL(readPort: () => number | undefined, path: string = '/v1'): () => string {
+  return () => {
+    const port = readPort()
+    if (port === undefined) {
+      throw new Error('dsh-router: 宿主 webServer 端口未就绪（webServer.port 读不到），无法定位 /v1 端点')
+    }
+    return `http://${LOOPBACK_HOST}:${String(port)}${path}`
+  }
+}

package/src/index.ts

@@ -2,7 +2,8 @@
  * Host half of dsh-router — a simplified 9router.
  *
  * dsh-router IS the router: it exposes an OpenAI-compatible `/v1/*` endpoint
- * on the DSH web server (http://localhost:3080/v1), and routes requests to
+ * on the DSH web server (http://127.0.0.1:<宿主监听端口>/v1 — 端口随启动通道
+ * 变，`dsh web` 默认 3080，见 host-base-url.ts), and routes requests to
  * internal suppliers.
  *
  * Routes:
@@ -42,6 +43,7 @@ import type { SupplierEnv, SupplierModule, SupplierRegistry } from './suppliers/
 import { SupplierConfigStore } from './supplier-config.ts'
 import { CredentialStore } from './credential-store.ts'
 import { dataDirOf, profileDirOf } from './data-dir.ts'
+import { loopbackBaseURL } from './host-base-url.ts'
 import { detectHostVersion, isHost017Plus, supportsLastHitDock } from './host-version.ts'
 import { ExtStore } from './ext/store.ts'
 import type { ExtInfo, ExtStoreService, RouterExt, RouterExtService } from './ext/contract.ts'
@@ -91,6 +93,12 @@ interface WebServerRoute {
 }
 interface WebServer {
   register: (route: WebServerRoute) => () => void
+  /**
+   * 宿主**实际监听**的端口（配置 port=0 时是 OS 分配的那个）。
+   * listen 之前为 undefined —— adapter 的端点按请求现读它，见 host-base-url.ts
+   * 与 issue #9。
+   */
+  readonly port?: number
 }
 
 /** Minimal shape of the llm service faces used here (设置-模型 提供方/模型目录). */
@@ -742,7 +750,11 @@ export function apply(rawContext: unknown): void {
       // 带上组合的上下文窗口：没有它 dsh 的自动压缩算不出阈值、会静默关闭。
       // 图片序列化需要读附件字节：把 ctx.attachments 传给 adapter（dsh-attachment
       // 是宿主注入的 service，插件不直接 import 它，只依赖 duck-typed 切面）。
-      disposers.push(ctx.llm.registerAdapter(['router'], new RouterAdapter('http://localhost:3080/v1', {
+      // 端点**按宿主实际监听端口现算**：`/v1` 路由注册在宿主 webServer 上，端口由
+      // 启动通道给（dsh web 默认 3080，桌面端/port=0 时不是），写死 3080 会让
+      // Router 在那些宿主上每一轮都 `fetch failed`（issue #9）。
+      disposers.push(ctx.llm.registerAdapter(['router'], new RouterAdapter(
+        loopbackBaseURL(() => ctx.webServer?.port), {
         comboModels: async () => (await router.combos()).map((c) => {
           const w = router.comboContextWindow(c)
           return { id: c.name, ...(w !== undefined ? { contextWindow: w } : {}) }

package/src/llm/adapter.ts

@@ -634,7 +634,12 @@ const ROUTER_REASONING_EFFORTS: readonly LlmReasoningEffortInfo[] = [
 ]
 
 export class RouterAdapter extends LlmAdapter {
-  private readonly baseURL: string
+  /**
+   * 网关端点。**函数形态 = 每次请求现算**：端口要等宿主 listen 完才有值的场景
+   * 必须传函数（写死 3080 在桌面端等非 3080 宿主上全线 `fetch failed`，
+   * issue #9），见 `host-base-url.ts`。
+   */
+  private readonly baseURL: string | (() => string)
   private readonly source: RouterAdapterSource
   private readonly resolveAttachments: () => RouterAttachmentStore | undefined
   /** 流空闲超时（ms）：上游这么久不吐字节就判 TIMEOUT。 */
@@ -649,7 +654,7 @@ export class RouterAdapter extends LlmAdapter {
    *   曾经那条路径是个空 `catch`，出问题跨版本都没人发现（issue #8）。
    */
   constructor(
-    baseURL: string,
+    baseURL: string | (() => string),
     source: RouterAdapterSource,
     resolveAttachments?: () => RouterAttachmentStore | undefined,
     idleTimeoutMs: number = STREAM_IDLE_TIMEOUT_MS,
@@ -713,7 +718,11 @@ export class RouterAdapter extends LlmAdapter {
     options.signal?.addEventListener('abort', onAbort, { once: true })
     let resp: Response
     try {
-      resp = await fetch(`${this.baseURL}/chat/completions`, {
+      // 端点现算：宿主监听端口在 listen 之后才有值、也会随宿主重启变（issue #9）。
+      // 解析器自己抛错时也落进下面这个 catch，于是「端口拿不到」是以
+      // LlmError 消息报出来的，而不是一句无从查证的 `fetch failed`。
+      const base = typeof this.baseURL === 'function' ? this.baseURL() : this.baseURL
+      resp = await fetch(`${base}/chat/completions`, {
         method: 'POST',
         // attributionHeaders() 是 dsh-llm 对 adapter 的硬契约：每个 provider
         // 请求都必须带（LlmAdapter 类注释原话）。它给出