dsh-connect-minimaxcode 0.6.0 → 0.6.2

package/README.en.md

@@ -357,7 +357,7 @@ A picture *can* reach a conversation: the host publishes
 store → durable reference" on its own. But the attachment entry point is a
 browser `File` upload and there is **no attachment library** to pick from,
 so it still has to travel as part of the next prompt. That last hop is
-planned for the next release.
+done in 0.6.1 (see below).
 
 ### About token refresh
 
@@ -384,6 +384,19 @@ The OAuth token is valid for about an hour and is refreshed automatically by the
 
 ## Changelog
 
+### 0.6.2 (2026-11-11)
+
+- **Fixed "could not send it to the conversation"**: the previous version looked for the session among the slot's props, but the host hands the session to the slot's **injection callback** (the slot is session-scoped), so the identifier was always missing and the picture had nowhere to go. The session is now taken the way the host gives it.
+- **One more way to deliver**: when the host offers no session face to send with, the plugin falls back to the input box's own attachment channel — the very road a picture dragged in by hand takes, so it appears in the input box and you press send.
+- The picture's arrival is the feedback, so nothing is left on screen and the composer stays clean.
+- `tests/generate-dock.spec.ts` rewritten to drive the plugin **the way the host does** (6 cases): the session identifier arrives through the injection, the picture travels as `{type:"image", mediaType, data}` with the prompt, the fallback into the input box when there is no way to send, and the message shown when neither is there.
+
+### 0.6.1 (2026-11-11)
+
+- **A generated picture can now go straight into the conversation**: the composer tool row gained a **Generate an image** entry. Write a prompt, press generate, and the picture is sent as part of this turn — through the host's own road (`ctx.sessions.binding(id).session.prompt(content, mode, signal, requestId)`, the very call the send button makes), so the host validates it, commits it as a durable attachment and treats it as an ordinary message.
+- A host that exposes no session face gets a plain "could not send it to the conversation" instead of a silent failure, and the plugin page's panel keeps working regardless.
+- Added `tests/generate-dock.spec.ts` (4 cases) pinning: the entry is registered in the tool row, it declares the `sessions` service, the picture travels as `{type:"image", mediaType, data}` (raw base64, no data-url prefix) together with the prompt, and the message shown when there is no session to send to. All 252 cases pass.
+
 ### 0.6.0 (2026-11-11)
 
 - **Added H3 image and video generation**: the plugin page gained a **Generate** panel that drives MiniMax's `MiniMax-H3-Image` (text to image) and `MiniMax-H3` (video) directly. It goes through the endpoints the open platform's documentation gives (`POST /v1/images/generations`, `POST /v2/video_generation` plus polling `/v2/query/video_generation/{id}`), and **no key has to be configured**: the generation endpoints want the account's own open-platform key, and the plugin gets it by asking `token_plan_credit` with the OAuth bearer — the endpoint it already reads for the balance.

package/README.md

@@ -368,7 +368,7 @@ GET  https://api.minimax.cn/v2/query/video_generation/{id}  # 轮询任务
 1. **不能像普通模型那样出现在模型选择器里。** DSH 宿主的 `ctx.llm` 只有对话适配器这一个注册点（`registerAdapter`），没有图像 provider 的挂载处；模型描述符 `LlmModelInfo` 也没有「输出模态」字段，选择器无从区分图像模型。pi-ai 自己虽有图像生成 API（`ImagesProvider` / `generateImages`），但 DSH 从不构造 `ImagesModels`，插件自己 `new` 一个也没有人会读。这三点都是宿主层面的事，插件改不动。
 2. **视频在 DSH 侧目前没有承载。** `pi-ai`、`dsh-llm`、`dsh-attachment`、`dsh-llm-pi-ai` 四个包里关于 video 的声明各为零处 —— 没有视频内容块、没有附件媒体类型、没有渲染。视频因此只能生成后在面板里播放与下载，不能像图片那样进对话。
 
-图片进对话是可行的：宿主公开了 `ctx.attachments.admitPromptContent()`，插件可以独立完成「生成 → 落库 → 拿到持久引用」；但附件入口是浏览器 `File` 上传，**没有附件库**可供挑选，因此要进对话仍需作为下一轮 prompt 的一部分提交。这一步的宿主接线待下一版完成。
+图片进对话是可行的：宿主公开了 `ctx.attachments.admitPromptContent()`，插件可以独立完成「生成 → 落库 → 拿到持久引用」；但附件入口是浏览器 `File` 上传，**没有附件库**可供挑选，因此要进对话仍需作为下一轮 prompt 的一部分提交。这一步已由 0.6.1 完成（见下）。
 
 ### 关于续期
 
