@llm4ts/runner 0.1.0

package/src/Connectors.ts

@@ -0,0 +1,225 @@
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import * as Redacted from "effect/Redacted"
+import {
+  ApiConnectorConfig,
+  CliConnectorConfig,
+  type ConnectorConfig
+} from "@llm4ts/core/ConnectorConfig"
+import { ConnectorIds, connectorDefaultBaseUrl } from "@llm4ts/core/Models"
+import { ScriptUsage } from "./FlowArgs.ts"
+
+export const claude = CliConnectorConfig.make({
+  connectorId: ConnectorIds.ClaudeCli,
+  flags: {
+    "permission-mode": "acceptEdits"
+  }
+})
+
+export const codex = CliConnectorConfig.make({
+  connectorId: ConnectorIds.Codex,
+  flags: {
+    sandbox: "workspace-write"
+  }
+})
+
+export const gemini = CliConnectorConfig.make({
+  connectorId: ConnectorIds.GeminiCli
+})
+
+export const pi = CliConnectorConfig.make({
+  connectorId: ConnectorIds.Pi
+})
+
+export const antigravity = CliConnectorConfig.make({
+  connectorId: ConnectorIds.AntigravityCli,
+  flags: {
+    mode: "accept-edits"
+  }
+})
+
+export const grok = CliConnectorConfig.make({
+  connectorId: ConnectorIds.Grok
+})
+
+export const cursor = CliConnectorConfig.make({
+  connectorId: ConnectorIds.Cursor
+})
+
+export const opencode = CliConnectorConfig.make({
+  connectorId: ConnectorIds.OpenCode
+})
+
+export const lmStudio = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.LmStudio,
+  baseUrl: "http://localhost:1234/v1"
+})
+
+export const openAI = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.OpenAI
+})
+
+export const anthropic = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.Anthropic
+})
+
+export const geminiApi = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.GeminiApi
+})
+
+export const ollama = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.Ollama
+})
+
+export const mock = ApiConnectorConfig.make({
+  connectorId: ConnectorIds.Mock,
+  model: "mock"
+})
+
+export function withModel(config: CliConnectorConfig, model: string): CliConnectorConfig
+export function withModel(config: ApiConnectorConfig, model: string): ApiConnectorConfig
+export function withModel(
+  config: CliConnectorConfig | ApiConnectorConfig,
+  model: string
+): CliConnectorConfig | ApiConnectorConfig {
+  return config instanceof CliConnectorConfig
+    ? CliConnectorConfig.make({ ...config, model })
+    : ApiConnectorConfig.make({ ...config, model })
+}
+
+export const withTurnLimit = (config: CliConnectorConfig, turnLimit: number): CliConnectorConfig =>
+  CliConnectorConfig.make({
+    ...config,
+    turnLimit
+  })
+
+export const withEnvironment = (
+  config: CliConnectorConfig,
+  environment: Readonly<Record<string, string>>
+): CliConnectorConfig =>
+  CliConnectorConfig.make({
+    ...config,
+    envVars: {
+      ...config.envVars,
+      ...environment
+    }
+  })
+
+export const asReadOnly = (config: CliConnectorConfig): CliConnectorConfig =>
+  CliConnectorConfig.make({ ...config, readOnly: true })
+
+export const withTimeoutSeconds = (
+  config: ApiConnectorConfig,
+  seconds: number
+): ApiConnectorConfig =>
+  ApiConnectorConfig.make({
+    ...config,
+    timeout: Duration.seconds(seconds)
+  })
+
+const environmentApiKey = (
+  config: ApiConnectorConfig,
+  environment: Readonly<Record<string, string | undefined>>
+): string | undefined => {
+  switch (config.connectorId.value) {
+    case "openai":
+      return environment.OPENAI_API_KEY
+    case "anthropic":
+      return environment.ANTHROPIC_API_KEY
+    case "gemini-api":
+      return environment.GEMINI_API_KEY ?? environment.GOOGLE_API_KEY
+    default:
+      return undefined
+  }
+}
+
+export const enrichApiConnector = (
+  config: ApiConnectorConfig,
+  environment: Readonly<Record<string, string | undefined>> = process.env
+): ApiConnectorConfig => {
+  const baseUrl = config.baseUrl ?? connectorDefaultBaseUrl(config.connectorId)
+  const environmentKey = environmentApiKey(config, environment)
+  return ApiConnectorConfig.make({
+    ...config,
+    ...(baseUrl === undefined ? {} : { baseUrl }),
+    ...(config.apiKey !== undefined
+      ? { apiKey: config.apiKey }
+      : environmentKey === undefined
+        ? {}
+        : { apiKey: Redacted.make(environmentKey) })
+  })
+}
+
+export const prepareConnector = (
+  config: ConnectorConfig,
+  workDir: string,
+  environment: Readonly<Record<string, string | undefined>> = process.env
+): ConnectorConfig =>
+  config instanceof ApiConnectorConfig
+    ? enrichApiConnector(config, environment)
+    : CliConnectorConfig.make({ ...config, workingDir: workDir })
+
+export const apiConnectorFromEnvironment = Effect.fn(
+  "@llm4ts/runner/Connectors.apiConnectorFromEnvironment"
+)(function* (
+  environment: Readonly<Record<string, string | undefined>> = process.env
+): Effect.fn.Return<ApiConnectorConfig, ScriptUsage> {
+  const provider = environment.LLM4TS_PROVIDER?.trim().toLowerCase() ?? "mock"
+  const preset = (() => {
+    switch (provider) {
+      case "mock":
+        return mock
+      case "openai":
+        return openAI
+      case "anthropic":
+        return anthropic
+      case "gemini":
+      case "gemini-api":
+        return geminiApi
+      case "lm-studio":
+      case "lmstudio":
+        return lmStudio
+      case "ollama":
+        return ollama
+      default:
+        return undefined
+    }
+  })()
+  if (preset === undefined) {
+    return yield* ScriptUsage.make({
+      message:
+        `unknown LLM4TS_PROVIDER '${provider}'; expected ` +
+        "mock|openai|anthropic|gemini|lm-studio|ollama"
+    })
+  }
+  const model = environment.LLM4TS_MODEL?.trim()
+  if (provider !== "mock" && (model === undefined || model.length === 0)) {
+    return yield* ScriptUsage.make({
+      message: `LLM4TS_MODEL is required for provider '${provider}' (e.g. LLM4TS_MODEL=gpt-4o-mini)`
+    })
+  }
+  return model === undefined || model.length === 0 ? preset : withModel(preset, model)
+})
+
+export const coderFromEnv = (
+  env: Readonly<Record<string, string | undefined>> = process.env
+): CliConnectorConfig => {
+  switch (env.LLM4TS_CODER ?? env.LLM4ZIO_CODER ?? "claude") {
+    case "codex":
+      return codex
+    case "gemini":
+      return gemini
+    case "pi":
+      return pi
+    case "agy":
+      return antigravity
+    case "grok":
+      return grok
+    case "cursor":
+      return cursor
+    case "opencode":
+      return opencode
+    default:
+      return claude
+  }
+}

