@mirrowel/opencode-openshare 0.1.1 → 0.2.0-dev.2

package/src/v2-server.ts

@@ -74,114 +74,10 @@ type V2Context = {
   signal?: AbortSignal
 }
 
-// --- v2 message -> v1 items ---------------------------------------------------
-
-function toolContentText(content: unknown): string {
-  if (typeof content === "string") return content
-  if (Array.isArray(content)) {
-    return content
-      .map((item) => {
-        if (typeof item === "string") return item
-        if (item && typeof item === "object") {
-          const record = item as Record<string, unknown>
-          if (typeof record.text === "string") return record.text
-        }
-        return ""
-      })
-      .join("")
-  }
-  return ""
-}
-
-function convertToolState(state: unknown): Record<string, unknown> {
-  if (!state || typeof state !== "object") return { status: "pending" }
-  const record = state as Record<string, unknown>
-  const status = String(record.status ?? "pending")
-  const mapped: Record<string, unknown> = {}
-  if (status === "streaming" || status === "running") mapped.status = "running"
-  else if (status === "completed") mapped.status = "completed"
-  else if (status === "failed" || status === "error") mapped.status = "error"
-  else mapped.status = "pending"
-  if (record.input !== undefined) mapped.input = record.input
-  if (record.output !== undefined) mapped.output = toolContentText(record.output)
-  if (record.error !== undefined) mapped.error = record.error
-  if (record.time !== undefined) mapped.time = record.time
-  return mapped
-}
-
-/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
-export function convertV2Message(message: V2Message, sessionID: string): { info: MessageInfo; parts: PartInfo[] } | undefined {
-  if (!message || typeof message.id !== "string") return undefined
-  const base = {
-    id: message.id,
-    sessionID,
-  }
-  if (message.type === "user") {
-    return {
-      info: {
-        ...base,
-        role: "user",
-        time: { created: message.time?.created ?? 0 },
-        text: message.text ?? "",
-      },
-      parts: [],
-    }
-  }
-  if (message.type === "assistant") {
-    const parts: PartInfo[] = []
-    const content = Array.isArray(message.content) ? message.content : []
-    content.forEach((block, index) => {
-      const record = block as Record<string, unknown>
-      const kind = String(record.type ?? "")
-      if (kind === "text") {
-        parts.push({
-          id: `${message.id}_t${index}`,
-          messageID: message.id,
-          sessionID,
-          type: "text",
-          text: String(record.text ?? ""),
-          synthetic: false,
-          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-        })
-      } else if (kind === "reasoning") {
-        parts.push({
-          id: `${message.id}_r${index}`,
-          messageID: message.id,
-          sessionID,
-          type: "reasoning",
-          text: String(record.text ?? ""),
-          synthetic: false,
-          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
-        })
-      } else if (kind === "tool") {
-        parts.push({
-          id: String(record.id ?? `${message.id}_tool${index}`),
-          messageID: message.id,
-          sessionID,
-          type: "tool",
-          tool: String(record.name ?? "unknown"),
-          state: convertToolState(record.state),
-          synthetic: false,
-        })
-      }
-    })
-    return {
-      info: {
-        ...base,
-        role: "assistant",
-        agent: message.agent,
-        model: message.model
-          ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id }
-          : undefined,
-        time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 },
-      },
-      parts,
-    }
-  }
-  return undefined
-}
-
 // --- v2 client -> engine ClientApi ---------------------------------------------
