@kidsinai/kids-client 0.0.19 → 0.0.20

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@kidsinai/kids-client",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "type": "module",
   "description": "Own-client TUI for Kids OpenCode — talks to local `opencode serve` via @opencode-ai/sdk v2 with kid-warm rendering, mission progress, permission dialog, and stderr-tail audit pipeline.",
   "license": "MIT",
@@ -35,7 +35,7 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "react": "^18.3.1",
-    "@kidsinai/kids-opencode-plugin": "^0.0.19"
+    "@kidsinai/kids-opencode-plugin": "^0.0.20"
   },
   "devDependencies": {
     "@opencode-ai/sdk": "^1.14.51",

package/src/core/debug.ts

@@ -0,0 +1,51 @@
+/**
+ * Tiny file-based debug logger.
+ *
+ * Always-on writes to ~/.config/kids-opencode/debug.log so we can see what
+ * actually happened in a TUI session after the fact (Ink owns the terminal,
+ * so console.log/error doesn't show on screen and would also break the
+ * alt-screen-buffer canvas).
+ *
+ * Set KIDS_DEBUG=0 to silence it. Otherwise it's on by default while we're
+ * still chasing the "thinking…" hang in dogfood.
+ */
+
+import { appendFileSync, mkdirSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+
+const PATH = process.env.KIDS_DEBUG_LOG
+  ?? join(process.env.KIDS_OPENCODE_CONFIG_DIR ?? join(homedir(), ".config", "kids-opencode"), "debug.log")
+
+const ENABLED = process.env.KIDS_DEBUG !== "0"
+
+let initialised = false
+
+function init(): void {
+  if (initialised) return
+  try {
+    mkdirSync(dirname(PATH), { recursive: true })
+    appendFileSync(PATH, `\n===== kids-client debug log opened at ${new Date().toISOString()} (pid ${process.pid}) =====\n`, "utf8")
+  } catch {
+    // can't init — disable to avoid further failures
+    initialised = true
+    return
+  }
+  initialised = true
+}
+
+export function debug(message: string, fields?: Record<string, unknown>): void {
+  if (!ENABLED) return
+  init()
+  try {
+    const stamp = new Date().toISOString()
+    const tail = fields ? " " + JSON.stringify(fields) : ""
+    appendFileSync(PATH, `${stamp} ${message}${tail}\n`, "utf8")
+  } catch {
+    // best-effort, never throw from the logger
+  }
+}
+
+export function debugLogPath(): string {
+  return PATH
+}

package/src/core/events.ts

@@ -66,6 +66,14 @@ export class EventSubscriber {
     this.abort.abort()
   }
 
+  private dbg(message: string, fields?: Record<string, unknown>): void {
+    // Lazy require to avoid a hard dep cycle if debug.ts grows imports.
+    try {
+      const { debug } = require("./debug.ts") as { debug: (m: string, f?: Record<string, unknown>) => void }
+      debug(`[events] ${message}`, fields)
+    } catch { /* never let logging block events */ }
+  }
+
   private async consume(): Promise<void> {
     // The SDK exposes the SSE stream via client.global.event(). The shape
     // has changed across SDK versions:
@@ -78,19 +86,24 @@ export class EventSubscriber {
     if (!eventApi || typeof eventApi.event !== "function") {
       throw new Error("@opencode-ai/sdk/v2: client.global.event() not available — SDK version drift")
     }
+    this.dbg("consume: calling event()")
     const result = await Promise.resolve(eventApi.event())
+    this.dbg("consume: event() returned", { shape: describeShape(result) })
     const iterable = pickAsyncIterable(result)
     if (!iterable) {
       throw new Error(`@opencode-ai/sdk/v2: client.global.event() returned an unrecognised shape: ${describeShape(result)}`)
     }
+    this.dbg("consume: got iterable, awaiting SSE events…")
     for await (const raw of iterable) {
       if (this.abort.signal.aborted) return
       if (this.retries > 0) {
         this.retries = 0
         this.handlers.onReconnected?.()
       }
+      this.dbg("consume: raw event", { preview: previewRaw(raw) })
       this.dispatch(raw)
     }
+    this.dbg("consume: iterable ended")
   }
 
   private dispatch(raw: unknown): void {
@@ -239,3 +252,12 @@ function describeShape(value: unknown): string {
   if (typeof value !== "object") return typeof value
   return `object keys=[${Object.keys(value as object).join(",")}]`
 }
+
+function previewRaw(raw: unknown): string {
+  try {
+    const s = JSON.stringify(raw)
+    return s.length > 220 ? s.slice(0, 220) + "…" : s
+  } catch {
+    return describeShape(raw)
+  }
+}

package/src/core/session.ts

@@ -11,6 +11,16 @@
 
 import type { OpencodeClient } from "./connection.ts"
 import type { SessionSummary } from "./store.ts"
+import { debug } from "./debug.ts"
+
+/**
+ * SDK 1.14.x default is `ThrowOnError=false` which returns the discriminated
+ * union { data, error }. If we don't inspect `.error`, auth / 4xx / 5xx
+ * responses are silently swallowed and the kid sees "thinking…" forever.
+ * Pass this options object to every call so the SDK throws and the
+ * orchestrator's existing try/catch can surface the error on ErrorScreen.
+ */
+const SDK_THROW: { throwOnError: true } = { throwOnError: true }
 
 export class SessionManager {
   private client: OpencodeClient
@@ -50,35 +60,59 @@ export class SessionManager {
   }
 
   async create(): Promise<string> {
-    const api = (this.client as unknown as { session?: { create: (input?: unknown) => Promise<{ data?: { id?: string } } | { id?: string } | string> } }).session
+    const api = (this.client as unknown as { session?: { create: (input?: unknown, options?: unknown) => Promise<{ data?: { id?: string } } | { id?: string } | string> } }).session
     if (!api?.create) throw new Error("SDK v2: client.session.create unavailable")
-    const result = await api.create({})
+    debug("session.create: calling SDK")
+    const result = await api.create({}, SDK_THROW)
+    debug("session.create: result shape", { keys: result && typeof result === "object" ? Object.keys(result) : typeof result })
     const id = extractId(result)
     if (!id) throw new Error("SDK v2 session.create returned no id")
     this.currentSessionId = id
+    debug("session.create: id", { id })
     return id
   }
 
   async prompt(text: string, opts?: { model?: string; agent?: string }): Promise<void> {
     if (!this.currentSessionId) await this.create()
     const sessionID = this.currentSessionId!
-    const api = (this.client as unknown as { session?: { prompt: (sessionID: string, body: unknown) => Promise<unknown> } }).session
+    const api = (this.client as unknown as { session?: { prompt: (parameters: unknown, options?: unknown) => Promise<unknown> } }).session
     if (!api?.prompt) throw new Error("SDK v2: client.session.prompt unavailable")
-    await api.prompt(sessionID, {
-      parts: [{ type: "text", text }],
-      model: opts?.model,
-      agent: opts?.agent,
-    })
+    // SDK 1.14.51 signature: single parameters object, kid's text under .prompt.text.
+    // Pass SDK_THROW so 4xx/5xx surface as exceptions instead of getting
+    // silently swallowed (the bug behind the "thinking…" hang).
+    // `model` (from the /model picker) is a "providerID/modelID" string; the SDK
+    // wants it split into { providerID, modelID }.
+    const model = splitModelId(opts?.model)
+    const payload = {
+      sessionID,
+      prompt: { text },
+      ...(model ? { model } : {}),
+      ...(opts?.agent ? { agent: opts.agent } : {}),
+    }
+    debug("session.prompt: sending", { sessionID, textLen: text.length })
+    try {
+      const result = await api.prompt(payload, SDK_THROW)
+      debug("session.prompt: SDK returned", { keys: result && typeof result === "object" ? Object.keys(result) : typeof result })
+    } catch (err) {
+      debug("session.prompt: SDK threw", { error: errMsg(err) })
+      throw err
+    }
   }
 
   async abort(): Promise<void> {
     if (!this.currentSessionId) return
-    const api = (this.client as unknown as { session?: { abort: (sessionID: string) => Promise<unknown> } }).session
+    const api = (this.client as unknown as { session?: { abort: (parameters: unknown, options?: unknown) => Promise<unknown> } }).session
     if (!api?.abort) return
-    await api.abort(this.currentSessionId)
+    debug("session.abort", { sessionID: this.currentSessionId })
+    await api.abort({ sessionID: this.currentSessionId }, SDK_THROW)
   }
 }
 
+function errMsg(err: unknown): string {
+  if (err instanceof Error) return `${err.name}: ${err.message}`
+  try { return JSON.stringify(err) } catch { return String(err) }
+}
+
 function extractId(result: unknown): string | null {
   if (typeof result === "string") return result
   if (result && typeof result === "object") {
@@ -88,6 +122,18 @@ function extractId(result: unknown): string | null {
   return null
 }
 
+/**
+ * Split a "providerID/modelID" id (as built by the /model picker) into the
+ * shape the SDK prompt body wants. Splits on the FIRST slash so model ids that
+ * themselves contain "/" survive. Returns undefined for empty/no input.
+ */
+function splitModelId(id: string | undefined): { providerID: string; modelID: string } | undefined {
+  if (!id) return undefined
+  const slash = id.indexOf("/")
+  if (slash <= 0 || slash === id.length - 1) return undefined
+  return { providerID: id.slice(0, slash), modelID: id.slice(slash + 1) }
+}
+
 /** SDK list responses come back as `T[]` or `{ data: T[] }` across versions. */
 function unwrapArray(result: unknown): unknown[] {
   if (Array.isArray(result)) return result