saeeol 1.4.2 → 1.4.3

package/src/project/vcs.ts

@@ -1,230 +0,0 @@
-import { Effect, Layer, Context, Schema, Stream, Scope } from "effect"
-import { formatPatch, structuredPatch } from "diff"
-import path from "path"
-import { Bus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { InstanceState } from "@/effect/instance-state"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { FileWatcher } from "@/file/watcher"
-import { Git } from "@/git"
-import * as Log from "@saeeol/core/util/log"
-import { zod } from "@/util/effect-zod"
-import { makeRuntime } from "@/effect/run-service" 
-import { NonNegativeInt, withStatics } from "@/util/schema"
-
-const log = Log.create({ service: "vcs" })
-
-const count = (text: string) => {
-  if (!text) return 0
-  if (!text.endsWith("\n")) return text.split("\n").length
-  return text.slice(0, -1).split("\n").length
-}
-
-const work = Effect.fnUntraced(function* (fs: AppFileSystem.Interface, cwd: string, file: string) {
-  const full = path.join(cwd, file)
-  if (!(yield* fs.exists(full).pipe(Effect.orDie))) return ""
-  const buf = yield* fs.readFile(full).pipe(Effect.catch(() => Effect.succeed(new Uint8Array())))
-  if (Buffer.from(buf).includes(0)) return ""
-  return Buffer.from(buf).toString("utf8")
-})
-
-const nums = (list: Git.Stat[]) =>
-  new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }] as const))
-
-const merge = (...lists: Git.Item[][]) => {
-  const out = new Map<string, Git.Item>()
-  lists.flat().forEach((item) => {
-    if (!out.has(item.file)) out.set(item.file, item)
-  })
-  return [...out.values()]
-}
-
-const files = Effect.fnUntraced(function* (
-  fs: AppFileSystem.Interface,
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-  list: Git.Item[],
-  map: Map<string, { additions: number; deletions: number }>,
-) {
-  const base = ref ? yield* git.prefix(cwd) : ""
-  const patch = (file: string, before: string, after: string) =>
-    formatPatch(structuredPatch(file, file, before, after, "", "", { context: Number.MAX_SAFE_INTEGER }))
-  const next = yield* Effect.forEach(
-    list,
-    (item) =>
-      Effect.gen(function* () {
-        const before = item.status === "added" || !ref ? "" : yield* git.show(cwd, ref, item.file, base)
-        const after = item.status === "deleted" ? "" : yield* work(fs, cwd, item.file)
-        const stat = map.get(item.file)
-        return {
-          file: item.file,
-          patch: patch(item.file, before, after),
-          additions: stat?.additions ?? (item.status === "added" ? count(after) : 0),
-          deletions: stat?.deletions ?? (item.status === "deleted" ? count(before) : 0),
-          status: item.status,
-        } satisfies FileDiff
-      }),
-    { concurrency: 8 },
-  )
-  return next.toSorted((a, b) => a.file.localeCompare(b.file))
-})
-
-const track = Effect.fnUntraced(function* (
-  fs: AppFileSystem.Interface,
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-) {
-  if (!ref) return yield* files(fs, git, cwd, ref, yield* git.status(cwd), new Map())
-  const [list, stats] = yield* Effect.all([git.status(cwd), git.stats(cwd, ref)], { concurrency: 2 })
-  return yield* files(fs, git, cwd, ref, list, nums(stats))
-})
-
-const compare = Effect.fnUntraced(function* (
-  fs: AppFileSystem.Interface,
-  git: Git.Interface,
-  cwd: string,
-  ref: string,
-) {
-  const [list, stats, extra] = yield* Effect.all([git.diff(cwd, ref), git.stats(cwd, ref), git.status(cwd)], {
-    concurrency: 3,
-  })
-  return yield* files(
-    fs,
-    git,
-    cwd,
-    ref,
-    merge(
-      list,
-      extra.filter((item) => item.code === "??"),
-    ),
-    nums(stats),
-  )
-})
-
-export const Mode = Schema.Literals(["git", "branch"]).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Mode = Schema.Schema.Type<typeof Mode>
-
-export const Event = {
-  BranchUpdated: BusEvent.define(
-    "vcs.branch.updated",
-    Schema.Struct({
-      branch: Schema.optional(Schema.String),
-    }),
-  ),
-}
-
-export const Info = Schema.Struct({
-  branch: Schema.optional(Schema.String),
-  default_branch: Schema.optional(Schema.String),
-})
-  .annotate({ identifier: "VcsInfo" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const FileDiff = Schema.Struct({
-  file: Schema.String,
-  patch: Schema.String,
-  additions: NonNegativeInt,
-  deletions: NonNegativeInt,
-  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
-})
-  .annotate({ identifier: "VcsFileDiff" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type FileDiff = Schema.Schema.Type<typeof FileDiff>
-
-export interface Interface {
-  readonly init: () => Effect.Effect<void>
-  readonly branch: () => Effect.Effect<string | undefined>
-  readonly defaultBranch: () => Effect.Effect<string | undefined>
-  readonly diff: (mode: Mode) => Effect.Effect<FileDiff[]>
-}
-
-interface State {
-  current: string | undefined
-  root: Git.Base | undefined
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/Vcs") {}
-
-export const layer: Layer.Layer<Service, never, AppFileSystem.Service | Git.Service | Bus.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const git = yield* Git.Service
-    const bus = yield* Bus.Service
-    const scope = yield* Scope.Scope
-
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Vcs.state")(function* (ctx) {
-        if (ctx.project.vcs !== "git") {
-          return { current: undefined, root: undefined }
-        }
-
-        const get = Effect.fnUntraced(function* () {
-          return yield* git.branch(ctx.directory)
-        })
-        const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
-          concurrency: 2,
-        })
-        const value = { current, root }
-        log.info("initialized", { branch: value.current, default_branch: value.root?.name })
-
-        yield* bus.subscribe(FileWatcher.Event.Updated).pipe(
-          Stream.filter((evt) => evt.properties.file.endsWith("HEAD")),
-          Stream.runForEach((_evt) =>
-            Effect.gen(function* () {
-              const next = yield* get()
-              if (next !== value.current) {
-                log.info("branch changed", { from: value.current, to: next })
-                value.current = next
-                yield* bus.publish(Event.BranchUpdated, { branch: next })
-              }
-            }),
-          ),
-          Effect.forkScoped,
-        )
-
-        return value
-      }),
-    )
-
-    return Service.of({
-      init: Effect.fn("Vcs.init")(function* () {
-        yield* InstanceState.get(state).pipe(Effect.forkIn(scope))
-      }),
-      branch: Effect.fn("Vcs.branch")(function* () {
-        return yield* InstanceState.use(state, (x) => x.current)
-      }),
-      defaultBranch: Effect.fn("Vcs.defaultBranch")(function* () {
-        return yield* InstanceState.use(state, (x) => x.root?.name)
-      }),
-      diff: Effect.fn("Vcs.diff")(function* (mode: Mode) {
-        const value = yield* InstanceState.get(state)
-        const ctx = yield* InstanceState.context
-        if (ctx.project.vcs !== "git") return []
-        if (mode === "git") {
-          return yield* track(fs, git, ctx.directory, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined)
-        }
-
-        if (!value.root) return []
-        if (value.current && value.current === value.root.name) return []
-        const ref = yield* git.mergeBase(ctx.directory, value.root.ref)
-        if (!ref) return []
-        return yield* compare(fs, git, ctx.directory, ref)
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(Git.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Bus.layer),
-)
-const { runPromise } = makeRuntime(Service, defaultLayer)
-export const branch = () => runPromise((svc) => svc.branch())
-export const defaultBranch = () => runPromise((svc) => svc.defaultBranch())
-
-export * as Vcs from "./vcs"

package/src/provider/auth.ts

@@ -1,243 +0,0 @@
-import type { AuthOAuthResult, Hooks } from "@saeeol/plugin"
-import { Auth } from "@/auth"
-import { InstanceState } from "@/effect/instance-state"
-import { zod } from "@/util/effect-zod"
-import { namedSchemaError } from "@/util/named-schema-error"
-import { optionalOmitUndefined, withStatics } from "@/util/schema"
-import { Plugin } from "../plugin"
-import { ProviderID } from "./schema"
-import { Array as Arr, Effect, Layer, Record, Result, Context, Schema } from "effect"
-import { Telemetry } from "@saeeol/telemetry"
-import { ModelCache } from "./model-cache"
-import { Instance } from "@/project/instance"
-import { InstanceStore } from "@/project/instance-store"
-
-const When = Schema.Struct({
-  key: Schema.String,
-  op: Schema.Literals(["eq", "neq"]),
-  value: Schema.String,
-})
-
-const TextPrompt = Schema.Struct({
-  type: Schema.Literal("text"),
-  key: Schema.String,
-  message: Schema.String,
-  placeholder: optionalOmitUndefined(Schema.String),
-  when: optionalOmitUndefined(When),
-})
-
-const SelectOption = Schema.Struct({
-  label: Schema.String,
-  value: Schema.String,
-  hint: optionalOmitUndefined(Schema.String),
-})
-
-const SelectPrompt = Schema.Struct({
-  type: Schema.Literal("select"),
-  key: Schema.String,
-  message: Schema.String,
-  options: Schema.Array(SelectOption),
-  when: optionalOmitUndefined(When),
-})
-
-const Prompt = Schema.Union([TextPrompt, SelectPrompt])
-
-export class Method extends Schema.Class<Method>("ProviderAuthMethod")({
-  type: Schema.Literals(["oauth", "api"]),
-  label: Schema.String,
-  prompts: optionalOmitUndefined(Schema.Array(Prompt)),
-}) {
-  static readonly zod = zod(this)
-}
-
-export const Methods = Schema.Record(Schema.String, Schema.Array(Method)).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Methods = typeof Methods.Type
-
-export class Authorization extends Schema.Class<Authorization>("ProviderAuthAuthorization")({
-  url: Schema.String,
-  method: Schema.Literals(["auto", "code"]),
-  instructions: Schema.String,
-}) {
-  static readonly zod = zod(this)
-}
-
-export const AuthorizeInput = Schema.Struct({
-  method: Schema.Finite.annotate({ description: "Auth method index" }),
-  inputs: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({ description: "Prompt inputs" }),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type AuthorizeInput = Schema.Schema.Type<typeof AuthorizeInput>
-
-export const CallbackInput = Schema.Struct({
-  method: Schema.Finite.annotate({ description: "Auth method index" }),
-  code: Schema.optional(Schema.String).annotate({ description: "OAuth authorization code" }),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type CallbackInput = Schema.Schema.Type<typeof CallbackInput>
-
-export const OauthMissing = namedSchemaError("ProviderAuthOauthMissing", { providerID: ProviderID })
-
-export const OauthCodeMissing = namedSchemaError("ProviderAuthOauthCodeMissing", { providerID: ProviderID })
-
-export const OauthCallbackFailed = namedSchemaError("ProviderAuthOauthCallbackFailed", {})
-
-export const ValidationFailed = namedSchemaError("ProviderAuthValidationFailed", {
-  field: Schema.String,
-  message: Schema.String,
-})
-
-export type Error =
-  | Auth.AuthError
-  | InstanceType<typeof OauthMissing>
-  | InstanceType<typeof OauthCodeMissing>
-  | InstanceType<typeof OauthCallbackFailed>
-  | InstanceType<typeof ValidationFailed>
-
-type Hook = NonNullable<Hooks["auth"]>
-
-export interface Interface {
-  readonly methods: () => Effect.Effect<Methods>
-  readonly authorize: (
-    input: {
-      providerID: ProviderID
-    } & AuthorizeInput,
-  ) => Effect.Effect<Authorization | undefined, Error>
-  readonly callback: (input: { providerID: ProviderID } & CallbackInput) => Effect.Effect<void, Error>
-}
-
-interface State {
-  hooks: Record<ProviderID, Hook>
-  pending: Map<ProviderID, AuthOAuthResult>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/ProviderAuth") {}
-
-export const layer: Layer.Layer<Service, never, Auth.Service | Plugin.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const auth = yield* Auth.Service
-    const plugin = yield* Plugin.Service
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("ProviderAuth.state")(function* () {
-        const plugins = yield* plugin.list()
-        return {
-          hooks: Record.fromEntries(
-            Arr.filterMap(plugins, (x) =>
-              x.auth?.provider !== undefined
-                ? Result.succeed([ProviderID.make(x.auth.provider), x.auth] as const)
-                : Result.failVoid,
-            ),
-          ),
-          pending: new Map<ProviderID, AuthOAuthResult>(),
-        }
-      }),
-    )
-
-    const decode = Schema.decodeUnknownSync(Methods)
-    const methods = Effect.fn("ProviderAuth.methods")(function* () {
-      const hooks = (yield* InstanceState.get(state)).hooks
-      return decode(
-        Record.map(hooks, (item) =>
-          item.methods.map((method) => ({
-            type: method.type,
-            label: method.label,
-            ...(method.prompts && {
-              prompts: method.prompts.map((prompt) => {
-                if (prompt.type === "select") {
-                  return {
-                    type: "select" as const,
-                    key: prompt.key,
-                    message: prompt.message,
-                    options: prompt.options,
-                    ...(prompt.when && { when: prompt.when }),
-                  }
-                }
-                return {
-                  type: "text" as const,
-                  key: prompt.key,
-                  message: prompt.message,
-                  ...(prompt.placeholder && { placeholder: prompt.placeholder }),
-                  ...(prompt.when && { when: prompt.when }),
-                }
-              }),
-            }),
-          })),
-        ),
-      )
-    })
-
-    const authorize = Effect.fn("ProviderAuth.authorize")(function* (
-      input: { providerID: ProviderID } & AuthorizeInput,
-    ) {
-      const { hooks, pending } = yield* InstanceState.get(state)
-      const method = hooks[input.providerID].methods[input.method]
-      if (method.type !== "oauth") return
-
-      if (method.prompts && input.inputs) {
-        for (const prompt of method.prompts) {
-          if (prompt.type === "text" && prompt.validate && input.inputs[prompt.key] !== undefined) {
-            const error = prompt.validate(input.inputs[prompt.key])
-            if (error) return yield* Effect.fail(new ValidationFailed({ field: prompt.key, message: error }))
-          }
-        }
-      }
-
-      const result = yield* Effect.promise(() => method.authorize(input.inputs))
-      pending.set(input.providerID, result)
-      return {
-        url: result.url,
-        method: result.method,
-        instructions: result.instructions,
-      }
-    })
-
-    const callback = Effect.fn("ProviderAuth.callback")(function* (input: { providerID: ProviderID } & CallbackInput) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const match = pending.get(input.providerID)
-      if (!match) return yield* Effect.fail(new OauthMissing({ providerID: input.providerID }))
-      if (match.method === "code" && !input.code) {
-        return yield* Effect.fail(new OauthCodeMissing({ providerID: input.providerID }))
-      }
-
-      const result = yield* Effect.promise(() =>
-        match.method === "code" ? match.callback(input.code!) : match.callback(),
-      )
-      if (!result || result.type !== "success") return yield* Effect.fail(new OauthCallbackFailed({}))
-
-      if ("key" in result) {
-        yield* auth.set(input.providerID, {
-          type: "api",
-          key: result.key,
-        })
-      }
-
-      if ("refresh" in result) {
-        const { type: _, provider: __, refresh, access, expires, ...extra } = result
-        yield* auth.set(input.providerID, {
-          type: "oauth",
-          access,
-          refresh,
-          expires,
-          ...extra,
-        })
-      }
-      if (input.providerID === "saeeol") {
-        const info = yield* auth.get(input.providerID)
-        if (info) {
-          const token = info.type === "oauth" ? info.access : info.type === "api" ? info.key : null
-          const accountId = info.type === "oauth" ? info.accountId : undefined
-          yield* Effect.promise(() => Telemetry.updateIdentity(token, accountId))
-        }
-      }
-      Telemetry.trackAuthSuccess(input.providerID)
-      ModelCache.clear(input.providerID)
-      yield* Effect.promise(() => InstanceStore.disposeAllInstances())
-    })
-
-    return Service.of({ methods, authorize, callback })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(Layer.provide(Auth.defaultLayer), Layer.provide(Plugin.defaultLayer)),
-)
-
-export * as ProviderAuth from "./auth"

package/src/provider/bundled-providers.ts

@@ -1,41 +0,0 @@
-import type { BundledSDK } from "./provider-types"
-
-export function shouldUseCopilotResponsesApi(modelID: string): boolean {
-  const match = /^gpt-(\d+)/.exec(modelID)
-  if (!match) return false
-  return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")
-}
-
-export function useLanguageModel(sdk: any) {
-  return sdk.responses === undefined && sdk.chat === undefined
-}
-
-// ╔══════════════════════════════════════════════════════════════════╗
-// ║  티어별 provider 로딩                                            ║
-// ║                                                                   ║
-// ║  SAEEOL_TIER는 build.ts define으로 "light"|"code"|"master" 주입    ║
-// ║  Bun은 dead branch를 제거하므로 다른 티어의 import()가 제외됨      ║
-// ╚══════════════════════════════════════════════════════════════════╝
-
-declare const SAEEOL_TIER: string
-
-type ProviderLoader = () => Promise<(opts: any) => BundledSDK>
-
-// 티어별 파일에서 각각 서로 다른 provider 집합을 import
-// Bun은 조건에 맞지 않는 branch의 import()를 dead code로 처리
-
-function getProviders(): Record<string, ProviderLoader> {
-  const tier = typeof SAEEOL_TIER === "string" ? SAEEOL_TIER : "master"
-  if (tier === "light") {
-    const m = require("./tiers/light") as typeof import("./tiers/light")
-    return m.lightProviders
-  }
-  if (tier === "code") {
-    const m = require("./tiers/code") as typeof import("./tiers/code")
-    return m.codeProviders
-  }
-  const m = require("./tiers/master") as typeof import("./tiers/master")
-  return m.masterProviders
-}
-
-export const BUNDLED_PROVIDERS: Record<string, ProviderLoader> = getProviders()

package/src/provider/custom-loaders.ts

@@ -1,175 +0,0 @@
-import { Effect } from "effect"
-import type { CustomDep, CustomLoader } from "./provider-types"
-import type { Info } from "./provider-schema"
-import { useLanguageModel } from "./bundled-providers"
-import { cloudLoaders } from "./loader-cloud"
-import { platformLoaders } from "./loader-platform"
-import { localLoaders } from "./loader-local"
-import { iife } from "@/util/iife"
-
-export function custom(dep: CustomDep): Record<string, CustomLoader> {
-  return {
-    ...localLoaders(dep),
-    ...cloudLoaders(dep),
-    ...platformLoaders(dep),
-    anthropic: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "anthropic-beta": "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
-          },
-        },
-      }),
-    saeeol: Effect.fnUntraced(function* (input: Info) {
-      const env = yield* dep.env()
-      const hasKey = iife(() => {
-        if (input.env.some((item) => env[item])) return true
-        return false
-      })
-      const ok =
-        hasKey ||
-        Boolean(yield* dep.auth(input.id)) ||
-        Boolean((yield* dep.config()).provider?.["saeeol"]?.options?.apiKey)
-
-      if (!ok) {
-        for (const [key, value] of Object.entries(input.models)) {
-          if (value.cost.input === 0) continue
-          delete input.models[key]
-        }
-      }
-
-      return {
-        autoload: Object.keys(input.models).length > 0,
-        options: ok ? {} : { apiKey: "public" },
-      }
-    }),
-    openai: () =>
-      Effect.succeed({
-        autoload: false,
-        async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {
-          return sdk.responses(modelID)
-        },
-        options: {},
-      }),
-    xai: () =>
-      Effect.succeed({
-        autoload: false,
-        async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {
-          return sdk.responses(modelID)
-        },
-        options: {},
-      }),
-    llmgateway: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "HTTP-Referer": "https://saeeol.ai/", 
-            "X-Title": "SAEEOL", 
-            "X-Source": "saeeol", 
-          },
-        },
-      }),
-    openrouter: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "HTTP-Referer": "https://saeeol.ai/", 
-            "X-Title": "SAEEOL", 
-          },
-        },
-      }),
-    nvidia: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "HTTP-Referer": "https://saeeol.ai/", 
-            "X-Title": "SAEEOL", 
-            "X-BILLING-INVOKE-ORIGIN": "SaeeolCode", 
-          },
-        },
-      }),
-    vercel: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "http-referer": "https://saeeol.ai/", 
-            "x-title": "SAEEOL", 
-          },
-        },
-      }),
-    "google-vertex-anthropic": Effect.fnUntraced(function* () {
-      const env = yield* dep.env()
-      const project = env["GOOGLE_CLOUD_PROJECT"] ?? env["GCP_PROJECT"] ?? env["GCLOUD_PROJECT"]
-      const location = env["GOOGLE_CLOUD_LOCATION"] ?? env["VERTEX_LOCATION"] ?? "global"
-      const autoload = Boolean(project)
-      if (!autoload) return { autoload: false }
-      return {
-        autoload: true,
-        options: {
-          project,
-          location,
-        },
-        async getModel(sdk: any, modelID) {
-          const id = String(modelID).trim()
-          return sdk.languageModel(id)
-        },
-      }
-    }),
-    "sap-ai-core": Effect.fnUntraced(function* () {
-      const auth = yield* dep.auth("sap-ai-core")
-      const envServiceKey = iife(() => {
-        const envAICoreServiceKey = process.env.AICORE_SERVICE_KEY
-        if (envAICoreServiceKey) return envAICoreServiceKey
-        if (auth?.type === "api") {
-          process.env.AICORE_SERVICE_KEY = auth.key
-          return auth.key
-        }
-        return undefined
-      })
-      const deploymentId = process.env.AICORE_DEPLOYMENT_ID
-      const resourceGroup = process.env.AICORE_RESOURCE_GROUP
-
-      return {
-        autoload: !!envServiceKey,
-        options: envServiceKey ? { deploymentId, resourceGroup } : {},
-        async getModel(sdk: any, modelID: string) {
-          return sdk(modelID)
-        },
-      }
-    }),
-    zenmux: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "HTTP-Referer": "https://saeeol.ai/", 
-            "X-Title": "SAEEOL", 
-          },
-        },
-      }),
-    cerebras: () =>
-      Effect.succeed({
-        autoload: false,
-        options: {
-          headers: {
-            "X-Cerebras-3rd-Party-Integration": "SAEEOL", 
-          },
-        },
-      }),
-  }
-}
-
-// Provider ID lists by category
-export const LOCAL_PROVIDERS = ["ollama", "lmstudio", "vllm", "text-generation-webui", "llama.cpp"] as const
-export const CUSTOM_PROVIDERS = ["llmgateway", "openrouter", "nvidia", "vercel", "zenmux", "cerebras"] as const
-export const CLOUD_PROVIDERS = [
-  "anthropic", "openai", "xai", "saeeol",
-  "azure", "azure-cognitive-services", "amazon-bedrock",
-  "google-vertex", "google-vertex-anthropic", "sap-ai-core",
-  "gitlab", "cloudflare-workers-ai", "cloudflare-ai-gateway", "github-copilot",
-] as const