17-编写 LLM adapter 接入自有模型

switch (chunk.type) {
  case 'text-delta': appendText(chunk.text); break
  case 'reasoning-delta': appendReasoning(chunk.text); break
  // …其余五种逐一列出，没有 default
}

declare abstract class LlmAdapter {
  providerInfo(provider: string): LlmProviderInfo
  providerRetryPolicy(_provider: string): ResolvedRetryPolicy | undefined
  listModels(_provider: string): Promise<readonly LlmModelInfo[]>
  resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>
  async prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>
  abstract stream(options: GenerateOptions): AsyncIterable<StreamChunk>
}

interface LlmFailure {
  readonly message: string                    // 给人看的
  readonly code: string                       // 给程序路由的，稳定
  readonly status?: number                    // HTTP 状态码
  readonly providerRetryAfterMs?: number      // provider 要求的等待时长
  readonly requestId?: ProviderRequestId      // provider 侧的请求 id
}

export const name = 'dsh-llm-ollama'

// 注册 adapter 走 ctx.llm；没有这个服务，插件没有意义。
export const inject = ['llm']

export interface Config {
    /** 本 adapter 占用的 provider 路由名；会话的 provider 字段按它匹配。 */
    provider: string
    /** OpenAI 兼容端点前缀；Ollama 默认在 11434 端口暴露 `/v1`。 */
    baseURL: string
    /** 对外 advertise 的模型名，只影响选择器，不限制实际能请求的模型。 */
    models: string[]
}

export const Config: Schema<Config> = Schema.object({
    provider: Schema.string().default('ollama'),
    baseURL: Schema.string().default('http://127.0.0.1:11434/v1'),
    models: Schema.array(Schema.string()).default([]),
})

export function apply(ctx: Context, config: Config): void {
    // 注册本身就是 effect：卸载、重载、被 patch 停用时路由跟着摘掉。
    ctx.llm.registerAdapter([config.provider], new OllamaAdapter(config))
    console.log(`[${name}] provider "${config.provider}" 已接上 ${config.baseURL}`)
}

    async * stream(options: GenerateOptions): AsyncIterable<StreamChunk> {
        const response = await fetch(`${this.config.baseURL}/chat/completions`, {
            method: 'POST',
            headers: {
                'content-type': 'application/json',
                // adapter 契约的一条：每个 provider 请求都带上应用标识头。
                ...attributionHeaders(),
            },
            body: JSON.stringify({
                model: options.model,
                messages: toWireMessages(options),
                stream: true,
                // 不加这个，OpenAI 兼容端点不会在流末尾补一个 usage 分片。
                stream_options: { include_usage: true },
                ...options.tools === undefined ? {} : { tools: toWireTools(options.tools) },
                ...options.temperature === undefined ? {} : { temperature: options.temperature },
                ...options.maxTokens === undefined ? {} : { max_tokens: options.maxTokens },
                ...options.stop === undefined ? {} : { stop: options.stop },
            }),
            signal: options.signal,
        })

        if (!response.ok || response.body === null) {
            // 传输与协议错误走 throw 这条路；provider 在流里报的错走 finish。
            throw new LlmError(
                `Ollama 请求失败：HTTP ${response.status} ${await response.text()}`,
                'TRANSPORT',
                { status: response.status },
            )
        }

        yield* translate(response.body)
    }

function toWireMessages(options: GenerateOptions): WireMessage[] {
    const wire: WireMessage[] = []
    if (options.system !== undefined && options.system !== '') {
        wire.push({ role: 'system', content: options.system })
    }

    for (const message of options.messages) {
        const text = textOf(message.content)
        if (message.role === 'assistant') {
            const calls = message.content.filter((block): block is ToolCallBlock => block.type === 'tool-call')
            wire.push({
                role: 'assistant',
                content: text,
                ...calls.length === 0 ? {} : {
                    tool_calls: calls.map(call => ({
                        id: String(call.id),
                        type: 'function' as const,
                        function: { name: call.name, arguments: call.arguments },
                    })),
                },
            })
            continue
        }
        if (message.role === 'system') {
            if (text !== '') wire.push({ role: 'system', content: text })
            continue
        }
        if (message.role === 'tool') {
            wire.push({ role: 'tool', tool_call_id: String(message.toolCallId), content: text })
            continue
        }
        if (text !== '') wire.push({ role: 'user', content: text })
    }
    return wire
}

    function handle(chunk: WireChunk): StreamChunk[] {
        const out: StreamChunk[] = []
        const choice = chunk.choices?.[0]
        const delta = choice?.delta

        if (delta?.reasoning_content) {
            reasoning ??= { index: nextIndex++, text: '' }
            if (reasoning.text === '') {
                out.push({ type: 'block-start', index: reasoning.index, blockType: 'reasoning' })
            }
            reasoning.text += delta.reasoning_content
            out.push({ type: 'reasoning-delta', index: reasoning.index, text: delta.reasoning_content })
        }

        if (delta?.content) {
            text ??= { index: nextIndex++, text: '' }
            if (text.text === '') {
                out.push({ type: 'block-start', index: text.index, blockType: 'text' })
            }
            text.text += delta.content
            out.push({ type: 'text-delta', index: text.index, text: delta.content })
        }

        for (const call of delta?.tool_calls ?? []) {
            let open = toolCalls.get(call.index)
            if (open === undefined) {
                // id 与函数名只出现在第一个分片里，后面的分片只带参数增量。
                open = {
                    index: nextIndex++,
                    id: call.id ?? `call_${call.index}`,
                    name: call.function?.name ?? '',
                    args: '',
                }
                toolCalls.set(call.index, open)
                out.push({ type: 'block-start', index: open.index, blockType: 'tool-call' })
            }
            const argumentsDelta = call.function?.arguments ?? ''
            open.args += argumentsDelta
            out.push({
                type: 'tool-call-delta',
                index: open.index,
                id: ToolCallId(open.id),
                name: open.name,
                argumentsDelta,
            })
        }
        // 省略：usage、流内错误、finish_reason
        return out
    }

    if (reasoning !== undefined) {
        yield { type: 'block-end', index: reasoning.index, block: { type: 'reasoning', text: reasoning.text } }
    }
    if (text !== undefined) {
        yield { type: 'block-end', index: text.index, block: { type: 'text', text: text.text } }
    }
    for (const open of toolCalls.values()) {
        yield {
            type: 'block-end',
            index: open.index,
            block: { type: 'tool-call', id: ToolCallId(open.id), name: open.name, arguments: open.args },
        }
    }
    if (usage !== undefined) yield { type: 'usage', usage }

    if (failure !== undefined) {
        yield { type: 'finish', reason: { kind: 'error', failure } }
        return
    }

    // 正常结束却一个块都没有，是可重试的 EMPTY_RESPONSE，不是静默的成功。
    const empty = text === undefined && reasoning === undefined && toolCalls.size === 0
    if (reason.kind === 'stop' && empty) {
        yield {
            type: 'finish',
            reason: {
                kind: 'error',
                failure: { message: 'Ollama 返回了空补全', code: EMPTY_RESPONSE_CODE },
            },
        }
        return
    }

    yield { type: 'finish', reason }

    override providerRetryPolicy(_provider: string): ResolvedRetryPolicy | undefined {
        return undefined   // 用默认：正常模式最多 5 次，带退避与抖动
    }

export interface Config {
  // 两个字段在 schema 里声明为 .volatile()：可现场改（14-把插件配置搬进设置页那条线）
  provider: Volatile<string>
  model: Volatile<string>
}