@@ -395,6 +395,19 @@ OAuth 令牌有效期约 1 小时，由客户端自动续期。插件**只在自
 
 ## 更新记录
 
+### 0.6.2（2026-11-11）
+
+- **修复「无法发送到对话」**：上一版从插槽的 props 里找会话标识，但宿主是把会话交给**插槽的注入回调**的（该插槽是会话作用域的），于是标识始终为空，图片自然送不出去。现在按宿主的方式取会话标识。
+- **多一条投递路径**：宿主若不提供直接发送的会话面，插件会退回到输入框自己的附件通道 —— 与手动拖一张图进输入框完全同路，图片出现在输入框里，由你按下发送。
+- 图片到达本身就是反馈，成功后不再留提示条，输入框保持干净。
+- `tests/generate-dock.spec.ts` 重写为**按宿主的真实投递方式**驱动插件（6 个用例）：会话标识来自注入回调、图片作为 `{type:"image", mediaType, data}` 随提示词发出、没有发送通道时退回输入框、以及两条路都没有时的提示。
+
+### 0.6.1（2026-11-11）
+
+- **生成的图片现在能直接进对话**：输入框工具行新增一个「生成图片」入口，写下提示词点生成，图片会作为**这一轮消息的一部分**发给模型 —— 走的是宿主自己那条路（`ctx.sessions.binding(id).session.prompt(content, mode, signal, requestId)`，与输入框按发送键完全相同），因此图片会被宿主校验、落成持久附件，并按普通消息参与对话。
+- 宿主若不暴露会话句柄，该入口会明确提示「无法发送到对话」，而不是静默失败；插件页的生成面板仍可照常使用。
+- 新增 `tests/generate-dock.spec.ts`（4 个用例）钉住：入口注册在工具行、声明了 `sessions` 服务、生成的图以 `{type:"image", mediaType, data}` 的形态（原始 base64，不带 data-url 前缀）随提示词一起发出、以及没有会话句柄时的提示。全量 252 个用例通过。
+
 ### 0.6.0（2026-11-11）
 
 - **新增 H3 图像与视频生成**：插件页多了一个「生成」面板，可直接调用 MiniMax 的 `MiniMax-H3-Image`（文生图）与 `MiniMax-H3`（视频生成）。走的是开放平台官方文档给出的接口（`POST /v1/images/generations`、`POST /v2/video_generation` + 轮询 `/v2/query/video_generation/{id}`），**用户无需配置任何密钥** —— 生成接口要的是账户自己的开放平台密钥，插件用 OAuth 令牌问本来就在读的 `token_plan_credit` 就能拿到。

package/lib/client.js

@@ -94,6 +94,11 @@
         generateSaved: '已存入 DSH 附件库',
         generateFailed: '生成失败',
         generateHint: '生成走 MiniMax 的开放平台，用的是你账号自己的额度。图片会并存进 DSH 的附件库。',
+        generateToChat: '生成图片',
+        generateToChatHint: '生成的图片会作为这一轮消息的一部分发给模型。',
+        generateSent: '图片已发送到对话',
+        generateDrafted: '图片已放入输入框',
+        generateSendFailed: '无法发送到对话，请到插件页生成后下载。',
     };
     const en = {
         title: 'MiniMax Code credits',
@@ -161,6 +166,11 @@
         generateSaved: 'Saved to DSH attachments',
         generateFailed: 'Generation failed',
         generateHint: 'Generation runs on MiniMax\'s open platform with your own account\'s allowance. Images are also stored in DSH\'s attachment store.',
+        generateToChat: 'Generate an image',
+        generateToChatHint: 'The generated picture is sent as part of this turn.',
+        generateSent: 'The picture is on its way to the conversation',
+        generateDrafted: 'The picture is in the input box',
+        generateSendFailed: 'Could not send it to the conversation; generate on the plugin page and download it instead.',
     };
     const loader = globalThis.__ModuleLoader__;
     if (loader === undefined)
