saeeol 1.0.0 → 1.0.2

package/package.json

@@ -1,9 +1,13 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "name": "saeeol",
   "type": "module",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/byfabulist/saeeol"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"

package/src/cli/cmd/init.ts

@@ -0,0 +1,325 @@
+import fs from "fs/promises"
+import path from "path"
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "@saeeol/core/global"
+import { Instance } from "../../project/instance"
+import { Auth } from "../../auth"
+import { AppRuntime } from "../../effect/app-runtime"
+import { Config } from "@/config/config"
+import { Effect } from "effect"
+import { put } from "./providers-auth"
+
+const { TEXT_HIGHLIGHT: H, TEXT_NORMAL: N, TEXT_DIM: D, TEXT_SUCCESS: S, TEXT_NORMAL_BOLD: B, TEXT_WARNING: W } = UI.Style
+
+interface Preset {
+  id: string
+  label: string
+  provider: string
+  envVar: string
+  models: Array<{ id: string; label: string }>
+  hint: string
+  defaultModel?: string
+}
+
+const presets: Preset[] = [
+  {
+    id: "anthropic",
+    label: "Anthropic (Claude)",
+    provider: "anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    models: [
+      { id: "anthropic/claude-sonnet-4", label: "Claude Sonnet 4 (추천)" },
+      { id: "anthropic/claude-haiku-4-5", label: "Claude Haiku 4.5 (빠름/저렴)" },
+      { id: "anthropic/claude-opus-4", label: "Claude Opus 4 (강력)" },
+    ],
+    hint: "https://console.anthropic.com/settings/keys",
+    defaultModel: "anthropic/claude-sonnet-4",
+  },
+  {
+    id: "openai",
+    label: "OpenAI (GPT)",
+    provider: "openai",
+    envVar: "OPENAI_API_KEY",
+    models: [
+      { id: "openai/gpt-5", label: "GPT-5" },
+      { id: "openai/gpt-5-mini", label: "GPT-5 Mini (빠름)" },
+      { id: "openai/o3", label: "o3 (추론)" },
+    ],
+    hint: "https://platform.openai.com/api-keys",
+  },
+  {
+    id: "google",
+    label: "Google (Gemini)",
+    provider: "google",
+    envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
+    models: [
+      { id: "google/gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+      { id: "google/gemini-2.5-flash", label: "Gemini 2.5 Flash (빠름)" },
+    ],
+    hint: "https://aistudio.google.com/apikey",
+  },
+  {
+    id: "openrouter",
+    label: "OpenRouter (멀티 provider)",
+    provider: "openrouter",
+    envVar: "OPENROUTER_API_KEY",
+    models: [
+      { id: "openrouter/anthropic/claude-sonnet-4", label: "Claude Sonnet 4 via OpenRouter" },
+      { id: "openrouter/openai/gpt-5", label: "GPT-5 via OpenRouter" },
+      { id: "openrouter/google/gemini-2.5-pro", label: "Gemini 2.5 Pro via OpenRouter" },
+    ],
+    hint: "https://openrouter.ai/keys",
+  },
+  {
+    id: "groq",
+    label: "Groq (초고속 추론)",
+    provider: "groq",
+    envVar: "GROQ_API_KEY",
+    models: [
+      { id: "groq/llama-4-maverick-17b-128e-instruct", label: "Llama 4 Maverick" },
+    ],
+    hint: "https://console.groq.com/keys",
+  },
+  {
+    id: "github-copilot",
+    label: "GitHub Copilot (무료)",
+    provider: "github-copilot",
+    envVar: "",
+    models: [
+      { id: "github-copilot/gpt-5", label: "GPT-5 via Copilot" },
+      { id: "github-copilot/claude-sonnet-4", label: "Claude Sonnet 4 via Copilot" },
+    ],
+    hint: "GitHub 계정으로 OAuth 로그인",
+  },
+  {
+    id: "bedrock",
+    label: "Amazon Bedrock",
+    provider: "amazon-bedrock",
+    envVar: "AWS_ACCESS_KEY_ID",
+    models: [
+      { id: "amazon-bedrock/anthropic.claude-sonnet-4-20250514", label: "Claude Sonnet 4" },
+    ],
+    hint: "AWS 자격 증명 필요",
+  },
+  {
+    id: "custom",
+    label: "직접 입력 (OpenAI 호환)",
+    provider: "",
+    envVar: "",
+    models: [],
+    hint: "",
+  },
+]
+
+export const InitCommand = cmd({
+  command: "init",
+  describe: "최초 설정 — provider, API key, 모델 선택",
+  builder: (y) =>
+    y
+      .option("preset", {
+        type: "string",
+        describe: "프리셋 ID (anthropic, openai, google, openrouter, groq, github-copilot, bedrock, custom)",
+        choices: presets.map((p) => p.id),
+      })
+      .option("api-key", {
+        type: "string",
+        describe: "API key (인터랙티브 입력 스킵)",
+      })
+      .option("model", {
+        type: "string",
+        describe: "기본 모델 (예: anthropic/claude-sonnet-4)",
+      })
+      .option("base-url", {
+        type: "string",
+        describe: "커스텀 API base URL (custom 프리셋용)",
+      })
+      .option("yes", {
+        type: "boolean",
+        alias: "y",
+        describe: "기본값으로 자동 진행",
+        default: false,
+      }),
+  handler: async (args) => {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        UI.empty()
+        UI.println(logo())
+        UI.empty()
+        prompts.intro(`${B}SAEEOL 초기 설정${N}`)
+        UI.empty()
+
+        // 1. Preset 선택
+        const preset = resolvePreset(args.preset)
+        const selected = preset ?? (await promptPreset())
+        if (!selected) return
+
+        // 2. API Key
+        if (selected.id === "github-copilot") {
+          prompts.log.info("GitHub Copilot은 OAuth 로그인이 필요합니다.")
+          prompts.log.info("나중에 ${H}saeeol auth login -p github-copilot${N} 으로 로그인하세요.")
+        } else if (selected.id === "custom") {
+          await handleCustom(args)
+          return
+        } else if (selected.envVar) {
+          const existingKey = process.env[selected.envVar]
+          if (existingKey) {
+            prompts.log.info(`${D}${selected.envVar} 환경변수가 이미 설정되어 있습니다.${N}`)
+          } else {
+            const key = args["api-key"] ?? (await promptApiKey(selected))
+            if (!key) return
+            await put(selected.provider, { type: "api", key })
+            prompts.log.success("API key 저장 완료")
+          }
+        }
+
+        // 3. 모델 선택
+        const model = args.model ?? (await promptModel(selected))
+        if (!model) return
+
+        // 4. 설정 파일 저장
+        await saveConfig(selected, model, args["base-url"])
+
+        UI.empty()
+        prompts.outro(`${S}설정 완료!${N}`)
+        UI.empty()
+        UI.println(`  ${D}시작하기:${N}`)
+        UI.println(`    ${H}saeeol${N}          ${D}# 대화형 세션 시작${N}`)
+        UI.println(`    ${H}saeeol run${N}      ${D}# 프롬프트 바로 실행${N}`)
+        UI.empty()
+      },
+    })
+  },
+})
+
+function logo(): string {
+  const lines = [
+    "  ██████╗  █████╗ ███████╗███████╗██╗  ██╗",
+    "  ██╔══██╗██╔══██╗██╔════╝██╔════╝██║ ██╔╝",
+    "  ██████╔╝███████║███████╗███████╗█████╔╝ ",
+    "  ██╔═══╝ ██╔══██║╚════██║╚════██║██╔═██╗ ",
+    "  ██║     ██║  ██║███████║███████║██║  ██╗",
+    "  ╚═╝     ╚═╝  ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝",
+  ]
+  return lines.map((l) => `${H}${l}${N}`).join("\n")
+}
+
+function resolvePreset(id?: string): Preset | undefined {
+  if (!id) return
+  return presets.find((p) => p.id === id)
+}
+
+async function promptPreset(): Promise<Preset | undefined> {
+  const selected = await prompts.select({
+    message: "사용할 AI Provider를 선택하세요",
+    options: presets.map((p) => ({
+      label: p.label,
+      value: p.id,
+      hint: p.id === "custom" ? "OpenAI 호환 API" : p.provider,
+    })),
+  })
+  if (prompts.isCancel(selected)) throw new UI.CancelledError()
+  return presets.find((p) => p.id === selected)
+}
+
+async function promptApiKey(preset: Preset): Promise<string | undefined> {
+  prompts.log.info(`${D}API key 발급: ${preset.hint}${N}`)
+  const key = await prompts.password({
+    message: `${preset.label} API Key를 입력하세요`,
+    validate: (x) => (x && x.length > 0 ? undefined : "필수 입력입니다"),
+  })
+  if (prompts.isCancel(key)) throw new UI.CancelledError()
+  return key
+}
+
+async function promptModel(preset: Preset): Promise<string | undefined> {
+  if (preset.models.length === 0) return
+  if (preset.models.length === 1 && preset.defaultModel) return preset.defaultModel
+
+  const selected = await prompts.select({
+    message: "기본 모델을 선택하세요",
+    options: preset.models.map((m) => ({
+      label: m.label,
+      value: m.id,
+    })),
+  })
+  if (prompts.isCancel(selected)) throw new UI.CancelledError()
+  return selected as string
+}
+
+async function handleCustom(args: Record<string, unknown>) {
+  const baseUrl = (args["base-url"] as string) ?? (await prompts.text({
+    message: "API Base URL을 입력하세요",
+    placeholder: "https://api.example.com/v1",
+    validate: (x) => (x && x.startsWith("http") ? undefined : "http:// 또는 https:// 로 시작해야 합니다"),
+  }))
+  if (prompts.isCancel(baseUrl)) throw new UI.CancelledError()
+
+  const key = (args["api-key"] as string) ?? (await prompts.password({
+    message: "API Key를 입력하세요",
+    validate: (x) => (x && x.length > 0 ? undefined : "필수 입력입니다"),
+  }))
+  if (prompts.isCancel(key)) throw new UI.CancelledError()
+
+  const modelId = (args.model as string) ?? (await prompts.text({
+    message: "기본 모델 ID를 입력하세요",
+    placeholder: "custom/my-model",
+    validate: (x) => (x && x.length > 0 ? undefined : "필수 입력입니다"),
+  }))
+  if (prompts.isCancel(modelId)) throw new UI.CancelledError()
+
+  const providerId = modelId.split("/")[0] || "custom"
+  await put(providerId, { type: "api", key })
+
+  const config = buildConfigObj(modelId, { [providerId]: { api: baseUrl } })
+  await saveConfigFile(config)
+
+  UI.empty()
+  prompts.outro(`${S}설정 완료!${N}`)
+}
+
+function buildConfigObj(model: string, provider?: Record<string, unknown>) {
+  const obj: Record<string, unknown> = {
+    $schema: "https://app.saeeol.ai/config.json",
+    model,
+  }
+  if (provider && Object.keys(provider).length > 0) {
+    obj.provider = provider
+  }
+  return obj
+}
+
+async function saveConfig(preset: Preset, model: string, baseUrl?: string) {
+  const provider: Record<string, unknown> = {}
+  if (baseUrl) {
+    const pid = model.split("/")[0] || preset.provider
+    provider[pid] = { api: baseUrl }
+  }
+  const config = buildConfigObj(model, provider)
+  await saveConfigFile(config)
+}
+
+async function saveConfigFile(config: Record<string, unknown>) {
+  const configPath = path.join(Global.Path.config, "saeeol.json")
+  const existing = await fs.readFile(configPath, "utf-8").catch(() => null)
+
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing)
+      const merged = { ...parsed, ...config }
+      if (parsed.provider && config.provider) {
+        merged.provider = { ...parsed.provider, ...(config.provider as Record<string, unknown>) }
+      }
+      await fs.writeFile(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8")
+    } catch {
+      await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8")
+    }
+  } else {
+    await fs.mkdir(Global.Path.config, { recursive: true })
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8")
+  }
+
+  prompts.log.success(`설정 파일: ${D}${configPath}${N}`)
+}

