feat(attachments): skip unsupported media and warn users

Author: monotykamary

packages/opencode/src/provider/models.ts

@@ -9,43 +9,83 @@ export namespace ModelsDev {
   const log = Log.create({ service: "models.dev" })
   const filepath = path.join(Global.Path.cache, "models.json")
 
+  const isoDate = z
+    .string()
+    .regex(/^\d{4}-\d{2}(-\d{2})?$/, {
+      message: "Must be in YYYY-MM or YYYY-MM-DD format",
+    })
+
   export const Model = z
     .object({
       id: z.string(),
-      name: z.string(),
-      release_date: z.string(),
+      name: z.string().min(1, "Model name cannot be empty"),
       attachment: z.boolean(),
       reasoning: z.boolean(),
       temperature: z.boolean(),
       tool_call: z.boolean(),
-      cost: z.object({
-        input: z.number(),
-        output: z.number(),
-        cache_read: z.number().optional(),
-        cache_write: z.number().optional(),
+      knowledge: isoDate.optional(),
+      release_date: isoDate,
+      last_updated: isoDate,
+      modalities: z.object({
+        input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
+        output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])),
       }),
+      open_weights: z.boolean(),
+      cost: z
+        .object({
+          input: z.number().min(0, "Input price cannot be negative"),
+          output: z.number().min(0, "Output price cannot be negative"),
+          reasoning: z.number().min(0, "Reasoning price cannot be negative").optional(),
+          cache_read: z.number().min(0, "Cache read price cannot be negative").optional(),
+          cache_write: z.number().min(0, "Cache write price cannot be negative").optional(),
+          input_audio: z.number().min(0, "Audio input price cannot be negative").optional(),
+          output_audio: z.number().min(0, "Audio output price cannot be negative").optional(),
+        })
+        .optional(),
       limit: z.object({
-        context: z.number(),
-        output: z.number(),
+        context: z.number().min(0, "Context window must be positive"),
+        output: z.number().min(0, "Output tokens must be positive"),
       }),
+      alpha: z.boolean().optional(),
+      beta: z.boolean().optional(),
       experimental: z.boolean().optional(),
-      options: z.record(z.string(), z.any()),
-      provider: z.object({ npm: z.string() }).optional(),
+      options: z.record(z.string(), z.any()).optional(),
+      provider: z.object({ npm: z.string().optional(), api: z.string().optional() }).optional(),
     })
+    .refine(
+      (data) => !(data.reasoning === false && data.cost?.reasoning !== undefined),
+      {
+        message: "Cannot set cost.reasoning when reasoning is false",
+        path: ["cost", "reasoning"],
+      },
+    )
     .meta({
       ref: "Model",
     })
   export type Model = z.infer<typeof Model>
 
   export const Provider = z
     .object({
-      api: z.string().optional(),
-      name: z.string(),
-      env: z.array(z.string()),
+      api: z
+        .string()
+        .optional(),
+      name: z.string().min(1, "Provider name cannot be empty"),
+      env: z.array(z.string()).min(1, "Provider env cannot be empty"),
       id: z.string(),
-      npm: z.string().optional(),
+      npm: z.string().min(1, "Provider npm module cannot be empty"),
+      doc: z.string().min(1, "Please provide provider documentation link"),
       models: z.record(z.string(), Model),
+      options: z.record(z.string(), z.any()).optional(),
     })
+    .refine(
+      (data) =>
+        (data.npm === "@ai-sdk/openai-compatible" && data.api !== undefined) ||
+        (data.npm !== "@ai-sdk/openai-compatible" && data.api === undefined),
+      {
+        message: "'api' field is required if and only if npm is '@ai-sdk/openai-compatible'",
+        path: ["api"],
+      },
+    )
     .meta({
       ref: "Provider",
     })

packages/opencode/src/provider/provider.ts

