@llm4ts/core 0.1.0

package/src/providers/CodexConnector.ts

@@ -0,0 +1,251 @@
+import * as Effect from "effect/Effect"
+import type * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
+import type { CliConnectorConfig } from "../ConnectorConfig.ts"
+import { ProviderError, type LlmError } from "../Errors.ts"
+import type { StructuredResult } from "../LlmService.ts"
+import { ConnectorIds, LlmChunk, TokenUsage, type JsonSchema } from "../Models.ts"
+import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
+import { collect } from "../Streaming.ts"
+import type { TemporaryFilesShape } from "../TemporaryFiles.ts"
+import { parseFromText, withSchemaHint } from "../StructuredOutput.ts"
+import {
+  failClassifiedCliError,
+  isJsonRecord,
+  jsonField,
+  jsonIntField,
+  jsonStringField,
+  jsonText,
+  optionalModelArgs,
+  parseJsonLine,
+  sortedFlagArgs,
+  toolEventChunk,
+  usageEventChunk,
+  type JsonValue
+} from "./CliSupport.ts"
+
+export const codexExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => {
+  const effectiveFlags = config.readOnly
+    ? {
+        ...config.flags,
+        sandbox: "read-only"
+      }
+    : config.flags
+  return [...optionalModelArgs(config.model), ...sortedFlagArgs(effectiveFlags)]
+}
+
+export const codexSchemaEnforceable = (schema: JsonSchema): boolean => {
+  const properties = schema.properties
+  return properties !== undefined && isJsonRecord(properties) && Object.keys(properties).length > 0
+}
+
+export const codexStrictSchema = (json: JsonValue): JsonValue => {
+  if (Array.isArray(json)) {
+    return json.map(codexStrictSchema)
+  }
+  if (!isJsonRecord(json)) {
+    return json
+  }
+
+  const recursed: Record<string, JsonValue> = {}
+  for (const [key, value] of Object.entries(json)) {
+    recursed[key] = codexStrictSchema(value)
+  }
+  const properties = recursed.properties
+  if (properties === undefined || !isJsonRecord(properties)) {
+    return recursed
+  }
+
+  const strict: Record<string, JsonValue> = {}
+  for (const [key, value] of Object.entries(recursed)) {
+    if (key !== "additionalProperties" && key !== "required") {
+      strict[key] = value
+    }
+  }
+  strict.additionalProperties = false
+  strict.required = Object.keys(properties)
+  return strict
+}
+
+export const parseCodexStreamLine = (line: string): ReadonlyArray<LlmChunk> => {
+  const json = parseJsonLine(line)
+  if (json === undefined) {
+    return []
+  }
+
+  switch (jsonStringField(json, "type")) {
+    case "item.completed": {
+      const item = jsonField(json, "item")
+      switch (jsonStringField(item, "type")) {
+        case "agent_message": {
+          const text = jsonStringField(item, "text")
+          return text === undefined || text.length === 0 ? [] : [LlmChunk.make({ delta: text })]
+        }
+        case "command_execution":
+          return [
+            toolEventChunk("Bash", {
+              command: jsonStringField(item, "command") ?? ""
+            })
+          ]
+        default:
+          return []
+      }
+    }
+    case "turn.completed": {
+      const usage = jsonField(json, "usage")
+      if (usage === undefined) {
+        return []
+      }
+      const prompt = jsonIntField(usage, "input_tokens") ?? 0
+      const completion = jsonIntField(usage, "output_tokens") ?? 0
+      return [
+        usageEventChunk(
+          undefined,
+          TokenUsage.make({
+            prompt,
+            completion,
+            total: prompt + completion
+          })
+        )
+      ]
+    }
+    case "error":
+      return [
+        LlmChunk.make({
+          delta: "",
+          metadata: {
+            codexError: jsonStringField(json, "message") ?? "codex error"
+          }
+        })
+      ]
+    case "turn.failed":
+      return [
+        LlmChunk.make({
+          delta: "",
+          metadata: {
+            codexError: jsonStringField(jsonField(json, "error"), "message") ?? "turn failed"
+          }
+        })
+      ]
+    default:
+      return []
+  }
+}
+
+export const makeCodexConnector = (
+  config: CliConnectorConfig,
+  executor: ProcessExecutorShape,
+  temporaryFiles: TemporaryFilesShape
+): CliConnectorShape => {
+  const cwd = config.workingDir ?? "."
+  const extraArgs = codexExtraArgs(config)
+
+  const stampModel = (chunk: LlmChunk): LlmChunk =>
+    chunk.usage === undefined || chunk.metadata.model !== undefined || config.model === undefined
+      ? chunk
+      : LlmChunk.make({
+          ...chunk,
+          metadata: {
+            ...chunk.metadata,
+            model: config.model
+          }
+        })
+
+  const rawStream = (
+    argv: ReadonlyArray<string>,
+    prompt: string
+  ): Stream.Stream<LlmChunk, LlmError> =>
+    executor.runStreamingWithStdin(argv, cwd, config.envVars, prompt).pipe(
+      Stream.flatMap((line) => Stream.fromIterable(parseCodexStreamLine(line))),
+      Stream.map(stampModel)
+    )
+
+  const failCodexChunk = (chunk: LlmChunk): Effect.Effect<LlmChunk, LlmError> => {
+    const message = chunk.metadata.codexError
+    return message === undefined
+      ? Effect.succeed(chunk)
+      : failClassifiedCliError("codex", "codex error", message)
+  }
+
+  const complete = Effect.fn("@llm4ts/core/providers/CodexConnector.complete")(function* (
+    prompt: string
+  ) {
+    const result = yield* executor.runWithStdin(
+      ["codex", "exec", ...extraArgs],
+      cwd,
+      config.envVars,
+      prompt
+    )
+    if (result.exitCode !== 0) {
+      return yield* ProviderError.make({
+        message: `codex exited with code ${result.exitCode}: ${result.stdout.join("\n")}`
+      })
+    }
+    return result.stdout.join("\n")
+  })
+
+  const completeStream = (prompt: string) =>
+    rawStream(["codex", "exec", "--json", ...extraArgs], prompt).pipe(
+      Stream.mapEffect(failCodexChunk)
+    )
+
+  const base = makeCliConnector({
+    id: ConnectorIds.Codex,
+    interactionSupport: "InteractiveStdin",
+    buildArgv: (prompt, _context) => ["codex", "exec", ...extraArgs, prompt],
+    buildInteractiveArgv: (_context) => ["codex", ...extraArgs],
+    complete,
+    completeStream,
+    versionProbe: { executor, binary: "codex", cwd }
+  })
+
+  const executeStructuredWithUsage = <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ): Effect.Effect<StructuredResult<A>, LlmError, RD> => {
+    if (!codexSchemaEnforceable(jsonSchema)) {
+      return Effect.gen(function* () {
+        const text = yield* complete(withSchemaHint(prompt, jsonSchema))
+        const value = yield* parseFromText(text, schema, jsonSchema)
+        const result: StructuredResult<A> = [value, undefined, config.model]
+        return result
+      })
+    }
+
+    return Effect.scoped(
+      Effect.gen(function* () {
+        const path = yield* temporaryFiles.write(
+          "codex-schema-",
+          ".json",
+          jsonText(codexStrictSchema(jsonSchema))
+        )
+        const reply = yield* collect(
+          rawStream(["codex", "exec", "--json", "--output-schema", path, ...extraArgs], prompt)
+        )
+        if (reply.metadata.codexError !== undefined) {
+          return yield* failClassifiedCliError("codex", "codex error", reply.metadata.codexError)
+        }
+        const value = yield* parseFromText(reply.content, schema, jsonSchema)
+        const result: StructuredResult<A> = [
+          value,
+          reply.usage,
+          reply.metadata.model ?? config.model
+        ]
+        return result
+      })
+    )
+  }
+
+  return {
+    ...base,
+    executeStructured: <A, E, RD, RE>(
+      prompt: string,
+      schema: Schema.ConstraintCodec<A, E, RD, RE>,
+      jsonSchema: JsonSchema
+    ): Effect.Effect<A, LlmError, RD> =>
+      Effect.map(executeStructuredWithUsage(prompt, schema, jsonSchema), ([value]) => value),
+    executeStructuredWithUsage
+  }
+}