package/src/provider/provider.ts

@@ -1,64 +1,8 @@
-import { mapValues, mergeDeep, omit, pickBy, sortBy } from "remeda"
-import fuzzysort from "fuzzysort"
-import { Effect, Layer, Context, Schema } from "effect"
-import * as Log from "@saeeol/core/util/log"
-import { iife } from "@/util/iife"
-import { isRecord } from "@/util/record"
+import { Effect, Schema } from "effect"
 import { namedSchemaError } from "@/util/named-schema-error"
-import { Config } from "@/config/config"
-import { Plugin } from "../plugin"
-import { Auth } from "../auth"
-import { Env } from "../env"
-import { makeRuntime } from "@/effect/run-service"
-import { EffectBridge } from "@/effect/bridge"
-import { InstanceState } from "@/effect/instance-state"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Global } from "@saeeol/core/global"
-import { Flag } from "@saeeol/core/flag/flag"
-import path from "path"
-import * as ModelsDev from "./models"
 import { ModelID, ProviderID } from "./schema"
-import * as ProviderTransform from "./transform"
-import { custom } from "./provider-custom-loaders"
-import { customCloud } from "./provider-custom-cloud"
-import { customGitlab } from "./provider-custom-gitlab"
 import { Model, Info, ListResult, ConfigProvidersResult, fromModelsDevProvider, sortModels, defaultModelIDs } from "./provider-schemas"
