npm install @reeve/app-sdk

import { reeve } from '@reeve/app-sdk';

const config = await reeve.init();

const result = await reeve.ai.complete({
  prompt: 'Summarize this product description for an ad headline',
  systemPrompt: 'You are an expert ecommerce copywriter. Be concise and punchy.',
  intent: 'summarization',
  maxTokens: 200,
  temperature: 0.7,
});

console.log(result.content);  // The generated text
console.log(result.model);    // Which model was used, e.g. 'gpt-4o-mini'
console.log(result.tokens);   // { prompt: 42, completion: 38, total: 80 }

let buffer = '';

await reeve.ai.stream(
  {
    prompt: 'Write a 3-paragraph product description for wireless earbuds',
    intent: 'generation',
  },
  (chunk) => {
    buffer += chunk.delta;
    setOutput(buffer);

    if (chunk.done) {
      console.log('Stream complete. Total tokens:', chunk.tokens?.total);
    }
  }
);

await reeve.storage.set('contacts', 'id-123', {
  name: 'Jane Smith',
  email: 'jane@acme.com',
  tags: ['vip', 'wholesale'],
  createdAt: new Date().toISOString(),
});

const doc = await reeve.storage.get('contacts', 'id-123');

if (doc) {
  console.log(doc.name);   // 'Jane Smith'
  console.log(doc._meta.updatedAt);  // ISO timestamp
}

const result = await reeve.storage.list('contacts', {
  limit: 20,
  cursor: undefined,   // for pagination, pass result.nextCursor
  orderBy: 'createdAt',
  orderDir: 'desc',
  filter: { tags: { includes: 'vip' } },
});

console.log(result.items);       // Document[]
console.log(result.nextCursor);  // Pass to next call to paginate
console.log(result.total);       // Total count in collection

await reeve.storage.delete('contacts', 'id-123');

await reeve.storage.deleteCollection('contacts');

const result = await reeve.data.query({
  source: 'shopify',
  type: 'orders',
  filters: {
    status: 'fulfilled',
    created_at_min: '2025-01-01',
  },
  limit: 50,
  fields: ['id', 'name', 'total_price', 'created_at', 'line_items'],
});

console.log(result.data);       // Order[]
console.log(result.total);      // Total matching records
console.log(result.source);     // 'shopify'
console.log(result.cachedAt);   // ISO timestamp of when data was cached

const unsubscribe = reeve.events.subscribe('shopify:order_created', (event) => {
  console.log('New order!', event.data);
  console.log('Event ID:', event.id);
  console.log('Timestamp:', event.timestamp);
});

// Later, to clean up:
unsubscribe();

reeve.events.emit('app:ready', {
  version: '1.0.0',
  features: ['dashboard', 'export'],
});

reeve.events.emit('app:campaign_created', {
  campaignId: 'camp_abc123',
  name: 'Summer Sale',
});

// Navigate to a built-in Cockpit route
reeve.navigate('/cockpit/agents');
reeve.navigate('/cockpit/dashboard');
reeve.navigate('/cockpit/apps');

// Open an external URL in a new tab
reeve.navigate('https://docs.meetreeve.com', { external: true });

reeve.onThemeChange((theme) => {
  // theme: 'light' | 'dark'
  document.documentElement.setAttribute('data-theme', theme);
  setIsDark(theme === 'dark');
});

// Full type exports from @reeve/app-sdk

export interface ReeveConfig {
  orgId: string;
  userId: string;
  theme: 'light' | 'dark';
  locale: string;
  appId: string;
  permissions: Permission[];
}

export type AIIntent =
  | 'chat'
  | 'summarization'
  | 'generation'
  | 'analysis'
  | 'extraction'
  | 'classification'
  | 'code';

export interface AICompleteOptions {
  prompt: string;
  systemPrompt?: string;
  intent?: AIIntent;
  maxTokens?: number;
  temperature?: number;
  context?: Record<string, unknown>;
}

export interface AICompletionResult {
  content: string;
  model: string;
  tokens: { prompt: number; completion: number; total: number };
  finishReason: 'stop' | 'length' | 'error';
}

export interface AIStreamChunk {
  delta: string;
  done: boolean;
  tokens?: { prompt: number; completion: number; total: number };
}

export interface StorageListOptions {
  limit?: number;
  cursor?: string;
  orderBy?: string;
  orderDir?: 'asc' | 'desc';
  filter?: Record<string, unknown>;
}

export interface StorageListResult<T = unknown> {
  items: (T & { _meta: { id: string; createdAt: string; updatedAt: string } })[];
  nextCursor: string | null;
  total: number;
}

export type DataSource = 'shopify' | 'email' | 'social' | 'ads' | 'analytics';

export interface DataQueryOptions {
  source: DataSource;
  type: string;
  filters?: Record<string, unknown>;
  limit?: number;
  fields?: string[];
  cursor?: string;
}

export interface DataQueryResult<T = unknown> {
  data: T[];
  total: number;
  source: DataSource;
  cachedAt: string;
  nextCursor: string | null;
}

export interface ReeveEvent<T = unknown> {
  id: string;
  event: string;
  data: T;
  timestamp: string;
}

export type Permission =
  | 'ai.complete'
  | 'ai.stream'
  | 'storage.read'
  | 'storage.write'
  | 'data.shopify'
  | 'data.email'
  | 'data.social'
  | 'data.ads'
  | 'data.analytics'
  | 'events.subscribe'
  | 'events.emit';

// Errors
export class ReeveNotInitializedError extends Error {}
export class ReevePermissionError extends Error {
  permission: Permission;
}
export class ReeveDataSourceError extends Error {
  source: DataSource;
  type: string;
}

import { reeve, ReevePermissionError, ReeveDataSourceError } from '@reeve/app-sdk';

try {
  const orders = await reeve.data.query({ source: 'shopify', type: 'orders' });
} catch (err) {
  if (err instanceof ReevePermissionError) {
    // App doesn't have data.shopify permission
    showError(`Permission denied: ${err.permission}`);
  } else if (err instanceof ReeveDataSourceError) {
    // Shopify not connected, or API error
    showError(`Shopify unavailable. Please reconnect in Connectors.`);
  } else {
    throw err; // unexpected error
  }
}