@swarmclawai/swarmclaw 1.2.8 → 1.2.9

package/src/components/wallets/wallet-section.tsx

@@ -1,260 +0,0 @@
-'use client'
-
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { api } from '@/lib/app/api-client'
-import { copyTextToClipboard } from '@/lib/clipboard'
-import { useAppStore } from '@/stores/use-app-store'
-import type { AgentWallet, WalletAssetBalance, WalletPortfolioSummary, WalletChain } from '@/types'
-import { toast } from 'sonner'
-import { errorMessage } from '@/lib/shared-utils'
-import {
-  SUPPORTED_WALLET_CHAINS,
-  formatWalletAmount,
-  getWalletBalanceAtomic,
-  getWalletChainMeta,
-  getWalletLimitAtomic,
-} from '@/lib/wallet/wallet'
-
-type SafeWallet = Omit<AgentWallet, 'encryptedPrivateKey'> & {
-  balanceAtomic?: string
-  balanceLamports?: number
-  balanceFormatted?: string
-  balanceSymbol?: string
-  assets?: WalletAssetBalance[]
-  portfolioSummary?: WalletPortfolioSummary
-  isActive?: boolean
-}
-
-interface WalletSectionProps {
-  agentId: string
-  wallets: SafeWallet[]
-  activeWalletId: string | null
-  onWalletCreated: () => void
-}
-
-export function WalletSection({ agentId, wallets, activeWalletId, onWalletCreated }: WalletSectionProps) {
-  const appSettings = useAppStore((s) => s.appSettings)
-  const [creating, setCreating] = useState(false)
-  const [activatingWalletId, setActivatingWalletId] = useState<string | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [copiedWalletId, setCopiedWalletId] = useState<string | null>(null)
-
-  const connectedChains = useMemo(() => new Set(wallets.map((wallet) => wallet.chain)), [wallets])
-  const availableChains = useMemo(
-    () => SUPPORTED_WALLET_CHAINS.filter((chain) => !connectedChains.has(chain)),
-    [connectedChains],
-  )
-  const sortedWallets = useMemo(
-    () => [...wallets].sort((a, b) => {
-      const aActive = a.id === activeWalletId || a.isActive === true
-      const bActive = b.id === activeWalletId || b.isActive === true
-      if (aActive !== bActive) return aActive ? -1 : 1
-      return a.chain.localeCompare(b.chain)
-    }),
-    [activeWalletId, wallets],
-  )
-
-  const [chain, setChain] = useState<WalletChain>(availableChains[0] || 'solana')
-  const walletApprovalsEnabled = appSettings.walletApprovalsEnabled !== false
-
-  useEffect(() => {
-    if (availableChains.length === 0) return
-    if (!availableChains.includes(chain)) setChain(availableChains[0])
-  }, [availableChains, chain])
-
-  const createWallet = useCallback(async () => {
-    if (!availableChains.includes(chain)) return
-    setCreating(true)
-    setError(null)
-    try {
-      await api('POST', '/wallets', { agentId, chain })
-      toast.success('Agent wallet created successfully')
-      await onWalletCreated()
-    } catch (err: unknown) {
-      const msg = errorMessage(err)
-      setError(msg)
-      toast.error(msg)
-    } finally {
-      setCreating(false)
-    }
-  }, [agentId, availableChains, chain, onWalletCreated])
-
-  const copyAddress = useCallback(async (wallet: SafeWallet) => {
-    const copiedValue = await copyTextToClipboard(wallet.publicKey)
-    if (!copiedValue) return
-    setCopiedWalletId(wallet.id)
-    setTimeout(() => {
-      setCopiedWalletId((current) => current === wallet.id ? null : current)
-    }, 2000)
-  }, [])
-
-  const setActiveWallet = useCallback(async (walletId: string) => {
-    setActivatingWalletId(walletId)
-    setError(null)
-    try {
-      await api('PATCH', `/wallets/${walletId}`, { makeActive: true })
-      toast.success('Default wallet updated')
-      await onWalletCreated()
-    } catch (err: unknown) {
-      const msg = errorMessage(err)
-      setError(msg)
-      toast.error(msg)
-    } finally {
-      setActivatingWalletId(null)
-    }
-  }, [onWalletCreated])
-
-  return (
-    <div className="mb-8">
-      <div className="flex items-center gap-2 mb-3">
-        <label className="block font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em]">
-          Wallets
-        </label>
-        <span className="px-1.5 py-0.5 rounded-[4px] bg-amber-500/15 text-amber-400 text-[9px] font-600 uppercase tracking-wide">
-          Experimental
-        </span>
-      </div>
-
-      {sortedWallets.length > 0 ? (
-        <div className="space-y-3">
-          <div className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50">
-            <div className="flex items-center justify-between gap-3 mb-2">
-              <div>
-                <div className="text-[12px] font-600 text-text-1">Combined Wallet Summary</div>
-                <p className="text-[11px] text-text-3/70 mt-1">
-                  {sortedWallets.length} wallet{sortedWallets.length === 1 ? '' : 's'} connected. The active wallet is used by default when the agent does not specify a chain explicitly.
-                </p>
-              </div>
-              <div className="text-right">
-                <div className="text-[18px] font-600 text-text-1">{sortedWallets.length}</div>
-                <div className="text-[10px] uppercase tracking-wide text-text-3/50">Connected</div>
-              </div>
-            </div>
-            <div className="grid gap-2 md:grid-cols-2">
-              {sortedWallets.map((wallet) => {
-                const walletMeta = getWalletChainMeta(wallet.chain)
-                const balanceFormatted = wallet.balanceFormatted || formatWalletAmount(wallet.chain, getWalletBalanceAtomic(wallet), { minFractionDigits: 4, maxFractionDigits: 6 })
-                const isActive = wallet.id === activeWalletId || wallet.isActive === true
-                return (
-                  <div key={wallet.id} className="rounded-[10px] border border-white/[0.06] bg-black/10 px-3 py-2">
-                    <div className="flex items-center gap-2">
-                      <span className="text-[10px] text-text-3/60 uppercase tracking-wide font-600">{walletMeta.label}</span>
-                      {isActive && (
-                        <span className="px-1.5 py-0.5 rounded-[999px] bg-accent-soft text-accent-bright text-[9px] font-600 uppercase tracking-wide">
-                          Active
-                        </span>
-                      )}
-                    </div>
-                    <div className="mt-1 text-[14px] font-600 text-text-1">{balanceFormatted} {walletMeta.symbol}</div>
-                    {wallet.portfolioSummary?.nonZeroAssets ? (
-                      <div className="mt-1 text-[10px] text-text-3/55">
-                        {wallet.portfolioSummary.nonZeroAssets} asset{wallet.portfolioSummary.nonZeroAssets === 1 ? '' : 's'} tracked
-                      </div>
-                    ) : null}
-                    <div className="mt-1 text-[10px] text-text-3/55 font-mono truncate">{wallet.publicKey}</div>
-                  </div>
-                )
-              })}
-            </div>
-          </div>
-
-          {sortedWallets.map((wallet) => {
-            const walletMeta = getWalletChainMeta(wallet.chain)
-            const balanceFormatted = wallet.balanceFormatted || formatWalletAmount(wallet.chain, getWalletBalanceAtomic(wallet), { minFractionDigits: 4, maxFractionDigits: 6 })
-            const perTxLimit = formatWalletAmount(wallet.chain, getWalletLimitAtomic(wallet, 'perTx'), { maxFractionDigits: 6 })
-            const dailyLimit = formatWalletAmount(wallet.chain, getWalletLimitAtomic(wallet, 'daily'), { maxFractionDigits: 6 })
-            const isActive = wallet.id === activeWalletId || wallet.isActive === true
-            return (
-              <div key={wallet.id} className="p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50 space-y-3">
-                <div className="flex items-center gap-2">
-                  <span className="text-[10px] text-text-3/60 uppercase tracking-wide font-600">
-                    {walletMeta.label}
-                  </span>
-                  {isActive && (
-                    <span className="px-1.5 py-0.5 rounded-[999px] bg-accent-soft text-accent-bright text-[9px] font-600 uppercase tracking-wide">
-                      Default
-                    </span>
-                  )}
-                  <span className="flex-1" />
-                  <span className="text-[13px] font-600 text-text-1">
-                    {balanceFormatted} {walletMeta.symbol}
-                  </span>
-                </div>
-                <div className="flex items-center gap-2">
-                  <code className="text-[11px] text-text-3 bg-black/20 px-2 py-1 rounded-[6px] font-mono truncate flex-1">
-                    {wallet.publicKey}
-                  </code>
-                  <button
-                    type="button"
-                    onClick={() => copyAddress(wallet)}
-                    className="shrink-0 px-2 py-1 rounded-[6px] text-[10px] text-text-3 hover:text-text-2 border border-white/[0.08] bg-surface transition-colors cursor-pointer"
-                    style={{ fontFamily: 'inherit' }}
-                  >
-                    {copiedWalletId === wallet.id ? 'Copied!' : 'Copy'}
-                  </button>
-                  {!isActive && (
-                    <button
-                      type="button"
-                      onClick={() => setActiveWallet(wallet.id)}
-                      disabled={activatingWalletId === wallet.id}
-                      className="shrink-0 px-2 py-1 rounded-[6px] text-[10px] font-600 text-accent-bright border border-accent-bright/20 bg-accent-soft/10 hover:bg-accent-soft/20 transition-colors cursor-pointer disabled:opacity-50"
-                      style={{ fontFamily: 'inherit' }}
-                    >
-                      {activatingWalletId === wallet.id ? 'Setting...' : 'Set Default'}
-                    </button>
-                  )}
-                </div>
-                <div className="flex flex-wrap items-center gap-3 text-[10px] text-text-3/60">
-                  <span>Limit: {perTxLimit} {walletMeta.symbol}/tx</span>
-                  <span>Daily: {dailyLimit} {walletMeta.symbol}</span>
-                  <span>{!walletApprovalsEnabled ? 'Approvals off globally' : (wallet.requireApproval ? 'Approval required' : 'Auto-send')}</span>
-                  {wallet.portfolioSummary?.nonZeroAssets ? (
-                    <span>{wallet.portfolioSummary.nonZeroAssets} asset{wallet.portfolioSummary.nonZeroAssets === 1 ? '' : 's'} detected</span>
-                  ) : null}
-                </div>
-              </div>
-            )
-          })}
-        </div>
-      ) : null}
-
-      {availableChains.length > 0 ? (
-        <div className="mt-3 p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50">
-          <p className="text-[12px] text-text-3/70 mb-3">
-            {getWalletChainMeta(chain).createDescription}
-          </p>
-          <label className="block text-[11px] text-text-3/70 mb-1">Wallet Type</label>
-          <select
-            value={chain}
-            onChange={(event) => setChain(event.target.value as WalletChain)}
-            className="w-full mb-3 px-3 py-2 rounded-[8px] border border-white/[0.08] bg-surface text-[12px] text-text-1 outline-none focus:border-accent/40"
-            style={{ fontFamily: 'inherit' }}
-          >
-            {availableChains.map((availableChain) => (
-              <option key={availableChain} value={availableChain}>
-                {getWalletChainMeta(availableChain).label}
-              </option>
-            ))}
-          </select>
-          <button
-            type="button"
-            onClick={createWallet}
-            disabled={creating}
-            className="px-3 py-1.5 rounded-[8px] bg-accent-soft text-accent-bright text-[11px] font-600 hover:bg-accent-bright/15 transition-all cursor-pointer disabled:opacity-50 border border-accent-bright/20"
-            style={{ fontFamily: 'inherit' }}
-          >
-            {creating ? 'Creating...' : `Create ${getWalletChainMeta(chain).label} Wallet`}
-          </button>
-          {error && <p className="text-[11px] text-red-400 mt-2">{error}</p>}
-        </div>
-      ) : (
-        <div className="mt-3 p-4 rounded-[12px] border border-white/[0.06] bg-surface-2/50">
-          <p className="text-[12px] text-text-3/70">
-            This agent already has both supported wallet types connected. Use the default toggle above to choose which wallet autonomous actions use when no chain is specified.
-          </p>
-          {error && <p className="text-[11px] text-red-400 mt-2">{error}</p>}
-        </div>
-      )}
-    </div>
-  )
-}

