@daniel156161/prism 0.2.92 → 0.2.96

package/src/prism-extensions/core/voicebox-client.ts

@@ -1,205 +0,0 @@
-import { readSettings } from "./shared-config.js"
-
-export interface VoiceboxConfig {
-  baseUrl: string
-  profile?: string
-  language: string
-  engine?: string
-  personality?: boolean
-  clientId: string
-  timeoutMs: number
-  generationTimeoutMs: number
-}
-
-export interface VoiceboxGenerationStatus {
-  id: string
-  status: string
-  duration?: number
-  error?: string | null
-  source?: string
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-function boolSetting(value: unknown): boolean | undefined {
-  if (typeof value === "boolean") return value
-  if (typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim())) return true
-  if (typeof value === "string" && /^(0|false|no|off)$/i.test(value.trim())) return false
-  return undefined
-}
-
-function numberSetting(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) return value
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value)
-    if (Number.isFinite(parsed)) return parsed
-  }
-  return undefined
-}
-
-function getVoiceboxSettings(env: NodeJS.ProcessEnv): any {
-  const settings = readSettings(undefined, env)
-  return settings?.voicebox ?? settings?.voice?.voicebox ?? {}
-}
-
-function getVoiceSettings(env: NodeJS.ProcessEnv): any {
-  return readSettings(undefined, env)?.voice ?? {}
-}
-
-export function normalizeVoiceboxBaseUrl(value: string): string {
-  return value.replace(/\/+$/, "")
-}
-
-export function resolveVoiceboxConfig(env: NodeJS.ProcessEnv = process.env): VoiceboxConfig {
-  const voicebox = getVoiceboxSettings(env)
-  return {
-    baseUrl: normalizeVoiceboxBaseUrl(nonEmpty(env.PRISM_VOICEBOX_URL) ?? nonEmpty(voicebox.url) ?? nonEmpty(voicebox.baseUrl) ?? "http://127.0.0.1:17493"),
-    profile: nonEmpty(env.PRISM_VOICEBOX_PROFILE) ?? nonEmpty(voicebox.profile),
-    language: nonEmpty(env.PRISM_VOICEBOX_LANGUAGE) ?? nonEmpty(voicebox.language) ?? "en",
-    engine: nonEmpty(env.PRISM_VOICEBOX_ENGINE) ?? nonEmpty(voicebox.engine),
-    personality: boolSetting(env.PRISM_VOICEBOX_PERSONALITY) ?? boolSetting(voicebox.personality) ?? false,
-    clientId: nonEmpty(env.PRISM_VOICEBOX_CLIENT_ID) ?? nonEmpty(voicebox.clientId) ?? "prism",
-    timeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_TIMEOUT_MS) ?? numberSetting(voicebox.timeoutMs) ?? 30_000),
-    generationTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_GENERATION_TIMEOUT_MS) ?? numberSetting(voicebox.generationTimeoutMs) ?? 180_000),
-  }
-}
-
-export function resolveVoiceBackend(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  return nonEmpty(env.PRISM_VOICE_BACKEND) ?? nonEmpty(getVoiceSettings(env).backend)
-}
-
-export function isVoiceboxBackend(env: NodeJS.ProcessEnv = process.env): boolean {
-  return /^(voicebox|auto)$/i.test(resolveVoiceBackend(env) ?? "") || !!nonEmpty(env.PRISM_VOICEBOX_URL) || !!nonEmpty(getVoiceboxSettings(env).url) || !!nonEmpty(getVoiceboxSettings(env).baseUrl)
-}
-
-async function fetchJson(url: string, init: RequestInit, timeoutMs: number): Promise<any> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  const text = await response.text()
-  const parsed = parseJsonOrText(text)
-  if (!response.ok) {
-    const detail = typeof parsed?.detail === "string" ? parsed.detail : typeof parsed === "string" ? parsed : `HTTP ${response.status}`
-    throw new Error(detail)
-  }
-  return parsed
-}
-
-async function fetchBuffer(url: string, init: RequestInit, timeoutMs: number): Promise<Buffer> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  return Buffer.from(await response.arrayBuffer())
-}
-
-async function fetchStream(url: string, init: RequestInit, timeoutMs: number, onChunk: (chunk: Uint8Array) => void | Promise<void>): Promise<void> {
-  const response = await fetch(url, { ...init, signal: AbortSignal.timeout(timeoutMs) })
-  if (!response.ok) throw new Error(`HTTP ${response.status}`)
-  if (!response.body) return
-  const reader = response.body.getReader()
-  try {
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      if (value?.byteLength) await onChunk(value)
-    }
-  } finally {
-    reader.releaseLock()
-  }
-}
-
-function parseJsonOrText(text: string): any {
-  try { return text ? JSON.parse(text) : undefined } catch { return text }
-}
-
-function parseVoiceboxStatusEvent(text: string): VoiceboxGenerationStatus | undefined {
-  for (const line of text.split(/\r?\n/)) {
-    if (!line.startsWith("data:")) continue
-    const parsed = parseJsonOrText(line.replace(/^data:\s*/, ""))
-    if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed
-  }
-  const parsed = parseJsonOrText(text)
-  if (parsed && typeof parsed === "object" && typeof parsed.status === "string") return parsed
-  return undefined
-}
-
-export async function checkVoiceboxHealth(config = resolveVoiceboxConfig()): Promise<boolean> {
-  try {
-    await fetchJson(`${config.baseUrl}/health`, { method: "GET" }, Math.min(config.timeoutMs, 5_000))
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function speakWithVoicebox(text: string, config = resolveVoiceboxConfig()): Promise<any> {
-  return fetchJson(`${config.baseUrl}/speak`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "X-Voicebox-Client-Id": config.clientId,
-    },
-    body: JSON.stringify({
-      text,
-      profile: config.profile,
-      language: config.language,
-      engine: config.engine,
-      personality: config.personality,
-    }),
-  }, config.timeoutMs)
-}
-
-function isAbortLikeError(error: unknown): boolean {
-  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")
-}
-
-export async function waitForVoiceboxGeneration(id: string, config = resolveVoiceboxConfig()): Promise<VoiceboxGenerationStatus> {
-  const deadline = Date.now() + config.generationTimeoutMs
-  let lastStatus: VoiceboxGenerationStatus | undefined
-  while (Date.now() < deadline) {
-    try {
-      const response = await fetch(`${config.baseUrl}/generate/${encodeURIComponent(id)}/status`, { method: "GET", signal: AbortSignal.timeout(Math.min(config.timeoutMs, 10_000)) })
-      const text = await response.text()
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
-      lastStatus = parseVoiceboxStatusEvent(text) ?? lastStatus
-      if (lastStatus?.status === "completed") return lastStatus
-      if (lastStatus?.status === "failed") throw new Error(lastStatus.error || "Voicebox generation failed")
-    } catch (error) {
-      if (!isAbortLikeError(error)) throw error
-      // Voicebox can block status responses while lazily loading a TTS model.
-      // Treat individual poll timeouts as transient; the overall generation
-      // timeout below remains the hard limit.
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500))
-  }
-  throw new Error(`Voicebox generation timed out${lastStatus?.status ? ` (${lastStatus.status})` : ""}`)
-}
-
-export async function downloadVoiceboxAudio(id: string, config = resolveVoiceboxConfig()): Promise<Buffer> {
-  return fetchBuffer(`${config.baseUrl}/audio/${encodeURIComponent(id)}`, { method: "GET" }, config.timeoutMs)
-}
-
-export async function synthesizeSpeechWithVoicebox(text: string, config = resolveVoiceboxConfig()): Promise<Buffer> {
-  const generation = await speakWithVoicebox(text, config)
-  const id = String(generation?.id ?? "")
-  if (!id) throw new Error("Voicebox did not return a generation id")
-  await waitForVoiceboxGeneration(id, config)
-  return downloadVoiceboxAudio(id, config)
-}
-
-export async function streamSpeechWithVoicebox(text: string, onChunk: (chunk: Uint8Array) => void | Promise<void>, config = resolveVoiceboxConfig()): Promise<void> {
-  const generation = await speakWithVoicebox(text, config)
-  const id = String(generation?.id ?? "")
-  if (!id) throw new Error("Voicebox did not return a generation id")
-  await waitForVoiceboxGeneration(id, config)
-  await fetchStream(`${config.baseUrl}/audio/${encodeURIComponent(id)}`, { method: "GET" }, config.timeoutMs, onChunk)
-}
-
-export async function transcribeWithVoicebox(audio: Blob | Buffer | Uint8Array, options: { fileName?: string; language?: string; model?: string } = {}, config = resolveVoiceboxConfig()): Promise<string> {
-  const form = new FormData()
-  const file = audio instanceof Blob ? audio : new Blob([new Uint8Array(audio)])
-  form.append("file", file, options.fileName ?? "audio.wav")
-  if (options.language) form.append("language", options.language)
-  if (options.model) form.append("model", options.model)
-  const result = await fetchJson(`${config.baseUrl}/transcribe`, { method: "POST", body: form }, config.timeoutMs)
-  return String(result?.text ?? "")
-}