@@ -170,6 +180,13 @@
         factory(require) {
             const React = require('react');
             const h = React.createElement;
+            /**
+             * The host's client context, once the plugin is applied.
+             *
+             * The components are closures over the module, not over the context, so
+             * this is how they reach the host's services.
+             */
+            let clientContext;
             /** Format a credit amount without pretending to more precision. */
             function credits(value, digits) {
                 if (value === undefined || !Number.isFinite(value))
@@ -419,6 +436,167 @@
                     return null;
                 return h(CreditPill, props);
             }
+            /**
+             * Generate a picture and send it to the conversation.
+             *
+             * The composer already knows how to send a message with an image in it,
+             * and the picture the upstream produces is an ordinary image file, so
+             * the dock does the same thing the composer does: it asks the session
+             * to accept a turn whose content is the picture plus the prompt.
+             *
+             * Nothing here is required of the host beyond what the composer itself
+             * uses. A host that does not expose the session face simply gets the
+             * message that says so, and the plugin page still offers the picture.
+             */
+            function GenerateDock(props) {
+                const t = props.t ?? ((key, params) => {
+                    const template = zh[key] ?? key;
+                    return template.replace(/\\{(\\w+)\\}/g, (_match, name) => String(params?.[name] ?? ''));
+                });
+                const [open, setOpen] = React.useState(false);
+                const [prompt, setPrompt] = React.useState('');
+                const [busy, setBusy] = React.useState(false);
+                const [note, setNote] = React.useState('');
+                /**
+                 * The session the picture belongs to.
+                 *
+                 * The host hands the session id to the slot through its injection,
+                 * because the slot is session-scoped; it is also carried on the
+                 * standard props, so either may deliver it.
+                 */
+                const sessionId = () => props.sessionId;
+                /**
+                 * The session's own send path.
+                 *
+                 * `binding(id).session.prompt(content, mode, signal, requestId)` is
+                 * what the composer calls when the person presses send, so a picture
+                 * sent this way is a normal turn.
+                 */
+                const sessionFace = () => {
+                    const id = sessionId();
+                    if (id === undefined)
+                        return undefined;
+                    const binding = clientContext?.sessions?.binding?.(id);
+                    const send = binding?.session?.prompt;
+                    return typeof send === 'function' ? { prompt: send } : undefined;
+                };
+                /**
+                 * The conversation's own draft channel.
+                 *
+                 * The composer builds a draft from a browser File and hands its id to
+                 * the input box, which is how a picture attached by hand appears
+                 * there. Using the same two steps leaves the picture in the input box
+                 * for the person to send, rather than sending on their behalf.
+                 */
+                const draftFace = () => {
+                    const id = sessionId();
+                    if (id === undefined)
+                        return undefined;
+                    const scoped = clientContext?.sessions?.scope?.(id);
+                    const conversation = scoped?.get?.('conversation');
+                    const create = conversation?.createDrafts;
+                    return typeof create === 'function'
+                        ? { createDrafts: create.bind(conversation) }
+                        : undefined;
+                };
+                /** The bytes behind a data URL. */
+                const base64Bytes = (dataUrl) => {
+                    const comma = dataUrl.indexOf(',');
+                    const base64 = comma < 0 ? dataUrl : dataUrl.slice(comma + 1);
+                    const binary = atob(base64);
+                    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+                    for (let index = 0; index < binary.length; index += 1) {
+                        bytes[index] = binary.charCodeAt(index);
+                    }
+                    return bytes;
+                };
+                /** Turn a data URL into the parts the session's admission accepts. */
+                const imagePart = (dataUrl, mediaType) => {
+                    const comma = dataUrl.indexOf(',');
+                    if (comma < 0)
+                        return undefined;
+                    return { type: 'image', mediaType, data: dataUrl.slice(comma + 1) };
+                };
+                async function send() {
+                    const text = prompt.trim();
+                    if (text === '')
+                        return;
+                    setBusy(true);
+                    setNote('');
+                    try {
+                        const response = await fetch(GENERATE_PATH, {
+                            method: 'POST',
+                            headers: { 'content-type': 'application/json' },
+                            body: JSON.stringify({ kind: 'image', prompt: text, area: '1K' }),
+                        });
+                        const body = await response.json();
+                        if (body.ok !== true || body.dataUrl === undefined) {
+                            setNote(body.error ?? t('generateFailed'));
+                            return;
+                        }
+                        const part = imagePart(body.dataUrl, body.mediaType ?? 'image/jpeg');
+                        if (part === undefined) {
+                            setNote(t('generateFailed'));
+                            return;
+                        }
+                        // Sending the picture as a turn is what the dock promises; the
+                        // draft channel is the fallback for a host that only offers that.
+                        const face = sessionFace();
+                        if (face !== undefined) {
+                            await face.prompt([part, { type: 'text', text }], 'queue', undefined, `minimax-h3-${Date.now()}`);
+                            setPrompt('');
+                            setOpen(false);
+                            // The picture's own arrival is the feedback: it is in the
+                            // conversation now, so the composer needs no banner.
+                            setNote('');
+                            return;
+                        }
+                        const drafts = draftFace();
+                        const addAttachments = props.inputActions?.addAttachments;
+                        if (drafts !== undefined && typeof addAttachments === 'function') {
+                            const file = new File([base64Bytes(body.dataUrl)], 'minimax-h3-image.jpg', { type: body.mediaType ?? 'image/jpeg' });
+                            const created = drafts.createDrafts(sessionId(), [file], true);
+                            addAttachments(created.map(draft => draft.id));
+                            setPrompt('');
+                            setOpen(false);
+                            setNote('');
+                            return;
+                        }
+                        setNote(t('generateSendFailed'));
+                    }
+                    catch {
+                        setNote(t('generateSendFailed'));
+                    }
+                    finally {
+                        setBusy(false);
+                    }
+                }
+                if (!open) {
+                    return h('button', {
+                        type: 'button',
+                        style: buttonStyle,
+                        title: t('generateToChatHint'),
+                        onClick: () => { setOpen(true); setNote(''); },
+                    }, t('generateToChat'));
+                }
+                return h('div', { style: dockStyle, 'data-minimax-generate-dock': true }, h('input', {
+                    value: prompt,
+                    placeholder: t('generatePrompt'),
+                    style: dockInputStyle,
+                    disabled: busy,
+                    onChange: (event) => setPrompt(event.target.value),
+                }), h('button', {
+                    type: 'button',
+                    style: buttonStyle,
+                    disabled: busy || prompt.trim() === '',
+                    onClick: () => { void send(); },
+                }, busy ? t('generateRunning') : t('generateRun')), h('button', {
+                    type: 'button',
+                    style: buttonStyle,
+                    disabled: busy,
+                    onClick: () => { setOpen(false); setPrompt(''); setNote(''); },
+                }, '✕'), note === '' ? null : h('span', { style: mutedStyle }, note));
+            }
             /** Ask the host to do something, and let the card read the result. */
             async function act(action, body) {
                 try {
@@ -694,6 +872,21 @@
                 opacity: 0.8,
                 padding: '1px 8px',
             };
+            const dockStyle = {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '4px',
+            };
+            const dockInputStyle = {
+                width: '160px',
+                padding: '2px 6px',
+                borderRadius: '999px',
+                border: '1px solid var(--dsh-composer-dock-inset, currentColor)',
+                background: 'transparent',
+                color: 'inherit',
+                font: 'inherit',
+                fontSize: '12px',
+            };
             const detailStyle = {
                 position: 'absolute',
                 bottom: 'calc(100% + 6px)',
@@ -828,9 +1021,15 @@
                 borderRadius: '8px',
             };
             return {
-                inject: ['slots', 'locale'],
+                // The sessions service is what lets a generated picture be delivered
+                // into the conversation the composer belongs to.
+                inject: ['slots', 'locale', 'sessions'],
                 apply(ctx) {
                     const context = ctx;
+                    // The components need the host's sessions service to deliver a
+                    // generated picture into the conversation, so it is kept where the
+                    // components can reach it.
+                    clientContext = context;
                     // Visible text goes through the host's locale service.
                     context.effect(() => context.locale.register(NAMESPACE, { zh, en }), `${BUNDLE_NAME}: locale`);
                     // The composer and plugin-page slots carry no translator in their
@@ -850,6 +1049,18 @@
                         locale: NAMESPACE,
                         inject: () => ({ t }),
                     }, CreditPillGate));
+                    // The image dock sits beside the balance: it is the same provider's
+                    // capability, and it needs the session the composer belongs to.
+                    context.slots.inject('conversation.input.left', () => context.slots.register({
+                        name: 'conversation.input.left',
+                        id: 'minimax-generate',
+                        order: 5,
+                        locale: NAMESPACE,
+                        // The slot is session-scoped, and its injection receives the
+                        // session it is scoped to — which is how the dock learns which
+                        // conversation a picture belongs to.
+                        inject: (sessionId) => ({ t, sessionId }),
+                    }, GenerateDock));
                     // The plugin's own page, keyed by the package name, where the
                     // balance and the expiry schedule are spelled out.
                     context.slots.inject('plugins.bundle.config', () => context.slots.register({

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-minimaxcode",
   "displayName": "DSH Connect MiniMax Code",
   "description": "把本机已登录的 MiniMax Code 桌面 App 模型接入 DeepSeek Harness：零配置、Anthropic Messages 兼容、动态模型目录，并显示积分余额与到期 — bring MiniMax Code desktop app models into DSH with a dynamic model catalog and a credit balance with expiry details.",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "author": "JeffTsuiCUG",
   "contributors": [
     {