@elliotsystems/eai 0.1.3 → 0.1.5

package/plugin/opencode-plugin/src/proxy-provider.ts

@@ -1,96 +1,148 @@
 /**
- * The Elliot proxy provider: a `config` hook that registers a custom
- * `elliot` OpenCode provider pointed at the Elliot LightLLM proxy, and an
- * `auth` hook whose `loader` returns a self-refreshing `fetch` that attaches
- * a live bearer token per request.
+ * The Elliot provider: a `config` hook that registers a custom `elliot`
+ * OpenCode provider pointed at LiteLLM directly.
  *
- * Mechanism pinned in `.superpowers/sdd/2026-09-03-eai-proxy-auth/task-1-findings.md`:
- *   - `config` hook mutates its input in place (no separate output param).
- *   - `auth.loader`'s return value is spread wholesale into the provider's
- *     resolved `options`, so `{ apiKey, fetch }` land there directly.
- *   - `apiKey` is baked into the AI-SDK client at construction time and
- *     never changes; the actually-rotating credential is injected per
- *     request by `options.fetch`'s `Authorization` header (never the static
- *     `apiKey`) — same pattern as OpenCode's bundled snowflake-cortex plugin.
- *   - The loader only runs once a stored auth entry exists for its
- *     `provider` id (`provider.ts:1584`); the plugin seeds that entry itself
- *     at init (see `index.ts`) so no interactive `opencode auth login` step
- *     is ever required.
+ * Since `/llm-proxy` was removed, this no longer needs a self-refreshing
+ * per-request `auth` hook (Task-1's pinned mechanism, `.superpowers/sdd/
+ * 2026-09-03-eai-proxy-auth/task-1-findings.md` — kept only as history: the
+ * per-instance JWT that mechanism refreshed doesn't authenticate this path
+ * anymore). LiteLLM's `litellm_master_key` is ONE static secret for the whole
+ * gateway — it never expires, so it is baked into `options.apiKey` directly,
+ * the same way OpenCode's own `{env:VAR}` config substitution would, just
+ * read from `~/.elliot/config.json` instead of the process environment.
  *
  * Everything here is a no-op when the user isn't logged in
  * (`readElliotConfig()` returns null) — OpenCode then runs exactly as it
  * would without this plugin.
  */
-import { freshToken, readElliotConfig } from "./elliot-auth.js"
+import { readElliotConfig, type ElliotCredential } from "./elliot-auth.js"
 
-export const ELLIOT_LLM_PROXY_URL = "https://backend.elliotsystemsonline.com/llm-proxy"
 export const ELLIOT_PROVIDER_ID = "elliot"
+export const ELLIOT_GENERAL_MODEL_ID = "elliot-general"
+export const ELLIOT_CODER_MODEL_ID = "elliot-coder"
+
+const ALL_MODELS = {
+  [ELLIOT_GENERAL_MODEL_ID]: { name: "Elliot General" },
+  [ELLIOT_CODER_MODEL_ID]: { name: "Elliot Coder" },
+}
 
 /**
- * Registers the `elliot` provider (baseURL = the LightLLM proxy) and
- * defaults `cfg.model` to it, mutating `cfg` in place. No-op when the user
- * isn't logged in. Never overwrites a model the user already configured, or
- * any other existing key under `cfg.provider`/`cfg.plugin`/`cfg.mcp`/etc.
+ * The `models` block for one registered provider, filtered to
+ * `allowedModels` (Phase 4 governance, docs/LITELLM_GATEWAY.md §14) —
+ * LiteLLM gateway audit finding #5, mirrors the identical fix already made
+ * to `app/services/opencode/teamconfig.py::build_opencode_config` and
+ * `elliot-launcher/lib/setup.js::elliotProvider`. LiteLLM was always the
+ * real enforcement point regardless of what this offers; this only stops
+ * the menu from offering a model that will be rejected. Falsy
+ * (undefined/null/empty) — every team until an admin restricts it — offers
+ * both, unchanged from before this parameter existed.
+ *
+ * A team restricted to ONLY elliot-classifier (never offered here —
+ * internal-only, deploy/litellm/config.yaml §5) would otherwise get an
+ * empty, unusable menu; degrades to offering both for that listing only,
+ * same as the two sibling generators — LiteLLM still rejects any actual
+ * request the team isn't allowed to make either way.
  */