package/src/prism-extensions/core/voicebox-service.ts

@@ -1,137 +0,0 @@
-import * as fs from "node:fs"
-import * as os from "node:os"
-import * as path from "node:path"
-import { spawnSync, type SpawnSyncReturns } from "node:child_process"
-import { readSettings } from "./shared-config.js"
-import { checkVoiceboxHealth, resolveVoiceboxConfig } from "./voicebox-client.js"
-
-const VOICEBOX_REPO_URL = "https://github.com/jamiepine/voicebox.git"
-
-export interface VoiceboxServiceConfig {
-  autoInstall: boolean
-  autoStart: boolean
-  autoStop: boolean
-  installDir: string
-  installCommand: string
-  startCommand: string
-  stopCommand: string
-  startupTimeoutMs: number
-  installTimeoutMs: number
-  stopTimeoutMs: number
-}
-
-function nonEmpty(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-function boolSetting(value: unknown): boolean | undefined {
-  if (typeof value === "boolean") return value
-  if (typeof value === "string" && /^(1|true|yes|on)$/i.test(value.trim())) return true
-  if (typeof value === "string" && /^(0|false|no|off)$/i.test(value.trim())) return false
-  return undefined
-}
-
-function numberSetting(value: unknown): number | undefined {
-  if (typeof value === "number" && Number.isFinite(value)) return value
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value)
-    if (Number.isFinite(parsed)) return parsed
-  }
-  return undefined
-}
-
-function quote(value: string): string {
-  return JSON.stringify(value)
-}
-
-function defaultInstallDir(env: NodeJS.ProcessEnv): string {
-  return nonEmpty(env.PRISM_VOICEBOX_DIR) ?? path.join(os.homedir(), ".local", "share", "prism", "voicebox")
-}
-
-function defaultInstallCommand(installDir: string): string {
-  return `mkdir -p ${quote(path.dirname(installDir))} && git clone ${quote(VOICEBOX_REPO_URL)} ${quote(installDir)}`
-}
-
-function defaultStartCommand(installDir: string): string {
-  return `if command -v prism-voicebox >/dev/null 2>&1; then prism-voicebox start; else cd ${quote(installDir)} && docker compose up -d --build; fi`
-}
-
-function defaultStopCommand(installDir: string): string {
-  return `if command -v prism-voicebox >/dev/null 2>&1; then prism-voicebox stop; else cd ${quote(installDir)} && docker compose down; fi`
-}
-
-export function resolveVoiceboxServiceConfig(env: NodeJS.ProcessEnv = process.env): VoiceboxServiceConfig {
-  const settings = readSettings(undefined, env)?.voicebox ?? {}
-  const installDir = nonEmpty(env.PRISM_VOICEBOX_DIR) ?? nonEmpty(settings.installDir) ?? defaultInstallDir(env)
-  return {
-    autoInstall: boolSetting(env.PRISM_VOICEBOX_AUTO_INSTALL) ?? boolSetting(settings.autoInstall) ?? true,
-    autoStart: boolSetting(env.PRISM_VOICEBOX_AUTO_START) ?? boolSetting(settings.autoStart) ?? true,
-    autoStop: boolSetting(env.PRISM_VOICEBOX_AUTO_STOP) ?? boolSetting(settings.autoStop) ?? true,
-    installDir,
-    installCommand: nonEmpty(env.PRISM_VOICEBOX_INSTALL_COMMAND) ?? nonEmpty(settings.installCommand) ?? defaultInstallCommand(installDir),
-    startCommand: nonEmpty(env.PRISM_VOICEBOX_START_COMMAND) ?? nonEmpty(settings.startCommand) ?? defaultStartCommand(installDir),
-    stopCommand: nonEmpty(env.PRISM_VOICEBOX_STOP_COMMAND) ?? nonEmpty(settings.stopCommand) ?? defaultStopCommand(installDir),
-    startupTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_STARTUP_TIMEOUT_MS) ?? numberSetting(settings.startupTimeoutMs) ?? 120_000),
-    installTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_INSTALL_TIMEOUT_MS) ?? numberSetting(settings.installTimeoutMs) ?? 300_000),
-    stopTimeoutMs: Math.max(1_000, numberSetting(env.PRISM_VOICEBOX_STOP_TIMEOUT_MS) ?? numberSetting(settings.stopTimeoutMs) ?? 60_000),
-  }
-}
-
-async function sleep(ms: number): Promise<void> {
-  await new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function runShell(command: string, timeoutMs: number, env: NodeJS.ProcessEnv, spawnSyncProcess: typeof spawnSync): boolean {
-  const result: SpawnSyncReturns<Buffer> = spawnSyncProcess("sh", ["-lc", command], { env, stdio: "ignore", timeout: timeoutMs })
-  return !result.error && (result.status === 0 || result.status === null)
-}
-
-export function isVoiceboxServiceInstalled(env: NodeJS.ProcessEnv = process.env): boolean {
-  const service = resolveVoiceboxServiceConfig(env)
-  return fs.existsSync(path.join(service.installDir, "docker-compose.yml")) || fs.existsSync(path.join(service.installDir, "compose.yml"))
-}
-
-export async function installVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (isVoiceboxServiceInstalled(env)) return true
-  if (!service.autoInstall) return false
-  return runShell(service.installCommand, service.installTimeoutMs, env, spawnSyncProcess) && isVoiceboxServiceInstalled(env)
-}
-
-export async function startVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (!service.autoStart) return false
-  if (!isVoiceboxServiceInstalled(env) && !(await installVoiceboxService(env, spawnSyncProcess))) return false
-  return runShell(service.startCommand, service.startupTimeoutMs, env, spawnSyncProcess)
-}
-
-export async function stopVoiceboxService(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync): Promise<boolean> {
-  const service = resolveVoiceboxServiceConfig(env)
-  if (!service.autoStop) return false
-  if (!isVoiceboxServiceInstalled(env)) return false
-  return runShell(service.stopCommand, service.stopTimeoutMs, env, spawnSyncProcess)
-}
-
-export async function ensureVoiceboxServiceRunning(env: NodeJS.ProcessEnv = process.env, spawnSyncProcess: typeof spawnSync = spawnSync, onStatus?: (message: string, level?: string) => void): Promise<boolean> {
-  const config = resolveVoiceboxConfig(env)
-  if (await checkVoiceboxHealth(config)) return true
-  const service = resolveVoiceboxServiceConfig(env)
-
-  if (!isVoiceboxServiceInstalled(env)) {
-    if (!service.autoInstall) return false
-    onStatus?.(`Voicebox is not installed. Installing to ${service.installDir}…`, "info")
-    if (!(await installVoiceboxService(env, spawnSyncProcess))) return false
-  }
-
-  if (!service.autoStart) return false
-  onStatus?.("Voicebox is not running. Starting local Voicebox container…", "info")
-  const started = await startVoiceboxService(env, spawnSyncProcess)
-  if (!started) return false
-
-  const deadline = Date.now() + service.startupTimeoutMs
-  while (Date.now() < deadline) {
-    if (await checkVoiceboxHealth(config)) return true
-    await sleep(1_000)
-  }
-  return false
-}

