@llm4ts/core 0.1.0

package/src/providers/GeminiModels.ts

@@ -0,0 +1,97 @@
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { JsonSchema } from "../Models.ts"
+
+const empty = <A>(): ReadonlyArray<A> => Object.freeze([])
+
+const arrayWithDefaults = <A extends Schema.Top>(item: A) =>
+  Schema.Array(item).pipe(
+    Schema.withConstructorDefault(Effect.succeed(empty<typeof item.Type>())),
+    Schema.withDecodingDefault(Effect.succeed(empty<typeof item.Encoded>()))
+  )
+
+export class GeminiGenerationConfig extends Schema.Class<GeminiGenerationConfig>(
+  "GeminiGenerationConfig"
+)({
+  responseMimeType: Schema.optionalKey(Schema.String),
+  responseSchema: Schema.optionalKey(JsonSchema)
+}) {}
+
+export class GeminiPart extends Schema.Class<GeminiPart>("GeminiPart")({
+  text: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class GeminiContent extends Schema.Class<GeminiContent>("GeminiContent")({
+  parts: Schema.Array(GeminiPart)
+}) {}
+
+export class GeminiGenerateContentRequest extends Schema.Class<GeminiGenerateContentRequest>(
+  "GeminiGenerateContentRequest"
+)({
+  contents: Schema.Array(GeminiContent),
+  generationConfig: Schema.optionalKey(GeminiGenerationConfig)
+}) {}
+
+export class GeminiUsageMetadata extends Schema.Class<GeminiUsageMetadata>("GeminiUsageMetadata")({
+  promptTokenCount: Schema.optionalKey(Schema.Int),
+  candidatesTokenCount: Schema.optionalKey(Schema.Int),
+  totalTokenCount: Schema.optionalKey(Schema.Int)
+}) {}
+
+export class GeminiCandidate extends Schema.Class<GeminiCandidate>("GeminiCandidate")({
+  content: GeminiContent,
+  finishReason: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class GeminiGenerateContentResponse extends Schema.Class<GeminiGenerateContentResponse>(
+  "GeminiGenerateContentResponse"
+)({
+  candidates: arrayWithDefaults(GeminiCandidate),
+  usageMetadata: Schema.optionalKey(GeminiUsageMetadata)
+}) {}
+
+export class GeminiFunctionDeclaration extends Schema.Class<GeminiFunctionDeclaration>(
+  "GeminiFunctionDeclaration"
+)({
+  name: Schema.String,
+  description: Schema.String,
+  parameters: JsonSchema
+}) {}
+
+export class GeminiToolDef extends Schema.Class<GeminiToolDef>("GeminiToolDef")({
+  functionDeclarations: Schema.Array(GeminiFunctionDeclaration)
+}) {}
+
+export class GeminiFunctionCall extends Schema.Class<GeminiFunctionCall>("GeminiFunctionCall")({
+  name: Schema.String,
+  args: Schema.Json
+}) {}
+
+export class GeminiPartFull extends Schema.Class<GeminiPartFull>("GeminiPartFull")({
+  text: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  functionCall: Schema.optionalKey(GeminiFunctionCall)
+}) {}
+
+export class GeminiContentFull extends Schema.Class<GeminiContentFull>("GeminiContentFull")({
+  parts: Schema.Array(GeminiPartFull)
+}) {}
+
+export class GeminiCandidateFull extends Schema.Class<GeminiCandidateFull>("GeminiCandidateFull")({
+  content: GeminiContentFull,
+  finishReason: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class GeminiGenerateContentResponseFull extends Schema.Class<GeminiGenerateContentResponseFull>(
+  "GeminiGenerateContentResponseFull"
+)({
+  candidates: arrayWithDefaults(GeminiCandidateFull),
+  usageMetadata: Schema.optionalKey(GeminiUsageMetadata)
+}) {}
+
+export class GeminiGenerateContentRequestWithTools extends Schema.Class<GeminiGenerateContentRequestWithTools>(
+  "GeminiGenerateContentRequestWithTools"
+)({
+  contents: Schema.Array(GeminiContent),
+  tools: Schema.Array(GeminiToolDef),
+  generationConfig: Schema.optionalKey(GeminiGenerationConfig)
+}) {}

package/src/providers/GrokCliConnector.ts

@@ -0,0 +1,117 @@
+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, TokenUsage } from "../Models.ts"
+import type { ProcessExecutorShape } from "../ProcessExecutor.ts"
+import {
+  failClassifiedCliError,
+  jsonField,
+  jsonIntField,
+  jsonObjectEntries,
+  jsonStringField,
+  optionalModelArgs,
+  parseJsonLine,
+  sortedFlagArgs,
+  usageEventChunk
+} from "./CliSupport.ts"
+
+export const grokCliExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => [
+  ...optionalModelArgs(config.model),
+  ...(config.readOnly ? ["--permission-mode", "plan"] : ["--always-approve"]),
+  ...sortedFlagArgs(config.flags)
+]
+
+export const parseGrokCliStreamLine = (line: string): ReadonlyArray<LlmChunk> => {
+  const json = parseJsonLine(line)
+  if (json === undefined) {
+    return []
+  }
+
+  switch (jsonStringField(json, "type")) {
+    case "text": {
+      const text = jsonStringField(json, "data")
+      return text === undefined || text.length === 0 ? [] : [LlmChunk.make({ delta: text })]
+    }
+    case "end": {
+      const usage = jsonField(json, "usage")
+      if (usage === undefined) {
+        return []
+      }
+      const prompt = jsonIntField(usage, "input_tokens") ?? 0
+      const completion = jsonIntField(usage, "output_tokens") ?? 0
+      const cached = jsonIntField(usage, "cache_read_input_tokens")
+      const model = jsonObjectEntries(jsonField(json, "modelUsage"))[0]?.[0]
+      return [
+        usageEventChunk(
+          model,
+          TokenUsage.make({
+            prompt,
+            completion,
+            total: jsonIntField(usage, "total_tokens") ?? prompt + completion,
+            ...(cached === undefined ? {} : { cached })
+          })
+        )
+      ]
+    }
+    case "error":
+      return [
+        LlmChunk.make({
+          delta: "",
+          metadata: {
+            grokError:
+              jsonStringField(json, "data") ?? jsonStringField(json, "message") ?? "grok error"
+          }
+        })
+      ]
+    default:
+      return []
+  }
+}
+
+export const makeGrokCliConnector = (
+  config: CliConnectorConfig,
+  executor: ProcessExecutorShape
+): CliConnectorShape => {
+  const cwd = config.workingDir ?? "."
+  const extraArgs = grokCliExtraArgs(config)
+  const buildArgv = (prompt: string): ReadonlyArray<string> => ["grok", ...extraArgs, "-p", prompt]
+
+  const complete = Effect.fn("@llm4ts/core/providers/GrokCliConnector.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("grok", `grok exited with code ${result.exitCode}`, raw)
+    }
+    return result.stdout.join("\n")
+  })
+
+  const completeStream = (prompt: string) =>
+    executor
+      .runStreaming(
+        ["grok", "--output-format", "streaming-json", ...extraArgs, "-p", prompt],
+        cwd,
+        config.envVars
+      )
+      .pipe(
+        Stream.flatMap((line) => Stream.fromIterable(parseGrokCliStreamLine(line))),
+        Stream.mapEffect((chunk) => {
+          const message = chunk.metadata.grokError
+          return message === undefined
+            ? Effect.succeed(chunk)
+            : failClassifiedCliError("grok", "grok error", message)
+        })
+      )
+
+  return makeCliConnector({
+    id: ConnectorIds.Grok,
+    interactionSupport: "ContinuationOnly",
+    buildArgv: (prompt, _context) => buildArgv(prompt),
+    buildInteractiveArgv: (_context) => ["grok", ...extraArgs],
+    complete,
+    completeStream,
+    versionProbe: { executor, binary: "grok", cwd }
+  })
+}

package/src/providers/LmStudioModels.ts

@@ -0,0 +1,117 @@
+import * as Schema from "effect/Schema"
+
+export class LmStudioInput extends Schema.Class<LmStudioInput>("LmStudioInput")({
+  type: Schema.String,
+  content: Schema.optionalKey(Schema.String),
+  data_url: Schema.optionalKey(Schema.String)
+}) {}
+
+export const LmStudioInputPayload = Schema.Union([Schema.String, Schema.Array(LmStudioInput)])
+export type LmStudioInputPayload = typeof LmStudioInputPayload.Type
+
+export class LmStudioPluginIntegration extends Schema.Class<LmStudioPluginIntegration>(
+  "LmStudioPluginIntegration"
+)({
+  type: Schema.String,
+  id: Schema.String,
+  allowed_tools: Schema.optionalKey(Schema.Array(Schema.String))
+}) {}
+
+export class LmStudioEphemeralMcpIntegration extends Schema.Class<LmStudioEphemeralMcpIntegration>(
+  "LmStudioEphemeralMcpIntegration"
+)({
+  type: Schema.String,
+  server_label: Schema.String,
+  server_url: Schema.String,
+  allowed_tools: Schema.optionalKey(Schema.Array(Schema.String)),
+  headers: Schema.optionalKey(Schema.Record(Schema.String, Schema.String))
+}) {}
+
+export const LmStudioIntegration = Schema.Union([
+  LmStudioPluginIntegration,
+  LmStudioEphemeralMcpIntegration
+])
+export type LmStudioIntegration = typeof LmStudioIntegration.Type
+
+export class LmStudioChatRequest extends Schema.Class<LmStudioChatRequest>("LmStudioChatRequest")({
+  model: Schema.String,
+  input: LmStudioInputPayload,
+  system_prompt: Schema.optionalKey(Schema.String),
+  integrations: Schema.optionalKey(Schema.Array(LmStudioIntegration)),
+  stream: Schema.optionalKey(Schema.Boolean),
+  temperature: Schema.optionalKey(Schema.Number),
+  top_p: Schema.optionalKey(Schema.Number),
+  top_k: Schema.optionalKey(Schema.Int),
+  min_p: Schema.optionalKey(Schema.Number),
+  repeat_penalty: Schema.optionalKey(Schema.Number),
+  max_output_tokens: Schema.optionalKey(Schema.Int),
+  reasoning: Schema.optionalKey(Schema.String),
+  context_length: Schema.optionalKey(Schema.Int),
+  store: Schema.optionalKey(Schema.Boolean),
+  previous_response_id: Schema.optionalKey(Schema.String)
+}) {}
+
+export class LmStudioMessage extends Schema.Class<LmStudioMessage>("LmStudioMessage")({
+  role: Schema.String,
+  content: Schema.String,
+  name: Schema.optionalKey(Schema.String)
+}) {}
+
+export class LmStudioOutputItem extends Schema.Class<LmStudioOutputItem>("LmStudioOutputItem")({
+  type: Schema.String,
+  content: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  tool: Schema.optionalKey(Schema.String),
+  arguments: Schema.optionalKey(Schema.Json),
+  output: Schema.optionalKey(Schema.String),
+  provider_info: Schema.optionalKey(Schema.Json),
+  reason: Schema.optionalKey(Schema.String),
+  metadata: Schema.optionalKey(Schema.Json)
+}) {}
+
+export class LmStudioStats extends Schema.Class<LmStudioStats>("LmStudioStats")({
+  input_tokens: Schema.optionalKey(Schema.Int),
+  total_output_tokens: Schema.optionalKey(Schema.Int),
+  reasoning_output_tokens: Schema.optionalKey(Schema.Int),
+  tokens_per_second: Schema.optionalKey(Schema.Number),
+  time_to_first_token_seconds: Schema.optionalKey(Schema.Number),
+  model_load_time_seconds: Schema.optionalKey(Schema.Number)
+}) {}
+
+export class LmStudioChatResponse extends Schema.Class<LmStudioChatResponse>(
+  "LmStudioChatResponse"
+)({
+  model_instance_id: Schema.String,
+  output: Schema.Array(LmStudioOutputItem),
+  stats: Schema.optionalKey(LmStudioStats),
+  response_id: Schema.optionalKey(Schema.String)
+}) {}
+
+export class LmStudioModel extends Schema.Class<LmStudioModel>("LmStudioModel")({
+  id: Schema.String,
+  path: Schema.String,
+  type: Schema.String,
+  loaded: Schema.Boolean,
+  architecture: Schema.optionalKey(Schema.String)
+}) {}
+
+export class LmStudioModelsResponse extends Schema.Class<LmStudioModelsResponse>(
+  "LmStudioModelsResponse"
+)({
+  models: Schema.Array(LmStudioModel)
+}) {}
+
+export class LmStudioLoadModelRequest extends Schema.Class<LmStudioLoadModelRequest>(
+  "LmStudioLoadModelRequest"
+)({
+  model: Schema.String,
+  context_length: Schema.optionalKey(Schema.Int),
+  gpu_layers: Schema.optionalKey(Schema.Int)
+}) {}
+
+export class LmStudioLoadModelResponse extends Schema.Class<LmStudioLoadModelResponse>(
+  "LmStudioLoadModelResponse"
+)({
+  success: Schema.Boolean,
+  model: Schema.String,
+  message: Schema.optionalKey(Schema.String)
+}) {}

package/src/providers/LmStudioProvider.ts

@@ -0,0 +1,260 @@
+import * as Effect from "effect/Effect"
+import * as Redacted from "effect/Redacted"
+import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import { makeApiConnector, type ApiConnectorShape } from "../Connector.ts"
+import { ConfigError, InvalidRequestError, ParseError, type LlmError } from "../Errors.ts"
+import type { HttpClientShape } from "../HttpClient.ts"
+import type { StructuredResult } from "../LlmService.ts"
+import {
+  ConnectorIds,
+  LlmChunk,
+  type JsonSchema,
+  type LlmConfig,
+  type Message,
+  type MessageRole
+} from "../Models.ts"
+import { parseFromText } from "../StructuredOutput.ts"
+import { LmStudioChatRequest, LmStudioChatResponse, LmStudioMessage } from "./LmStudioModels.ts"
+import { OpenAIChatChunk, OpenAIChatCompletionRequest, OpenAIChatMessage } from "./OpenAIModels.ts"
+
+const emptyHeaders: Readonly<Record<string, string>> = Object.freeze({})
+
+export const normalizeLmStudioBaseUrl = (raw: string): string => {
+  const trimmed = raw.trim().replace(/\/+$/, "")
+  return trimmed.endsWith("/v1") ? trimmed.slice(0, -"/v1".length) : trimmed
+}
+
+const roleName = (role: MessageRole): string => {
+  switch (role) {
+    case "System":
+      return "system"
+    case "User":
+      return "user"
+    case "Assistant":
+      return "assistant"
+    case "Tool":
+      return "tool"
+  }
+}
+
+export const lmStudioHistory = (messages: ReadonlyArray<Message>): ReadonlyArray<LmStudioMessage> =>
+  messages.map((message) =>
+    LmStudioMessage.make({
+      role: roleName(message.role),
+      content: message.content
+    })
+  )
+
+export interface LmStudioNativeInput {
+  readonly input: string
+  readonly systemPrompt: string | undefined
+}
+
+export const renderLmStudioNativeInput = (
+  messages: ReadonlyArray<LmStudioMessage>
+): LmStudioNativeInput => {
+  const nonSystem = messages.filter((message) => message.role !== "system")
+  const inputMessages = nonSystem.length > 0 ? nonSystem : messages
+  const system = messages
+    .filter((message) => message.role === "system")
+    .map((message) => message.content.trim())
+    .filter((content) => content.length > 0)
+
+  return {
+    input: inputMessages.map((message) => `${message.role}: ${message.content}`).join("\n"),
+    systemPrompt: system.length === 0 ? undefined : system.join("\n")
+  }
+}
+
+const decodeNativeResponse = (raw: string): Effect.Effect<LmStudioChatResponse, ParseError> =>
+  Schema.decodeUnknownEffect(Schema.fromJsonString(LmStudioChatResponse))(raw).pipe(
+    Effect.mapError((error) =>
+      ParseError.make({
+        message: `Failed to decode LmStudio native API response: ${String(error)}`,
+        raw
+      })
+    )
+  )
+
+const decodeStreamChunk = (raw: string): Effect.Effect<OpenAIChatChunk, ParseError> =>
+  Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatChunk))(raw).pipe(
+    Effect.mapError((error) =>
+      ParseError.make({
+        message: `Failed to parse LmStudio stream chunk: ${String(error)}`,
+        raw
+      })
+    )
+  )
+
+const nativeContent = (
+  response: LmStudioChatResponse,
+  raw: string
+): Effect.Effect<string, ParseError> => {
+  const content = response.output
+    .find(
+      (item) =>
+        item.type === "message" &&
+        item.content !== undefined &&
+        item.content !== null &&
+        item.content.trim().length > 0
+    )
+    ?.content?.trim()
+
+  return content === undefined || content === null
+    ? Effect.fail(
+        ParseError.make({
+          message: "LmStudio response missing choices[0].message.content",
+          raw
+        })
+      )
+    : Effect.succeed(content)
+}
+
+export const makeLmStudioProvider = (
+  config: LlmConfig,
+  httpClient: HttpClientShape
+): ApiConnectorShape => {
+  const baseUrl: Effect.Effect<string, ConfigError> =
+    config.baseUrl === undefined
+      ? Effect.fail(
+          ConfigError.make({
+            message: "Missing baseUrl for LmStudio provider"
+          })
+        )
+      : Effect.succeed(normalizeLmStudioBaseUrl(config.baseUrl))
+
+  const authHeaders = (): Readonly<Record<string, string>> =>
+    config.apiKey === undefined
+      ? emptyHeaders
+      : {
+          Authorization: `Bearer ${Redacted.value(config.apiKey)}`
+        }
+
+  const streamRequest = (
+    messages: ReadonlyArray<LmStudioMessage>
+  ): Stream.Stream<LlmChunk, LlmError> =>
+    Stream.unwrap(
+      Effect.map(baseUrl, (normalized) => {
+        const request = OpenAIChatCompletionRequest.make({
+          model: config.model,
+          messages: messages.map((message) =>
+            OpenAIChatMessage.make({
+              role: message.role,
+              content: message.content
+            })
+          ),
+          temperature: config.temperature ?? 0.7,
+          stream: true,
+          ...(config.maxTokens === undefined ? {} : { max_tokens: config.maxTokens })
+        })
+        return httpClient
+          .postJsonStreamSSE(
+            `${normalized}/v1/chat/completions`,
+            JSON.stringify(request),
+            authHeaders(),
+            config.timeout
+          )
+          .pipe(
+            Stream.mapEffect(decodeStreamChunk),
+            Stream.flatMap((chunk) => {
+              const choice = chunk.choices[0]
+              const delta = choice?.delta?.content ?? ""
+              const finishReason = choice?.finish_reason ?? undefined
+              return delta.length > 0 || finishReason !== undefined
+                ? Stream.succeed(
+                    LlmChunk.make({
+                      delta,
+                      metadata: {
+                        provider: "lmstudio",
+                        model: config.model
+                      },
+                      ...(finishReason === undefined ? {} : { finishReason })
+                    })
+                  )
+                : Stream.empty
+            })
+          )
+      })
+    )
+
+  const nativeRequest = (
+    messages: ReadonlyArray<LmStudioMessage>
+  ): Effect.Effect<readonly [response: LmStudioChatResponse, raw: string], LlmError> =>
+    Effect.gen(function* () {
+      const normalized = yield* baseUrl
+      const rendered = renderLmStudioNativeInput(messages)
+      const request = LmStudioChatRequest.make({
+        model: config.model,
+        input: rendered.input,
+        temperature: config.temperature ?? 0.7,
+        stream: false,
+        ...(rendered.systemPrompt === undefined ? {} : { system_prompt: rendered.systemPrompt }),
+        ...(config.maxTokens === undefined ? {} : { max_output_tokens: config.maxTokens })
+      })
+      const raw = yield* httpClient.postJson(
+        `${normalized}/api/v1/chat`,
+        JSON.stringify(request),
+        authHeaders(),
+        config.timeout
+      )
+      const response = yield* decodeNativeResponse(raw)
+      return [response, raw]
+    })
+
+  const executeStructuredWithUsage = <A, E, RD, RE>(
+    prompt: string,
+    schema: Schema.ConstraintCodec<A, E, RD, RE>,
+    jsonSchema: JsonSchema
+  ): Effect.Effect<StructuredResult<A>, LlmError, RD> =>
+    Effect.gen(function* () {
+      const [response, raw] = yield* nativeRequest([
+        LmStudioMessage.make({
+          role: "user",
+          content:
+            `${prompt}\n\n` +
+            "Please respond with valid JSON only, no additional text or markdown formatting."
+        })
+      ])
+      const content = yield* nativeContent(response, raw)
+      const value = yield* parseFromText(content, schema, jsonSchema)
+      const result: StructuredResult<A> = [value, undefined, undefined]
+      return result
+    })
+
+  const isAvailable: Effect.Effect<boolean> =
+    config.baseUrl === undefined
+      ? Effect.succeed(false)
+      : httpClient
+          .get(
+            `${normalizeLmStudioBaseUrl(config.baseUrl)}/api/v1/models`,
+            emptyHeaders,
+            config.timeout
+          )
+          .pipe(
+            Effect.match({
+              onFailure: () => false,
+              onSuccess: () => true
+            })
+          )
+
+  return makeApiConnector({
+    id: ConnectorIds.LmStudio,
+    executeStream: (prompt) =>
+      streamRequest([
+        LmStudioMessage.make({
+          role: "user",
+          content: prompt
+        })
+      ]),
+    executeStreamWithHistory: (messages) => streamRequest(lmStudioHistory(messages)),
+    executeWithTools: () =>
+      Effect.fail(
+        InvalidRequestError.make({
+          message: "LmStudio provider does not yet support tool calling in this implementation"
+        })
+      ),
+    executeStructuredWithUsage,
+    isAvailable
+  })
+}