@miaws/miaw 1.18.4 → 1.18.5

package/src/session/instruction.ts

@@ -0,0 +1,250 @@
+import { LayerNode } from "@miaw/core/effect/layer-node"
+import { httpClient } from "@miaw/core/effect/layer-node-platform"
+import path from "path"
+import { SessionV1 } from "@miaw/core/v1/session"
+import { Effect, Layer, Context } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Config } from "@/config/config"
+import { InstanceState } from "@/effect/instance-state"
+import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Flag } from "@miaw/core/flag/flag"
+import { FSUtil } from "@miaw/core/fs-util"
+import { withTransientReadRetry } from "@/util/effect-http-client"
+import { Global } from "@miaw/core/global"
+import type { MessageV2 } from "./message-v2"
+import type { MessageID } from "./schema"
+
+function extract(messages: SessionV1.WithParts[]) {
+  const paths = new Set<string>()
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (part.type === "tool" && part.tool === "read" && part.state.status === "completed") {
+        if (part.state.time.compacted) continue
+        const loaded = part.state.metadata?.loaded
+        if (!loaded || !Array.isArray(loaded)) continue
+        for (const p of loaded) {
+          if (typeof p === "string") paths.add(p)
+        }
+      }
+    }
+  }
+  return paths
+}
+
+export interface Interface {
+  readonly clear: (messageID: MessageID) => Effect.Effect<void>
+  readonly systemPaths: () => Effect.Effect<Set<string>, FSUtil.Error>
+  readonly system: () => Effect.Effect<string[], FSUtil.Error>
+  readonly find: (dir: string) => Effect.Effect<string | undefined, FSUtil.Error>
+  readonly resolve: (
+    messages: SessionV1.WithParts[],
+    filepath: string,
+    messageID: MessageID,
+  ) => Effect.Effect<{ filepath: string; content: string }[], FSUtil.Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@miaw/Instruction") {}
+
+export const layer: Layer.Layer<
+  Service,
+  never,
+  FSUtil.Service | Config.Service | Global.Service | HttpClient.HttpClient | RuntimeFlags.Service
+> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const cfg = yield* Config.Service
+    const fs = yield* FSUtil.Service
+    const global = yield* Global.Service
+    const flags = yield* RuntimeFlags.Service
+    const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
+    const globalFiles = [
+      path.join(global.config, "AGENTS.md"),
+      ...(!flags.disableClaudeCodePrompt ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
+    ]
+    const instructionFiles = [
+      "AGENTS.md",
+      ...(!flags.disableClaudeCodePrompt ? ["CLAUDE.md"] : []),
+      "CONTEXT.md", // deprecated
+    ]
+
+    const state = yield* InstanceState.make(
+      Effect.fn("Instruction.state")(() =>
+        Effect.succeed({
+          // Track which instruction files have already been attached for a given assistant message.
+          claims: new Map<MessageID, Set<string>>(),
+        }),
+      ),
+    )
+
+    const relative = Effect.fnUntraced(function* (instruction: string) {
+      const ctx = yield* InstanceState.context
+      if (!Flag.MIAW_DISABLE_PROJECT_CONFIG) {
+        return yield* fs
+          .globUp(instruction, ctx.directory, ctx.worktree)
+          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+      }
+      return yield* fs
+        .globUp(instruction, global.config, global.config)
+        .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+    })
+
+    const read = Effect.fnUntraced(function* (filepath: string) {
+      return yield* fs.readFileString(filepath).pipe(Effect.catch(() => Effect.succeed("")))
+    })
+
+    const fetch = Effect.fnUntraced(function* (url: string) {
+      const res = yield* http.execute(HttpClientRequest.get(url)).pipe(
+        Effect.timeout(5000),
+        Effect.catch(() => Effect.succeed(null)),
+      )
+      if (!res) return ""
+      const body = yield* res.arrayBuffer.pipe(Effect.catch(() => Effect.succeed(new ArrayBuffer(0))))
+      return new TextDecoder().decode(body)
+    })
+
+    const clear = Effect.fn("Instruction.clear")(function* (messageID: MessageID) {
+      const s = yield* InstanceState.get(state)
+      s.claims.delete(messageID)
+    })
+
+    const systemPaths = Effect.fn("Instruction.systemPaths")(function* () {
+      const config = yield* cfg.get()
+      const ctx = yield* InstanceState.context
+      const paths = new Set<string>()
+
+      for (const file of globalFiles) {
+        if (yield* fs.existsSafe(file)) {
+          paths.add(path.resolve(file))
+          break
+        }
+      }
+
+      // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
+      if (!Flag.MIAW_DISABLE_PROJECT_CONFIG) {
+        for (const file of instructionFiles) {
+          const matches = yield* fs
+            .findUp(file, ctx.directory, ctx.worktree)
+            .pipe(Effect.catch(() => Effect.succeed([])))
+          if (matches.length > 0) {
+            matches.forEach((item) => paths.add(path.resolve(item)))
+            break
+          }
+        }
+      }
+
+      if (config.instructions) {
+        for (const raw of config.instructions) {
+          if (raw.startsWith("https://") || raw.startsWith("http://")) continue
+          const instruction = raw.startsWith("~/") ? path.join(global.home, raw.slice(2)) : raw
+          const matches = yield* (
+            path.isAbsolute(instruction)
+              ? fs.glob(path.basename(instruction), {
+                  cwd: path.dirname(instruction),
+                  absolute: true,
+                  include: "file",
+                })
+              : relative(instruction)
+          ).pipe(Effect.catch(() => Effect.succeed([] as string[])))
+          matches.forEach((item) => paths.add(path.resolve(item)))
+        }
+      }
+
+      if (!Flag.MIAW_DISABLE_PROJECT_CONFIG) {
+        for (const pattern of [".miaw/rules/**/*.md", ".omo/rules/**/*.md"]) {
+          const matches = yield* fs
+            .glob(pattern, { cwd: ctx.directory, absolute: true, include: "file" })
+            .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+          matches.forEach((item) => paths.add(path.resolve(item)))
+        }
+      }
+
+      return paths
+    })
+
+    const system = Effect.fn("Instruction.system")(function* () {
+      const config = yield* cfg.get()
+      const paths = yield* systemPaths()
+      const urls = (config.instructions ?? []).filter(
+        (item) => item.startsWith("https://") || item.startsWith("http://"),
+      )
+
+      const files = yield* Effect.forEach(Array.from(paths), read, { concurrency: 8 })
+      const remote = yield* Effect.forEach(urls, fetch, { concurrency: 4 })
+
+      return [
+        ...Array.from(paths).flatMap((item, i) => (files[i] ? [`Instructions from: ${item}\n${files[i]}`] : [])),
+        ...urls.flatMap((item, i) => (remote[i] ? [`Instructions from: ${item}\n${remote[i]}`] : [])),
+      ]
+    })
+
+    const find = Effect.fn("Instruction.find")(function* (dir: string) {
+      for (const file of instructionFiles) {
+        const filepath = path.resolve(path.join(dir, file))
+        if (yield* fs.existsSafe(filepath)) return filepath
+      }
+      return undefined
+    })
+
+    const resolve = Effect.fn("Instruction.resolve")(function* (
+      messages: SessionV1.WithParts[],
+      filepath: string,
+      messageID: MessageID,
+    ) {
+      const sys = yield* systemPaths()
+      const already = extract(messages)
+      const results: { filepath: string; content: string }[] = []
+      const s = yield* InstanceState.get(state)
+      const root = path.resolve(yield* InstanceState.directory)
+
+      const target = path.resolve(filepath)
+      let current = path.dirname(target)
+
+      // Walk upward from the file being read and attach nearby instruction files once per message.
+      while (current.startsWith(root) && current !== root) {
+        const found = yield* find(current)
+        if (!found || found === target || sys.has(found) || already.has(found)) {
+          current = path.dirname(current)
+          continue
+        }
+
+        let set = s.claims.get(messageID)
+        if (!set) {
+          set = new Set()
+          s.claims.set(messageID, set)
+        }
+        if (set.has(found)) {
+          current = path.dirname(current)
+          continue
+        }
+
+        set.add(found)
+        const content = yield* read(found)
+        if (content) {
+          results.push({ filepath: found, content: `Instructions from: ${found}\n${content}` })
+        }
+
+        current = path.dirname(current)
+      }
+
+      return results
+    })
+
+    return Service.of({ clear, systemPaths, system, find, resolve })
+  }),
+)
+
+export const defaultLayer = layer.pipe(
+  Layer.provide(Config.defaultLayer),
+  Layer.provide(Global.layer),
+  Layer.provide(FSUtil.defaultLayer),
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(RuntimeFlags.defaultLayer),
+)
+
+export function loaded(messages: SessionV1.WithParts[]) {
+  return extract(messages)
+}
+
+export const node = LayerNode.make(layer, [Config.node, FSUtil.node, Global.node, RuntimeFlags.node, httpClient])
+
+export * as Instruction from "./instruction"