package/src/prism-extensions/integrations/honcho-memory.ts

@@ -1,299 +0,0 @@
-import { readSettings, getPrismSettingsPath } from "../core/shared-config.js"
-import { schema } from "../core/vault.js"
-import { renderSingleLineToolCall, type ThemeLike } from "../ui/tool-call-rendering.js"
-
-export type ExtensionAPI = any
-
-export type HonchoConfig = {
-  baseUrl?: string
-  apiKey?: string
-  workspace: string
-  userPeer: string
-  assistantPeer: string
-  sessionId?: string
-  autoCapture: boolean
-  maxCaptureChars: number
-}
-
-type HonchoMessage = {
-  role?: string
-  content?: unknown
-  customType?: string
-  stopReason?: string
-  metadata?: Record<string, unknown>
-}
-
-const DEFAULT_WORKSPACE = "prism"
-const DEFAULT_USER_PEER = "user"
-const DEFAULT_ASSISTANT_PEER = "prism"
-const DEFAULT_MAX_CAPTURE_CHARS = 12_000
-
-const INJECTED_CONTEXT_TYPES = new Set([
-  "honcho-memory-context",
-  "obsidian-memory-context",
-  "logseq-memory-context",
-  "rp-memory-context",
-])
-
-function nonEmptyString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value.trim() : undefined
-}
-
-function boolFromConfig(value: unknown, fallback: boolean): boolean {
-  if (value === undefined || value === null) return fallback
-  if (typeof value === "boolean") return value
-  const normalized = String(value).trim().toLowerCase()
-  if (["0", "false", "no", "off"].includes(normalized)) return false
-  if (["1", "true", "yes", "on"].includes(normalized)) return true
-  return fallback
-}
-
-export function sanitizeHonchoId(value: string): string {
-  const cleaned = value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "")
-  return cleaned || "default"
-}
-
-function honchoSettingsBlock(settings: any): any {
-  return settings?.honchoMemory ?? settings?.honcho ?? settings?.integrations?.honcho ?? settings?.memory?.honcho ?? {}
-}
-
-export function readHonchoSettings(env: NodeJS.ProcessEnv = process.env): any {
-  return honchoSettingsBlock(readSettings(getPrismSettingsPath(env)))
-}
-
-export function resolveHonchoConfig(env: NodeJS.ProcessEnv = process.env, settings: any = readHonchoSettings(env)): HonchoConfig {
-  const sessionId = nonEmptyString(env.PRISM_HONCHO_SESSION_ID) ?? nonEmptyString(settings?.sessionId) ?? nonEmptyString(settings?.session)
-  const maxCaptureChars = nonEmptyString(env.PRISM_HONCHO_MAX_CAPTURE_CHARS) ?? settings?.maxCaptureChars
-  return {
-    baseUrl: nonEmptyString(env.PRISM_HONCHO_BASE_URL) ?? nonEmptyString(env.HONCHO_BASE_URL) ?? nonEmptyString(settings?.baseUrl) ?? nonEmptyString(settings?.baseURL) ?? nonEmptyString(settings?.url),
-    apiKey: nonEmptyString(env.PRISM_HONCHO_API_KEY) ?? nonEmptyString(env.HONCHO_API_KEY) ?? nonEmptyString(settings?.apiKey) ?? nonEmptyString(settings?.token) ?? nonEmptyString(settings?.jwt),
-    workspace: sanitizeHonchoId(nonEmptyString(env.PRISM_HONCHO_WORKSPACE) ?? nonEmptyString(env.HONCHO_WORKSPACE) ?? nonEmptyString(settings?.workspace) ?? DEFAULT_WORKSPACE),
-    userPeer: sanitizeHonchoId(nonEmptyString(env.PRISM_HONCHO_USER_PEER) ?? nonEmptyString(settings?.userPeer) ?? nonEmptyString(settings?.user) ?? DEFAULT_USER_PEER),
-    assistantPeer: sanitizeHonchoId(nonEmptyString(env.PRISM_HONCHO_ASSISTANT_PEER) ?? nonEmptyString(settings?.assistantPeer) ?? nonEmptyString(settings?.assistant) ?? DEFAULT_ASSISTANT_PEER),
-    sessionId: sessionId ? sanitizeHonchoId(sessionId) : undefined,
-    autoCapture: boolFromConfig(env.PRISM_HONCHO_AUTO_CAPTURE ?? settings?.autoCapture, true),
-    maxCaptureChars: Math.max(100, Math.min(Number(maxCaptureChars ?? DEFAULT_MAX_CAPTURE_CHARS) || DEFAULT_MAX_CAPTURE_CHARS, 25_000)),
-  }
-}
-
-export function isHonchoConfigured(env: NodeJS.ProcessEnv = process.env): boolean {
-  return !!resolveHonchoConfig(env).baseUrl
-}
-
-function textFromContent(content: unknown): string {
-  if (typeof content === "string") return content
-  if (Array.isArray(content)) {
-    return content.map((part) => {
-      if (typeof part === "string") return part
-      if (part && typeof part === "object" && typeof (part as any).text === "string") return (part as any).text
-      return ""
-    }).filter(Boolean).join("\n")
-  }
-  return ""
-}
-
-export function shouldCaptureHonchoMessage(message: HonchoMessage): boolean {
-  const role = message?.role
-  if (role !== "user" && role !== "assistant") return false
-  if (message.customType && INJECTED_CONTEXT_TYPES.has(message.customType)) return false
-  if (role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted")) return false
-  const text = textFromContent(message.content).trim()
-  if (!text) return false
-  const lower = text.slice(0, 200).toLowerCase()
-  if (lower.includes("prompt-relevant memories from the user's obsidian vault")) return false
-  if (lower.includes("always-loaded context from 00 kontext")) return false
-  if (lower.includes("prompt-relevant pages from the user's logseq vault")) return false
-  if (lower.includes("honcho memory context")) return false
-  return true
-}
-
-export function honchoSessionIdFromContext(ctx: any, fallback = "prism-session"): string {
-  const explicit = nonEmptyString(ctx?.sessionId) ?? nonEmptyString(ctx?.session?.id) ?? nonEmptyString(ctx?.sessionManager?.sessionId)
-  if (explicit) return sanitizeHonchoId(explicit)
-  const file = nonEmptyString(ctx?.sessionManager?.getSessionFile?.())
-  if (file) return sanitizeHonchoId(file.split(/[\\/]/).pop()?.replace(/\.[^.]+$/, "") ?? file)
-  return sanitizeHonchoId(fallback)
-}
-
-class HonchoHttpClient {
-  readonly baseUrl: string
-  readonly apiKey?: string
-
-  constructor(config: HonchoConfig) {
-    if (!config.baseUrl) throw new Error("Honcho base URL is not configured")
-    this.baseUrl = config.baseUrl.replace(/\/+$/, "")
-    this.apiKey = config.apiKey
-  }
-
-  private headers(): Record<string, string> {
-    const headers: Record<string, string> = { "content-type": "application/json" }
-    if (this.apiKey) headers.authorization = `Bearer ${this.apiKey}`
-    return headers
-  }
-
-  private async request(path: string, init: RequestInit = {}): Promise<any> {
-    const response = await fetch(`${this.baseUrl}${path}`, { ...init, headers: { ...this.headers(), ...(init.headers as any ?? {}) } })
-    const text = await response.text()
-    const body = text ? safeJsonParse(text) : undefined
-    if (!response.ok) {
-      const detail = typeof body?.detail === "string" ? body.detail : typeof body?.error?.message === "string" ? body.error.message : text
-      throw new Error(`Honcho ${response.status}: ${detail || response.statusText}`)
-    }
-    return body
-  }
-
-  async health(): Promise<any> { return this.request("/health", { method: "GET" }) }
-  async ensureWorkspace(workspace: string): Promise<void> { await this.request("/v3/workspaces", { method: "POST", body: JSON.stringify({ id: workspace }) }) }
-  async ensurePeer(workspace: string, peer: string): Promise<void> { await this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/peers`, { method: "POST", body: JSON.stringify({ id: peer }) }) }
-  async ensureSession(workspace: string, session: string, peers: string[]): Promise<void> {
-    const peerMap = Object.fromEntries(peers.map((peer) => [peer, {}]))
-    await this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/sessions`, { method: "POST", body: JSON.stringify({ id: session, peers: peerMap }) })
-  }
-  async addMessages(workspace: string, session: string, messages: Array<{ peer_id: string; content: string; metadata?: Record<string, unknown> }>): Promise<any> {
-    return this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/sessions/${encodeURIComponent(session)}/messages`, { method: "POST", body: JSON.stringify({ messages }) })
-  }
-  async chat(workspace: string, peer: string, query: string, sessionId?: string, reasoningLevel = "low"): Promise<string> {
-    const body: Record<string, unknown> = { query, reasoning_level: reasoningLevel, stream: false }
-    if (sessionId) body.session_id = sessionId
-    const result = await this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/peers/${encodeURIComponent(peer)}/chat`, { method: "POST", body: JSON.stringify(body) })
-    return String(result?.content ?? "")
-  }
-  async representation(workspace: string, peer: string, options: Record<string, unknown> = {}): Promise<string> {
-    const result = await this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/peers/${encodeURIComponent(peer)}/representation`, { method: "POST", body: JSON.stringify(options) })
-    return String(result?.representation ?? "")
-  }
-  async context(workspace: string, session: string, tokens = 2000, summary = true): Promise<any> {
-    const params = new URLSearchParams({ tokens: String(tokens), summary: String(summary) })
-    return this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/sessions/${encodeURIComponent(session)}/context?${params}`, { method: "GET" })
-  }
-  async queueStatus(workspace: string): Promise<any> { return this.request(`/v3/workspaces/${encodeURIComponent(workspace)}/queue/status`, { method: "GET" }) }
-}
-
-function safeJsonParse(text: string): any {
-  try { return JSON.parse(text) } catch { return undefined }
-}
-
-async function ensureBase(client: HonchoHttpClient, config: HonchoConfig, sessionId?: string): Promise<void> {
-  await client.ensureWorkspace(config.workspace)
-  await client.ensurePeer(config.workspace, config.userPeer)
-  await client.ensurePeer(config.workspace, config.assistantPeer)
-  if (sessionId) await client.ensureSession(config.workspace, sessionId, [config.userPeer, config.assistantPeer])
-}
-
-export function buildCapturedHonchoMessages(messages: HonchoMessage[], config: HonchoConfig): Array<{ peer_id: string; content: string; metadata: Record<string, unknown> }> {
-  return messages.filter(shouldCaptureHonchoMessage).map((message) => {
-    const role = message.role === "assistant" ? "assistant" : "user"
-    const peer_id = role === "assistant" ? config.assistantPeer : config.userPeer
-    const raw = textFromContent(message.content).trim()
-    const content = raw.length > config.maxCaptureChars ? `${raw.slice(0, config.maxCaptureChars)}\n\n[truncated by Prism Honcho auto-capture]` : raw
-    return { peer_id, content, metadata: { source: "prism", role, auto_capture: true } }
-  })
-}
-
-function formatToolCall(action: string, value: unknown, theme: ThemeLike): string {
-  const label = typeof value === "string" && value.trim() ? value.trim() : "..."
-  return `${theme.fg("toolTitle", theme.bold(`honcho ${action}`))} ${theme.fg("accent", label)}`
-}
-
-export default async function honchoMemoryExtension(pi: ExtensionAPI): Promise<void> {
-  const config = resolveHonchoConfig()
-  if (!config.baseUrl) return
-
-  const client = new HonchoHttpClient(config)
-
-  pi.on?.("session_start", async (_event: any, ctx: any) => {
-    const status = config.apiKey ? `Honcho: ${config.workspace}` : "Honcho: missing API key"
-    ctx.ui?.setStatus?.("honcho-memory", status)
-  })
-
-  pi.on?.("agent_end", async (event: any, ctx: any) => {
-    if (!config.autoCapture || !config.apiKey) return
-    const sessionId = config.sessionId ?? honchoSessionIdFromContext(ctx)
-    const messages = buildCapturedHonchoMessages(event?.messages ?? [], config)
-    if (messages.length === 0) return
-    try {
-      await ensureBase(client, config, sessionId)
-      await client.addMessages(config.workspace, sessionId, messages)
-      ctx?.ui?.setStatus?.("honcho-memory", `Honcho: captured ${messages.length}`)
-    } catch (error) {
-      ctx?.ui?.notify?.(`Honcho auto-capture failed: ${error instanceof Error ? error.message : String(error)}`, "warning")
-    }
-  })
-
-  pi.registerTool({
-    name: "honcho_status",
-    label: "Honcho Status",
-    description: "Check Honcho memory integration status, auth, workspace, queue and API health.",
-    promptSnippet: "Check Honcho memory integration status",
-    parameters: schema({}),
-    async execute() {
-      const health = await client.health()
-      const queue = config.apiKey ? await client.queueStatus(config.workspace).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })) : { error: "Missing PRISM_HONCHO_API_KEY" }
-      return { content: [{ type: "text", text: [`Honcho: ${config.baseUrl}`, `Workspace: ${config.workspace}`, `Auth: ${config.apiKey ? "configured" : "missing API key"}`, `Auto-capture: ${config.autoCapture ? "on" : "off"}`, `Health: ${JSON.stringify(health)}`, `Queue: ${JSON.stringify(queue)}`].join("\n") }], details: { config: { ...config, apiKey: config.apiKey ? "<configured>" : undefined }, health, queue } }
-    },
-    renderCall(_args: any, theme: ThemeLike, context: any) { return renderSingleLineToolCall(formatToolCall("status", config.workspace, theme), context) },
-  } as any)
-
-  pi.registerTool({
-    name: "honcho_remember",
-    label: "Honcho Remember",
-    description: "Store a memory/message in Honcho for a peer/session. Uses Honcho automatic reasoning later.",
-    promptSnippet: "Store conversational memory in Honcho [show peer/session and content summary]",
-    promptGuidelines: [
-      "Use honcho_remember for conversational facts/preferences that should be available to future Prism runs.",
-      "Do not store secrets, passwords, API keys, or sensitive personal data unless the user explicitly requests it.",
-      "Use Obsidian for curated durable source-of-truth notes; use Honcho for automatic conversational memory.",
-    ],
-    parameters: schema({ text: { type: "string", description: "Memory text to store" }, peer: { type: "string", description: "Peer ID, default Daniel/user peer" }, session: { type: "string", description: "Honcho session ID, default current Prism session" } }, ["text"]),
-    async execute(_id: string, params: any, _signal: any, _onUpdate: any, ctx: any) {
-      const sessionId = sanitizeHonchoId(params.session || config.sessionId || honchoSessionIdFromContext(ctx))
-      const peer = sanitizeHonchoId(params.peer || config.userPeer)
-      await ensureBase(client, config, sessionId)
-      if (peer !== config.userPeer && peer !== config.assistantPeer) await client.ensurePeer(config.workspace, peer)
-      await client.addMessages(config.workspace, sessionId, [{ peer_id: peer, content: String(params.text ?? ""), metadata: { source: "prism", manual: true } }])
-      return { content: [{ type: "text", text: `Stored in Honcho.\nWorkspace: ${config.workspace}\nSession: ${sessionId}\nPeer: ${peer}` }], details: { workspace: config.workspace, session: sessionId, peer } }
-    },
-    renderCall(args: any, theme: ThemeLike, context: any) { return renderSingleLineToolCall(formatToolCall("remember", args?.peer ?? config.userPeer, theme), context) },
-  } as any)
-
-  pi.registerTool({
-    name: "honcho_recall",
-    label: "Honcho Recall",
-    description: "Ask Honcho a natural-language question about a peer's remembered context.",
-    promptSnippet: "Recall conversational memory from Honcho [show query]",
-    parameters: schema({ query: { type: "string", description: "Question to ask Honcho" }, peer: { type: "string", description: "Peer ID, default Daniel/user peer" }, session: { type: "string", description: "Optional session scope" }, reasoningLevel: { type: "string", description: "minimal, low, medium, high, max. Default low" } }, ["query"]),
-    async execute(_id: string, params: any) {
-      const peer = sanitizeHonchoId(params.peer || config.userPeer)
-      const sessionId = params.session ? sanitizeHonchoId(params.session) : undefined
-      const answer = await client.chat(config.workspace, peer, String(params.query), sessionId, params.reasoningLevel || "low")
-      return { content: [{ type: "text", text: answer || "Honcho returned no answer." }], details: { workspace: config.workspace, peer, session: sessionId, query: params.query } }
-    },
-    renderCall(args: any, theme: ThemeLike, context: any) { return renderSingleLineToolCall(formatToolCall("recall", args?.query, theme), context) },
-  } as any)
-
-  pi.registerTool({
-    name: "honcho_context",
-    label: "Honcho Context",
-    description: "Read Honcho session context with recent messages and optional summary.",
-    promptSnippet: "Read Honcho session context [show session]",
-    parameters: schema({ session: { type: "string", description: "Honcho session ID, default current Prism session" }, tokens: { type: "number", description: "Token budget, default 2000" }, summary: { type: "boolean", description: "Include summary if available, default true" } }),
-    async execute(_id: string, params: any, _signal: any, _onUpdate: any, ctx: any) {
-      const sessionId = sanitizeHonchoId(params.session || config.sessionId || honchoSessionIdFromContext(ctx))
-      const result = await client.context(config.workspace, sessionId, params.tokens ?? 2000, params.summary ?? true)
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: { workspace: config.workspace, session: sessionId } }
-    },
-    renderCall(args: any, theme: ThemeLike, context: any) { return renderSingleLineToolCall(formatToolCall("context", args?.session ?? "current", theme), context) },
-  } as any)
-
-  pi.registerCommand("honcho", {
-    description: "Show Honcho memory integration status",
-    handler: async (_args: string, ctx: any) => {
-      try {
-        const health = await client.health()
-        ctx.ui.notify(`Honcho: ${config.baseUrl}\nWorkspace: ${config.workspace}\nAuth: ${config.apiKey ? "configured" : "missing API key"}\nAuto-capture: ${config.autoCapture ? "on" : "off"}\nHealth: ${JSON.stringify(health)}`, config.apiKey ? "info" : "warning")
-      } catch (error) {
-        ctx.ui.notify(`Honcho unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning")
-      }
-    },
-  })
-}