package/src/Doctor.ts

@@ -0,0 +1,44 @@
+import * as Effect from "effect/Effect"
+import type { HealthStatus } from "@llm4ts/core/Models"
+import type { ConnectorRegistryShape } from "@llm4ts/core/ConnectorRegistry"
+import { nodeFlowRunnerDependencies } from "./FlowRunner.ts"
+
+const credentialKeys = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY"
+] as const
+
+const statusLine = (id: string, status: HealthStatus): string => {
+  const mark =
+    status.availability === "Healthy" ? "✔" : status.availability === "Unknown" ? "?" : "✖"
+  const auth = status.authStatus === "Unknown" ? "" : `  auth: ${status.authStatus.toLowerCase()}`
+  return `  ${mark} ${id.padEnd(14)} ${status.availability.toLowerCase()}${auth}`
+}
+
+export const makeDoctorProgram = (
+  registry: ConnectorRegistryShape = nodeFlowRunnerDependencies().registry,
+  environment: Readonly<Record<string, string | undefined>> = process.env
+): Effect.Effect<string> =>
+  Effect.map(registry.healthCheckAll, (statuses) => {
+    const lines: Array<string> = []
+    lines.push("llm4ts doctor")
+    lines.push("")
+    lines.push("connectors:")
+    const sorted = Array.from(statuses.entries()).sort(([a], [b]) => a.value.localeCompare(b.value))
+    for (const [id, status] of sorted) {
+      lines.push(statusLine(id.value, status))
+    }
+    lines.push("")
+    lines.push("credentials:")
+    for (const key of credentialKeys) {
+      const value = environment[key]
+      lines.push(`  ${value === undefined || value.length === 0 ? "✖" : "✔"} ${key}`)
+    }
+    lines.push("")
+    lines.push(
+      `coder: ${environment.LLM4TS_CODER ?? environment.LLM4ZIO_CODER ?? "claude (default)"}`
+    )
+    return `${lines.join("\n")}\n`
+  })