package/src/session/llm/AGENTS.md

@@ -0,0 +1,90 @@
+# Session LLM Runtime Boundaries
+
+`../llm.ts` is the miaw session LLM service. It owns miaw concerns: auth, config, model/provider resolution, plugins, permissions, telemetry headers, and runtime selection. It is the only file in this area that should know about the full session request shape.
+
+This folder contains adapters behind that service boundary:
+
+- `ai-sdk.ts` converts AI SDK `fullStream` parts into `@miaw/llm` `LLMEvent`s. This is the default runtime path.
+- `native-request.ts` converts miaw's normalized session input into a native `@miaw/llm` `LLMRequest`. It does not execute requests.
+- `native-runtime.ts` is the opt-in native runtime adapter. It decides whether a selected model is supported, builds the native request, bridges miaw tools into native executable tools, and delegates transport to `LLMClient` / `RequestExecutor`.
+
+## File Structure
+
+```txt
+src/session/
+  llm.ts                    session-owned orchestration and runtime selection
+  llm/
+    AGENTS.md               boundary notes for the adapter layer
+    ai-sdk.ts               AI SDK fullStream -> @miaw/llm LLMEvent adapter
+    native-request.ts       miaw/AI SDK-shaped input -> @miaw/llm LLMRequest
+    native-runtime.ts       native runtime gate, tool bridge, and LLMClient handoff
+```
+
+Integration points:
+
+- `../llm.ts` imports `LLMClient` from `@miaw/llm/route`; native execution is the only path that calls it directly.
+- `../llm.ts` imports `LLMAISDK` from `./llm/ai-sdk`; the AI SDK path still calls `streamText(...)` locally, then adapts `result.fullStream` into shared `LLMEvent`s.
+- `../llm.ts` imports `LLMNativeRuntime` from `./llm/native-runtime`; this is the runtime-selection seam. Unsupported native requests return a reason and fall back to AI SDK.
+- `native-runtime.ts` imports `LLMNative` from `./native-request`; this keeps request lowering separate from transport and tool execution.
+- `native-request.ts` is the only adapter file that should construct `LLM.request(...)`, `LLM.model(...)`, `Message.*`, `SystemPart`, `ToolCallPart`, `ToolResultPart`, or `ToolDefinition` values from `@miaw/llm`.
+- `ai-sdk.ts` and `native-runtime.ts` both emit `@miaw/llm` `LLMEvent`s so downstream session processing does not care which runtime handled the request.
+
+Keep new integration code on one of these seams. Avoid importing session services into `native-request.ts`; pass normalized data through `RequestInput` instead.
+
+## Runtime selection
+
+Both runtimes converge on the same `LLMEvent` stream consumed by the session processor. The gate is per-request: a single session can route some calls through native and fall back for others.
+
+```txt
+                             ╭───────────────────╮
+╭───────────────────────────▶│ session processor │
+│                            ╰─────────┬─────────╯
+│                                      │
+│                                      │
+│                                      │
+│                                      ▼
+│                         ╭─────────────────────────╮
+│                         │ LLM.Service (../llm.ts) │
+│                         ╰────────────┬────────────╯
+│                                      │
+│                                      │
+│                                      │
+│                                      ▼
+│                                ╭───────────╮
+│                              ╭─╯           ╰─╮
+│                              │  native gate  │
+│                              ╰─╮           ╭─╯
+│                                ╰─────┬─────╯
+│                                      │
+│                     ╭────── no ──────┴─────── yes ────────╮
+│                     │                                     │
+│                     ▼                                     ▼
+│       ╭───────────────────────────╮             ╭───────────────────╮
+│       │          AI SDK           │             │ native-runtime.ts │
+│       │ streamText / generateText │             ╰────────┬──────────╯
+│       ╰─────────────┬─────────────╯                      │
+│                     │                                    │
+│                 ╭───╯                                    │
+│                 │                                        │
+│                 ▼                                        ▼
+│     ╭───────────────────────╮             ╭────────────────────────────╮
+│     │       ai-sdk.ts       │             │     native-request.ts      │
+│     │ fullStream → LLMEvent │             │ session input → LLMRequest │
+│     ╰──────────┬────────────╯             ╰──────────────┬─────────────╯
+│                │                                         │
+│                │                                     ╭───╯
+│                │                                     │
+│                ▼                                     ▼
+│       ╭─────────────────╮             ╭─────────────────────────────╮
+╰───────┤ LLMEvent stream │◀────────────┤ LLMClient · RequestExecutor │
+        ╰─────────────────╯             ╰─────────────────────────────╯
+```
+
+`native-runtime.ts` evaluates the gate and either bridges into `@miaw/llm` or returns control so `llm.ts` can take the AI SDK path. Tool execution stays miaw-owned in both branches; only request lowering and transport differ.
+
+Safety boundary:
+
+- AI SDK remains the default.
+- `MIAW_EXPERIMENTAL_NATIVE_LLM=true` or the umbrella `MIAW_EXPERIMENTAL=true` opts in. Native is not a global replacement.
+- Native execution currently supports OpenAI, miaw-managed OpenAI-compatible, and Anthropic API-key paths backed by `@ai-sdk/openai`, `@ai-sdk/openai-compatible`, or `@ai-sdk/anthropic` catalog entries.
+- Unsupported providers, OpenAI OAuth, and missing API-key cases fall back to AI SDK.