package/src/providers/ConnectorFactories.ts

@@ -0,0 +1,142 @@
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import {
+  ApiConnectorConfig,
+  CliConnectorConfig,
+  toLlmConfig,
+  type ConnectorConfig
+} from "../ConnectorConfig.ts"
+import {
+  ConnectorRegistry,
+  makeConnectorRegistry,
+  type ConnectorFactory,
+  type ConnectorRegistryShape
+} from "../ConnectorRegistry.ts"
+import type { ConnectorShape } from "../Connector.ts"
+import { ConfigError, type LlmError } from "../Errors.ts"
+import { HttpClient, type HttpClientShape } from "../HttpClient.ts"
+import { ConnectorIds, LlmConfig, type ConnectorId, type ConnectorKind } from "../Models.ts"
+import { ProcessExecutor, type ProcessExecutorShape } from "../ProcessExecutor.ts"
+import { TemporaryFiles, type TemporaryFilesShape } from "../TemporaryFiles.ts"
+import { makeAnthropicProvider } from "./AnthropicProvider.ts"
+import { makeAntigravityConnector } from "./AntigravityConnector.ts"
+import { makeClaudeCliConnector } from "./ClaudeCliConnector.ts"
+import { makeCodexConnector } from "./CodexConnector.ts"
+import { makeCopilotConnector } from "./CopilotConnector.ts"
+import { makeCursorConnector } from "./CursorConnector.ts"
+import { makeGeminiApiProvider } from "./GeminiApiProvider.ts"
+import {
+  GeminiCliExecutor,
+  geminiCliExecutionContextFrom,
+  makeGeminiCliProvider,
+  type GeminiCliExecutorShape
+} from "./GeminiCliProvider.ts"
+import { makeGrokCliConnector } from "./GrokCliConnector.ts"
+import { makeLmStudioProvider } from "./LmStudioProvider.ts"
+import { makeMockProvider } from "./MockProvider.ts"
+import { makeOllamaProvider } from "./OllamaProvider.ts"
+import { makeOpenAIProvider } from "./OpenAIProvider.ts"
+import { makeOpenCodeCliConnector } from "./OpenCodeCliConnector.ts"
+import { makePiConnector } from "./PiConnector.ts"
+
+export interface ConnectorFactoryDependencies {
+  readonly http: HttpClientShape
+  readonly process: ProcessExecutorShape
+  readonly temporaryFiles: TemporaryFilesShape
+  readonly geminiCli: GeminiCliExecutorShape
+}
+
+const expectedConfig = (kind: ConnectorKind, id: ConnectorId): ConfigError =>
+  ConfigError.make({
+    message: `Expected ${kind === "Api" ? "ApiConnectorConfig" : "CliConnectorConfig"} for ${id.value}`
+  })
+
+const apiFactory = (
+  id: ConnectorId,
+  build: (config: ApiConnectorConfig) => ConnectorShape
+): ConnectorFactory => ({
+  connectorId: id,
+  kind: "Api",
+  create: (config: ConnectorConfig): Effect.Effect<ConnectorShape, LlmError> =>
+    config instanceof ApiConnectorConfig
+      ? Effect.succeed(build(config))
+      : Effect.fail(expectedConfig("Api", id))
+})
+
+const cliFactory = (
+  id: ConnectorId,
+  build: (config: CliConnectorConfig) => ConnectorShape
+): ConnectorFactory => ({
+  connectorId: id,
+  kind: "Cli",
+  create: (config: ConnectorConfig): Effect.Effect<ConnectorShape, LlmError> =>
+    config instanceof CliConnectorConfig
+      ? Effect.succeed(build(config))
+      : Effect.fail(expectedConfig("Cli", id))
+})
+
+export const createConnectorRegistry = (
+  dependencies: ConnectorFactoryDependencies
+): ConnectorRegistryShape =>
+  makeConnectorRegistry([
+    apiFactory(ConnectorIds.OpenAI, (config) =>
+      makeOpenAIProvider(toLlmConfig(config), dependencies.http)
+    ),
+    apiFactory(ConnectorIds.Anthropic, (config) =>
+      makeAnthropicProvider(toLlmConfig(config), dependencies.http)
+    ),
+    apiFactory(ConnectorIds.GeminiApi, (config) =>
+      makeGeminiApiProvider(toLlmConfig(config), dependencies.http)
+    ),
+    apiFactory(ConnectorIds.LmStudio, (config) =>
+      makeLmStudioProvider(toLlmConfig(config), dependencies.http)
+    ),
+    apiFactory(ConnectorIds.Ollama, (config) =>
+      makeOllamaProvider(toLlmConfig(config), dependencies.http)
+    ),
+    cliFactory(ConnectorIds.ClaudeCli, (config) =>
+      makeClaudeCliConnector(config, dependencies.process)
+    ),
+    cliFactory(ConnectorIds.OpenCode, (config) =>
+      makeOpenCodeCliConnector(config, dependencies.process)
+    ),
+    cliFactory(ConnectorIds.GeminiCli, (config) =>
+      makeGeminiCliProvider(
+        LlmConfig.make({
+          provider: "GeminiCli",
+          model: config.model ?? "gemini-2.5-flash"
+        }),
+        dependencies.geminiCli,
+        geminiCliExecutionContextFrom(config)
+      )
+    ),
+    cliFactory(ConnectorIds.Codex, (config) =>
+      makeCodexConnector(config, dependencies.process, dependencies.temporaryFiles)
+    ),
+    cliFactory(ConnectorIds.Copilot, (config) =>
+      makeCopilotConnector(config, dependencies.process)
+    ),
+    cliFactory(ConnectorIds.Pi, (config) => makePiConnector(config, dependencies.process)),
+    cliFactory(ConnectorIds.AntigravityCli, (config) =>
+      makeAntigravityConnector(config, dependencies.process)
+    ),
+    cliFactory(ConnectorIds.Grok, (config) => makeGrokCliConnector(config, dependencies.process)),
+    cliFactory(ConnectorIds.Cursor, (config) => makeCursorConnector(config, dependencies.process)),
+    apiFactory(ConnectorIds.Mock, (config) => makeMockProvider(toLlmConfig(config)))
+  ])
+
+export const ConnectorRegistryLive = Layer.effect(
+  ConnectorRegistry,
+  Effect.gen(function* () {
+    const http = yield* HttpClient
+    const process = yield* ProcessExecutor
+    const temporaryFiles = yield* TemporaryFiles
+    const geminiCli = yield* GeminiCliExecutor
+    return createConnectorRegistry({
+      http,
+      process,
+      temporaryFiles,
+      geminiCli
+    })
+  })
+)