package/src/FlowArgs.ts

@@ -0,0 +1,167 @@
+import { readFile, stat } from "node:fs/promises"
+import { resolve } from "node:path"
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+export interface FlowArgs {
+  readonly promptText?: string
+  readonly promptFile?: string
+  readonly repo?: string
+  readonly help?: boolean
+  readonly version?: boolean
+}
+
+export const FlowUsage =
+  'usage: llm4ts ["<prompt>" | --prompt-file <path> | @<path>] [--repo <path>] | llm4ts doctor'
+
+export const FlowHelp = `${FlowUsage}
+
+Stream one prompt to your configured coding agent and print the response.
+
+arguments:
+  "<prompt>"              prompt text
+  @<path>                 read the prompt from a file
+  --prompt-file <path>    read the prompt from a file
+  --repo, -C <path>       run against this repository (default: current directory)
+  -h, --help              show this help
+  --version               print the version
+
+commands:
+  doctor                  check connector availability and credentials
+
+environment:
+  LLM4TS_CODER            coding agent: claude|codex|gemini|pi|agy|grok|cursor|opencode (default: claude)
+  LLM4TS_VERBOSITY        terminal verbosity: quiet|normal|verbose
+  OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY
+                          credentials for API providers
+
+A trace of each run is written under .llm4ts/ in the target repository.
+`
+
+export class ScriptUsage extends Schema.TaggedErrorClass<ScriptUsage>()("ScriptUsage", {
+  message: Schema.String
+}) {}
+
+export type FlowArgsParseResult =
+  | { readonly ok: true; readonly value: FlowArgs }
+  | { readonly ok: false; readonly error: ScriptUsage }
+
+export const parseFlowArgs = (args: ReadonlyArray<string>): FlowArgsParseResult => {
+  let parsed: FlowArgs = {}
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index] ?? ""
+    if (argument === "--") {
+      continue
+    } else if (argument === "--help" || argument === "-h") {
+      parsed = { ...parsed, help: true }
+    } else if (argument === "--version") {
+      parsed = { ...parsed, version: true }
+    } else if (argument === "--prompt-file") {
+      const value = args[index + 1]
+      if (value === undefined) {
+        return {
+          ok: false,
+          error: ScriptUsage.make({
+            message: `--prompt-file requires a path\n${FlowUsage}`
+          })
+        }
+      }
+      parsed = { ...parsed, promptFile: value }
+      index += 1
+    } else if (argument.startsWith("--prompt-file=")) {
+      parsed = {
+        ...parsed,
+        promptFile: argument.slice("--prompt-file=".length)
+      }
+    } else if (argument === "--repo" || argument === "-C") {
+      const value = args[index + 1]
+      if (value === undefined) {
+        return {
+          ok: false,
+          error: ScriptUsage.make({
+            message: `${argument} requires a path\n${FlowUsage}`
+          })
+        }
+      }
+      parsed = { ...parsed, repo: value }
+      index += 1
+    } else if (argument.startsWith("--repo=")) {
+      parsed = { ...parsed, repo: argument.slice("--repo=".length) }
+    } else if (argument.startsWith("--")) {
+      return {
+        ok: false,
+        error: ScriptUsage.make({
+          message: `unknown flag: ${argument}\n${FlowUsage}`
+        })
+      }
+    } else if (argument.startsWith("@") && argument.length > 1 && parsed.promptFile === undefined) {
+      parsed = { ...parsed, promptFile: argument.slice(1) }
+    } else if (parsed.promptText === undefined && argument.trim().length > 0) {
+      parsed = { ...parsed, promptText: argument.trim() }
+    }
+  }
+  return { ok: true, value: parsed }
+}
+
+export const readFlowPrompt = (
+  args: FlowArgs,
+  defaultPrompt?: string
+): Effect.Effect<string, ScriptUsage> => {
+  if (args.promptFile !== undefined) {
+    return Effect.tryPromise({
+      try: () => readFile(args.promptFile ?? "", "utf8"),
+      catch: (error) =>
+        ScriptUsage.make({
+          message: `could not read prompt file ${args.promptFile}: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        })
+    })
+  }
+  const prompt = args.promptText ?? defaultPrompt
+  return prompt === undefined
+    ? Effect.fail(ScriptUsage.make({ message: FlowUsage }))
+    : Effect.succeed(prompt)
+}
+
+export const resolveFlowRepo = (
+  args: FlowArgs,
+  workspace: string
+): Effect.Effect<string, ScriptUsage> => {
+  const path = resolve(workspace, args.repo ?? ".")
+  return Effect.tryPromise({
+    try: async () => {
+      const information = await stat(path)
+      if (!information.isDirectory()) {
+        throw new Error("not a directory")
+      }
+      return path
+    },
+    catch: (error) =>
+      ScriptUsage.make({
+        message: `--repo is not a directory: ${path}${
+          error instanceof Error ? ` (${error.message})` : ""
+        }`
+      })
+  })
+}
+
+export interface FlowInput {
+  readonly prompt: string
+  readonly workDir: string
+  readonly workspace: string
+}
+
+export const resolveFlowInput = Effect.fn("@llm4ts/runner/FlowArgs.resolveFlowInput")(function* (
+  defaultPrompt?: string,
+  argv: ReadonlyArray<string> = process.argv.slice(2),
+  workspace = process.cwd()
+): Effect.fn.Return<FlowInput, ScriptUsage> {
+  const parsed = parseFlowArgs(argv)
+  if (!parsed.ok) {
+    return yield* parsed.error
+  }
+  const prompt = yield* readFlowPrompt(parsed.value, defaultPrompt)
+  const workDir = yield* resolveFlowRepo(parsed.value, workspace)
+  return { prompt, workDir, workspace }
+})

package/src/FlowRunner.ts

@@ -0,0 +1,220 @@
+import * as Clock from "effect/Clock"
+import * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
+import type { ConnectorConfig } from "@llm4ts/core/ConnectorConfig"
+import { defaultReasoningConfig } from "@llm4ts/core/ConnectorConfig"
+import type { ConnectorRegistryShape } from "@llm4ts/core/ConnectorRegistry"
+import type { HttpClientShape } from "@llm4ts/core/HttpClient"
+import type { ProcessExecutorShape } from "@llm4ts/core/ProcessExecutor"
+import type { TemporaryFilesShape } from "@llm4ts/core/TemporaryFiles"
+import type { GeminiCliExecutorShape } from "@llm4ts/core/providers/GeminiCliProvider"
+import { createConnectorRegistry } from "@llm4ts/core/providers/ConnectorFactories"
+import { makeCostTracker } from "@llm4ts/flow/CostTracker"
+import { FlowLlmError, type FlowError } from "@llm4ts/flow/FlowError"
+import { makeFlowEventHub, type FlowEventHub } from "@llm4ts/flow/FlowEvents"
+import { FlowContext, type FlowContextShape } from "@llm4ts/flow/FlowContext"
+import { makeFlowRecorder } from "@llm4ts/flow/FlowRecorder"
+import { makeGitHubTool } from "@llm4ts/flow/GitHubTool"
+import { makeGitTool } from "@llm4ts/flow/GitTool"
+import type { PlainFileStoreShape } from "@llm4ts/flow/Persistence"
+import { nodeHttpClient } from "./NodeHttpClient.ts"
+import { nodeGeminiCliExecutor } from "./NodeGeminiCliExecutor.ts"
+import { nodePlainFileStore } from "./NodePlainFileStore.ts"
+import { nodeProcessExecutor } from "./NodeProcessExecutor.ts"
+import { nodeTemporaryFiles } from "./NodeTemporaryFiles.ts"
+import { prepareConnector } from "./Connectors.ts"
+import {
+  consumeTerminalEvents,
+  makeTerminalSurface,
+  type TerminalSurface,
+  type Verbosity
+} from "./Terminal.ts"
+
+export interface FlowRunnerDependencies {
+  readonly registry: ConnectorRegistryShape
+  readonly process: ProcessExecutorShape
+  readonly files: PlainFileStoreShape
+}
+
+export interface NodeConnectorDependencies {
+  readonly http: HttpClientShape
+  readonly process: ProcessExecutorShape
+  readonly temporaryFiles: TemporaryFilesShape
+  readonly geminiCli: GeminiCliExecutorShape
+}
+
+export const nodeFlowRunnerDependencies = (): FlowRunnerDependencies => ({
+  process: nodeProcessExecutor,
+  files: nodePlainFileStore,
+  registry: createConnectorRegistry({
+    http: nodeHttpClient,
+    process: nodeProcessExecutor,
+    temporaryFiles: nodeTemporaryFiles,
+    geminiCli: nodeGeminiCliExecutor
+  })
+})
+
+export interface FlowRunnerOptions {
+  readonly workDir: string
+  readonly workspace: string
+  readonly userPrompt: string
+  readonly coder: ConnectorConfig
+  readonly reasoning?: ConnectorConfig
+  readonly reviewers?: ReadonlyArray<ConnectorConfig>
+  readonly tracePath?: string
+  readonly runId?: string
+  readonly verbosity?: Verbosity
+  readonly surface?: TerminalSurface
+  readonly environment?: Readonly<Record<string, string | undefined>>
+}
+
+export interface FlowRunnerBundle {
+  readonly context: FlowContextShape
+  readonly events: FlowEventHub
+}
+
+export const makeFlowRunnerContext = Effect.fn("@llm4ts/runner/FlowRunner.makeContext")(function* (
+  options: FlowRunnerOptions,
+  dependencies: FlowRunnerDependencies
+): Effect.fn.Return<FlowRunnerBundle, FlowError> {
+  const events = yield* makeFlowEventHub()
+  const coderConfig = prepareConnector(
+    options.coder,
+    options.workDir,
+    options.environment ?? process.env
+  )
+  const reasoning = defaultReasoningConfig(options.coder, options.reasoning)
+  const reasoningPrepared = prepareConnector(
+    reasoning,
+    options.workDir,
+    options.environment ?? process.env
+  )
+  const coder = yield* dependencies.registry
+    .resolve(coderConfig)
+    .pipe(Effect.mapError(FlowLlmError.from))
+  const reasoningService = yield* dependencies.registry
+    .resolve(reasoningPrepared)
+    .pipe(Effect.mapError(FlowLlmError.from))
+  const reviewers = yield* Effect.forEach(options.reviewers ?? [], (configuration) =>
+    dependencies.registry
+      .resolve(prepareConnector(configuration, options.workDir, options.environment ?? process.env))
+      .pipe(Effect.mapError(FlowLlmError.from))
+  )
+  return {
+    events,
+    context: FlowContext.of({
+      reasoning: reasoningService,
+      coder,
+      git: makeGitTool(dependencies.process, options.workDir, events),
+      hosting: makeGitHubTool(dependencies.process, options.workDir, events),
+      events,
+      reviewers,
+      coderCapabilities: coder.capabilities,
+      userPrompt: options.userPrompt,
+      workDir: options.workDir,
+      workspace: options.workspace
+    })
+  }
+})
+
+export const runWithBundle = Effect.fn("@llm4ts/runner/FlowRunner.runWithBundle")(function* <
+  A,
+  E,
+  R
+>(
+  bundle: FlowRunnerBundle,
+  options: FlowRunnerOptions,
+  body: (context: FlowContextShape) => Effect.Effect<A, E, R>,
+  dependencies: FlowRunnerDependencies = nodeFlowRunnerDependencies()
+): Effect.fn.Return<A, E | FlowError, R | Scope.Scope> {
+  const tracker = yield* makeCostTracker()
+  const surface =
+    options.surface ?? (yield* makeTerminalSurface(options.environment ?? process.env))
+  const palette = surface.palette
+  const terminal = yield* consumeTerminalEvents(
+    bundle.events,
+    surface,
+    options.verbosity ?? "Normal"
+  )
+  yield* tracker.consume(bundle.events)
+  const recorder =
+    options.tracePath === undefined
+      ? undefined
+      : yield* makeFlowRecorder(
+          dependencies.files,
+          options.tracePath,
+          options.runId ?? `run-${(yield* Clock.currentTimeMillis).toString()}`
+        )
+  if (recorder !== undefined) {
+    yield* recorder.consume(bundle.events)
+  }
+  yield* surface.setStatus("preparing flow")
+  return yield* body(bundle.context).pipe(
+    Effect.provideService(FlowContext, bundle.context),
+    Effect.ensuring(
+      Effect.all(
+        [
+          terminal.awaitDrained(),
+          tracker.awaitDrained(bundle.events),
+          recorder === undefined ? Effect.void : recorder.awaitDrained(bundle.events)
+        ],
+        { concurrency: "unbounded" }
+      ).pipe(
+        Effect.andThen(surface.setStatus(undefined)),
+        Effect.andThen(tracker.summary),
+        Effect.flatMap((summary) => surface.log(`\n${summary}`))
+      )
+    ),
+    Effect.tapError((error) =>
+      surface
+        .setStatus(undefined)
+        .pipe(
+          Effect.andThen(
+            surface.log(
+              `\n${palette.fail(
+                `flow failed: ${error instanceof Error ? error.message : String(error)}`
+              )}`
+            )
+          )
+        )
+    ),
+    Effect.tap(() =>
+      surface
+        .setStatus(undefined)
+        .pipe(Effect.andThen(surface.log(`\n${palette.stageDone("flow completed")}`)))
+    )
+  )
+})
+
+export const runEmbedded = Effect.fn("@llm4ts/runner/FlowRunner.runEmbedded")(function* <A, E, R>(
+  options: FlowRunnerOptions,
+  body: (context: FlowContextShape) => Effect.Effect<A, E, R>,
+  dependencies: FlowRunnerDependencies = nodeFlowRunnerDependencies()
+): Effect.fn.Return<A, E | FlowError, R | Scope.Scope> {
+  const bundle = yield* makeFlowRunnerContext(options, dependencies)
+  return yield* runWithBundle(bundle, options, body, dependencies)
+})
+
+export const runNode = <A, E, R>(
+  options: FlowRunnerOptions,
+  body: (context: FlowContextShape) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E | FlowError, R> => Effect.scoped(runEmbedded(options, body))
+
+const mainErrorMessage = (error: unknown): string =>
+  error instanceof Error && error.message.length > 0 ? error.message : String(error)
+
+export const runFlowMain = <E>(program: Effect.Effect<void, E>): void => {
+  Effect.runFork(
+    program.pipe(
+      Effect.match({
+        onFailure: (error) =>
+          Effect.sync(() => {
+            process.stderr.write(`${mainErrorMessage(error)}\n`)
+            process.exitCode = 1
+          }),
+        onSuccess: () => Effect.void
+      }),
+      Effect.flatten
+    )
+  )
+}

package/src/McpStdio.ts

@@ -0,0 +1,41 @@
+import { createInterface } from "node:readline"
+import { stdin, stdout } from "node:process"
+import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
+import { ProcessError, type FlowError } from "@llm4ts/flow/FlowError"
+import { handleMcpLine, type McpTool } from "@llm4ts/flow/McpServer"
+
+export const mcpStdioResponses = <R>(
+  lines: Stream.Stream<string, FlowError, R>,
+  tools: ReadonlyArray<McpTool>
+): Stream.Stream<string, FlowError, R> =>
+  lines.pipe(
+    Stream.mapEffect((line) => handleMcpLine(line, tools)),
+    Stream.filter((response): response is string => response !== undefined)
+  )
+
+export const runMcpStdio = (
+  tools: ReadonlyArray<McpTool>,
+  write: (line: string) => void = (line) => stdout.write(`${line}\n`)
+): Effect.Effect<void, FlowError> =>
+  Effect.acquireUseRelease(
+    Effect.sync(() =>
+      createInterface({
+        input: stdin,
+        crlfDelay: Infinity,
+        terminal: false
+      })
+    ),
+    (input) => {
+      const lines = Stream.fromAsyncIterable(input, (error) =>
+        ProcessError.make({
+          message: "MCP stdio input",
+          detail: error instanceof Error ? error.message : String(error)
+        })
+      )
+      return mcpStdioResponses(lines, tools).pipe(
+        Stream.runForEach((line) => Effect.sync(() => write(line)))
+      )
+    },
+    (input) => Effect.sync(() => input.close())
+  )