onlycode 1.18.0 → 1.20.0

package/src/session/llm/native-request.ts

@@ -1,196 +0,0 @@
-import type { JsonSchema, LLMRequest, ProviderMetadata } from "@opencode-ai/llm"
-import { LLM, Message, SystemPart, ToolCallPart, ToolDefinition, ToolResultPart } from "@opencode-ai/llm"
-import {
-  AmazonBedrock,
-  Anthropic,
-  Azure,
-  Google,
-  OpenAI,
-  OpenAICompatible,
-  OpenRouter,
-} from "@opencode-ai/llm/providers"
-import type { ModelMessage } from "ai"
-import type { Provider } from "@/provider/provider"
-import { isRecord } from "@/util/record"
-
-type ToolInput = {
-  readonly description?: string
-  readonly inputSchema?: unknown
-}
-
-export type RequestInput = {
-  readonly model: Provider.Model
-  readonly apiKey?: string
-  readonly baseURL?: string
-  readonly system?: readonly string[]
-  readonly messages: readonly ModelMessage[]
-  readonly tools?: Record<string, ToolInput>
-  readonly toolChoice?: "auto" | "required" | "none"
-  readonly temperature?: number
-  readonly topP?: number
-  readonly topK?: number
-  readonly maxOutputTokens?: number
-  readonly providerOptions?: LLMRequest["providerOptions"]
-  readonly headers?: Record<string, string>
-}
-
-const providerMetadata = (value: unknown): ProviderMetadata | undefined => {
-  if (!isRecord(value)) return undefined
-  const result = Object.fromEntries(
-    Object.entries(value).filter((entry): entry is [string, Record<string, unknown>] => isRecord(entry[1])),
-  )
-  return Object.keys(result).length === 0 ? undefined : result
-}
-
-// Stored AI SDK parts historically kept provider-owned continuation metadata in
-// `providerOptions`; native parts now use `providerMetadata` directly.
-const partProviderMetadata = (part: Record<string, unknown>) =>
-  providerMetadata(part.providerMetadata) ?? providerMetadata(part.providerOptions)
-
-const textPart = (part: Record<string, unknown>) => ({
-  type: "text" as const,
-  text: typeof part.text === "string" ? part.text : "",
-  providerMetadata: partProviderMetadata(part),
-})
-
-const mediaPart = (part: Record<string, unknown>) => {
-  if (typeof part.data !== "string" && !(part.data instanceof Uint8Array))
-    throw new Error("Native LLM request adapter only supports file parts with string or Uint8Array data")
-  return {
-    type: "media" as const,
-    mediaType: typeof part.mediaType === "string" ? part.mediaType : "application/octet-stream",
-    data: part.data,
-    filename: typeof part.filename === "string" ? part.filename : undefined,
-  }
-}
-
-const toolResult = (part: Record<string, unknown>) => {
-  const output = isRecord(part.output) ? part.output : { type: "json", value: part.output }
-  const type = output.type === "text" ? "text" : output.type === "error-text" ? "error" : "json"
-  return ToolResultPart.make({
-    id: typeof part.toolCallId === "string" ? part.toolCallId : "",
-    name: typeof part.toolName === "string" ? part.toolName : "",
-    result: "value" in output ? output.value : output,
-    resultType: type,
-    providerExecuted: typeof part.providerExecuted === "boolean" ? part.providerExecuted : undefined,
-    providerMetadata: partProviderMetadata(part),
-  })
-}
-
-const contentPart = (part: unknown) => {
-  if (!isRecord(part)) throw new Error("Native LLM request adapter only supports object content parts")
-  if (part.type === "text") return textPart(part)
-  if (part.type === "file") return mediaPart(part)
-  if (part.type === "reasoning")
-    return {
-      type: "reasoning" as const,
-      text: typeof part.text === "string" ? part.text : "",
-      providerMetadata: partProviderMetadata(part),
-    }
-  if (part.type === "tool-call")
-    return ToolCallPart.make({
-      id: typeof part.toolCallId === "string" ? part.toolCallId : "",
-      name: typeof part.toolName === "string" ? part.toolName : "",
-      input: part.input,
-      providerExecuted: typeof part.providerExecuted === "boolean" ? part.providerExecuted : undefined,
-      providerMetadata: partProviderMetadata(part),
-    })
-  if (part.type === "tool-result") return toolResult(part)
-  throw new Error(`Native LLM request adapter does not support ${String(part.type)} content parts`)
-}
-
-const content = (value: ModelMessage["content"]) =>
-  typeof value === "string" ? [{ type: "text" as const, text: value }] : value.map(contentPart)
-
-const messages = (input: readonly ModelMessage[]) => {
-  const system = input.flatMap((message) => (message.role === "system" ? [SystemPart.make(message.content)] : []))
-  const messages = input.flatMap((message) => {
-    if (message.role === "system") return []
-    return [
-      Message.make({
-        role: message.role,
-        content: content(message.content),
-        native: isRecord(message.providerOptions) ? { providerOptions: message.providerOptions } : undefined,
-      }),
-    ]
-  })
-  return { system, messages }
-}
-
-const schema = (value: unknown): JsonSchema => {
-  if (!isRecord(value)) return { type: "object", properties: {} }
-  if (isRecord(value.jsonSchema)) return value.jsonSchema
-  return value
-}
-
-const tools = (input: Record<string, ToolInput> | undefined): ToolDefinition[] =>
-  Object.entries(input ?? {}).map(([name, item]) =>
-    ToolDefinition.make({
-      name,
-      description: item.description ?? "",
-      inputSchema: schema(item.inputSchema),
-    }),
-  )
-
-const generation = (input: RequestInput) => {
-  const result = {
-    temperature: input.temperature,
-    topP: input.topP,
-    topK: input.topK,
-    maxTokens: input.maxOutputTokens,
-  }
-  return Object.values(result).some((value) => value !== undefined) ? result : undefined
-}
-
-const baseURL = (input: Provider.Model | RequestInput) =>
-  "model" in input ? (input.baseURL ?? (input.model.api.url || undefined)) : input.api.url || undefined
-
-const requireBaseURL = (model: Provider.Model, url: string | undefined) => {
-  if (url) return url
-  throw new Error(`Native LLM request adapter requires a base URL for ${model.providerID}/${model.id}`)
-}
-
-export const model = (input: Provider.Model | RequestInput, headers?: Record<string, string>) => {
-  const model = "model" in input ? input.model : input
-  const url = baseURL(input)
-  const options = {
-    ...("model" in input && input.apiKey ? { apiKey: input.apiKey } : {}),
-    ...(url ? { baseURL: url } : {}),
-    headers: Object.keys({ ...model.headers, ...headers }).length === 0 ? undefined : { ...model.headers, ...headers },
-    limits: {
-      context: model.limit.context,
-      output: model.limit.output,
-    },
-  }
-  if (model.api.npm === "@ai-sdk/openai") return OpenAI.configure(options).responses(model.api.id)
-  if (model.api.npm === "@ai-sdk/azure")
-    return Azure.configure({ ...options, baseURL: requireBaseURL(model, url) }).responses(model.api.id)
-  if (model.api.npm === "@ai-sdk/anthropic") return Anthropic.configure(options).model(model.api.id)
-  if (model.api.npm === "@ai-sdk/google") return Google.configure(options).model(model.api.id)
-  if (model.api.npm === "@ai-sdk/amazon-bedrock") return AmazonBedrock.configure(options).model(model.api.id)
-  if (model.api.npm === "@ai-sdk/openai-compatible")
-    return OpenAICompatible.configure({
-      ...options,
-      provider: String(model.providerID),
-      baseURL: requireBaseURL(model, url),
-    }).model(model.api.id)
-  if (model.api.npm === "@openrouter/ai-sdk-provider") return OpenRouter.configure(options).model(model.api.id)
-  throw new Error(`Native LLM request adapter does not support provider package ${model.api.npm}`)
-}
-
-export const request = (input: RequestInput) => {
-  const converted = messages(input.messages)
-  // This is the only native adapter boundary that should construct canonical
-  // @opencode-ai/llm request objects from opencode's session/AI SDK-shaped data.
-  return LLM.request({
-    model: model(input, input.headers),
-    system: [...(input.system ?? []).map(SystemPart.make), ...converted.system],
-    messages: converted.messages,
-    tools: tools(input.tools),
-    toolChoice: input.toolChoice,
-    generation: generation(input),
-    providerOptions: input.providerOptions,
-  })
-}
-
-export * as LLMNative from "./native-request"