package/src/providers/CopilotConnector.ts

@@ -0,0 +1,47 @@
+import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
+import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
+import type { CliConnectorConfig } from "../ConnectorConfig.ts"
+import { ProviderError } from "../Errors.ts"
+import { ConnectorIds, LlmChunk } from "../Models.ts"
+import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
+
+export const buildCopilotArgv = (prompt: string): ReadonlyArray<string> => [
+  "gh",
+  "copilot",
+  "suggest",
+  "-t",
+  "shell",
+  prompt
+]
+
+export const makeCopilotConnector = (
+  config: CliConnectorConfig,
+  executor: ProcessExecutorShape
+): CliConnectorShape => {
+  const complete = Effect.fn("@llm4ts/core/providers/CopilotConnector.complete")(function* (
+    prompt: string
+  ) {
+    const argv = buildCopilotArgv(prompt)
+    const result = yield* executor.run(argv, ".", config.envVars)
+    if (result.exitCode !== 0) {
+      return yield* ProviderError.make({
+        message: `gh copilot exited with code ${result.exitCode}: ${result.stdout.join("\n")}`
+      })
+    }
+    return result.stdout.join("\n")
+  })
+
+  return makeCliConnector({
+    id: ConnectorIds.Copilot,
+    interactionSupport: "ContinuationOnly",
+    buildArgv: (prompt, _context) => buildCopilotArgv(prompt),
+    buildInteractiveArgv: (_context) => ["gh", "copilot"],
+    complete,
+    completeStream: (prompt) =>
+      Stream.fromEffect(complete(prompt)).pipe(
+        Stream.map((text) => LlmChunk.make({ delta: text }))
+      ),
+    versionProbe: { executor, binary: "gh", versionArgs: ["copilot", "--version"], cwd: "." }
+  })
+}

