@anionex/dsh-vision-toolkit 0.1.40 → 0.1.44

package/src/client/paste-images.tsx

@@ -1,9 +1,10 @@
 /** Clipboard-only multi-image input for DSH Web. */
 
 import { useSyncExternalStore, type ReactNode } from 'react'
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
-import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { Context as ClientContext } from '@deepseek-ai/cordis'
+import type { DraftAttachmentId } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { InputTriggerSource } from '@deepseek-ai/dsh-client-ui-input-trigger/client'
+import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
 import type { PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
 import { readDisplayConfig } from './display-config.ts'
 
@@ -17,6 +18,47 @@ const MAX_BATCH_BYTES = 80 * 1024 * 1024
 /** A confirmed paste verdict older than this is unknown again, even while a refresh is in flight. */
 const VERDICT_MAX_AGE_MS = 15000
 
+/**
+ * Count the draft attachment ids in an InputState snapshot across DSH
+ * generations. DSH 0.1.5 renamed the field to `attachmentIds` and widened its
+ * meaning from image-only ids to every draft attachment id; the older
+ * `imageIds` name survives only as a compatibility fallback for hosts that
+ * still publish it, and never crashes when it is absent.
+ * @param snapshot - the `input.state.getSnapshot()` value (either generation).
+ * @returns the draft attachment count, 0 when neither field is published.
+ */
+function draftAttachmentCount(snapshot: unknown): number {
+  if (snapshot === null || typeof snapshot !== 'object') return 0
+  const row = snapshot as {
+    attachmentIds?: readonly DraftAttachmentId[]
+    imageIds?: readonly string[]
+  }
+  if (Array.isArray(row.attachmentIds)) return row.attachmentIds.length
+  return Array.isArray(row.imageIds) ? row.imageIds.length : 0
+}
+
+/**
+ * The Client Session registry face this controller reads. DSH 0.1.5 publishes
+ * it as `Context.sessions` from `@deepseek-ai/dsh-api-session-controller/client`,
+ * whose peer set spans the whole host package graph and therefore cannot be a
+ * peer of a Web-only plugin; only these two members are used, so the face is
+ * declared structurally instead of importing that package.
+ */
+interface ClientSessionRegistry {
+  /** Resolve the Session-scoped Context; undefined once the Session has closed. */
+  scope(sessionId: never): ClientContext | undefined
+  /** Live Session list projection; `current` is the focused Session id. */
+  readonly list: { getSnapshot(): { readonly current?: string | undefined } }
+}
+
+/**
+ * @param ctx - the browser plugin Context.
+ * @returns the host's Session registry through the structural face above.
+ */
+function sessionRegistry(ctx: ClientContext): ClientSessionRegistry {
+  return (ctx as unknown as { readonly sessions: ClientSessionRegistry }).sessions
+}
+
 interface PasteRecord {
   ref: string
   file: File
@@ -58,6 +100,8 @@ interface PasteOccurrence {
   source: string
   ref: string
   offset: number
+  /** DSH rc.8+ stores the full @label text; older releases used one placeholder. */
+  length?: number
   label: string
 }
 
@@ -166,6 +210,10 @@ function pasteLabel(file: File, index: number): string {
   return file.name.trim() || `clipboard-image-${index + 1}`
 }
 
+function occurrenceEnd(occurrence: PasteOccurrence): number {
+  return occurrence.offset + (occurrence.length ?? 1)
+}
+
 /** Owns browser File objects until DSH serializes the corresponding text references. */
 export class PasteImageController {
   private readonly records = new Map<string, PasteRecord>()
@@ -216,7 +264,7 @@ export class PasteImageController {
   }
 
   private inputFor(sessionId: string) {
-    const actx = this.ctx.sessions.scope(sessionId as never)
+    const actx = sessionRegistry(this.ctx).scope(sessionId as never)
     if (actx === undefined) throw new Error('Open a live session before pasting images')
     return this.ctx.conversation.input.for(actx)
   }
@@ -241,6 +289,7 @@ export class PasteImageController {
       if (before !== '' && !/\s$/u.test(before)) cursor = this.insertText(input, ' ', cursor)
       for (const [index, file] of files.entries()) {
         const ref = id()
+        const label = pasteLabel(file, index)
         const record: PasteRecord = { ref, file, batch, status: 'ready' }
         batch.records.push(record)
         this.records.set(ref, record)
@@ -248,11 +297,14 @@ export class PasteImageController {
         const accepted = input.insertReference({
           source: SOURCE,
           ref,
-          label: pasteLabel(file, index),
-          clipboardText: `[pasted image: ${pasteLabel(file, index)}]`,
+          label,
+          clipboardText: `[pasted image: ${label}]`,
         }, { start: cursor, end: cursor, draftRev: snapshot.draftRev })
         if (!accepted) throw new Error('The composer changed before pasted images could be inserted')
-        cursor += 1
+        const inserted = input.state.getSnapshot().occurrences.find(occurrence =>
+          occurrence.source === SOURCE && occurrence.ref === ref)
+        if (inserted === undefined) throw new Error('The pasted image reference was not present after insertion')
+        cursor = occurrenceEnd(inserted)
         const hasNext = index + 1 < files.length
         const suffix = input.state.getSnapshot().draft.slice(cursor)
         if (hasNext || (suffix !== '' && !/^\s/u.test(suffix))) cursor = this.insertText(input, ' ', cursor)
@@ -472,7 +524,9 @@ export class PasteImageController {
    * Auto-switch flow: switch the Session to the image-input variant, announce
    * it, then replay the paste into the composer's native intake. A failed
    * switch, or an environment that cannot replay clipboard bytes, degrades to
-   * the path takeover with the same files.
+   * the path takeover with the same files. The post-replay probe compares the
+   * draft attachment count before and after, so it observes any attachment the
+   * native intake admitted rather than images alone.
    * @param sessionId - the live Session id.
    * @param target - the composer textarea the paste landed on.
    * @param files - the captured image files.
@@ -501,10 +555,10 @@ export class PasteImageController {
     // Replaying lets the composer's own intake run (thumbnail, limits,
     // keyboard); if the environment cannot replay clipboard bytes, the
     // images still land as workspace paths.
-    const before = input.state.getSnapshot().imageIds.length
+    const attachmentsBefore = draftAttachmentCount(input.state.getSnapshot())
     const replayed = this.replayPaste(target, files, text)
-    const after = input.state.getSnapshot().imageIds.length
-    if (!replayed || after <= before) {
+    const attachmentsAfter = draftAttachmentCount(input.state.getSnapshot())
+    if (!replayed || attachmentsAfter <= attachmentsBefore) {
       this.takeoverPaste(sessionId, target, files, text)
     }
   }
@@ -548,7 +602,7 @@ export class PasteImageController {
     const target = event.target
     if (!(target instanceof HTMLTextAreaElement) || target.closest('[data-composer-card]') === null) return false
 
-    const sessionId = this.ctx.sessions.list.getSnapshot().current
+    const sessionId = sessionRegistry(this.ctx).list.getSnapshot().current
     if (sessionId === undefined) return false
     const modelLabel = currentModelLabel()
     this.refreshVerdict(sessionId, modelLabel)
@@ -594,7 +648,7 @@ export class PasteImageController {
       insertText: (text: string, span: { start: number; end: number; draftRev: number }) => boolean
     }).insertText('', {
       start: current.offset,
-      end: current.offset + 1,
+      end: occurrenceEnd(current),
       draftRev: snapshot.draftRev,
     })
     if (!accepted) return
@@ -725,7 +779,7 @@ export function installPasteImages(ctx: ClientContext): void {
     const listener = (event: ClipboardEvent): void => { controller.handlePaste(event) }
     // A focus-time prefetch has the verdict ready before the first paste can land.
     const onFocusIn = (): void => {
-      const sessionId = ctx.sessions.list.getSnapshot().current
+      const sessionId = sessionRegistry(ctx).list.getSnapshot().current
       if (sessionId !== undefined) controller.refreshVerdict(String(sessionId), currentModelLabel())
     }
     document.addEventListener('paste', listener, true)

package/src/exposure.ts

@@ -9,6 +9,7 @@
 import type { Agent } from '@deepseek-ai/dsh-agent'
 import type { ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { Session } from '@deepseek-ai/dsh-session'
+import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
 import { defineTool, type ToolDefinition } from '@deepseek-ai/dsh-tools'
 import type { Context } from '@deepseek-ai/cordis'
 import { VISION_SKILLS_CONTENT, VISION_SKILLS_NAME } from './skill.ts'
@@ -78,10 +79,50 @@ function isBundledSkillResult(value: unknown): boolean {
     && isBundledSkillContent(value.content)
 }
 
+/** Event names for one settled programmatic (PTC) Tool dispatch. */
+const PTC_DISPATCH_EVENT_TYPES: readonly string[] = ['tool/ptc-dispatch', 'tool/code-dispatch']
+
+/**
+ * Whether one PTC dispatch event records a successful load of the bundled
+ * Skill. The event is `tool/code-dispatch` through 0.1.2 and `tool/ptc-dispatch`
+ * from 0.1.5, so the name is compared outside the typed union and the payload is
+ * read structurally instead of narrowing on the installed host's literal.
+ * @param event - one durable Session event.
+ * @returns true when this dispatch ran the bundled Skill and returned its content.
+ */
+function isBundledSkillPtcDispatch(event: SessionEvent): boolean {
+  const type: string = event.type
+  if (!PTC_DISPATCH_EVENT_TYPES.includes(type)) return false
+  const data = (event as { data?: unknown }).data
+  return isRecord(data)
+    && data.name === 'skill'
+    && data.isError === false
+    && isVisionSkillArguments(data.arguments)
+    && containsBundledSkillContent(Array.isArray(data.content) ? data.content : [])
+}
+
+/**
+ * Read a Session's durable event log across both published accessors: 0.1.1 and
+ * earlier expose the `events` getter, while 0.1.2 replaced it with
+ * `snapshotEvents()` and dropped the property from the type. Probing
+ * structurally keeps every release line this package declares working at
+ * runtime and still compiles against the installed 0.1.5 typings.
+ * @param session - the Session whose durable history is inspected.
+ * @returns the event log in log order, empty when neither accessor is present.
+ */
+function sessionEvents(session: Session): readonly SessionEvent[] {
+  const adapter = session as unknown as {
+    snapshotEvents?: () => readonly SessionEvent[]
+    events?: readonly SessionEvent[]
+  }
+  return typeof adapter.snapshotEvents === 'function' ? adapter.snapshotEvents() : adapter.events ?? []
+}
+
 /** Whether durable history proves that this Session loaded the bundled Skill. */
 function hasLoadedVisionSkill(session: Session): boolean {
   const nativeCalls = new Set<string>()
-  for (const event of session.events) {
+  const events = sessionEvents(session)
+  for (const event of events) {
     if (event.type === 'user/message') {
       const source = event.data.source
       if (source.kind === 'skill-invocation'
@@ -103,11 +144,7 @@ function hasLoadedVisionSkill(session: Session): boolean {
         && containsBundledSkillContent(block.content)) return true
       continue
     }
-    if (event.type === 'tool/code-dispatch'
-      && event.data.name === 'skill'
-      && event.data.isError === false
-      && isVisionSkillArguments(event.data.arguments)
-      && containsBundledSkillContent(event.data.content)) return true
+    if (isBundledSkillPtcDispatch(event)) return true
   }
   return false
 }

package/src/tools.ts

@@ -7,7 +7,7 @@
  */
 
 import type { ContentBlock } from '@deepseek-ai/dsh-llm'
-import { defineTool, type JsonValue, type ToolRunContext, type ValueSchemaSpec } from '@deepseek-ai/dsh-tools'
+import { defineTool, type ToolRunContext, type ValueSchemaSpec } from '@deepseek-ai/dsh-tools'
 import {
   VisionToolkitRuntime,
   type CropRequest,
@@ -23,6 +23,17 @@ import {
 } from './runtime.ts'
 import { platformTempDirectory } from './paths.ts'
 
+/**
+ * A value that round-trips through JSON without loss, as the host transports it
+ * through `presentationMeta`. DSH 0.1.2 stopped exporting this type from
+ * `@deepseek-ai/dsh-tools`, and 0.1.5 keeps it in `@deepseek-ai/dsh-util-values`,
+ * a package that does not exist before 0.1.2-alpha.2, so no single specifier
+ * covers every release line this package declares. Both homes declare the
+ * identical structural union, so redeclaring it here costs nothing and lets old
+ * and new hosts compile against the same contract.
+ */
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue }
+
 const renderJson = (_args: unknown, value: unknown): ContentBlock[] => [{
   type: 'text',
   text: JSON.stringify(value, null, 2),