@@ -195,47 +195,64 @@ export namespace Provider {
       const existing = database[providerID]
       const parsed: ModelsDev.Provider = {
         id: providerID,
-        npm: provider.npm ?? existing?.npm,
+        npm: provider.npm ?? existing?.npm ?? "",
         name: provider.name ?? existing?.name ?? providerID,
         env: provider.env ?? existing?.env ?? [],
         api: provider.api ?? existing?.api,
+        doc: provider.doc ?? existing?.doc ?? "https://opencode.ai",
         models: existing?.models ?? {},
+        options: provider.options ?? existing?.options,
       }
 
       for (const [modelID, model] of Object.entries(provider.models ?? {})) {
-        const existing = parsed.models[modelID]
+        const existingModel = parsed.models[modelID]
+        const baseModalities =
+          model.modalities ??
+          existingModel?.modalities ?? {
+            input: ["text"],
+            output: ["text"],
+          }
         const parsedModel: ModelsDev.Model = {
           id: modelID,
-          name: model.name ?? existing?.name ?? modelID,
-          release_date: model.release_date ?? existing?.release_date,
-          attachment: model.attachment ?? existing?.attachment ?? false,
-          reasoning: model.reasoning ?? existing?.reasoning ?? false,
-          temperature: model.temperature ?? existing?.temperature ?? false,
-          tool_call: model.tool_call ?? existing?.tool_call ?? true,
+          name: model.name ?? existingModel?.name ?? modelID,
+          attachment: model.attachment ?? existingModel?.attachment ?? false,
+          reasoning: model.reasoning ?? existingModel?.reasoning ?? false,
+          temperature: model.temperature ?? existingModel?.temperature ?? false,
+          tool_call: model.tool_call ?? existingModel?.tool_call ?? true,
+          knowledge: model.knowledge ?? existingModel?.knowledge,
+          release_date: model.release_date ?? existingModel?.release_date ?? "1970-01",
+          last_updated:
+            model.last_updated ??
+            existingModel?.last_updated ??
+            model.release_date ??
+            existingModel?.release_date ??
+            "1970-01",
+          modalities: baseModalities,
+          open_weights: model.open_weights ?? existingModel?.open_weights ?? false,
           cost:
-            !model.cost && !existing?.cost
+            !model.cost && !existingModel?.cost
               ? {
                   input: 0,
                   output: 0,
-                  cache_read: 0,
-                  cache_write: 0,
                 }
               : {
-                  cache_read: 0,
-                  cache_write: 0,
-                  ...existing?.cost,
+                  ...existingModel?.cost,
                   ...model.cost,
                 },
-          options: {
-            ...existing?.options,
-            ...model.options,
-          },
-          limit: model.limit ??
-            existing?.limit ?? {
+          limit:
+            model.limit ??
+            existingModel?.limit ?? {
               context: 0,
               output: 0,
             },
-          provider: model.provider ?? existing?.provider,
+          alpha: model.alpha ?? existingModel?.alpha,
+          beta: model.beta ?? existingModel?.beta,
+          experimental: model.experimental ?? existingModel?.experimental,
+          options: {
+            ...existingModel?.options,
+            ...model.options,
+          },
+          provider: model.provider ?? existingModel?.provider,
         }
         parsed.models[modelID] = parsedModel
       }

packages/opencode/src/session/prompt.ts

@@ -161,6 +161,13 @@ export namespace SessionPrompt {
     const outputLimit = Math.min(model.info.limit.output, OUTPUT_TOKEN_MAX) || OUTPUT_TOKEN_MAX
     using abort = lock(input.sessionID)
 
+    await handleUnsupportedAttachments({
+      message: userMsg,
+      modalities: model.info.modalities,
+      modelID: model.modelID,
+      providerID: model.providerID,
+    })
+
     const system = await resolveSystemPrompt({
       providerID: model.providerID,
       modelID: model.info.id,
@@ -215,6 +222,7 @@ export namespace SessionPrompt {
           providerID: model.providerID,
         }),
         (messages) => insertReminders({ messages, agent }),
+        (messages) => sanitizeMessages(messages, model.info.modalities),
       )
       if (step === 0)
         ensureTitle({
@@ -501,6 +509,62 @@ export namespace SessionPrompt {
     return tools
   }
 
+  function modalityFromMime(mime: string) {
+    if (mime.startsWith("image/")) return "image"
+    if (mime.startsWith("audio/")) return "audio"
+    if (mime.startsWith("video/")) return "video"
+    if (mime === "application/pdf") return "pdf"
+    return undefined
+  }
+
+  function acceptsFile(modalities: ModelsDev.Model["modalities"], mime: string) {
+    if (mime === "text/plain") return true
+    if (mime === "application/x-directory") return true
+    const kind = modalityFromMime(mime)
+    if (!kind) return true
+    return modalities.input.includes(kind)
+  }
+
+  async function handleUnsupportedAttachments(input: {
+    message: MessageV2.WithParts
+    modalities: ModelsDev.Model["modalities"]
+    providerID: string
+    modelID: string
+  }) {
+    const skip = input.message.parts.filter(
+      (part): part is MessageV2.FilePart => part.type === "file" && !acceptsFile(input.modalities, part.mime),
+    )
+    if (skip.length === 0) return
+    const kinds = Array.from(new Set(skip.map((part) => modalityFromMime(part.mime) ?? "file")))
+    const label = kinds.join(", ")
+    const count = skip.length
+    const part: MessageV2.TextPart = {
+      id: Identifier.ascending("part"),
+      messageID: input.message.info.id,
+      sessionID: input.message.info.sessionID,
+      type: "text",
+      synthetic: true,
+      text: `Skipped ${count} attachment${count === 1 ? "" : "s"} (${label}) because ${input.providerID}/${input.modelID} does not accept those inputs.`,
+    }
+    input.message.parts.push(part)
+    await Session.updatePart(part)
+  }
+
+  function sanitizeMessages(messages: MessageV2.WithParts[], modalities: ModelsDev.Model["modalities"]) {
+    return messages.map((msg) => {
+      if (msg.info.role !== "user") return msg
+      const parts = msg.parts.filter((part) => {
+        if (part.type !== "file") return true
+        return acceptsFile(modalities, part.mime)
+      })
+      if (parts.length === msg.parts.length) return msg
+      return {
+        ...msg,
+        parts,
+      }
+    })
+  }
+
   async function createUserMessage(input: PromptInput) {
     const info: MessageV2.Info = {
       id: input.messageID ?? Identifier.ascending("message"),