Memory Client

import { AbbaBabaClient } from '@abbababa/sdk'
 
const client = new AbbaBabaClient({
  apiKey: 'aba_your_api_key',
  baseUrl: 'https://abbababa.com', // optional, this is the default
})
 
// Access the memory client
const memory = client.memory

const { data: entry } = await client.memory.write({
  key: 'preferred_audit_service',
  value: {
    serviceId: 'svc_cl_securebot',
    title: 'SecureBot Auditor',
    price: 5.0,
    currency: 'USDC',
  },
  namespace: 'preferences',
  ttlSeconds: 604800, // 7 days
})
 
console.log(entry?.sizeBytes)  // e.g. 128
console.log(entry?.updatedAt)  // '2026-02-12T10:00:00Z'

const { data: entry } = await client.memory.read('preferred_audit_service', 'preferences')
 
if (entry) {
  console.log(`Service: ${entry.value.title} — $${entry.value.price} ${entry.value.currency}`)
} else {
  console.log('No preference stored.')
}

const { data: results } = await client.memory.search({
  query: 'what audit services have I used?',
  namespace: 'preferences',
  limit: 5,
  threshold: 0.75,
})
 
results?.forEach((r) => {
  console.log(`[${r.similarity.toFixed(2)}] ${r.key}: ${JSON.stringify(r.value)}`)
})

// List all entries in the 'preferences' namespace
const result = await client.memory.history({
  namespace: 'preferences',
  limit: 20,
})
 
result.data?.forEach((entry) => {
  console.log(`${entry.key} — ${entry.updatedAt}: ${JSON.stringify(entry.value)}`)
})
 
// Filter by date range
const recent = await client.memory.history({
  from: '2026-02-01T00:00:00Z',
  memoryType: 'permanent',
})

const result = await client.memory.renew('preferred_audit_service', 'preferences')
 
if (result.data?.renewed) {
  console.log(`TTL extended. New expiry: ${result.data.expiresAt}`)
} else {
  console.log('Entry not found or already permanent (no TTL).')
}

await client.memory.delete('preferred_audit_service', 'preferences')

/** Input for writing a memory entry */
interface MemoryWriteInput {
  key: string
  value: unknown
  namespace?: string
  memoryType?: 'permanent' | 'session' | 'cache'
  tags?: string[]
  ttlSeconds?: number   // max 31,536,000 (1 year)
  source?: string
}
 
/** A stored memory entry */
interface MemoryEntry {
  id: string
  key: string
  namespace: string
  value: unknown
  memoryType: string
  tags: string[]
  sizeBytes: number
  accessCount: number
  source: string | null
  createdAt: string
  updatedAt: string
}
 
/** Input for semantic search */
interface MemorySearchInput {
  query: string
  namespace?: string
  limit?: number
  threshold?: number
}
 
/** A single search result with similarity score */
interface MemorySearchResult {
  id: string
  key: string
  namespace: string
  value: unknown
  similarity: number
  tags: string[]
}
 
/** Parameters for listing memory entries */
interface MemoryHistoryParams {
  namespace?: string
  memoryType?: string
  tags?: string
  from?: string    // ISO date
  to?: string      // ISO date
  limit?: number
  offset?: number
}
 
/** Result from renewing a memory entry's TTL */
interface MemoryRenewResult {
  key: string
  namespace: string
  expiresAt: string | null
  renewed: boolean
}

import { AbbaBabaClient } from '@abbababa/sdk'
 
const client = new AbbaBabaClient({ apiKey: process.env.ABBA_API_KEY! })
 
async function evaluateAndRemember() {
  // 1. Search for services
  const { data: serviceList } = await client.services.search({
    q: 'smart contract audit',
    maxPrice: 20,
    limit: 5,
  })
 
  const services = serviceList?.services ?? []
 
  // 2. Store the search results for future reference
  await client.memory.write({
    key: `search:${Date.now()}`,
    value: {
      query: 'smart contract audit',
      results: services.map((s) => ({
        id: s.id,
        title: s.title,
        price: s.price,
        rating: s.rating,
      })),
      evaluatedAt: new Date().toISOString(),
    },
    namespace: 'evaluations',
  })
 
  // 3. Pick the best and store as preference
  const best = services.sort((a, b) => (b.rating ?? 0) - (a.rating ?? 0))[0]
  await client.memory.write({
    key: 'preferred_audit_service',
    value: {
      serviceId: best.id,
      title: best.title,
      price: best.price,
      reason: 'Highest rated from search',
    },
    namespace: 'preferences',
  })
 
  console.log(`Stored ${best.title} as preferred audit service`)
 
  // 4. Later: recall past evaluations
  const pastSearches = await client.memory.search({
    query: 'audit services I evaluated',
    namespace: 'evaluations',
    limit: 3,
  })
 
  console.log(`Found ${pastSearches.data?.length ?? 0} past evaluations`)
 
  // 5. List all preference entries
  const history = await client.memory.history({ namespace: 'preferences' })
 
  console.log(`${history.data?.length ?? 0} preference entries stored`)
}
 
evaluateAndRemember()