@llm4ts/core 0.1.0

package/src/providers/OpenAIModels.ts

@@ -0,0 +1,152 @@
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { JsonSchema } from "../Models.ts"
+
+export class OpenAIJsonSchemaSpec extends Schema.Class<OpenAIJsonSchemaSpec>(
+  "OpenAIJsonSchemaSpec"
+)({
+  name: Schema.String,
+  schema: JsonSchema
+}) {}
+
+export class OpenAIResponseFormat extends Schema.Class<OpenAIResponseFormat>(
+  "OpenAIResponseFormat"
+)({
+  type: Schema.String,
+  json_schema: Schema.optionalKey(OpenAIJsonSchemaSpec)
+}) {}
+
+export class OpenAIChatMessage extends Schema.Class<OpenAIChatMessage>("OpenAIChatMessage")({
+  role: Schema.String,
+  content: Schema.String
+}) {}
+
+export class OpenAIChatCompletionRequest extends Schema.Class<OpenAIChatCompletionRequest>(
+  "OpenAIChatCompletionRequest"
+)({
+  model: Schema.String,
+  messages: Schema.Array(OpenAIChatMessage),
+  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(OpenAIResponseFormat)
+}) {}
+
+export class OpenAITokenUsage extends Schema.Class<OpenAITokenUsage>("OpenAITokenUsage")({
+  prompt_tokens: Schema.optionalKey(Schema.Int),
+  completion_tokens: Schema.optionalKey(Schema.Int),
+  total_tokens: Schema.optionalKey(Schema.Int)
+}) {}
+
+export class OpenAIChatResponseMessage extends Schema.Class<OpenAIChatResponseMessage>(
+  "OpenAIChatResponseMessage"
+)({
+  role: Schema.String,
+  content: Schema.NullOr(Schema.String)
+}) {}
+
+export class OpenAIChatChoice extends Schema.Class<OpenAIChatChoice>("OpenAIChatChoice")({
+  index: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(0))),
+  message: Schema.optionalKey(OpenAIChatResponseMessage),
+  text: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  finish_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class OpenAIChatCompletionResponse extends Schema.Class<OpenAIChatCompletionResponse>(
+  "OpenAIChatCompletionResponse"
+)({
+  id: Schema.optionalKey(Schema.String),
+  choices: Schema.Array(OpenAIChatChoice),
+  usage: Schema.optionalKey(OpenAITokenUsage),
+  model: Schema.optionalKey(Schema.String)
+}) {}
+
+export class OpenAIFunction extends Schema.Class<OpenAIFunction>("OpenAIFunction")({
+  name: Schema.String,
+  description: Schema.String,
+  parameters: JsonSchema
+}) {}
+
+export class OpenAITool extends Schema.Class<OpenAITool>("OpenAITool")({
+  type: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("function"))),
+  function: OpenAIFunction
+}) {}
+
+export class OpenAIToolCallFunction extends Schema.Class<OpenAIToolCallFunction>(
+  "OpenAIToolCallFunction"
+)({
+  name: Schema.String,
+  arguments: Schema.String
+}) {}
+
+export class OpenAIToolCall extends Schema.Class<OpenAIToolCall>("OpenAIToolCall")({
+  id: Schema.String,
+  type: Schema.String,
+  function: OpenAIToolCallFunction
+}) {}
+
+const noToolCalls: ReadonlyArray<OpenAIToolCall> = Object.freeze([])
+
+export class OpenAIChatMessageWithTools extends Schema.Class<OpenAIChatMessageWithTools>(
+  "OpenAIChatMessageWithTools"
+)({
+  role: Schema.String,
+  content: Schema.optionalKey(Schema.NullOr(Schema.String)),
+  tool_calls: Schema.Array(OpenAIToolCall).pipe(
+    Schema.withConstructorDefault(Effect.succeed(noToolCalls))
+  )
+}) {}
+
+export class OpenAIChatChoiceWithTools extends Schema.Class<OpenAIChatChoiceWithTools>(
+  "OpenAIChatChoiceWithTools"
+)({
+  index: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(0))),
+  message: Schema.optionalKey(OpenAIChatMessageWithTools),
+  finish_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class OpenAIChatCompletionResponseWithTools extends Schema.Class<OpenAIChatCompletionResponseWithTools>(
+  "OpenAIChatCompletionResponseWithTools"
+)({
+  id: Schema.optionalKey(Schema.String),
+  choices: Schema.Array(OpenAIChatChoiceWithTools),
+  usage: Schema.optionalKey(OpenAITokenUsage),
+  model: Schema.optionalKey(Schema.String)
+}) {}
+
+export class OpenAIChatCompletionRequestWithTools extends Schema.Class<OpenAIChatCompletionRequestWithTools>(
+  "OpenAIChatCompletionRequestWithTools"
+)({
+  model: Schema.String,
+  messages: Schema.Array(OpenAIChatMessage),
+  tools: Schema.Array(OpenAITool),
+  temperature: Schema.optionalKey(Schema.Number),
+  max_tokens: Schema.optionalKey(Schema.Int),
+  stream: Schema.optionalKey(Schema.Boolean)
+}) {}
+
+export class OpenAIChatChunkDelta extends Schema.Class<OpenAIChatChunkDelta>(
+  "OpenAIChatChunkDelta"
+)({
+  role: Schema.optionalKey(Schema.String),
+  content: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+export class OpenAIChatChunkChoice extends Schema.Class<OpenAIChatChunkChoice>(
+  "OpenAIChatChunkChoice"
+)({
+  index: Schema.Int.pipe(Schema.withConstructorDefault(Effect.succeed(0))),
+  delta: Schema.optionalKey(OpenAIChatChunkDelta),
+  finish_reason: Schema.optionalKey(Schema.NullOr(Schema.String))
+}) {}
+
+const noChunkChoices: ReadonlyArray<OpenAIChatChunkChoice> = Object.freeze([])
+
+export class OpenAIChatChunk extends Schema.Class<OpenAIChatChunk>("OpenAIChatChunk")({
+  id: Schema.optionalKey(Schema.String),
+  model: Schema.optionalKey(Schema.String),
+  choices: Schema.Array(OpenAIChatChunkChoice).pipe(
+    Schema.withConstructorDefault(Effect.succeed(noChunkChoices))
+  )
+}) {}

package/src/providers/OpenAIProvider.ts

@@ -0,0 +1,331 @@
+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, ParseError, type LlmError } from "../Errors.ts"
+import type { HttpClientShape } from "../HttpClient.ts"
+import type { StructuredResult } from "../LlmService.ts"
+import {
+  ConnectorIds,
+  LlmChunk,
+  ToolCall,
+  ToolCallResponse,
+  type JsonSchema,
+  type LlmConfig,
+  type Message,
+  type MessageRole,
+  type ToolDefinition
+} from "../Models.ts"
+import { parseFromText } from "../StructuredOutput.ts"
+import {
+  OpenAIChatChunk,
+  OpenAIChatCompletionRequest,
+  OpenAIChatCompletionRequestWithTools,
+  OpenAIChatCompletionResponse,
+  OpenAIChatCompletionResponseWithTools,
+  OpenAIChatMessage,
+  OpenAIFunction,
+  OpenAIJsonSchemaSpec,
+  OpenAIResponseFormat,
+  OpenAITool
+} from "./OpenAIModels.ts"
+
+const emptyHeaders: Readonly<Record<string, string>> = Object.freeze({})
+
+interface RequiredConfig {
+  readonly baseUrl: string
+}
+
+const normalizedBaseUrl = (baseUrl: string): string => baseUrl.replace(/\/+$/, "")
+
+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 openAIHistoryMessages = (
+  messages: ReadonlyArray<Message>
+): ReadonlyArray<OpenAIChatMessage> =>
+  messages.map((message) =>
+    OpenAIChatMessage.make({
+      role: roleName(message.role),
+      content: message.content
+    })
+  )
+
+export const buildOpenAIChatRequest = (
+  config: LlmConfig,
+  messages: ReadonlyArray<OpenAIChatMessage>,
+  stream: boolean,
+  responseFormat?: OpenAIResponseFormat
+): OpenAIChatCompletionRequest =>
+  OpenAIChatCompletionRequest.make({
+    model: config.model,
+    messages,
+    temperature: config.temperature ?? 0.7,
+    stream,
+    ...(config.maxTokens === undefined ? {} : { max_tokens: config.maxTokens }),
+    ...(responseFormat === undefined ? {} : { response_format: responseFormat })
+  })
+
+export const buildOpenAIToolRequest = (
+  config: LlmConfig,
+  prompt: string,
+  tools: ReadonlyArray<ToolDefinition>
+): OpenAIChatCompletionRequestWithTools =>
+  OpenAIChatCompletionRequestWithTools.make({
+    model: config.model,
+    messages: [
+      OpenAIChatMessage.make({
+        role: "user",
+        content: prompt
+      })
+    ],
+    tools: tools.map((tool) =>
+      OpenAITool.make({
+        function: OpenAIFunction.make({
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.parameters
+        })
+      })
+    ),
+    temperature: config.temperature ?? 0.7,
+    stream: false,
+    ...(config.maxTokens === undefined ? {} : { max_tokens: config.maxTokens })
+  })
+
+const decodeCompletionResponse = (
+  raw: string
+): Effect.Effect<OpenAIChatCompletionResponse, ParseError> =>
+  schemaDecode.completion(raw).pipe(
+    Effect.mapError((error) =>
+      ParseError.make({
+        message: `Failed to decode OpenAI response: ${String(error)}`,
+        raw
+      })
+    )
+  )
+
+const decodeToolResponse = (
+  raw: string
+): Effect.Effect<OpenAIChatCompletionResponseWithTools, ParseError> =>
+  schemaDecode.tools(raw).pipe(
+    Effect.mapError((error) =>
+      ParseError.make({
+        message: `Failed to decode OpenAI tool response: ${String(error)}`,
+        raw
+      })
+    )
+  )
+
+const decodeStreamChunk = (raw: string): Effect.Effect<OpenAIChatChunk, ParseError> =>
+  schemaDecode.chunk(raw).pipe(
+    Effect.mapError((error) =>
+      ParseError.make({
+        message: `Failed to parse OpenAI stream chunk: ${String(error)}`,
+        raw
+      })
+    )
+  )
+
+const schemaDecode = {
+  completion: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatCompletionResponse)),
+  tools: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatCompletionResponseWithTools)),
+  chunk: Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIChatChunk))
+}
+
+const extractContent = (
+  response: OpenAIChatCompletionResponse,
+  raw: string
+): Effect.Effect<string, ParseError> => {
+  const content = response.choices[0]?.message?.content?.trim()
+  return content === undefined || content === null || content.length === 0
+    ? Effect.fail(
+        ParseError.make({
+          message: "OpenAI response missing choices[0].message.content",
+          raw
+        })
+      )
+    : Effect.succeed(content)
+}
+
+export const makeOpenAIProvider = (
+  config: LlmConfig,
+  httpClient: HttpClientShape
+): ApiConnectorShape => {
+  const authHeaders = (): Readonly<Record<string, string>> =>
+    config.apiKey === undefined
+      ? emptyHeaders
+      : { Authorization: `Bearer ${Redacted.value(config.apiKey)}` }
+
+  const requiredConfig: Effect.Effect<RequiredConfig, LlmError> =
+    config.baseUrl === undefined
+      ? Effect.fail(
+          ConfigError.make({
+            message: "Missing baseUrl for OpenAI provider"
+          })
+        )
+      : config.apiKey === undefined
+        ? Effect.fail(
+            AuthenticationError.make({
+              message:
+                "Missing API key for OpenAI provider (set OPENAI_API_KEY or pass apiKey in the connector config)"
+            })
+          )
+        : Effect.succeed({
+            baseUrl: normalizedBaseUrl(config.baseUrl)
+          })
+
+  const executeRequest = (
+    messages: ReadonlyArray<OpenAIChatMessage>,
+    responseFormat?: OpenAIResponseFormat
+  ): Effect.Effect<readonly [response: OpenAIChatCompletionResponse, raw: string], LlmError> =>
+    Effect.gen(function* () {
+      const { baseUrl } = yield* requiredConfig
+      const request = buildOpenAIChatRequest(config, messages, false, responseFormat)
+      const raw = yield* httpClient.postJson(
+        `${baseUrl}/chat/completions`,
+        JSON.stringify(request),
+        authHeaders(),
+        config.timeout
+      )
+      const response = yield* decodeCompletionResponse(raw)
+      return [response, raw]
+    })
+
+  const executeStreamRequest = (
+    messages: ReadonlyArray<OpenAIChatMessage>
+  ): Stream.Stream<LlmChunk, LlmError> =>
+    Stream.unwrap(
+      Effect.map(requiredConfig, ({ baseUrl }) => {
+        const request = buildOpenAIChatRequest(config, messages, true)
+        return httpClient
+          .postJsonStreamSSE(
+            `${baseUrl}/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: "openai",
+                        model: config.model
+                      },
+                      ...(finishReason === undefined ? {} : { finishReason })
+                    })
+                  )
+                : Stream.empty
+            })
+          )
+      })
+    )
+
+  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 = OpenAIResponseFormat.make({
+        type: "json_schema",
+        json_schema: OpenAIJsonSchemaSpec.make({
+          name: "response",
+          schema: jsonSchema
+        })
+      })
+      const [response, raw] = yield* executeRequest(
+        [
+          OpenAIChatMessage.make({
+            role: "user",
+            content: prompt
+          })
+        ],
+        responseFormat
+      )
+      const content = yield* extractContent(response, raw)
+      const value = yield* parseFromText(content, schema, jsonSchema)
+      const result: StructuredResult<A> = [value, undefined, undefined]
+      return result
+    })
+
+  const executeWithTools = (
+    prompt: string,
+    tools: ReadonlyArray<ToolDefinition>
+  ): Effect.Effect<ToolCallResponse, LlmError> =>
+    Effect.gen(function* () {
+      const { baseUrl } = yield* requiredConfig
+      const request = buildOpenAIToolRequest(config, prompt, tools)
+      const raw = yield* httpClient.postJson(
+        `${baseUrl}/chat/completions`,
+        JSON.stringify(request),
+        authHeaders(),
+        config.timeout
+      )
+      const response = yield* decodeToolResponse(raw)
+      const choice = response.choices[0]
+      const toolCalls =
+        choice?.message?.tool_calls.map((toolCall) =>
+          ToolCall.make({
+            id: toolCall.id,
+            name: toolCall.function.name,
+            arguments: toolCall.function.arguments
+          })
+        ) ?? []
+      const content = choice?.message?.content ?? undefined
+      const finishReason = choice?.finish_reason ?? "stop"
+
+      return ToolCallResponse.make({
+        toolCalls,
+        finishReason,
+        ...(content === undefined || content === null ? {} : { content })
+      })
+    })
+
+  // Parity with llm4zio v4.2.0 OpenAIProvider.isAvailable (`catchAll(_ => ZIO.succeed(true))`):
+  // a configured baseUrl counts as available even when the /models probe fails.
+  const isAvailable: Effect.Effect<boolean> =
+    config.baseUrl === undefined
+      ? Effect.succeed(false)
+      : httpClient
+          .get(`${normalizedBaseUrl(config.baseUrl)}/models`, authHeaders(), config.timeout)
+          .pipe(
+            Effect.match({
+              onFailure: () => true,
+              onSuccess: () => true
+            })
+          )
+
+  return makeApiConnector({
+    id: ConnectorIds.OpenAI,
+    executeStream: (prompt) =>
+      executeStreamRequest([
+        OpenAIChatMessage.make({
+          role: "user",
+          content: prompt
+        })
+      ]),
+    executeStreamWithHistory: (messages) => executeStreamRequest(openAIHistoryMessages(messages)),
+    executeWithTools,
+    executeStructuredWithUsage,
+    isAvailable
+  })
+}

package/src/providers/OpenCodeCliConnector.ts

@@ -0,0 +1,135 @@
+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,
+  jsonStringField,
+  optionalModelArgs,
+  parseJsonLine,
+  sortedFlagArgs,
+  toolEventChunk,
+  usageEventChunk
+} from "./CliSupport.ts"
+
+export const openCodeCliExtraArgs = (config: CliConnectorConfig): ReadonlyArray<string> => [
+  ...optionalModelArgs(config.model),
+  ...(config.readOnly ? ["--agent", "plan"] : ["--auto"]),
+  ...sortedFlagArgs(config.flags)
+]
+
+export const parseOpenCodeCliStreamLine = (line: string): ReadonlyArray<LlmChunk> => {
+  const json = parseJsonLine(line)
+  if (json === undefined) {
+    return []
+  }
+
+  const part = jsonField(json, "part")
+  switch (jsonStringField(json, "type")) {
+    case "text": {
+      const text = jsonStringField(part, "text")
+      return text === undefined || text.length === 0 ? [] : [LlmChunk.make({ delta: text })]
+    }
+    case "tool_use":
+      return part === undefined
+        ? []
+        : [
+            toolEventChunk(
+              jsonStringField(part, "tool") ?? "",
+              jsonField(jsonField(part, "state"), "input")
+            )
+          ]
+    case "step_finish": {
+      const tokens = jsonField(part, "tokens")
+      if (tokens === undefined) {
+        return []
+      }
+      const prompt = jsonIntField(tokens, "input") ?? 0
+      const completion = jsonIntField(tokens, "output") ?? 0
+      const cached = jsonIntField(jsonField(tokens, "cache"), "read")
+      return [
+        usageEventChunk(
+          undefined,
+          TokenUsage.make({
+            prompt,
+            completion,
+            total: jsonIntField(tokens, "total") ?? prompt + completion,
+            ...(cached === undefined ? {} : { cached })
+          })
+        )
+      ]
+    }
+    case "error":
+      return [
+        LlmChunk.make({
+          delta: "",
+          metadata: {
+            opencodeError:
+              jsonStringField(json, "error") ?? jsonStringField(json, "message") ?? "opencode error"
+          }
+        })
+      ]
+    default:
+      return []
+  }
+}
+
+export const makeOpenCodeCliConnector = (
+  config: CliConnectorConfig,
+  executor: ProcessExecutorShape
+): CliConnectorShape => {
+  const cwd = config.workingDir ?? "."
+  const extraArgs = openCodeCliExtraArgs(config)
+  const buildArgv = (prompt: string): ReadonlyArray<string> => [
+    "opencode",
+    "run",
+    ...extraArgs,
+    prompt
+  ]
+
+  const complete = Effect.fn("@llm4ts/core/providers/OpenCodeCliConnector.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(
+        "opencode",
+        `opencode exited with code ${result.exitCode}`,
+        raw
+      )
+    }
+    return result.stdout.join("\n")
+  })
+
+  const completeStream = (prompt: string) =>
+    executor
+      .runStreaming(
+        ["opencode", "run", "--format", "json", ...extraArgs, prompt],
+        cwd,
+        config.envVars
+      )
+      .pipe(
+        Stream.flatMap((line) => Stream.fromIterable(parseOpenCodeCliStreamLine(line))),
+        Stream.mapEffect((chunk) => {
+          const message = chunk.metadata.opencodeError
+          return message === undefined
+            ? Effect.succeed(chunk)
+            : failClassifiedCliError("opencode", "opencode error", message)
+        })
+      )
+
+  return makeCliConnector({
+    id: ConnectorIds.OpenCode,
+    interactionSupport: "ContinuationOnly",
+    buildArgv: (prompt, _context) => buildArgv(prompt),
+    buildInteractiveArgv: (_context) => ["opencode"],
+    complete,
+    completeStream,
+    versionProbe: { executor, binary: "opencode", cwd }
+  })
+}

package/src/providers/OpenCodeModels.ts

@@ -0,0 +1,60 @@
+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)
+}) {}