package/src/session/llm/native-runtime.ts

@@ -1,195 +0,0 @@
-import type { Auth } from "@/auth"
-import type { Provider } from "@/provider/provider"
-import { ProviderTransform } from "@/provider/transform"
-import { errorMessage } from "@/util/error"
-import { isRecord } from "@/util/record"
-import { asSchema, type ModelMessage, type Tool } from "ai"
-import { Cause, Effect, FiberSet, Queue } from "effect"
-import * as Stream from "effect/Stream"
-import { FetchHttpClient } from "effect/unstable/http"
-import {
-  LLMRequest,
-  Tool as NativeTool,
-  ToolFailure,
-  ToolRuntime,
-  toDefinitions,
-  type JsonSchema,
-  type LLMEvent,
-} from "@opencode-ai/llm"
-import type { LLMClientShape } from "@opencode-ai/llm/route"
-import { LLMNative } from "./native-request"
-
-export type RuntimeStatus =
-  | { readonly type: "supported"; readonly apiKey: string; readonly baseURL?: string }
-  | { readonly type: "unsupported"; readonly reason: string }
-export type StreamResult =
-  | { readonly type: "supported"; readonly stream: Stream.Stream<LLMEvent, unknown> }
-  | { readonly type: "unsupported"; readonly reason: string }
-
-type StreamInput = {
-  readonly model: Provider.Model
-  readonly provider: Provider.Info
-  readonly auth: Auth.Info | undefined
-  readonly llmClient: LLMClientShape
-  readonly messages: ModelMessage[]
-  readonly tools: Record<string, Tool>
-  readonly toolChoice?: "auto" | "required" | "none"
-  readonly temperature?: number
-  readonly topP?: number
-  readonly topK?: number
-  readonly maxOutputTokens?: number
-  readonly providerOptions?: Record<string, any>
-  readonly headers: Record<string, string>
-  readonly abort: AbortSignal
-}
-
-export function status(input: Pick<StreamInput, "model" | "provider" | "auth">): RuntimeStatus {
-  return statusWithFetch(input, providerFetch(input))
-}
-
-function statusWithFetch(
-  input: Pick<StreamInput, "model" | "provider" | "auth">,
-  fetch: typeof globalThis.fetch | undefined,
-): RuntimeStatus {
-  const providerID = input.model.providerID
-  if (providerID !== "openai" && providerID !== "anthropic" && !providerID.startsWith("opencode"))
-    return { type: "unsupported", reason: "provider is not openai, opencode, or anthropic" }
-  const npm = input.model.api.npm
-  if (npm !== "@ai-sdk/openai" && npm !== "@ai-sdk/openai-compatible" && npm !== "@ai-sdk/anthropic")
-    return { type: "unsupported", reason: "provider package is not OpenAI, OpenAI-compatible, or Anthropic" }
-  if (input.auth?.type === "oauth" && !(input.provider.id === "openai" && fetch)) {
-    return { type: "unsupported", reason: "OAuth auth requires a provider fetch override" }
-  }
-
-  const apiKey = typeof input.provider.options.apiKey === "string" ? input.provider.options.apiKey : input.provider.key
-  if (!apiKey) return { type: "unsupported", reason: "API key is not configured" }
-
-  return {
-    type: "supported",
-    apiKey,
-    baseURL: typeof input.provider.options.baseURL === "string" ? input.provider.options.baseURL : undefined,
-  }
-}
-
-export function stream(input: StreamInput): StreamResult {
-  const fetch = providerFetch(input)
-  const current = statusWithFetch(input, fetch)
-  if (current.type === "unsupported") return current
-
-  // Integration point with @opencode-ai/llm: native-request lowers session data
-  // into an LLMRequest, then LLMClient handles route selection and transport.
-  //
-  // ProviderTransform.providerOptions builds AI-SDK-shaped options for the
-  // selected SDK key (e.g. "openai") and the native LLM SDK reads the same
-  // keys via OpenAIOptions.* (store, reasoningEffort, reasoningSummary,
-  // include, textVerbosity, promptCacheKey). Both sides intentionally use
-  // OpenAI's official wire field names, so this is identity, not translation
-  // — if a field ever needs to differ between the two surfaces, the
-  // translation belongs here, not split across both packages.
-  const tools = nativeTools(input.tools, input)
-  const request = LLMNative.request({
-    model: input.model,
-    apiKey: current.apiKey,
-    baseURL: current.baseURL,
-    messages: ProviderTransform.message(input.messages, input.model, input.providerOptions ?? {}),
-    toolChoice: input.toolChoice,
-    temperature: input.temperature,
-    topP: input.topP,
-    topK: input.topK,
-    maxOutputTokens: input.maxOutputTokens,
-    providerOptions: ProviderTransform.providerOptions(input.model, input.providerOptions ?? {}),
-    headers: { ...providerHeaders(input.provider.options.headers), ...input.headers },
-  })
-  const stream = Stream.scoped(
-    Stream.unwrap(
-      Effect.gen(function* () {
-        const settlements = yield* FiberSet.make<void>()
-        const results = yield* Queue.unbounded<LLMEvent, Cause.Done>()
-        const provider = input.llmClient
-          .stream(
-            LLMRequest.update(request, {
-              tools: [...request.tools, ...toDefinitions(tools)],
-            }),
-          )
-          .pipe(
-            Stream.flatMap((event) =>
-              event.type !== "tool-call" || event.providerExecuted
-                ? Stream.make(event)
-                : Stream.make(event).pipe(
-                    Stream.concat(
-                      Stream.fromEffectDrain(
-                        ToolRuntime.dispatch(tools, event).pipe(
-                          Effect.flatMap((dispatched) => Queue.offerAll(results, dispatched.events)),
-                          Effect.catchCause((cause) => Queue.failCause(results, cause)),
-                          Effect.asVoid,
-                          FiberSet.run(settlements, { startImmediately: true }),
-                        ),
-                      ),
-                    ),
-                  ),
-            ),
-            Stream.concat(
-              Stream.fromEffectDrain(
-                FiberSet.awaitEmpty(settlements).pipe(Effect.andThen(Queue.end(results)), Effect.asVoid),
-              ),
-            ),
-          )
-        return provider.pipe(Stream.concat(Stream.fromQueue(results)))
-      }),
-    ),
-  )
-
-  return {
-    ...current,
-    stream: fetch ? stream.pipe(Stream.provideService(FetchHttpClient.Fetch, fetch)) : stream,
-  }
-}
-
-function providerFetch(input: Pick<StreamInput, "provider" | "auth">): typeof globalThis.fetch | undefined {
-  if (input.provider.id !== "openai" || input.auth?.type !== "oauth") return undefined
-  const value: unknown = input.provider.options.fetch
-  if (typeof value !== "function") return undefined
-  return value as typeof globalThis.fetch
-}
-
-function providerHeaders(value: unknown): Record<string, string> | undefined {
-  if (!isRecord(value)) return undefined
-  return Object.fromEntries(
-    Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
-  )
-}
-
-function nativeSchema(value: unknown): JsonSchema {
-  if (!value || typeof value !== "object") return { type: "object", properties: {} }
-  if ("jsonSchema" in value && value.jsonSchema && typeof value.jsonSchema === "object")
-    return value.jsonSchema as JsonSchema
-  return asSchema(value as Parameters<typeof asSchema>[0]).jsonSchema as JsonSchema
-}
-
-export function nativeTools(tools: Record<string, Tool>, input: Pick<StreamInput, "messages" | "abort">) {
-  return Object.fromEntries(
-    Object.entries(tools).map(([name, item]) => [
-      name,
-      // Tool execution remains opencode-owned. The native runtime only adapts
-      // the @opencode-ai/llm tool call back into the AI SDK Tool.execute shape.
-      NativeTool.make({
-        description: item.description ?? "",
-        jsonSchema: nativeSchema(item.inputSchema),
-        execute: (args: unknown, ctx) =>
-          Effect.tryPromise({
-            try: () => {
-              if (!item.execute) throw new Error(`Tool has no execute handler: ${name}`)
-              return item.execute(args, {
-                toolCallId: ctx?.id ?? name,
-                messages: input.messages,
-                abortSignal: input.abort,
-              })
-            },
-            catch: (error) => new ToolFailure({ message: errorMessage(error), error }),
-          }),
-      }),
-    ]),
-  )
-}
-
-export * as LLMNativeRuntime from "./native-runtime"