+// Contract v2: messages pass through VERBATIM as v2 session messages (the
+// engine's ingestion detects v2-native shapes and enqueues them directly —
+// no v1 conversion, no dropped compaction, no dropped user text).
 
 function adaptSessionClient(session: V2SessionClient | undefined, message: V2MessageClient | undefined, directory: string | undefined): ClientApi | undefined {
   if (!session) return undefined
@@ -203,7 +99,7 @@ function adaptSessionClient(session: V2SessionClient | undefined, message: V2Mes
 
   const listMessages = async (sessionID: string) => {
     if (!message) return []
-    const out: Array<{ info: MessageInfo; parts: PartInfo[] }> = []
+    const out: Array<{ info: unknown; parts: unknown[] }> = []
     let cursor: string | undefined
     for (let page = 0; page < 50; page++) {
       const res = (await message.list({ sessionID, limit: 100, cursor })) as
@@ -212,8 +108,9 @@ function adaptSessionClient(session: V2SessionClient | undefined, message: V2Mes
       const data = res?.data
       if (!Array.isArray(data)) break
       for (const raw of data) {
-        const converted = convertV2Message(raw, sessionID)
-        if (converted) out.push(converted)
+        if (raw && typeof raw === "object" && typeof (raw as { id?: unknown }).id === "string") {
+          out.push({ info: raw, parts: [] })
+        }
       }
       const next = res?.cursor?.next ?? undefined
       if (!next || data.length === 0) break
@@ -332,7 +229,20 @@ export function createV2ServerSetup() {
     // the client adapter and feed them into the engine as the v1 events it
     // understands (session.updated / message.updated / message.part.updated).
     // The engine's keyed queue makes repeated re-syncs idempotent.
+    // NOTE: no content-hash dedupe here — a refresh that runs while the
+    // session is still dormant (pre-flag) would poison the cache without
+    // emitting anything, and the flag-time refresh would then SKIP the
+    // unchanged messages (live-caught in the v2 mock suite: the share's
+    // first assistant content arrived only as the next change). The dedupe
+    // belongs engine-side, where dormancy is known, if it's ever needed.
     const pendingRefresh = new Map<string, ReturnType<typeof setTimeout>>()
+    // queued inbox inputs per session: v2 persists the prompt in the inbox
+    // (delivery "queue") while the current turn still runs — the message
+    // row can exist before the model ever sees it, and a mid-turn refresh
+    // would surface it early. Held here until session.inbox.delivered
+    // fires (the turn actually starts); "steer" inputs inject into the
+    // live run, so they pass straight through.
+    const queuedInbox = new Map<string, Set<string>>()
     const refresh = (sessionID: string) => {
       let timer = pendingRefresh.get(sessionID)
       if (timer) clearTimeout(timer)
@@ -346,7 +256,9 @@ export function createV2ServerSetup() {
             })
             const messages = await (client as NonNullable<typeof client>).session.messages?.({ path: { id: sessionID } })
             const list = ((messages as { data?: unknown })?.data ?? []) as Array<{ info: MessageInfo; parts: PartInfo[] }>
+            const held = queuedInbox.get(sessionID)
             for (const message of list) {
+              if (held?.has(message.info.id)) continue // still queued — not sent to the model yet
               await engine.hooks.event({
                 event: { type: "message.updated", properties: { sessionID, info: message.info } },
               })
@@ -380,6 +292,41 @@ export function createV2ServerSetup() {
               await engine.hooks.event({ event: { type, properties: { sessionID: sid } } })
               continue
             }
+            if (type.startsWith("session.inbox.")) {
+              // queued-prompt lifecycle: hold delivery="queue" inputs off
+              // the share until they are actually delivered to the model
+              // (cancelled ones never appear). inboxID shares the message
+              // id space (the inbox item promotes into that message row).
+              const data = (event.data ?? {}) as { inboxID?: string; item?: { delivery?: string } }
+              const inboxID = data.inboxID
+              if (inboxID) {
+                let set = queuedInbox.get(sid)
+                if (!set) {
+                  set = new Set()
+                  queuedInbox.set(sid, set)
+                }
+                if (type === "session.inbox.enqueued" && data.item?.delivery === "queue") {
+                  set.add(inboxID)
+                } else if (type === "session.inbox.delivered") {
+                  set.delete(inboxID)
+                  refresh(sid) // the held prompt's turn is starting now
+                } else if (type === "session.inbox.cancelled") {
+                  // cancelled-before-run: the prompt never reaches the
+                  // model — keep it held forever so no later refresh
+                  // surfaces the orphaned row
+                  set.add(inboxID)
+                } else if (type === "session.inbox.delivery.changed") {
+                  // steer inputs inject into the live run — the model
+                  // sees them; only "queue" holds
+                  if (data.item?.delivery === "queue") set.add(inboxID)
+                  else {
+                    set.delete(inboxID)
+                    refresh(sid)
+                  }
+                }
+              }
+              continue
+            }
             if (type === "message.removed" || type === "message.part.removed") {
               // undo cleanup: forwarded verbatim — the engine emits the
               // tombstones that purge the reverted items from the share