package/src/features/missions/queries.ts

@@ -1,23 +0,0 @@
-import { useQuery } from '@tanstack/react-query'
-import { api } from '@/lib/app/api-client'
-import type { Mission } from '@/types'
-
-type MissionListOptions = {
-  enabled?: boolean
-  limit?: number
-}
-
-export const missionQueryKeys = {
-  all: ['missions'] as const,
-  list: (limit: number) => ['missions', 'list', { limit }] as const,
-}
-
-export function useMissionsQuery(options: MissionListOptions = {}) {
-  const limit = options.limit ?? 80
-  return useQuery<Mission[]>({
-    queryKey: missionQueryKeys.list(limit),
-    queryFn: () => api<Mission[]>('GET', `/missions?limit=${limit}`),
-    enabled: options.enabled,
-    staleTime: 30_000,
-  })
-}

package/src/lib/canvas-content.test.ts

@@ -1,360 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-import {
-  normalizeCanvasDocument,
-  normalizeCanvasContent,
-  isCanvasDocument,
-  summarizeCanvasContent,
-} from './canvas-content'
-
-describe('normalizeCanvasContent', () => {
-  it('returns null for null/undefined', () => {
-    assert.equal(normalizeCanvasContent(null), null)
-    assert.equal(normalizeCanvasContent(undefined), null)
-  })
-
-  it('returns string content as-is', () => {
-    assert.equal(normalizeCanvasContent('<p>hello</p>'), '<p>hello</p>')
-  })
-
-  it('returns null for empty string', () => {
-    assert.equal(normalizeCanvasContent(''), null)
-  })
-
-  it('normalizes a valid structured document', () => {
-    const doc = normalizeCanvasContent({
-      title: 'Test',
-      blocks: [{ type: 'markdown', markdown: '# Hello' }],
-    })
-    assert.ok(doc !== null && typeof doc === 'object')
-    assert.equal((doc as { kind: string }).kind, 'structured')
-  })
-
-  it('returns null for object without valid blocks', () => {
-    assert.equal(normalizeCanvasContent({ blocks: [] }), null)
-    assert.equal(normalizeCanvasContent({}), null)
-    assert.equal(normalizeCanvasContent({ blocks: [{ type: 'unknown' }] }), null)
-  })
-})
-
-describe('normalizeCanvasDocument', () => {
-  it('returns null for non-object input', () => {
-    assert.equal(normalizeCanvasDocument('string'), null)
-    assert.equal(normalizeCanvasDocument(42), null)
-    assert.equal(normalizeCanvasDocument(null), null)
-    assert.equal(normalizeCanvasDocument([]), null)
-    assert.equal(normalizeCanvasDocument(true), null)
-  })
-
-  it('normalizes a markdown block', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: '# Hi' }],
-    })
-    assert.ok(doc)
-    assert.equal(doc.blocks.length, 1)
-    assert.equal(doc.blocks[0].type, 'markdown')
-    assert.equal(doc.kind, 'structured')
-    assert.equal(doc.theme, 'slate') // default theme
-  })
-
-  it('applies theme when valid', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: 'x' }],
-      theme: 'emerald',
-    })
-    assert.ok(doc)
-    assert.equal(doc.theme, 'emerald')
-  })
-
-  it('defaults to slate for invalid theme', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: 'x' }],
-      theme: 'neon',
-    })
-    assert.ok(doc)
-    assert.equal(doc.theme, 'slate')
-  })
-
-  it('truncates title and subtitle', () => {
-    const doc = normalizeCanvasDocument({
-      title: 'A'.repeat(300),
-      subtitle: 'B'.repeat(500),
-      blocks: [{ type: 'markdown', markdown: 'x' }],
-    })
-    assert.ok(doc)
-    assert.equal(doc.title!.length, 180)
-    assert.equal(doc.subtitle!.length, 320)
-  })
-
-  it('skips invalid blocks and keeps valid ones', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [
-        { type: 'markdown', markdown: 'valid' },
-        { type: 'unknown_type' },
-        null,
-        'just a string',
-        { type: 'code', code: 'console.log(1)' },
-      ],
-    })
-    assert.ok(doc)
-    assert.equal(doc.blocks.length, 2)
-    assert.equal(doc.blocks[0].type, 'markdown')
-    assert.equal(doc.blocks[1].type, 'code')
-  })
-
-  it('enforces max 24 blocks', () => {
-    const blocks = Array.from({ length: 30 }, () => ({
-      type: 'markdown',
-      markdown: 'x',
-    }))
-    const doc = normalizeCanvasDocument({ blocks })
-    assert.ok(doc)
-    assert.equal(doc.blocks.length, 24)
-  })
-
-  it('normalizes metrics block', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'metrics',
-        items: [
-          { label: 'CPU', value: '90%', tone: 'warning' },
-          { label: 'Mem', value: '4GB', detail: 'of 16GB', tone: 'positive' },
-          { label: 'missing value' }, // should be skipped
-          { value: 'missing label' }, // should be skipped
-        ],
-      }],
-    })
-    assert.ok(doc)
-    assert.equal(doc.blocks.length, 1)
-    const block = doc.blocks[0] as { type: string; items: Array<{ label: string; value: string; tone: string }> }
-    assert.equal(block.items.length, 2)
-    assert.equal(block.items[0].tone, 'warning')
-    assert.equal(block.items[1].tone, 'positive')
-  })
-
-  it('enforces max 24 metric items', () => {
-    const items = Array.from({ length: 30 }, (_, i) => ({
-      label: `L${i}`, value: `V${i}`,
-    }))
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'metrics', items }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { items: unknown[] }
-    assert.equal(block.items.length, 24)
-  })
-
-  it('normalizes cards block', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'cards',
-        items: [
-          { title: 'Card 1', body: 'content', tone: 'negative' },
-          { body: 'no title' }, // skipped
-        ],
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { items: Array<{ title: string; tone: string }> }
-    assert.equal(block.items.length, 1)
-    assert.equal(block.items[0].tone, 'negative')
-  })
-
-  it('normalizes table block', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'table',
-        table: {
-          columns: ['Name', 'Age'],
-          rows: [['Alice', 30], ['Bob', true]],
-          caption: 'Users',
-        },
-      }],
-    })
-    assert.ok(doc)
-    assert.equal(doc.blocks[0].type, 'table')
-  })
-
-  it('rejects table with no columns', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'table',
-        table: { columns: [], rows: [] },
-      }],
-    })
-    assert.equal(doc, null) // no valid blocks
-  })
-
-  it('rejects table with no rows', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'table',
-        table: { columns: ['A'], rows: [] },
-      }],
-    })
-    assert.equal(doc, null)
-  })
-
-  it('limits table to 20 columns and 100 rows', () => {
-    const columns = Array.from({ length: 25 }, (_, i) => `Col${i}`)
-    const rows = Array.from({ length: 110 }, () => columns.map((_, i) => `val${i}`))
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'table',
-        table: { columns, rows },
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { table: { columns: string[]; rows: unknown[][] } }
-    assert.equal(block.table.columns.length, 20)
-    assert.equal(block.table.rows.length, 100)
-  })
-
-  it('normalizes actions block', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'actions',
-        items: [
-          { label: 'Submit', intent: 'primary', href: 'https://x.com' },
-          { label: 'Delete', intent: 'danger' },
-          { intent: 'primary' }, // no label → skipped
-        ],
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { items: Array<{ label: string; intent: string }> }
-    assert.equal(block.items.length, 2)
-    assert.equal(block.items[0].intent, 'primary')
-    assert.equal(block.items[1].intent, 'danger')
-  })
-
-  it('defaults action intent to secondary', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'actions',
-        items: [{ label: 'Go', intent: 'invalid' }],
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { items: Array<{ intent: string }> }
-    assert.equal(block.items[0].intent, 'secondary')
-  })
-
-  it('normalizes code block with language', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'code',
-        code: 'const x = 1;',
-        language: 'typescript',
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { type: string; code: string; language: string }
-    assert.equal(block.code, 'const x = 1;')
-    assert.equal(block.language, 'typescript')
-  })
-
-  it('rejects code block with empty code', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'code', code: '' }],
-    })
-    assert.equal(doc, null)
-  })
-
-  it('coerces number/boolean to string in asTrimmedString contexts', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{
-        type: 'metrics',
-        items: [{ label: 42, value: true }],
-      }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { items: Array<{ label: string; value: string }> }
-    assert.equal(block.items[0].label, '42')
-    assert.equal(block.items[0].value, 'true')
-  })
-
-  it('truncates markdown content to 20000 chars', () => {
-    const longMarkdown = 'x'.repeat(25000)
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: longMarkdown }],
-    })
-    assert.ok(doc)
-    const block = doc.blocks[0] as { markdown: string }
-    assert.equal(block.markdown.length, 20000)
-  })
-
-  it('uses provided updatedAt when valid', () => {
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: 'x' }],
-      updatedAt: 1234567890,
-    })
-    assert.ok(doc)
-    assert.equal(doc.updatedAt, 1234567890)
-  })
-
-  it('falls back to Date.now() for invalid updatedAt', () => {
-    const before = Date.now()
-    const doc = normalizeCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: 'x' }],
-      updatedAt: 'not a number',
-    })
-    const after = Date.now()
-    assert.ok(doc)
-    assert.ok(doc.updatedAt! >= before && doc.updatedAt! <= after)
-  })
-})
-
-describe('isCanvasDocument', () => {
-  it('returns true for valid document object', () => {
-    assert.equal(isCanvasDocument({
-      blocks: [{ type: 'markdown', markdown: 'hi' }],
-    }), true)
-  })
-
-  it('returns false for non-documents', () => {
-    assert.equal(isCanvasDocument('string'), false)
-    assert.equal(isCanvasDocument(null), false)
-    assert.equal(isCanvasDocument({}), false)
-    assert.equal(isCanvasDocument({ blocks: [] }), false)
-  })
-})
-
-describe('summarizeCanvasContent', () => {
-  it('summarizes null content', () => {
-    const summary = summarizeCanvasContent(null)
-    assert.equal(summary.kind, 'empty')
-    assert.equal(summary.hasContent, false)
-    assert.equal(summary.contentLength, 0)
-  })
-
-  it('summarizes string content', () => {
-    const summary = summarizeCanvasContent('<p>hello</p>')
-    assert.equal(summary.kind, 'html')
-    assert.equal(summary.hasContent, true)
-    assert.equal(summary.contentLength, 12)
-    assert.equal(summary.preview, '<p>hello</p>')
-  })
-
-  it('truncates preview to 500 chars for long strings', () => {
-    const long = 'x'.repeat(600)
-    const summary = summarizeCanvasContent(long)
-    assert.equal((summary.preview as string).length, 500)
-  })
-
-  it('summarizes structured document', () => {
-    const doc = normalizeCanvasDocument({
-      title: 'My Doc',
-      blocks: [
-        { type: 'markdown', markdown: '# Heading' },
-        { type: 'code', code: 'x = 1' },
-      ],
-    })!
-    const summary = summarizeCanvasContent(doc)
-    assert.equal(summary.kind, 'structured')
-    assert.equal(summary.hasContent, true)
-    assert.equal(summary.blockCount, 2)
-    assert.equal(summary.title, 'My Doc')
-    assert.deepEqual(summary.blockTypes, ['markdown', 'code'])
-  })
-})