@happy-creative/iroder 1.0.0

package/src/session/instruction.ts

@@ -0,0 +1,258 @@
+import os from "os"
+import path from "path"
+import { Effect, Layer, ServiceMap } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { Config } from "@/config/config"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { Flag } from "@/flag/flag"
+import { AppFileSystem } from "@/filesystem"
+import { withTransientReadRetry } from "@/util/effect-http-client"
+import { Global } from "../global"
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+import type { MessageV2 } from "./message-v2"
+import type { MessageID } from "./schema"
+
+const log = Log.create({ service: "instruction" })
+
+const FILES = [
+  "AGENTS.md",
+  ...(Flag.IRODER_DISABLE_CLAUDE_CODE_PROMPT ? [] : ["CLAUDE.md"]),
+  "CONTEXT.md", // deprecated
+]
+
+function globalFiles() {
+  const files = []
+  if (Flag.IRODER_CONFIG_DIR) {
+    files.push(path.join(Flag.IRODER_CONFIG_DIR, "AGENTS.md"))
+  }
+  files.push(path.join(Global.Path.config, "AGENTS.md"))
+  if (!Flag.IRODER_DISABLE_CLAUDE_CODE_PROMPT) {
+    files.push(path.join(os.homedir(), ".claude", "CLAUDE.md"))
+  }
+  return files
+}
+
+function extract(messages: MessageV2.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 namespace Instruction {
+  export interface Interface {
+    readonly clear: (messageID: MessageID) => Effect.Effect<void>
+    readonly systemPaths: () => Effect.Effect<Set<string>, AppFileSystem.Error>
+    readonly system: () => Effect.Effect<string[], AppFileSystem.Error>
+    readonly find: (dir: string) => Effect.Effect<string | undefined, AppFileSystem.Error>
+    readonly resolve: (
+      messages: MessageV2.WithParts[],
+      filepath: string,
+      messageID: MessageID,
+    ) => Effect.Effect<{ filepath: string; content: string }[], AppFileSystem.Error>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@iroder/Instruction") {}
+
+  export const layer: Layer.Layer<Service, never, AppFileSystem.Service | Config.Service | HttpClient.HttpClient> =
+    Layer.effect(
+      Service,
+      Effect.gen(function* () {
+        const cfg = yield* Config.Service
+        const fs = yield* AppFileSystem.Service
+        const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
+
+        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) {
+          if (!Flag.IRODER_DISABLE_PROJECT_CONFIG) {
+            return yield* fs
+              .globUp(instruction, Instance.directory, Instance.worktree)
+              .pipe(Effect.catch(() => Effect.succeed([] as string[])))
+          }
+          if (!Flag.IRODER_CONFIG_DIR) {
+            log.warn(
+              `Skipping relative instruction "${instruction}" - no IRODER_CONFIG_DIR set while project config is disabled`,
+            )
+            return []
+          }
+          return yield* fs
+            .globUp(instruction, Flag.IRODER_CONFIG_DIR, Flag.IRODER_CONFIG_DIR)
+            .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 paths = new Set<string>()
+
+          // The first project-level match wins so we don't stack AGENTS.md/CLAUDE.md from every ancestor.
+          if (!Flag.IRODER_DISABLE_PROJECT_CONFIG) {
+            for (const file of FILES) {
+              const matches = yield* fs.findUp(file, Instance.directory, Instance.worktree)
+              if (matches.length > 0) {
+                matches.forEach((item) => paths.add(path.resolve(item)))
+                break
+              }
+            }
+          }
+
+          for (const file of globalFiles()) {
+            if (yield* fs.existsSafe(file)) {
+              paths.add(path.resolve(file))
+              break
+            }
+          }
+
+          if (config.instructions) {
+            for (const raw of config.instructions) {
+              if (raw.startsWith("https://") || raw.startsWith("http://")) continue
+              const instruction = raw.startsWith("~/") ? path.join(os.homedir(), 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)))
+            }
+          }
+
+          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 FILES) {
+            const filepath = path.resolve(path.join(dir, file))
+            if (yield* fs.existsSafe(filepath)) return filepath
+          }
+        })
+
+        const resolve = Effect.fn("Instruction.resolve")(function* (
+          messages: MessageV2.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 target = path.resolve(filepath)
+          const root = path.resolve(Instance.directory)
+          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(AppFileSystem.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+  )
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export function clear(messageID: MessageID) {
+    return runPromise((svc) => svc.clear(messageID))
+  }
+
+  export async function systemPaths() {
+    return runPromise((svc) => svc.systemPaths())
+  }
+
+  export function loaded(messages: MessageV2.WithParts[]) {
+    return extract(messages)
+  }
+
+  export async function resolve(messages: MessageV2.WithParts[], filepath: string, messageID: MessageID) {
+    return runPromise((svc) => svc.resolve(messages, filepath, messageID))
+  }
+}

package/src/session/llm.ts

@@ -0,0 +1,412 @@
+import { Provider } from "@/provider/provider"
+import { Log } from "@/util/log"
+import { Cause, Effect, Layer, Record, ServiceMap } from "effect"
+import * as Queue from "effect/Queue"
+import * as Stream from "effect/Stream"
+import { streamText, wrapLanguageModel, type ModelMessage, type Tool, tool, jsonSchema } from "ai"
+import { mergeDeep, pipe } from "remeda"
+import { GitLabWorkflowLanguageModel } from "gitlab-ai-provider"
+import { ProviderTransform } from "@/provider/transform"
+import { Config } from "@/config/config"
+import { Instance } from "@/project/instance"
+import type { Agent } from "@/agent/agent"
+import type { MessageV2 } from "./message-v2"
+import { Plugin } from "@/plugin"
+import { SystemPrompt } from "./system"
+import { Flag } from "@/flag/flag"
+import { Permission } from "@/permission"
+import { PermissionID } from "@/permission/schema"
+import { Bus } from "@/bus"
+import { Wildcard } from "@/util/wildcard"
+import { SessionID } from "@/session/schema"
+import { Auth } from "@/auth"
+import { Installation } from "@/installation"
+
+export namespace LLM {
+  const log = Log.create({ service: "llm" })
+  export const OUTPUT_TOKEN_MAX = ProviderTransform.OUTPUT_TOKEN_MAX
+
+  export type StreamInput = {
+    user: MessageV2.User
+    sessionID: string
+    parentSessionID?: string
+    model: Provider.Model
+    agent: Agent.Info
+    permission?: Permission.Ruleset
+    system: string[]
+    messages: ModelMessage[]
+    small?: boolean
+    tools: Record<string, Tool>
+    retries?: number
+    toolChoice?: "auto" | "required" | "none"
+  }
+
+  export type StreamRequest = StreamInput & {
+    abort: AbortSignal
+  }
+
+  export type Event = Awaited<ReturnType<typeof stream>>["fullStream"] extends AsyncIterable<infer T> ? T : never
+
+  export interface Interface {
+    readonly stream: (input: StreamInput) => Stream.Stream<Event, unknown>
+  }
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@iroder/LLM") {}
+
+  export const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      return Service.of({
+        stream(input) {
+          return Stream.scoped(
+            Stream.unwrap(
+              Effect.gen(function* () {
+                const ctrl = yield* Effect.acquireRelease(
+                  Effect.sync(() => new AbortController()),
+                  (ctrl) => Effect.sync(() => ctrl.abort()),
+                )
+
+                const result = yield* Effect.promise(() => LLM.stream({ ...input, abort: ctrl.signal }))
+
+                return Stream.fromAsyncIterable(result.fullStream, (e) =>
+                  e instanceof Error ? e : new Error(String(e)),
+                )
+              }),
+            ),
+          )
+        },
+      })
+    }),
+  )
+
+  export const defaultLayer = layer
+
+  export async function stream(input: StreamRequest) {
+    const l = log
+      .clone()
+      .tag("providerID", input.model.providerID)
+      .tag("modelID", input.model.id)
+      .tag("sessionID", input.sessionID)
+      .tag("small", (input.small ?? false).toString())
+      .tag("agent", input.agent.name)
+      .tag("mode", input.agent.mode)
+    l.info("stream", {
+      modelID: input.model.id,
+      providerID: input.model.providerID,
+    })
+    const [language, cfg, provider, auth] = await Promise.all([
+      Provider.getLanguage(input.model),
+      Config.get(),
+      Provider.getProvider(input.model.providerID),
+      Auth.get(input.model.providerID),
+    ])
+    // TODO: move this to a proper hook
+    const isOpenaiOauth = provider.id === "openai" && auth?.type === "oauth"
+
+    const system: string[] = []
+    system.push(
+      [
+        // use agent prompt otherwise provider prompt
+        ...(input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(input.model)),
+        // any custom prompt passed into this call
+        ...input.system,
+        // any custom prompt from last user message
+        ...(input.user.system ? [input.user.system] : []),
+      ]
+        .filter((x) => x)
+        .join("\n"),
+    )
+
+    const header = system[0]
+    await Plugin.trigger(
+      "experimental.chat.system.transform",
+      { sessionID: input.sessionID, model: input.model },
+      { system },
+    )
+    // rejoin to maintain 2-part structure for caching if header unchanged
+    if (system.length > 2 && system[0] === header) {
+      const rest = system.slice(1)
+      system.length = 0
+      system.push(header, rest.join("\n"))
+    }
+
+    const variant =
+      !input.small && input.model.variants && input.user.model.variant
+        ? input.model.variants[input.user.model.variant]
+        : {}
+    const base = input.small
+      ? ProviderTransform.smallOptions(input.model)
+      : ProviderTransform.options({
+          model: input.model,
+          sessionID: input.sessionID,
+          providerOptions: provider.options,
+        })
+    const options: Record<string, any> = pipe(
+      base,
+      mergeDeep(input.model.options),
+      mergeDeep(input.agent.options),
+      mergeDeep(variant),
+    )
+    if (isOpenaiOauth) {
+      options.instructions = system.join("\n")
+    }
+
+    const isWorkflow = language instanceof GitLabWorkflowLanguageModel
+    const messages = isOpenaiOauth
+      ? input.messages
+      : isWorkflow
+        ? input.messages
+        : [
+            ...system.map(
+              (x): ModelMessage => ({
+                role: "system",
+                content: x,
+              }),
+            ),
+            ...input.messages,
+          ]
+
+    const params = await Plugin.trigger(
+      "chat.params",
+      {
+        sessionID: input.sessionID,
+        agent: input.agent.name,
+        model: input.model,
+        provider,
+        message: input.user,
+      },
+      {
+        temperature: input.model.capabilities.temperature
+          ? (input.agent.temperature ?? ProviderTransform.temperature(input.model))
+          : undefined,
+        topP: input.agent.topP ?? ProviderTransform.topP(input.model),
+        topK: ProviderTransform.topK(input.model),
+        maxOutputTokens: ProviderTransform.maxOutputTokens(input.model),
+        options,
+      },
+    )
+
+    const { headers } = await Plugin.trigger(
+      "chat.headers",
+      {
+        sessionID: input.sessionID,
+        agent: input.agent.name,
+        model: input.model,
+        provider,
+        message: input.user,
+      },
+      {
+        headers: {},
+      },
+    )
+
+    const tools = await resolveTools(input)
+
+    // LiteLLM and some Anthropic proxies require the tools parameter to be present
+    // when message history contains tool calls, even if no tools are being used.
+    // Add a dummy tool that is never called to satisfy this validation.
+    // This is enabled for:
+    // 1. Providers with "litellm" in their ID or API ID (auto-detected)
+    // 2. Providers with explicit "litellmProxy: true" option (opt-in for custom gateways)
+    const isLiteLLMProxy =
+      provider.options?.["litellmProxy"] === true ||
+      input.model.providerID.toLowerCase().includes("litellm") ||
+      input.model.api.id.toLowerCase().includes("litellm")
+
+    // LiteLLM/Bedrock rejects requests where the message history contains tool
+    // calls but no tools param is present. When there are no active tools (e.g.
+    // during compaction), inject a stub tool to satisfy the validation requirement.
+    // The stub description explicitly tells the model not to call it.
+    if (isLiteLLMProxy && Object.keys(tools).length === 0 && hasToolCalls(input.messages)) {
+      tools["_noop"] = tool({
+        description: "Do not call this tool. It exists only for API compatibility and must never be invoked.",
+        inputSchema: jsonSchema({
+          type: "object",
+          properties: {
+            reason: { type: "string", description: "Unused" },
+          },
+        }),
+        execute: async () => ({ output: "", title: "", metadata: {} }),
+      })
+    }
+
+    // Wire up toolExecutor for DWS workflow models so that tool calls
+    // from the workflow service are executed via iroder's tool system
+    // and results sent back over the WebSocket.
+    if (language instanceof GitLabWorkflowLanguageModel) {
+      const workflowModel = language
+      workflowModel.sessionID = input.sessionID
+      workflowModel.systemPrompt = system.join("\n")
+      workflowModel.toolExecutor = async (toolName, argsJson, _requestID) => {
+        const t = tools[toolName]
+        if (!t || !t.execute) {
+          return { result: "", error: `Unknown tool: ${toolName}` }
+        }
+        try {
+          const result = await t.execute!(JSON.parse(argsJson), {
+            toolCallId: _requestID,
+            messages: input.messages,
+            abortSignal: input.abort,
+          })
+          const output = typeof result === "string" ? result : (result?.output ?? JSON.stringify(result))
+          return {
+            result: output,
+            metadata: typeof result === "object" ? result?.metadata : undefined,
+            title: typeof result === "object" ? result?.title : undefined,
+          }
+        } catch (e: any) {
+          return { result: "", error: e.message ?? String(e) }
+        }
+      }
+
+      const ruleset = Permission.merge(input.agent.permission ?? [], input.permission ?? [])
+      workflowModel.sessionPreapprovedTools = Object.keys(tools).filter((name) => {
+        const match = ruleset.findLast((rule) => Wildcard.match(name, rule.permission))
+        return !match || match.action !== "ask"
+      })
+
+      const approvedToolsForSession = new Set<string>()
+      workflowModel.approvalHandler = Instance.bind(async (approvalTools) => {
+        const uniqueNames = [...new Set(approvalTools.map((t: { name: string }) => t.name))] as string[]
+        // Auto-approve tools that were already approved in this session
+        // (prevents infinite approval loops for server-side MCP tools)
+        if (uniqueNames.every((name) => approvedToolsForSession.has(name))) {
+          return { approved: true }
+        }
+
+        const id = PermissionID.ascending()
+        let reply: Permission.Reply | undefined
+        let unsub: (() => void) | undefined
+        try {
+          unsub = Bus.subscribe(Permission.Event.Replied, (evt) => {
+            if (evt.properties.requestID === id) reply = evt.properties.reply
+          })
+          const toolPatterns = approvalTools.map((t: { name: string; args: string }) => {
+            try {
+              const parsed = JSON.parse(t.args) as Record<string, unknown>
+              const title = (parsed?.title ?? parsed?.name ?? "") as string
+              return title ? `${t.name}: ${title}` : t.name
+            } catch {
+              return t.name
+            }
+          })
+          const uniquePatterns = [...new Set(toolPatterns)] as string[]
+          await Permission.ask({
+            id,
+            sessionID: SessionID.make(input.sessionID),
+            permission: "workflow_tool_approval",
+            patterns: uniquePatterns,
+            metadata: { tools: approvalTools },
+            always: uniquePatterns,
+            ruleset: [],
+          })
+          for (const name of uniqueNames) approvedToolsForSession.add(name)
+          workflowModel.sessionPreapprovedTools = [...workflowModel.sessionPreapprovedTools, ...uniqueNames]
+          return { approved: true }
+        } catch {
+          return { approved: false }
+        } finally {
+          unsub?.()
+        }
+      })
+    }
+
+    return streamText({
+      onError(error) {
+        l.error("stream error", {
+          error,
+        })
+      },
+      async experimental_repairToolCall(failed) {
+        const lower = failed.toolCall.toolName.toLowerCase()
+        if (lower !== failed.toolCall.toolName && tools[lower]) {
+          l.info("repairing tool call", {
+            tool: failed.toolCall.toolName,
+            repaired: lower,
+          })
+          return {
+            ...failed.toolCall,
+            toolName: lower,
+          }
+        }
+        return {
+          ...failed.toolCall,
+          input: JSON.stringify({
+            tool: failed.toolCall.toolName,
+            error: failed.error.message,
+          }),
+          toolName: "invalid",
+        }
+      },
+      temperature: params.temperature,
+      topP: params.topP,
+      topK: params.topK,
+      providerOptions: ProviderTransform.providerOptions(input.model, params.options),
+      activeTools: Object.keys(tools).filter((x) => x !== "invalid"),
+      tools,
+      toolChoice: input.toolChoice,
+      maxOutputTokens: params.maxOutputTokens,
+      abortSignal: input.abort,
+      headers: {
+        ...(input.model.providerID.startsWith("iroder")
+          ? {
+              "x-iroder-project": Instance.project.id,
+              "x-iroder-session": input.sessionID,
+              "x-iroder-request": input.user.id,
+              "x-iroder-client": Flag.IRODER_CLIENT,
+            }
+          : {
+              "x-session-affinity": input.sessionID,
+              ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
+              "User-Agent": `iroder/${Installation.VERSION}`,
+            }),
+        ...input.model.headers,
+        ...headers,
+      },
+      maxRetries: input.retries ?? 0,
+      messages,
+      model: wrapLanguageModel({
+        model: language,
+        middleware: [
+          {
+            specificationVersion: "v3" as const,
+            async transformParams(args) {
+              if (args.type === "stream") {
+                // @ts-expect-error
+                args.params.prompt = ProviderTransform.message(args.params.prompt, input.model, options)
+              }
+              return args.params
+            },
+          },
+        ],
+      }),
+      experimental_telemetry: {
+        isEnabled: cfg.experimental?.openTelemetry,
+        metadata: {
+          userId: cfg.username ?? "unknown",
+          sessionId: input.sessionID,
+        },
+      },
+    })
+  }
+
+  function resolveTools(input: Pick<StreamInput, "tools" | "agent" | "permission" | "user">) {
+    const disabled = Permission.disabled(
+      Object.keys(input.tools),
+      Permission.merge(input.agent.permission, input.permission ?? []),
+    )
+    return Record.filter(input.tools, (_, k) => input.user.tools?.[k] !== false && !disabled.has(k))
+  }
+
+  // Check if messages contain any tool-call content
+  // Used to determine if a dummy tool should be added for LiteLLM proxy compatibility
+  export function hasToolCalls(messages: ModelMessage[]): boolean {
+    for (const msg of messages) {
+      if (!Array.isArray(msg.content)) continue
+      for (const part of msg.content) {
+        if (part.type === "tool-call" || part.type === "tool-result") return true
+      }
+    }
+    return false
+  }
+}