@miaws/miaw 1.18.5 → 1.18.6

package/src/session/instruction.ts

@@ -1,250 +0,0 @@
-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

@@ -1,90 +0,0 @@
-# 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

@@ -1,288 +0,0 @@
-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"