package/src/session/llm/request.ts

@@ -1,216 +0,0 @@
-import { PermissionV1 } from "@opencode-ai/core/v1/permission"
-import type { Auth } from "@/auth"
-import { SessionV1 } from "@opencode-ai/core/v1/session"
-import type { RuntimeFlags } from "@/effect/runtime-flags"
-import { InstanceState } from "@/effect/instance-state"
-import { Permission } from "@/permission"
-import type { Agent } from "@/agent/agent"
-import type { MessageV2 } from "../message-v2"
-import type { Provider } from "@/provider/provider"
-import { ProviderTransform } from "@/provider/transform"
-import { SystemPrompt } from "../system"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { Effect, Record } from "effect"
-import { jsonSchema, tool as aiTool, type ModelMessage, type Tool } from "ai"
-import type { Plugin } from "@/plugin"
-import { mergeDeep } from "remeda"
-
-const USER_AGENT = `opencode/${InstallationVersion}`
-
-type PrepareInput = {
-  readonly user: SessionV1.User
-  readonly sessionID: string
-  readonly parentSessionID?: string
-  readonly model: Provider.Model
-  readonly agent: Agent.Info
-  readonly permission?: PermissionV1.Ruleset
-  readonly system: string[]
-  readonly messages: ModelMessage[]
-  readonly small?: boolean
-  readonly tools: Record<string, Tool>
-  readonly provider: Provider.Info
-  readonly auth: Auth.Info | undefined
-  readonly plugin: Plugin.Interface
-  readonly flags: RuntimeFlags.Info
-  readonly isWorkflow: boolean
-}
-
-export type Prepared = {
-  readonly system: string[]
-  readonly messages: ModelMessage[]
-  readonly tools: Record<string, Tool>
-  readonly params: {
-    readonly temperature?: number
-    readonly topP?: number
-    readonly topK?: number
-    readonly maxOutputTokens?: number
-    readonly options: Record<string, any>
-  }
-  readonly messageTransformOptions: Record<string, any>
-  readonly headers: Record<string, string>
-}
-
-const mergeOptions = (target: Record<string, any>, source: Record<string, any> | undefined): Record<string, any> =>
-  mergeDeep(target, source ?? {}) as Record<string, any>
-
-export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: PrepareInput) {
-  const isOpenaiOauth = input.provider.id === "openai" && input.auth?.type === "oauth"
-  const system = [
-    [
-      ...(input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(input.model)),
-      ...input.system,
-      ...(input.user.system ? [input.user.system] : []),
-    ]
-      .filter((x) => x)
-      .join("\n"),
-  ]
-
-  const header = system[0]
-  yield* input.plugin.trigger(
-    "experimental.chat.system.transform",
-    { sessionID: input.sessionID, model: input.model },
-    { system },
-  )
-  if (system.length > 2 && system[0] === header) {
-    const rest = system.slice(1)
-    system.length = 0
-    system.push(header, rest.join("\n"))
-  }
-
-  const variant =
-    !input.small && input.model.variants && input.user.model.variant
-      ? input.model.variants[input.user.model.variant]
-      : {}
-  const base = input.small
-    ? ProviderTransform.smallOptions(input.model)
-    : ProviderTransform.options({
-        model: input.model,
-        sessionID: input.sessionID,
-        providerOptions: input.provider.options,
-      })
-  const options = mergeOptions(mergeOptions(mergeOptions(base, input.model.options), input.agent.options), variant)
-  if (
-    input.model.api.npm === "@ai-sdk/azure" &&
-    (input.provider.options.useCompletionUrls || input.model.options.useCompletionUrls || options.useCompletionUrls)
-  ) {
-    delete options.reasoningSummary
-    delete options.include
-  }
-  if (isOpenaiOauth) options.instructions = system.join("\n")
-
-  const messages =
-    isOpenaiOauth || input.isWorkflow
-      ? input.messages
-      : [
-          ...system.map(
-            (x): ModelMessage => ({
-              role: "system",
-              content: x,
-            }),
-          ),
-          ...input.messages,
-        ]
-
-  const params = yield* input.plugin.trigger(
-    "chat.params",
-    {
-      sessionID: input.sessionID,
-      agent: input.agent.name,
-      model: input.model,
-      provider: input.provider,
-      message: input.user,
-    },
-    {
-      temperature: input.model.capabilities.temperature
-        ? (input.agent.temperature ?? ProviderTransform.temperature(input.model))
-        : undefined,
-      topP: input.agent.topP ?? ProviderTransform.topP(input.model),
-      topK: ProviderTransform.topK(input.model),
-      maxOutputTokens: ProviderTransform.maxOutputTokens(input.model, input.flags.outputTokenMax),
-      options,
-    },
-  )
-
-  const { headers } = yield* input.plugin.trigger(
-    "chat.headers",
-    {
-      sessionID: input.sessionID,
-      agent: input.agent.name,
-      model: input.model,
-      provider: input.provider,
-      message: input.user,
-    },
-    {
-      headers: {},
-    },
-  )
-
-  const tools = resolveTools(input)
-  if (
-    input.model.providerID.includes("github-copilot") &&
-    Object.keys(tools).length === 0 &&
-    hasToolCalls(input.messages)
-  ) {
-    // Copilot needs a tools field when replaying prior tool calls, even if no tools are currently enabled.
-    tools["_noop"] = aiTool({
-      description: "Do not call this tool. It exists only for API compatibility and must never be invoked.",
-      inputSchema: jsonSchema({
-        type: "object",
-        properties: {
-          reason: { type: "string", description: "Unused" },
-        },
-      }),
-      execute: async () => ({ output: "", title: "", metadata: {} }),
-    })
-  }
-
-  const opencodeProjectID = input.model.providerID.startsWith("opencode")
-    ? (yield* InstanceState.context).project.id
-    : undefined
-
-  return {
-    system,
-    messages,
-    tools: Object.fromEntries(Object.entries(tools).toSorted(([a], [b]) => a.localeCompare(b))),
-    params,
-    messageTransformOptions: options,
-    headers: {
-      ...(input.model.providerID.startsWith("opencode")
-        ? {
-            ...(opencodeProjectID ? { "x-opencode-project": opencodeProjectID } : {}),
-            "x-opencode-session": input.sessionID,
-            "x-opencode-request": input.user.id,
-            "x-opencode-client": input.flags.client,
-            "User-Agent": USER_AGENT,
-          }
-        : {
-            "x-session-affinity": input.sessionID,
-            "X-Session-Id": input.sessionID,
-            ...(input.parentSessionID ? { "x-parent-session-id": input.parentSessionID } : {}),
-            "User-Agent": USER_AGENT,
-          }),
-      ...input.model.headers,
-      ...headers,
-    },
-  }
-})
-
-function resolveTools(input: Pick<PrepareInput, "tools" | "agent" | "permission" | "user">) {
-  const disabled = Permission.disabled(
-    Object.keys(input.tools),
-    Permission.merge(input.agent.permission, input.permission ?? []),
-  )
-  return Record.filter(input.tools, (_, k) => input.user.tools?.[k] !== false && !disabled.has(k))
-}
-
-export function hasToolCalls(messages: ModelMessage[]): boolean {
-  for (const msg of messages) {
-    if (!Array.isArray(msg.content)) continue
-    for (const part of msg.content) {
-      if (part.type === "tool-call" || part.type === "tool-result") return true
-    }
-  }
-  return false
-}
-
-export * as LLMRequestPrep from "./request"