-import { resolveSDK } from "./provider-resolve"
 import type { State, BundledSDK } from "./provider-types"
-import { saeeolCustomLoaders, patchCustomLoaderResult, saeeolSmallModelPriority } from "@/saeeol/provider/provider"
-
-const log = Log.create({ service: "provider" })
-
-type CustomModelLoader = (sdk: any, modelID: string, options?: Record<string, any>) => Promise<any>
-type CustomVarsLoader = (options: Record<string, any>) => Record<string, string>
-type CustomDiscoverModels = () => Promise<Record<string, Model>>
-
-const BUNDLED_PROVIDERS: Record<string, () => Promise<(opts: any) => BundledSDK>> = {
-  "@ai-sdk/amazon-bedrock": () => import("@ai-sdk/amazon-bedrock").then((m) => m.createAmazonBedrock),
-  "@ai-sdk/anthropic": () => import("@ai-sdk/anthropic").then((m) => m.createAnthropic),
-  "@ai-sdk/azure": () => import("@ai-sdk/azure").then((m) => m.createAzure),
-  "@ai-sdk/google": () => import("@ai-sdk/google").then((m) => m.createGoogleGenerativeAI),
-  "@ai-sdk/google-vertex": () => import("@ai-sdk/google-vertex").then((m) => m.createVertex),
-  "@ai-sdk/google-vertex/anthropic": () => import("@ai-sdk/google-vertex/anthropic").then((m) => m.createVertexAnthropic),
-  "@ai-sdk/openai": () => import("@ai-sdk/openai").then((m) => m.createOpenAI),
-  "@ai-sdk/openai-compatible": () => import("@ai-sdk/openai-compatible").then((m) => m.createOpenAICompatible),
-  "@openrouter/ai-sdk-provider": () => import("@openrouter/ai-sdk-provider").then((m) => m.createOpenRouter),
-  "@ai-sdk/xai": () => import("@ai-sdk/xai").then((m) => m.createXai),
-  "@ai-sdk/mistral": () => import("@ai-sdk/mistral").then((m) => m.createMistral),
-  "@ai-sdk/groq": () => import("@ai-sdk/groq").then((m) => m.createGroq),
-  "@ai-sdk/deepinfra": () => import("@ai-sdk/deepinfra").then((m) => m.createDeepInfra),
-  "@ai-sdk/cerebras": () => import("@ai-sdk/cerebras").then((m) => m.createCerebras),
-  "@ai-sdk/cohere": () => import("@ai-sdk/cohere").then((m) => m.createCohere),
-  "@ai-sdk/gateway": () => import("@ai-sdk/gateway").then((m) => m.createGateway),
-  "@ai-sdk/togetherai": () => import("@ai-sdk/togetherai").then((m) => m.createTogetherAI),
-  "@ai-sdk/perplexity": () => import("@ai-sdk/perplexity").then((m) => m.createPerplexity),
-  "@ai-sdk/vercel": () => import("@ai-sdk/vercel").then((m) => m.createVercel),
-  "@ai-sdk/alibaba": () => import("@ai-sdk/alibaba").then((m) => m.createAlibaba),
-  "gitlab-ai-provider": () => import("gitlab-ai-provider").then((m) => m.createGitLab),
-  "@ai-sdk/github-copilot": () => import("./sdk/copilot/copilot-provider").then((m) => m.createOpenaiCompatible),
-  "venice-ai-sdk-provider": () => import("venice-ai-sdk-provider").then((m) => m.createVenice),
-  ...require("@/saeeol/provider/provider").SAEEOL_BUNDLED_PROVIDERS,
-}
 
 export interface Interface {
   readonly list: () => Effect.Effect<Record<ProviderID, Info>>

package/src/saeeol/commands.ts

@@ -22,6 +22,7 @@ import { SessionCommand } from "../cli/cmd/session"
 import { RemoteCommand } from "../cli/cmd/remote"
 import { DbCommand } from "../cli/cmd/db"
 import { ConfigCommand as ConfigCLICommand } from "../cli/cmd/config"
+import { InitCommand } from "../cli/cmd/init"
 import { PluginCommand } from "../cli/cmd/plug"
 import { DevSetupCommand, DevAliasCommand } from "./cli/dev-setup"
 import { RollCallCommand } from "./cli/cmd/roll-call"
@@ -65,6 +66,7 @@ export const commands = [
   RemoteCommand,
   DbCommand,
   ConfigCLICommand,
+  InitCommand,
   ...dev,
   PluginCommand,
   HelpCommand,

package/src/provider/provider-custom-cloud.ts

@@ -1,171 +0,0 @@
-/** 클라우드 프로바이더 커스텀 로더 — provider.ts에서 분리 */
-
-import { Effect } from "effect"
-import { iife } from "@/util/iife"
-import { InstallationVersion } from "@saeeol/core/installation/version"
-import { useLanguageModel, type CustomLoader, type CustomDep } from "./provider-custom-loaders"
-import type { Info } from "./provider-schemas"
-
-export function customCloud(dep: CustomDep): Record<string, CustomLoader> {
-  return {
-    azure: Effect.fnUntraced(function* (provider: Info) {
-      const env = yield* dep.env()
-      const auth = yield* dep.auth(provider.id)
-      const endpoint = iife(() => [provider.options?.baseURL, auth?.type === "api" ? auth.metadata?.baseURL : undefined, env["AZURE_OPENAI_ENDPOINT"]].find((url) => typeof url === "string" && url.trim() !== ""))
-      const resource = endpoint ? undefined : iife(() => [provider.options?.resourceName, auth?.type === "api" ? auth.metadata?.resourceName : undefined, env["AZURE_RESOURCE_NAME"], env["AZURE_OPENAI_RESOURCE_NAME"]].find((name) => typeof name === "string" && name.trim() !== ""))
-      if (!resource && !endpoint) {
-        return { autoload: false, async getModel() { throw new Error("Azure resource name or endpoint is missing. Set AZURE_RESOURCE_NAME, AZURE_OPENAI_RESOURCE_NAME, AZURE_OPENAI_ENDPOINT, or reconnect the azure provider.") } }
-      }
-      return {
-        autoload: false,
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
-          if (useLanguageModel(sdk)) return sdk.languageModel(modelID)
-          return options?.["useCompletionUrls"] ? sdk.chat(modelID) : sdk.responses(modelID)
-        },
-        options: { ...(endpoint ? { baseURL: endpoint } : { resourceName: resource }) },
-        vars(_options): Record<string, string> { return resource ? { AZURE_RESOURCE_NAME: resource } : {} },
-      }
-    }),
-    "azure-cognitive-services": Effect.fnUntraced(function* () {
-      const resourceName = yield* dep.get("AZURE_COGNITIVE_SERVICES_RESOURCE_NAME")
-      return {
-        autoload: false,
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
-          if (useLanguageModel(sdk)) return sdk.languageModel(modelID)
-          return options?.["useCompletionUrls"] ? sdk.chat(modelID) : sdk.responses(modelID)
-        },
-        options: { baseURL: resourceName ? `https://${resourceName}.cognitiveservices.azure.com/openai` : undefined },
-      }
-    }),
-    "amazon-bedrock": Effect.fnUntraced(function* (provider: Info) {
-      const providerConfig = (yield* dep.config()).provider?.["amazon-bedrock"]
-      const auth = yield* dep.auth("amazon-bedrock")
-      const env = yield* dep.env()
-      const configRegion = providerConfig?.options?.region
-      const envRegion = env["AWS_REGION"]
-      const defaultRegion = configRegion ?? envRegion ?? "us-east-1"
-      const configProfile = providerConfig?.options?.profile
-      const envProfile = env["AWS_PROFILE"]
-      const profile = configProfile ?? envProfile
-      const awsAccessKeyId = env["AWS_ACCESS_KEY_ID"]
-      const awsBearerToken = iife(() => {
-        const envToken = process.env.AWS_BEARER_TOKEN_BEDROCK
-        if (envToken) return envToken
-        if (auth?.type === "api") { process.env.AWS_BEARER_TOKEN_BEDROCK = auth.key; return auth.key }
-        return undefined
-      })
-      const awsWebIdentityTokenFile = env["AWS_WEB_IDENTITY_TOKEN_FILE"]
-      const containerCreds = Boolean(process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI)
-      if (!profile && !awsAccessKeyId && !awsBearerToken && !awsWebIdentityTokenFile && !containerCreds) return { autoload: false }
-      const { fromNodeProviderChain } = yield* Effect.promise(() => import("@aws-sdk/credential-providers"))
-      const providerOptions: Record<string, any> = { region: defaultRegion }
-      if (!awsBearerToken) {
-        const credentialProviderOptions = profile ? { profile } : {}
-        providerOptions.credentialProvider = fromNodeProviderChain(credentialProviderOptions)
-      }
-      const endpoint = providerConfig?.options?.endpoint ?? providerConfig?.options?.baseURL
-      if (endpoint) providerOptions.baseURL = endpoint
-      return {
-        autoload: true, options: providerOptions,
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
-          const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."]
-          if (crossRegionPrefixes.some((prefix) => modelID.startsWith(prefix))) return sdk.languageModel(modelID)
-          const region = options?.region ?? defaultRegion
-          let regionPrefix = region.split("-")[0]
-          switch (regionPrefix) {
-            case "us": {
-              const mReq = ["nova-micro", "nova-lite", "nova-pro", "nova-premier", "nova-2", "claude", "deepseek"].some((m) => modelID.includes(m))
-              if (mReq && !region.startsWith("us-gov")) modelID = `${regionPrefix}.${modelID}`
-              break
-            }
-            case "eu": {
-              const rReq = ["eu-west-1", "eu-west-2", "eu-west-3", "eu-north-1", "eu-central-1", "eu-south-1", "eu-south-2"].some((r) => region.includes(r))
-              const mReq = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((m) => modelID.includes(m))
-              if (rReq && mReq) modelID = `${regionPrefix}.${modelID}`
-              break
-            }
-            case "ap": {
-              const isAU = ["ap-southeast-2", "ap-southeast-4"].includes(region)
-              const isTokyo = region === "ap-northeast-1"
-              if (isAU && ["anthropic.claude-sonnet-4-5", "anthropic.claude-haiku"].some((m) => modelID.includes(m))) { regionPrefix = "au"; modelID = `${regionPrefix}.${modelID}` }
-              else if (isTokyo) { if (["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) => modelID.includes(m))) { regionPrefix = "jp"; modelID = `${regionPrefix}.${modelID}` } }
-              else { if (["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) => modelID.includes(m))) { regionPrefix = "apac"; modelID = `${regionPrefix}.${modelID}` } }
-              break
-            }
-          }
-          return sdk.languageModel(modelID)
-        },
-      }
-    }),
-    "google-vertex": Effect.fnUntraced(function* (provider: Info) {
-      const env = yield* dep.env()
-      const project = provider.options?.project ?? env["GOOGLE_CLOUD_PROJECT"] ?? env["GCP_PROJECT"] ?? env["GCLOUD_PROJECT"]
-      const location = String(provider.options?.location ?? env["GOOGLE_VERTEX_LOCATION"] ?? env["GOOGLE_CLOUD_LOCATION"] ?? env["VERTEX_LOCATION"] ?? "us-central1")
-      if (!project) return { autoload: false }
-      return {
-        autoload: true,
-        vars(_options: Record<string, any>) {
-          const endpoint = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`
-          return { ...(project && { GOOGLE_VERTEX_PROJECT: project }), GOOGLE_VERTEX_LOCATION: location, GOOGLE_VERTEX_ENDPOINT: endpoint }
-        },
-        options: { project, location, fetch: async (input: RequestInfo | URL, init?: RequestInit) => {
-          const { GoogleAuth } = await import("google-auth-library")
-          const auth = new GoogleAuth()
-          const client = await auth.getApplicationDefault()
-          const token = await client.credential.getAccessToken()
-          const headers = new Headers(init?.headers)
-          headers.set("Authorization", `Bearer ${token.token}`)
-          return fetch(input, { ...init, headers })
-        }},
-        async getModel(sdk: any, modelID: string) { return sdk.languageModel(String(modelID).trim()) },
-      }
-    }),
-    "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"
-      if (!project) return { autoload: false }
-      return { autoload: true, options: { project, location }, async getModel(sdk: any, modelID: string) { return sdk.languageModel(String(modelID).trim()) } }
-    }),
-    "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) } }
-    }),
-    "cloudflare-workers-ai": Effect.fnUntraced(function* (input: Info) {
-      if (input.options?.baseURL) return { autoload: false }
-      const auth = yield* dep.auth(input.id)
-      const env = yield* dep.env()
-      const accountId = env["CLOUDFLARE_ACCOUNT_ID"] || (auth?.type === "api" ? auth.metadata?.accountId : undefined)
-      if (!accountId) return { autoload: false, async getModel() { throw new Error("CLOUDFLARE_ACCOUNT_ID is missing. Set it with: export CLOUDFLARE_ACCOUNT_ID=<your-account-id>") } }
-      const apiKey = yield* Effect.gen(function* () { const envToken = env["CLOUDFLARE_API_KEY"]; if (envToken) return envToken; if (auth?.type === "api") return auth.key; return undefined })
-      return { autoload: !!apiKey, options: { apiKey, headers: { "User-Agent": `saeeol/${InstallationVersion} cloudflare-workers-ai (${process.platform}; ${process.arch})` } }, async getModel(sdk: any, modelID: string) { return sdk.languageModel(modelID) }, vars(_options) { return { CLOUDFLARE_ACCOUNT_ID: accountId } } }
-    }),
-    "cloudflare-ai-gateway": Effect.fnUntraced(function* (input: Info) {
-      if (input.options?.baseURL) return { autoload: false }
-      const auth = yield* dep.auth(input.id)
-      const env = yield* dep.env()
-      const accountId = env["CLOUDFLARE_ACCOUNT_ID"] || (auth?.type === "api" ? auth.metadata?.accountId : undefined)
-      const gateway = env["CLOUDFLARE_GATEWAY_ID"] || (auth?.type === "api" ? auth.metadata?.gatewayId : undefined)
-      if (!accountId || !gateway) {
-        const missing = [!accountId ? "CLOUDFLARE_ACCOUNT_ID" : undefined, !gateway ? "CLOUDFLARE_GATEWAY_ID" : undefined].filter((x): x is string => Boolean(x))
-        return { autoload: false, async getModel() { throw new Error(`${missing.join(" and ")} missing. Set with: ${missing.map((x) => `export ${x}=<value>`).join(" && ")}`) } }
-      }
-      const apiToken = yield* Effect.gen(function* () { const envToken = env["CLOUDFLARE_API_TOKEN"] || env["CF_AIG_TOKEN"]; if (envToken) return envToken; if (auth?.type === "api") return auth.key; return undefined })
-      if (!apiToken) throw new Error("CLOUDFLARE_API_TOKEN (or CF_AIG_TOKEN) is required for Cloudflare AI Gateway.")
-      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"))
-      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"))
-      const metadata = iife(() => { if (input.options?.metadata) return input.options.metadata; try { return JSON.parse(input.options?.headers?.["cf-aig-metadata"]) } catch { return undefined } })
-      const aigateway = createAiGateway({ accountId, gateway, apiKey: apiToken })
-      const unified = createUnified()
-      return { autoload: true, async getModel(_sdk: any, modelID: string) { return aigateway(unified(modelID)) }, options: {} }
-    }),
-  }
-}

package/src/provider/provider-custom-gitlab.ts

@@ -1,77 +0,0 @@
-/** GitLab 커스텀 로더 — provider.ts에서 분리 */
-
-import os from "os"
-import { Effect } from "effect"
-import * as Log from "@saeeol/core/util/log"
-import { InstallationVersion } from "@saeeol/core/installation/version"
-import { InstanceState } from "@/effect/instance-state"
-import { ModelID, ProviderID } from "./schema"
-import type { CustomLoader, CustomDep } from "./provider-custom-loaders"
-import type { Info, Model } from "./provider-schemas"
-
-const log = Log.create({ service: "provider" })
-
-export function customGitlab(dep: CustomDep): Record<string, CustomLoader> {
-  return {
-    gitlab: Effect.fnUntraced(function* (input: Info) {
-      const { VERSION: GITLAB_PROVIDER_VERSION, isWorkflowModel, discoverWorkflowModels } = yield* Effect.promise(() => import("gitlab-ai-provider"))
-      const instanceUrl = (yield* dep.get("GITLAB_INSTANCE_URL")) || "https://gitlab.com"
-      const auth = yield* dep.auth(input.id)
-      const apiKey = yield* Effect.sync(() => {
-        if (auth?.type === "oauth") return auth.access
-        if (auth?.type === "api") return auth.key
-        return undefined
-      })
-      const token = apiKey ?? (yield* dep.get("GITLAB_TOKEN"))
-      const providerConfig = (yield* dep.config()).provider?.["gitlab"]
-      const directory = yield* InstanceState.directory
-      const aiGatewayHeaders = {
-        "User-Agent": `saeeol/${InstallationVersion} gitlab-ai-provider/${GITLAB_PROVIDER_VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,
-        "anthropic-beta": "context-1m-2025-08-07",
-        ...providerConfig?.options?.aiGatewayHeaders,
-      }
-      const featureFlags = { duo_agent_platform_agentic_chat: true, duo_agent_platform: true, ...providerConfig?.options?.featureFlags }
-      return {
-        autoload: !!token,
-        options: { instanceUrl, apiKey: token, aiGatewayHeaders, featureFlags },
-        async getModel(sdk: any, modelID: string, options?: Record<string, any>) {
-          if (modelID.startsWith("duo-workflow-")) {
-            const workflowRef = typeof options?.workflowRef === "string" ? options.workflowRef : undefined
-            const sdkModelID = isWorkflowModel(modelID) ? modelID : "duo-workflow"
-            const workflowDefinition = typeof options?.workflowDefinition === "string" ? options.workflowDefinition : undefined
-            const model = sdk.workflowChat(sdkModelID, { featureFlags, workflowDefinition })
-            if (workflowRef) model.selectedModelRef = workflowRef
-            return model
-          }
-          return sdk.agenticChat(modelID, { aiGatewayHeaders, featureFlags })
-        },
-        async discoverModels(): Promise<Record<string, Model>> {
-          if (!apiKey) { log.info("gitlab model discovery skipped: no apiKey"); return {} }
-          try {
-            const getHeaders = (): Record<string, string> => auth?.type === "api" ? { "PRIVATE-TOKEN": token! } : { Authorization: `Bearer ${token!}` }
-            log.info("gitlab model discovery starting", { instanceUrl })
-            const result = await discoverWorkflowModels({ instanceUrl, getHeaders }, { workingDirectory: directory })
-            if (!result.models.length) {
-              log.info("gitlab model discovery skipped: no models found", { project: result.project ? { id: result.project.id, path: result.project.pathWithNamespace } : null })
-              return {}
-            }
-            const models: Record<string, Model> = {}
-            for (const m of result.models) {
-              if (!input.models[m.id]) {
-                models[m.id] = {
-                  id: ModelID.make(m.id), providerID: ProviderID.make("gitlab"), name: `Agent Platform (${m.name})`, family: "",
-                  api: { id: m.id, url: instanceUrl, npm: "gitlab-ai-provider" }, status: "active", headers: {}, options: { workflowRef: m.ref },
-                  cost: { input: 0, output: 0, cache: { read: 0, write: 0 } }, limit: { context: m.context, output: m.output },
-                  capabilities: { temperature: false, reasoning: true, attachment: true, toolcall: true, input: { text: true, audio: false, image: true, video: false, pdf: true }, output: { text: true, audio: false, image: false, video: false, pdf: false }, interleaved: false },
-                  release_date: "", variants: {},
-                }
-              }
-            }
-            log.info("gitlab model discovery complete", { count: Object.keys(models).length, models: Object.keys(models) })
-            return models
-          } catch (e) { log.warn("gitlab model discovery failed", { error: e }); return {} }
-        },
-      }
-    }),
-  }
-}

package/src/provider/provider-custom-loaders.ts

@@ -1,82 +0,0 @@
-/** 커스텀 로더 타입 + 심플 로더 — provider.ts에서 분리 */
-
-import { Effect } from "effect"
-import { iife } from "@/util/iife"
-import type { Info } from "./provider-schemas"
-import type { Model } from "./provider-schemas"
-import type { Config } from "@/config/config"
-import { Auth } from "../auth"
-import { shouldUseCopilotResponsesApi } from "./bundled-providers"
-
-export type CustomModelLoader = (sdk: any, modelID: string, options?: Record<string, any>) => Promise<any>
-export type CustomVarsLoader = (options: Record<string, any>) => Record<string, string>
-export type CustomDiscoverModels = () => Promise<Record<string, Model>>
-export type CustomLoader = (provider: Info) => Effect.Effect<{
-  autoload: boolean
-  getModel?: CustomModelLoader
-  vars?: CustomVarsLoader
-  options?: Record<string, any>
-  discoverModels?: CustomDiscoverModels
-}>
-
-export type CustomDep = {
-  auth: (id: string) => Effect.Effect<Auth.Info | undefined>
-  config: () => Effect.Effect<Config.Info>
-  env: () => Effect.Effect<Record<string, string | undefined>>
-  get: (key: string) => Effect.Effect<string | undefined>
-}
-
-export function useLanguageModel(sdk: any) {
-  return sdk.responses === undefined && sdk.chat === undefined
-}
-
-export function custom(dep: CustomDep): Record<string, CustomLoader> {
-  return {
-    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(() => input.env.some((item) => env[item]))
-      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) { return sdk.responses(modelID) }, options: {} }),
-    xai: () =>
-      Effect.succeed({ autoload: false, async getModel(sdk: any, modelID: string) { return sdk.responses(modelID) }, options: {} }),
-    "github-copilot": () =>
-      Effect.succeed({
-        autoload: false,
-        async getModel(sdk: any, modelID: string) {
-          if (useLanguageModel(sdk)) return sdk.languageModel(modelID)
-          return shouldUseCopilotResponsesApi(modelID) ? sdk.responses(modelID) : sdk.chat(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" } } }),
-    cerebras: () =>
-      Effect.succeed({ autoload: false, options: { headers: { "X-Cerebras-3rd-Party-Integration": "SAEEOL" } } }),
-    zenmux: () =>
-      Effect.succeed({ autoload: false, options: { headers: { "HTTP-Referer": "https://saeeol.ai/", "X-Title": "SAEEOL" } } }),
-  }
-}