-export function configHook(cfg: any): void {
-  if (!readElliotConfig()) return
+function offeredModels(allowedModels?: string[] | null): typeof ALL_MODELS {
+  if (!allowedModels || allowedModels.length === 0) return ALL_MODELS
 
-  cfg.provider ??= {}
-  cfg.provider[ELLIOT_PROVIDER_ID] = {
-    npm: "@ai-sdk/anthropic",
-    name: "Elliot (governed)",
-    options: { baseURL: ELLIOT_LLM_PROXY_URL },
-    models: { "elliot-governed": { name: "Elliot (governed)" } },
-  }
+  const allowed = new Set(allowedModels)
+  const offered = Object.keys(ALL_MODELS).filter((id) => allowed.has(id)) as Array<
+    keyof typeof ALL_MODELS
+  >
+  if (offered.length === 0) return ALL_MODELS
 
-  cfg.model ??= "elliot/elliot-governed"
+  const filtered = {} as typeof ALL_MODELS
+  for (const id of offered) filtered[id] = ALL_MODELS[id]
+  return filtered
 }
 
-/**
- * Merge `Authorization: Bearer <token>` into whatever headers `init` already
- * carries, without dropping them. Works whether `init.headers` is a plain
- * object, a `Headers` instance, or an array of pairs.
- */
-function withAuthHeader(init: RequestInit | undefined, token: string): RequestInit {
-  const headers = new Headers(init?.headers)
-  headers.set("Authorization", `Bearer ${token}`)
-  return { ...init, headers }
+function registerProvider(
+  cfg: any,
+  base: string,
+  providerId: string,
+  label: string,
+  apiKey: string,
+  allowedModels?: string[] | null,
+): void {
+  cfg.provider ??= {}
+  // Never clobber a provider id the user (or an earlier plugin) already
+  // configured — same "additive only" contract as the single-provider path
+  // this replaces.
+  cfg.provider[providerId] ??= {
+    npm: "@ai-sdk/openai-compatible",
+    name: label,
+    options: { baseURL: `${base}/v1`, apiKey },
+    models: offeredModels(allowedModels),
+  }
 }
 
 /**
- * The per-request fetch wrapper: reads `~/.elliot/config.json` fresh on
- * every call (so a refresh picked up by another process is honored
- * immediately), refreshes via `freshToken` when needed, and attaches the
- * bearer token. Never throws — a missing/expired/unrefreshable token just
- * means the request goes out unauthenticated and the proxy 401s.
+ * Registers one OpenCode provider per LiteLLM credential this person has
+ * (Phase 4, docs/LITELLM_GATEWAY.md §14): their own personal key under
+ * `elliot`, plus one `elliot-team-<slug>` provider per team they belong to —
+ * so `opencode.json`'s own global+project-local merge, not this plugin, is
+ * what decides which key a given folder actually uses (a project-local
+ * config pins `model` to a team's provider; the global default falls back to
+ * the personal one). Mutating `cfg` in place.
+ *
+ * Falls back to registering a single `elliot` provider from the legacy
+ * `litellm_master_key` field when `elliot.credentials` is absent — an
+ * `eai setup` written before this phase, or a backend that predates it,
+ * keeps working unchanged rather than losing LLM access outright.
+ *
+ * No-op when the user isn't logged in. Never overwrites a model the user
+ * already configured, or any other existing key under
+ * `cfg.provider`/`cfg.plugin`/`cfg.mcp`/etc.
  */
-async function elliotFetch(input: string | URL | Request, init?: RequestInit): Promise<Response> {
-  try {
-    const cfg = readElliotConfig()
-    const token = cfg ? await freshToken(cfg) : null
-    if (token) {
-      return globalThis.fetch(input, withAuthHeader(init, token))
+export function configHook(cfg: any): void {
+  const elliot = readElliotConfig()
+  if (!elliot?.litellm_base_url) return
+
+  const base = elliot.litellm_base_url.replace(/\/+$/, "")
+
+  // The DEFAULT provider's own offered models decide the default `model`
+  // below — never just `elliot-general` unconditionally, since the
+  // fallback (single-provider) path can itself be restricted. In the
+  // credentials path this is always the personal credential (provider_id
+  // "elliot"), which has no team and so is never restricted — `ALL_MODELS`
+  // unless a future personal restriction concept changes that.
+  let defaultProviderModels: typeof ALL_MODELS = ALL_MODELS
+
+  if (elliot.credentials?.length) {
+    for (const credential of elliot.credentials as ElliotCredential[]) {
+      if (!credential.provider_id || !credential.api_key) continue
+      registerProvider(
+        cfg,
+        base,
+        credential.provider_id,
+        credential.label,
+        credential.api_key,
+        credential.allowed_models,
+      )
+      if (credential.provider_id === ELLIOT_PROVIDER_ID) {
+        defaultProviderModels = offeredModels(credential.allowed_models)
+      }
     }
-    return globalThis.fetch(input, init)
-  } catch {
-    return globalThis.fetch(input, init)
+  } else if (elliot.litellm_master_key) {
+    registerProvider(
+      cfg,
+      base,
+      ELLIOT_PROVIDER_ID,
+      "Elliot (LiteLLM)",
+      elliot.litellm_master_key,
+      elliot.allowed_models,
+    )
+    defaultProviderModels = offeredModels(elliot.allowed_models)
+  } else {
+    return
   }
-}
 
-/**
- * Builds the `auth` hook object per the Task-1 pinned `AuthHook` shape.
- * `methods` is empty — this provider is never set up via interactive
- * `opencode auth login`; the plugin seeds the stored auth entry itself
- * (see `index.ts`) so the loader always fires once the user is logged into
- * Elliot.
- */
-export function makeAuthHook() {
-  return {
-    provider: ELLIOT_PROVIDER_ID,
-    methods: [] as unknown[],
-    loader: async (_auth: () => Promise<unknown>, _provider: unknown) => ({
-      apiKey: "elliot-managed",
-      fetch: elliotFetch,
-    }),
-  }
+  // Follows the restriction, not always General — a team restricted to
+  // Coder-only must not default to a model its own menu just excluded.
+  const defaultModelId =
+    ELLIOT_GENERAL_MODEL_ID in defaultProviderModels
+      ? ELLIOT_GENERAL_MODEL_ID
+      : Object.keys(defaultProviderModels)[0]
+  cfg.model ??= `${ELLIOT_PROVIDER_ID}/${defaultModelId}`
 }

package/plugin/opencode-plugin/src/scope.ts

@@ -2,7 +2,8 @@
  * Repository scope from the session worktree — the trusted-context half of the
  * "the model never names a repository" invariant.
  *
- * Ported (trimmed, not imported) from `elliot-cli/src/project.ts`: the same
+ * Ported (trimmed, not imported) from the retired elliot-ai CLI's
+ * `src/project.ts`: the same
  * `execFile` discipline — a fixed, hardcoded argument array, never a string a
  * shell would parse, and never anything the LLM supplies. The worktree path
  * comes from OpenCode's own `PluginInput`/`ToolContext`, which is session

package/plugin/opencode-plugin/src/tui/knowledge.ts

@@ -14,7 +14,7 @@
  * proven from session state or not shown.
  */
 
-import { knowledgeToolKey } from "../mcp-keys.js"
+import { KNOWLEDGE_TOOL, toCanonicalToolUnderAnyGateway } from "../mcp-keys.js"
 
 // ------------------------------------------------------------- host shapes --
 
@@ -106,9 +106,15 @@ export function elliotServerNames(items: readonly McpItem[]): string[] {
  * reasoning applies to a panel that would otherwise attribute a third party's
  * results to Elliot.
  */
-export function isKnowledgeTool(tool: string | undefined, serverNames: readonly string[]): boolean {
+export function isKnowledgeTool(
+  tool: string | undefined,
+  serverNames: readonly string[],
+): boolean {
   if (typeof tool !== "string") return false
-  return serverNames.some((name) => tool === knowledgeToolKey(name))
+  // Alias-agnostic BY NECESSITY, not by preference — see
+  // `toCanonicalToolUnderAnyGateway` for why the TUI cannot know the
+  // configured alias, and why that is safe for a display surface.
+  return toCanonicalToolUnderAnyGateway(tool, serverNames) === KNOWLEDGE_TOOL
 }
 
 /**