rird 2.1.231 → 2.3.0

package/src/project/vcs.ts

@@ -0,0 +1,76 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { $ } from "bun"
+import path from "path"
+import z from "zod"
+import { Log } from "@/util/log"
+import { Instance } from "./instance"
+import { FileWatcher } from "@/file/watcher"
+
+const log = Log.create({ service: "vcs" })
+
+export namespace Vcs {
+  export const Event = {
+    BranchUpdated: BusEvent.define(
+      "vcs.branch.updated",
+      z.object({
+        branch: z.string().optional(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      branch: z.string(),
+    })
+    .meta({
+      ref: "VcsInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  async function currentBranch() {
+    return $`git rev-parse --abbrev-ref HEAD`
+      .quiet()
+      .nothrow()
+      .cwd(Instance.worktree)
+      .text()
+      .then((x) => x.trim())
+      .catch(() => undefined)
+  }
+
+  const state = Instance.state(
+    async () => {
+      if (Instance.project.vcs !== "git") {
+        return { branch: async () => undefined, unsubscribe: undefined }
+      }
+      let current = await currentBranch()
+      log.info("initialized", { branch: current })
+
+      const unsubscribe = Bus.subscribe(FileWatcher.Event.Updated, async (evt) => {
+        if (evt.properties.file.endsWith("HEAD")) return
+        const next = await currentBranch()
+        if (next !== current) {
+          log.info("branch changed", { from: current, to: next })
+          current = next
+          Bus.publish(Event.BranchUpdated, { branch: next })
+        }
+      })
+
+      return {
+        branch: async () => current,
+        unsubscribe,
+      }
+    },
+    async (state) => {
+      state.unsubscribe?.()
+    },
+  )
+
+  export async function init() {
+    return state()
+  }
+
+  export async function branch() {
+    return await state().then((s) => s.branch())
+  }
+}

package/src/provider/auth.ts

@@ -0,0 +1,143 @@
+import { Instance } from "@/project/instance"
+import { Plugin } from "../plugin"
+import { map, filter, pipe, fromEntries, mapValues } from "remeda"
+import z from "zod"
+import { fn } from "@/util/fn"
+import type { AuthOuathResult, Hooks } from "@opencode-ai/plugin"
+import { NamedError } from "@opencode-ai/util/error"
+import { Auth } from "@/auth"
+
+export namespace ProviderAuth {
+  const state = Instance.state(async () => {
+    const methods = pipe(
+      await Plugin.list(),
+      filter((x) => x.auth?.provider !== undefined),
+      map((x) => [x.auth!.provider, x.auth!] as const),
+      fromEntries(),
+    )
+    return { methods, pending: {} as Record<string, AuthOuathResult> }
+  })
+
+  export const Method = z
+    .object({
+      type: z.union([z.literal("oauth"), z.literal("api")]),
+      label: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthMethod",
+    })
+  export type Method = z.infer<typeof Method>
+
+  export async function methods() {
+    const s = await state().then((x) => x.methods)
+    return mapValues(s, (x) =>
+      x.methods.map(
+        (y): Method => ({
+          type: y.type,
+          label: y.label,
+        }),
+      ),
+    )
+  }
+
+  export const Authorization = z
+    .object({
+      url: z.string(),
+      method: z.union([z.literal("auto"), z.literal("code")]),
+      instructions: z.string(),
+    })
+    .meta({
+      ref: "ProviderAuthAuthorization",
+    })
+  export type Authorization = z.infer<typeof Authorization>
+
+  export const authorize = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+    }),
+    async (input): Promise<Authorization | undefined> => {
+      const auth = await state().then((s) => s.methods[input.providerID])
+      const method = auth.methods[input.method]
+      if (method.type === "oauth") {
+        const result = await method.authorize()
+        await state().then((s) => (s.pending[input.providerID] = result))
+        return {
+          url: result.url,
+          method: result.method,
+          instructions: result.instructions,
+        }
+      }
+    },
+  )
+
+  export const callback = fn(
+    z.object({
+      providerID: z.string(),
+      method: z.number(),
+      code: z.string().optional(),
+    }),
+    async (input) => {
+      const match = await state().then((s) => s.pending[input.providerID])
+      if (!match) throw new OauthMissing({ providerID: input.providerID })
+      let result
+
+      if (match.method === "code") {
+        if (!input.code) throw new OauthCodeMissing({ providerID: input.providerID })
+        result = await match.callback(input.code)
+      }
+
+      if (match.method === "auto") {
+        result = await match.callback()
+      }
+
+      if (result?.type === "success") {
+        if ("key" in result) {
+          await Auth.set(input.providerID, {
+            type: "api",
+            key: result.key,
+          })
+        }
+        if ("refresh" in result) {
+          await Auth.set(input.providerID, {
+            type: "oauth",
+            access: result.access,
+            refresh: result.refresh,
+            expires: result.expires,
+          })
+        }
+        return
+      }
+
+      throw new OauthCallbackFailed({})
+    },
+  )
+
+  export const api = fn(
+    z.object({
+      providerID: z.string(),
+      key: z.string(),
+    }),
+    async (input) => {
+      await Auth.set(input.providerID, {
+        type: "api",
+        key: input.key,
+      })
+    },
+  )
+
+  export const OauthMissing = NamedError.create(
+    "ProviderAuthOauthMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+  export const OauthCodeMissing = NamedError.create(
+    "ProviderAuthOauthCodeMissing",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+
+  export const OauthCallbackFailed = NamedError.create("ProviderAuthOauthCallbackFailed", z.object({}))
+}

package/src/provider/models-macro.ts

@@ -0,0 +1,55 @@
+export async function data() {
+  return JSON.stringify({
+    rird: {
+      id: "rird",
+      name: "RIRD",
+      api: "https://rird.ai/api/llm/v1",
+      env: ["RIRD_API_KEY"],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        "deepseek-reasoner": {
+          id: "deepseek-reasoner",
+          name: "Planner",
+          family: "deepseek",
+          release_date: "2025-01-01",
+          attachment: false,
+          reasoning: true,
+          temperature: true,
+          tool_call: true,
+          cost: { input: 0, output: 0 },
+          limit: { context: 32768, output: 8192 },
+          modalities: { input: ["text"], output: ["text"] },
+          options: {},
+        },
+        "qwen3:8b": {
+          id: "qwen3:8b",
+          name: "Actor",
+          family: "qwen",
+          release_date: "2025-01-01",
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: { input: 0, output: 0 },
+          limit: { context: 32768, output: 8192 },
+          modalities: { input: ["text"], output: ["text"] },
+          options: {},
+        },
+        "qwen2.5-vl-7b": {
+          id: "qwen2.5-vl-7b",
+          name: "Vision",
+          family: "qwen",
+          release_date: "2025-01-01",
+          attachment: true,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: { input: 0, output: 0 },
+          limit: { context: 32768, output: 8192 },
+          modalities: { input: ["text", "image"], output: ["text"] },
+          options: {},
+        },
+      },
+    },
+  })
+}

package/src/provider/models.ts

@@ -0,0 +1,161 @@
+import z from "zod"
+
+export namespace ModelsDev {
+  export const Model = z.object({
+    id: z.string(),
+    name: z.string(),
+    family: z.string().optional(),
+    release_date: z.string(),
+    attachment: z.boolean(),
+    reasoning: z.boolean(),
+    temperature: z.boolean(),
+    tool_call: z.boolean(),
+    interleaved: z
+      .union([
+        z.literal(true),
+        z
+          .object({
+            field: z.enum(["reasoning_content", "reasoning_details"]),
+          })
+          .strict(),
+      ])
+      .optional(),
+    cost: z
+      .object({
+        input: z.number(),
+        output: z.number(),
+        cache_read: z.number().optional(),
+        cache_write: z.number().optional(),
+        context_over_200k: z
+          .object({
+            input: z.number(),
+            output: z.number(),
+            cache_read: z.number().optional(),
+            cache_write: z.number().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
+    limit: z.object({
+      context: z.number(),
+      output: z.number(),
+    }),
+    modalities: z
+      .object({
+        input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+        output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+      })
+      .optional(),
+    experimental: z.boolean().optional(),
+    status: z.enum(["alpha", "beta", "deprecated"]).optional(),
+    options: z.record(z.string(), z.any()),
+    headers: z.record(z.string(), z.string()).optional(),
+    provider: z.object({ npm: z.string() }).optional(),
+  })
+  export type Model = z.infer<typeof Model>
+
+  export const Provider = z.object({
+    api: z.string().optional(),
+    name: z.string(),
+    env: z.array(z.string()),
+    id: z.string(),
+    npm: z.string().optional(),
+    models: z.record(z.string(), Model),
+  })
+
+  export type Provider = z.infer<typeof Provider>
+
+  const RIRD_LLM_BASE_URL = "https://rird.ai/api/llm/v1"
+
+  const INTERNAL_PROVIDERS: Record<string, Provider> = {
+    rird: {
+      id: "rird",
+      name: "RIRD",
+      api: RIRD_LLM_BASE_URL,
+      env: ["RIRD_API_KEY"],
+      npm: "@ai-sdk/openai-compatible",
+      models: {
+        // Planner
+        "deepseek-reasoner": {
+          id: "deepseek-reasoner",
+          name: "Planner",
+          family: "deepseek",
+          release_date: "2025-01-01",
+          attachment: false,
+          reasoning: true,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+          },
+          limit: {
+            context: 32768,
+            output: 8192,
+          },
+          modalities: {
+            input: ["text"],
+            output: ["text"],
+          },
+          options: {},
+        },
+        // Actor (default)
+        "qwen3:8b": {
+          id: "qwen3:8b",
+          name: "Actor",
+          family: "qwen",
+          release_date: "2025-01-01",
+          attachment: false,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+          },
+          limit: {
+            context: 32768,
+            output: 8192,
+          },
+          modalities: {
+            input: ["text"],
+            output: ["text"],
+          },
+          options: {},
+        },
+        // Vision
+        "qwen2.5-vl-7b": {
+          id: "qwen2.5-vl-7b",
+          name: "Vision",
+          family: "qwen",
+          release_date: "2025-01-01",
+          attachment: true,
+          reasoning: false,
+          temperature: true,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+          },
+          limit: {
+            context: 32768,
+            output: 8192,
+          },
+          modalities: {
+            input: ["text", "image"],
+            output: ["text"],
+          },
+          options: {},
+        },
+      },
+    },
+  }
+
+  export async function get() {
+    return INTERNAL_PROVIDERS
+  }
+
+  export async function refresh() {
+    // No-op: RIRD uses a fixed internal model catalog.
+  }
+}