package/src/providers/CursorConnector.ts

@@ -0,0 +1,120 @@
+import * as Effect from "effect/Effect"
+import * as Stream from "effect/Stream"
+import { makeCliConnector, type CliConnectorShape } from "../Connector.ts"
+import type { CliConnectorConfig } from "../ConnectorConfig.ts"
+import { ConnectorIds, LlmChunk } from "../Models.ts"
+import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
+import {
+  failClassifiedCliError,
+  jsonArray,
+  jsonBooleanField,
+  jsonField,
+  jsonObjectEntries,
+  jsonStringField,
+  optionalModelArgs,
+  parseJsonLine,
+  sortedFlagArgs,
+  toolEventChunk,
+  type JsonValue
+} from "./CliSupport.ts"
+
+export const cursorExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => [
+  ...optionalModelArgs(config.model),
+  ...(config.readOnly ? [] : ["--force"]),
+  ...sortedFlagArgs(config.flags)
+]
+
+const cursorMessageText = (message: JsonValue) =>
+  jsonArray(jsonField(message, "content"))
+    .map((block) => jsonStringField(block, "text") ?? "")
+    .join("")
+
+export const parseCursorStreamLine = (line: string): ReadonlyArray<LlmChunk> => {
+  const json = parseJsonLine(line)
+  if (json === undefined) {
+    return []
+  }
+
+  switch (jsonStringField(json, "type")) {
+    case "assistant": {
+      const message = jsonField(json, "message")
+      const text = message === undefined ? "" : cursorMessageText(message)
+      return text.length === 0 ? [] : [LlmChunk.make({ delta: text })]
+    }
+    case "tool_call": {
+      if (jsonStringField(json, "subtype") !== "started") {
+        return []
+      }
+      const entry = jsonObjectEntries(jsonField(json, "tool_call"))[0]
+      return entry === undefined ? [] : [toolEventChunk(entry[0], jsonField(entry[1], "args"))]
+    }
+    case "result":
+      return jsonBooleanField(json, "is_error") === true
+        ? [
+            LlmChunk.make({
+              delta: "",
+              metadata: {
+                cursorError: jsonStringField(json, "result") ?? "cursor error"
+              }
+            })
+          ]
+        : [LlmChunk.make({ delta: "", finishReason: "stop" })]
+    default:
+      return []
+  }
+}
+
+export const makeCursorConnector = (
+  config: CliConnectorConfig,
+  executor: ProcessExecutorShape
+): CliConnectorShape => {
+  const cwd = config.workingDir ?? "."
+  const extraArgs = cursorExtraArgs(config)
+  const buildArgv = (prompt: string): ReadonlyArray<string> => [
+    "cursor-agent",
+    ...extraArgs,
+    "-p",
+    prompt
+  ]
+  const complete = Effect.fn("@llm4ts/core/providers/CursorConnector.complete")(function* (
+    prompt: string
+  ) {
+    const result = yield* executor.run(buildArgv(prompt), cwd, config.envVars)
+    if (result.exitCode !== 0) {
+      const raw = result.stdout.join("\n")
+      return yield* failClassifiedCliError(
+        "cursor",
+        `cursor-agent exited with code ${result.exitCode}`,
+        raw
+      )
+    }
+    return result.stdout.join("\n")
+  })
+
+  const completeStream = (prompt: string) =>
+    executor
+      .runStreaming(
+        ["cursor-agent", "--output-format", "stream-json", ...extraArgs, "-p", prompt],
+        cwd,
+        config.envVars
+      )
+      .pipe(
+        Stream.flatMap((line) => Stream.fromIterable(parseCursorStreamLine(line))),
+        Stream.mapEffect((chunk) => {
+          const message = chunk.metadata.cursorError
+          return message === undefined
+            ? Effect.succeed(chunk)
+            : failClassifiedCliError("cursor", "cursor error", message)
+        })
+      )
+
+  return makeCliConnector({
+    id: ConnectorIds.Cursor,
+    interactionSupport: "ContinuationOnly",
+    buildArgv: (prompt, _context) => buildArgv(prompt),
+    buildInteractiveArgv: (_context) => ["cursor-agent", ...extraArgs],
+    complete,
+    completeStream,
+    versionProbe: { executor, binary: "cursor-agent", cwd }
+  })
+}