@llm4ts/core 2.54.0 → 3.0.0

package/src/observability/Tracing.ts

@@ -1,146 +0,0 @@
-/**
- * @deprecated Since 2.30.0 (ADR 0026): llm4ts exports OpenTelemetry spans and
- * metrics over OTLP from `@llm4ts/runner/Otel`; this in-memory module is not
- * used by flow or runner and will be removed in the next major.
- */
-import * as Clock from "effect/Clock"
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Layer from "effect/Layer"
-import * as Ref from "effect/Ref"
-import * as Schema from "effect/Schema"
-import type { JsonValue } from "../providers/CliSupport.ts"
-import { redactText, sanitizeFields, type RedactionOptions } from "./Redaction.ts"
-
-export const TraceStatus = Schema.Literals(["Ok", "Error"])
-export type TraceStatus = typeof TraceStatus.Type
-
-export class TraceSpan extends Schema.Class<TraceSpan>("TraceSpan")({
-  traceId: Schema.String,
-  spanId: Schema.String,
-  parentSpanId: Schema.optionalKey(Schema.String),
-  correlationId: Schema.String,
-  name: Schema.String,
-  status: TraceStatus,
-  startedAt: Schema.Number,
-  endedAt: Schema.Number,
-  attributes: Schema.Record(Schema.String, Schema.Json),
-  errorMessage: Schema.optionalKey(Schema.String)
-}) {}
-
-interface TraceContext {
-  readonly traceId: string
-  readonly spanId: string
-  readonly correlationId: string
-}
-
-const CurrentTraceContext = Context.Reference<TraceContext | undefined>(
-  "@llm4ts/core/observability/CurrentTraceContext",
-  { defaultValue: () => undefined }
-)
-
-export interface TracingServiceShape {
-  readonly withCorrelationId: <A, E, R>(
-    id: string,
-    effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, R>
-  readonly correlationId: Effect.Effect<string>
-  readonly inSpan: <A, E, R>(
-    name: string,
-    attributes: Readonly<Record<string, JsonValue>>,
-    effect: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, E, R>
-  readonly recordedSpans: Effect.Effect<ReadonlyArray<TraceSpan>>
-}
-
-export class TracingService extends Context.Service<TracingService, TracingServiceShape>()(
-  "@llm4ts/core/observability/TracingService"
-) {}
-
-export interface TracingOptions extends RedactionOptions {
-  readonly makeId?: Effect.Effect<string>
-}
-
-const defaultId = Effect.sync(() => globalThis.crypto.randomUUID())
-
-export const makeTracingService = Effect.fn("@llm4ts/core/observability/TracingService.make")(
-  function* (options: TracingOptions = {}): Effect.fn.Return<TracingServiceShape> {
-    const spans = yield* Ref.make<ReadonlyArray<TraceSpan>>([])
-    const makeId = options.makeId ?? defaultId
-
-    const correlationId = Effect.flatMap(CurrentTraceContext, (current) =>
-      current === undefined ? makeId : Effect.succeed(current.correlationId)
-    )
-
-    const withCorrelationId = <A, E, R>(
-      id: string,
-      effect: Effect.Effect<A, E, R>
-    ): Effect.Effect<A, E, R> =>
-      Effect.flatMap(CurrentTraceContext, (current) =>
-        Effect.provideService(effect, CurrentTraceContext, {
-          traceId: current?.traceId ?? id,
-          spanId: current?.spanId ?? id,
-          correlationId: id
-        })
-      )
-
-    const inSpan = <A, E, R>(
-      name: string,
-      attributes: Readonly<Record<string, JsonValue>>,
-      effect: Effect.Effect<A, E, R>
-    ): Effect.Effect<A, E, R> =>
-      Effect.gen(function* () {
-        const parent = yield* CurrentTraceContext
-        const correlation = yield* correlationId
-        const traceId = parent?.traceId ?? (yield* makeId)
-        const spanId = yield* makeId
-        const startedAt = yield* Clock.currentTimeMillis
-        const next: TraceContext = {
-          traceId,
-          spanId,
-          correlationId: correlation
-        }
-        return yield* Effect.provideService(
-          effect.pipe(
-            Effect.onExit((exit) =>
-              Clock.currentTimeMillis.pipe(
-                Effect.flatMap((endedAt) =>
-                  Ref.update(spans, (current) => [
-                    ...current,
-                    TraceSpan.make({
-                      traceId,
-                      spanId,
-                      ...(parent === undefined ? {} : { parentSpanId: parent.spanId }),
-                      correlationId: correlation,
-                      name,
-                      status: Exit.isSuccess(exit) ? "Ok" : "Error",
-                      startedAt,
-                      endedAt,
-                      attributes: sanitizeFields(attributes, options),
-                      ...(Exit.isFailure(exit)
-                        ? {
-                            errorMessage: redactText(String(exit.cause), options)
-                          }
-                        : {})
-                    })
-                  ])
-                )
-              )
-            )
-          ),
-          CurrentTraceContext,
-          next
-        )
-      })
-
-    return {
-      withCorrelationId,
-      correlationId,
-      inSpan,
-      recordedSpans: Ref.get(spans)
-    }
-  }
-)
-
-export const TracingServiceLive = Layer.effect(TracingService, makeTracingService())

package/src/providers/OpenCodeModels.ts

@@ -1,60 +0,0 @@
-import * as Schema from "effect/Schema"
-import { JsonSchema } from "../Models.ts"
-
-export class OpenCodeMessage extends Schema.Class<OpenCodeMessage>("OpenCodeMessage")({
-  role: Schema.String,
-  content: Schema.String
-}) {}
-
-export class OpenCodeJsonSchemaSpec extends Schema.Class<OpenCodeJsonSchemaSpec>(
-  "OpenCodeJsonSchemaSpec"
-)({
-  name: Schema.String,
-  schema: JsonSchema
-}) {}
-
-export class OpenCodeResponseFormat extends Schema.Class<OpenCodeResponseFormat>(
-  "OpenCodeResponseFormat"
-)({
-  type: Schema.String,
-  json_schema: Schema.optionalKey(OpenCodeJsonSchemaSpec)
-}) {}
-
-export class OpenCodeCompletionRequest extends Schema.Class<OpenCodeCompletionRequest>(
-  "OpenCodeCompletionRequest"
-)({
-  model: Schema.String,
-  messages: Schema.Array(OpenCodeMessage),
-  temperature: Schema.optionalKey(Schema.Number),
-  max_tokens: Schema.optionalKey(Schema.Int),
-  max_completion_tokens: Schema.optionalKey(Schema.Int),
-  stream: Schema.optionalKey(Schema.Boolean),
-  response_format: Schema.optionalKey(OpenCodeResponseFormat)
-}) {}
-
-export class OpenCodeDelta extends Schema.Class<OpenCodeDelta>("OpenCodeDelta")({
-  content: Schema.optionalKey(Schema.NullOr(Schema.String))
-}) {}
-
-export class OpenCodeChoice extends Schema.Class<OpenCodeChoice>("OpenCodeChoice")({
-  index: Schema.optionalKey(Schema.Int),
-  message: Schema.optionalKey(OpenCodeMessage),
-  delta: Schema.optionalKey(OpenCodeDelta),
-  text: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  finish_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
-}) {}
-
-export class OpenCodeTokenUsage extends Schema.Class<OpenCodeTokenUsage>("OpenCodeTokenUsage")({
-  prompt_tokens: Schema.optionalKey(Schema.Int),
-  completion_tokens: Schema.optionalKey(Schema.Int),
-  total_tokens: Schema.optionalKey(Schema.Int)
-}) {}
-
-export class OpenCodeCompletionResponse extends Schema.Class<OpenCodeCompletionResponse>(
-  "OpenCodeCompletionResponse"
-)({
-  id: Schema.optionalKey(Schema.String),
-  choices: Schema.Array(OpenCodeChoice),
-  usage: Schema.optionalKey(OpenCodeTokenUsage),
-  model: Schema.optionalKey(Schema.String)
-}) {}

package/src/providers/OpenCodeProvider.ts

@@ -1,278 +0,0 @@
-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 {
-  AuthenticationError,
-  ConfigError,
-  InvalidRequestError,
-  ParseError,
-  type LlmError
-} from "../Errors.ts"
-import type { HttpClientShape } from "../HttpClient.ts"
-import type { StructuredResult } from "../LlmService.ts"
-import {
-  ConnectorIds,
-  LlmChunk,
-  TokenUsage,
-  type JsonSchema,
-  type LlmConfig,
-  type Message,
-  type MessageRole
-} from "../Models.ts"
-import { parseFromText } from "../StructuredOutput.ts"
-import {
-  OpenCodeCompletionRequest,
-  OpenCodeCompletionResponse,
-  OpenCodeJsonSchemaSpec,
-  OpenCodeMessage,
-  OpenCodeResponseFormat
-} from "./OpenCodeModels.ts"
-
-interface OpenCodeRequiredConfig {
-  readonly baseUrl: string
-  readonly apiKey: string
-}
-
-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 openCodeHistory = (messages: ReadonlyArray<Message>): ReadonlyArray<OpenCodeMessage> =>
-  messages.map((message) =>
-    OpenCodeMessage.make({
-      role: roleName(message.role),
-      content: message.content
-    })
-  )
-
-const usage = (response: OpenCodeCompletionResponse): TokenUsage | undefined =>
-  response.usage === undefined
-    ? undefined
-    : TokenUsage.make({
-        prompt: response.usage.prompt_tokens ?? 0,
-        completion: response.usage.completion_tokens ?? 0,
-        total: response.usage.total_tokens ?? 0
-      })
-
-const metadata = (
-  config: LlmConfig,
-  response: OpenCodeCompletionResponse
-): Readonly<Record<string, string>> => ({
-  provider: "opencode",
-  model: config.model,
-  ...(response.id === undefined ? {} : { id: response.id }),
-  ...(response.model === undefined ? {} : { response_model: response.model })
-})
-
-const decodeResponse = (
-  raw: string,
-  context: string
-): Effect.Effect<OpenCodeCompletionResponse, ParseError> =>
-  Schema.decodeUnknownEffect(Schema.fromJsonString(OpenCodeCompletionResponse))(raw).pipe(
-    Effect.mapError((error) =>
-      ParseError.make({
-        message: `${context}: ${String(error)}`,
-        raw
-      })
-    )
-  )
-
-const toChunk = (config: LlmConfig, response: OpenCodeCompletionResponse): LlmChunk => {
-  const choice = response.choices[0]
-  const delta = choice?.delta?.content ?? choice?.message?.content ?? choice?.text ?? ""
-  const finishReason = choice?.finish_reason ?? undefined
-  const tokenUsage = usage(response)
-  return LlmChunk.make({
-    delta,
-    metadata: metadata(config, response),
-    ...(finishReason === undefined || finishReason === null ? {} : { finishReason }),
-    ...(tokenUsage === undefined ? {} : { usage: tokenUsage })
-  })
-}
-
-export const parseOpenCodeSseBody = Effect.fn("@llm4ts/core/OpenCodeProvider.parseSseBody")(
-  function* (config: LlmConfig, raw: string): Effect.fn.Return<ReadonlyArray<LlmChunk>, LlmError> {
-    const payloads = raw
-      .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter((line) => line.startsWith("data:"))
-      .map((line) => line.slice("data:".length).trim())
-      .filter((payload) => payload.length > 0 && payload !== "[DONE]")
-    const chunks = yield* Effect.forEach(payloads, (payload) =>
-      Effect.map(decodeResponse(payload, "Failed to parse OpenCode SSE payload"), (response) =>
-        toChunk(config, response)
-      )
-    )
-    return chunks.length === 0
-      ? yield* Effect.fail(
-          ParseError.make({
-            message: "No stream chunks parsed from OpenCode SSE response",
-            raw
-          })
-        )
-      : chunks
-  }
-)
-
-export const makeOpenCodeProvider = (
-  config: LlmConfig,
-  httpClient: HttpClientShape
-): ApiConnectorShape => {
-  const requiredConfig: Effect.Effect<OpenCodeRequiredConfig, LlmError> =
-    config.baseUrl === undefined
-      ? Effect.fail(
-          ConfigError.make({
-            message: "Missing baseUrl for OpenCode provider"
-          })
-        )
-      : config.apiKey === undefined
-        ? Effect.fail(
-            AuthenticationError.make({
-              message: "Missing API key for OpenCode provider (pass apiKey in the connector config)"
-            })
-          )
-        : Effect.succeed({
-            baseUrl: config.baseUrl.replace(/\/+$/, ""),
-            apiKey: Redacted.value(config.apiKey)
-          })
-
-  const request = (
-    messages: ReadonlyArray<OpenCodeMessage>,
-    stream: boolean,
-    responseFormat?: OpenCodeResponseFormat
-  ): OpenCodeCompletionRequest =>
-    OpenCodeCompletionRequest.make({
-      model: config.model,
-      messages,
-      temperature: config.temperature ?? 0.7,
-      stream,
-      ...(config.maxTokens === undefined ? {} : { max_tokens: config.maxTokens }),
-      ...(responseFormat === undefined ? {} : { response_format: responseFormat })
-    })
-
-  const post = (
-    messages: ReadonlyArray<OpenCodeMessage>,
-    stream: boolean,
-    responseFormat?: OpenCodeResponseFormat
-  ): Effect.Effect<string, LlmError> =>
-    Effect.flatMap(requiredConfig, ({ apiKey, baseUrl }) =>
-      httpClient.postJson(
-        `${baseUrl}/chat/completions`,
-        JSON.stringify(request(messages, stream, responseFormat)),
-        {
-          Authorization: `Bearer ${apiKey}`
-        },
-        config.timeout
-      )
-    )
-
-  const executeResponse = (
-    messages: ReadonlyArray<OpenCodeMessage>,
-    responseFormat?: OpenCodeResponseFormat
-  ): Effect.Effect<readonly [response: OpenCodeCompletionResponse, raw: string], LlmError> =>
-    Effect.gen(function* () {
-      const raw = yield* post(messages, false, responseFormat)
-      const response = yield* decodeResponse(raw, "Failed to decode OpenCode response")
-      return [response, raw]
-    })
-
-  const responseContent = (
-    response: OpenCodeCompletionResponse,
-    raw: string
-  ): Effect.Effect<string, ParseError> => {
-    const content = (response.choices[0]?.message?.content ?? response.choices[0]?.text)?.trim()
-    return content === undefined || content === null || content.length === 0
-      ? Effect.fail(
-          ParseError.make({
-            message: "OpenCode response missing choices[0].message.content",
-            raw
-          })
-        )
-      : Effect.succeed(content)
-  }
-
-  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 responseFormat = OpenCodeResponseFormat.make({
-        type: "json_schema",
-        json_schema: OpenCodeJsonSchemaSpec.make({
-          name: "response",
-          schema: jsonSchema
-        })
-      })
-      const [response, raw] = yield* executeResponse(
-        [
-          OpenCodeMessage.make({
-            role: "user",
-            content: prompt
-          })
-        ],
-        responseFormat
-      )
-      const content = yield* responseContent(response, raw)
-      const value = yield* parseFromText(content, schema, jsonSchema)
-      const result: StructuredResult<A> = [value, undefined, undefined]
-      return result
-    })
-
-  const stream = (messages: ReadonlyArray<OpenCodeMessage>): Stream.Stream<LlmChunk, LlmError> =>
-    Stream.flatMap(
-      Stream.fromEffect(
-        Effect.flatMap(post(messages, true), (raw) => parseOpenCodeSseBody(config, raw))
-      ),
-      Stream.fromIterable
-    )
-
-  const isAvailable: Effect.Effect<boolean> =
-    config.baseUrl === undefined || config.apiKey === undefined
-      ? Effect.succeed(false)
-      : httpClient
-          .get(
-            `${config.baseUrl.replace(/\/+$/, "")}/models`,
-            {
-              Authorization: `Bearer ${Redacted.value(config.apiKey)}`
-            },
-            config.timeout
-          )
-          .pipe(
-            Effect.match({
-              onFailure: () => false,
-              onSuccess: () => true
-            })
-          )
-
-  return makeApiConnector({
-    id: ConnectorIds.OpenCode,
-    executeStream: (prompt) =>
-      stream([
-        OpenCodeMessage.make({
-          role: "user",
-          content: prompt
-        })
-      ]),
-    executeStreamWithHistory: (messages) => stream(openCodeHistory(messages)),
-    executeWithTools: () =>
-      Effect.fail(
-        InvalidRequestError.make({
-          message: "OpenCode provider does not yet support tool calling in this implementation"
-        })
-      ),
-    executeStructuredWithUsage,
-    isAvailable
-  })
-}