package/src/session/llm/ai-sdk.ts

@@ -0,0 +1,288 @@
+import { FinishReason, LLMEvent, ProviderMetadata, ToolResultValue } from "@miaw/llm"
+import { Effect, Schema } from "effect"
+import { type streamText } from "ai"
+import { errorMessage } from "@/util/error"
+
+type Result = Awaited<ReturnType<typeof streamText>>
+type AISDKEvent = Result["fullStream"] extends AsyncIterable<infer T> ? T : never
+
+export function adapterState() {
+  return {
+    step: 0,
+    text: 0,
+    reasoning: 0,
+    currentTextID: undefined as string | undefined,
+    currentReasoningID: undefined as string | undefined,
+    toolNames: {} as Record<string, string>,
+    copilotTotalNanoAiu: undefined as number | undefined,
+  }
+}
+
+function finishReason(value: string | undefined): FinishReason {
+  return Schema.is(FinishReason)(value) ? value : "unknown"
+}
+
+function providerMetadata(value: unknown): ProviderMetadata | undefined {
+  if (value == null) return undefined
+  return Schema.is(ProviderMetadata)(value) ? value : undefined
+}
+
+// Temporary AI SDK bridge: Copilot billing survives only in raw provider chunks here.
+// Move this extraction into @miaw/llm when Copilot is handled by the native runtime.
+function copilotTotalNanoAiu(value: unknown) {
+  if (!value || typeof value !== "object") return
+  const raw = value as Record<string, unknown>
+  const response =
+    raw.response && typeof raw.response === "object" ? (raw.response as Record<string, unknown>) : undefined
+  const usage = raw.copilot_usage ?? response?.copilot_usage
+  if (!usage || typeof usage !== "object") return
+  const total = (usage as Record<string, unknown>).total_nano_aiu
+  if (typeof total !== "number" || !Number.isFinite(total) || total < 0) return
+  return total
+}
+
+function usage(value: unknown) {
+  if (!value || typeof value !== "object") return undefined
+  const item = value as {
+    inputTokens?: number
+    outputTokens?: number
+    totalTokens?: number
+    reasoningTokens?: number
+    cachedInputTokens?: number
+    inputTokenDetails?: { cacheReadTokens?: number; cacheWriteTokens?: number }
+    outputTokenDetails?: { reasoningTokens?: number }
+  }
+  const entries = Object.entries({
+    inputTokens: item.inputTokens,
+    outputTokens: item.outputTokens,
+    totalTokens: item.totalTokens,
+    reasoningTokens: item.outputTokenDetails?.reasoningTokens ?? item.reasoningTokens,
+    cacheReadInputTokens: item.inputTokenDetails?.cacheReadTokens ?? item.cachedInputTokens,
+    cacheWriteInputTokens: item.inputTokenDetails?.cacheWriteTokens,
+  }).filter((entry) => entry[1] !== undefined)
+  return entries.length === 0 ? undefined : Object.fromEntries(entries)
+}
+
+function currentTextID(state: ReturnType<typeof adapterState>, id: string | undefined) {
+  state.currentTextID = id ?? state.currentTextID ?? `text-${state.text++}`
+  return state.currentTextID
+}
+
+function currentReasoningID(state: ReturnType<typeof adapterState>, id: string | undefined) {
+  state.currentReasoningID = id ?? state.currentReasoningID ?? `reasoning-${state.reasoning++}`
+  return state.currentReasoningID
+}
+
+export function toLLMEvents(
+  state: ReturnType<typeof adapterState>,
+  event: AISDKEvent,
+): Effect.Effect<ReadonlyArray<LLMEvent>, unknown> {
+  switch (event.type) {
+    case "start":
+      return Effect.succeed([])
+
+    case "start-step":
+      return Effect.succeed([LLMEvent.stepStart({ index: state.step })])
+
+    case "finish-step":
+      return Effect.sync(() => {
+        const original = providerMetadata(event.providerMetadata)
+        const metadata =
+          state.copilotTotalNanoAiu === undefined
+            ? original
+            : {
+                ...original,
+                copilot: {
+                  ...original?.copilot,
+                  totalNanoAiu: state.copilotTotalNanoAiu,
+                },
+              }
+        state.copilotTotalNanoAiu = undefined
+        return [
+          LLMEvent.stepFinish({
+            index: state.step++,
+            reason: finishReason(event.finishReason),
+            usage: usage(event.usage),
+            providerMetadata: metadata,
+          }),
+        ]
+      })
+
+    case "finish":
+      return Effect.sync(() => {
+        const events = [
+          LLMEvent.finish({
+            reason: finishReason(event.finishReason),
+            usage: usage(event.totalUsage),
+            providerMetadata: "providerMetadata" in event ? providerMetadata(event.providerMetadata) : undefined,
+          }),
+        ]
+        // Reset so the adapter can be reused for a follow-up stream without leaking
+        // counters or block IDs. adapterState() is the single source of truth for shape.
+        Object.assign(state, adapterState())
+        return events
+      })
+
+    case "text-start":
+      return Effect.sync(() => {
+        state.currentTextID = currentTextID(state, event.id)
+        return [
+          LLMEvent.textStart({
+            id: state.currentTextID,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "text-delta":
+      return Effect.succeed([
+        LLMEvent.textDelta({
+          id: currentTextID(state, event.id),
+          text: event.text,
+          providerMetadata: providerMetadata(event.providerMetadata),
+        }),
+      ])
+
+    case "text-end":
+      return Effect.sync(() => {
+        const id = currentTextID(state, event.id)
+        state.currentTextID = undefined
+        return [
+          LLMEvent.textEnd({
+            id,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "reasoning-start":
+      return Effect.sync(() => {
+        state.currentReasoningID = currentReasoningID(state, event.id)
+        return [
+          LLMEvent.reasoningStart({
+            id: state.currentReasoningID,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "reasoning-delta":
+      return Effect.succeed([
+        LLMEvent.reasoningDelta({
+          id: currentReasoningID(state, event.id),
+          text: event.text,
+          providerMetadata: providerMetadata(event.providerMetadata),
+        }),
+      ])
+
+    case "reasoning-end":
+      return Effect.sync(() => {
+        const id = currentReasoningID(state, event.id)
+        state.currentReasoningID = undefined
+        return [
+          LLMEvent.reasoningEnd({
+            id,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "tool-input-start":
+      return Effect.sync(() => {
+        state.toolNames[event.id] = event.toolName
+        return [
+          LLMEvent.toolInputStart({
+            id: event.id,
+            name: event.toolName,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "tool-input-delta":
+      return Effect.succeed([
+        LLMEvent.toolInputDelta({
+          id: event.id,
+          name: state.toolNames[event.id] ?? "unknown",
+          text: event.delta ?? "",
+        }),
+      ])
+
+    case "tool-input-end":
+      return Effect.succeed([
+        LLMEvent.toolInputEnd({
+          id: event.id,
+          name: state.toolNames[event.id] ?? "unknown",
+          providerMetadata: providerMetadata(event.providerMetadata),
+        }),
+      ])
+
+    case "tool-call":
+      return Effect.sync(() => {
+        state.toolNames[event.toolCallId] = event.toolName
+        return [
+          LLMEvent.toolCall({
+            id: event.toolCallId,
+            name: event.toolName,
+            input: event.input,
+            providerExecuted: "providerExecuted" in event ? event.providerExecuted : undefined,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "tool-result":
+      return Effect.sync(() => {
+        const name = state.toolNames[event.toolCallId] ?? "unknown"
+        delete state.toolNames[event.toolCallId]
+        return [
+          LLMEvent.toolResult({
+            id: event.toolCallId,
+            name,
+            result: ToolResultValue.make(event.output),
+            providerExecuted: "providerExecuted" in event ? event.providerExecuted : undefined,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "tool-error":
+      return Effect.sync(() => {
+        const name = state.toolNames[event.toolCallId] ?? ("toolName" in event ? event.toolName : "unknown")
+        delete state.toolNames[event.toolCallId]
+        return [
+          LLMEvent.toolError({
+            id: event.toolCallId,
+            name,
+            message: errorMessage(event.error),
+            error: event.error,
+            providerMetadata: providerMetadata(event.providerMetadata),
+          }),
+        ]
+      })
+
+    case "error":
+      return Effect.fail(event.error)
+
+    case "abort":
+    case "source":
+    case "file":
+    case "tool-output-denied":
+    case "tool-approval-request":
+      return Effect.succeed([])
+
+    case "raw":
+      return Effect.sync(() => {
+        state.copilotTotalNanoAiu = copilotTotalNanoAiu(event.rawValue) ?? state.copilotTotalNanoAiu
+        return []
+      })
+
+    default: {
+      const _exhaustive: never = event
+      void _exhaustive
+      return Effect.succeed([])
+    }
+  }
+}
+
+export * as LLMAISDK from "./ai-sdk"