@ductape/mcp 0.1.27 → 0.1.28

package/dist/index.js

@@ -2341,6 +2341,532 @@ Notes:
     resilience) emits its own logs automatically — manual add/publish is only needed for custom logs.
   - language defaults to "typescript" so the backend knows which SDK emitted the entry.
   - Logs are batched in memory and sent in a single publish() call per operation.
+`.trim(),
+    client: `
+DUCTAPE CLIENT SDK (@ductape/client)
+
+The client SDK is for frontend applications (React, Vue, Svelte, vanilla JS). All HTTP
+operations are routed through the Ductape proxy using a publishableKey. WebSocket subscriptions
+connect to the proxy's /realtime gateway. Never use this package on the server — use @ductape/sdk
+for server-side code.
+
+INSTALL
+  npm install @ductape/client
+
+INITIALIZATION
+  import { createClient } from '@ductape/client';
+  // or: import Ductape from '@ductape/client';
+
+  const ductape = createClient({
+    publishableKey: 'pk_live_...',            // from Workbench → Settings → Publishable Keys
+    baseUrl: 'https://your-proxy.example.com', // your deployed proxy URL
+    product: 'my-product',                    // default product tag (can be overridden per call)
+    env: 'prd',                               // default environment slug
+  });
+
+  When publishableKey is set:
+    - HTTP calls go to baseUrl/proxy/v1/sdk-proxy/execute
+    - WebSocket connects to wss://your-proxy.example.com/realtime?token=pk_live_...
+    - No server secret is exposed to the browser
+
+  Use accessKey only for server-side or trusted environments — never in a browser bundle.
+  Override wsUrl to point to a custom WebSocket endpoint.
+
+REAL-TIME CONNECTION
+  await ductape.connect();        // opens WebSocket; required before any .subscribe() call
+  ductape.disconnect();           // closes WebSocket and clears all subscriptions
+  ductape.isConnected             // boolean
+  ductape.connectionState         // 'disconnected' | 'connecting' | 'connected' | 'reconnecting'
+  ductape.onConnectionChange(cb)  // listen to state changes; returns unsubscribe fn
+
+SERVICES
+  ductape.databases     DatabaseService    — CRUD + real-time query subscriptions
+  ductape.features      FeatureService     — execute features, subscribe to execution status
+  ductape.agents        AgentService       — run AI agents, subscribe to output stream
+  ductape.vectors       VectorService      — vector upsert / search
+  ductape.graphs        GraphService       — graph queries + subscriptions
+  ductape.brokers       BrokerService      — publish / subscribe to message brokers
+  ductape.sessions      SessionService     — verify, refresh, revoke sessions
+  ductape.resilience    ResilienceService  — subscribe to healthcheck status
+  ductape.storage       StorageService     — upload / download files
+  ductape.warehouse     WarehouseService   — cross-store federated queries
+  ductape.cache         CacheService       — key-value cache get / set / clear
+  ductape.api           ApiService         — run app actions with OAuth credential support
+  ductape.notifications NotificationsService — send push / email / SMS / callback
+  ductape.analytics     AnalyticsService   — track pageviews, clicks, custom events
+  ductape.workflows     (deprecated alias → features)
+  ductape.actions       (deprecated alias → api)
+
+DATABASE SERVICE
+  await ductape.databases.connect({ database: 'core-db' });
+  const { data } = await ductape.databases.query({ entity: 'users', where: { active: true } });
+  await ductape.databases.insert({ entity: 'users', data: { name: 'Alice', email: 'a@b.com' } });
+  await ductape.databases.update({ entity: 'users', where: { id: 1 }, data: { name: 'Bob' } });
+  await ductape.databases.delete({ entity: 'users', where: { id: 1 } });
+  await ductape.databases.upsert({ entity: 'users', data: { email: 'a@b.com' }, conflict: ['email'] });
+  const total = await ductape.databases.count({ entity: 'users', where: { active: true } });
+  await ductape.databases.raw({ query: 'SELECT * FROM users WHERE id = $1', params: [1] });
+  await ductape.databases.transaction(async (tx) => {
+    await tx.insert({ entity: 'orders', data: { ... } });
+    await tx.update({ entity: 'inventory', where: { ... }, data: { ... } });
+  });
+  await ductape.databases.disconnect();
+
+  Real-time subscription (ductape.connect() must be called first):
+  const sub = ductape.databases.subscribe(
+    { entity: 'orders', where: { status: 'pending' } },
+    (rows) => console.log('live update', rows),
+  );
+  sub.unsubscribe(); // stop receiving updates
+
+FEATURE SERVICE
+  const { executionId } = await ductape.features.execute({ feature: 'onboard-user', input: { userId: 'u_1' } });
+  const status = await ductape.features.status({ feature: 'onboard-user', executionId });
+  await ductape.features.cancel({ feature: 'onboard-user', executionId, reason: 'user request' });
+  await ductape.features.signal({ feature: 'onboard-user', executionId, signal: 'payment-confirmed' });
+  const history = await ductape.features.history({ feature: 'onboard-user', executionId });
+  const { executions } = await ductape.features.list({ status: 'running', limit: 20 });
+
+  Real-time status subscription:
+  const sub = ductape.features.subscribe(
+    { feature: 'onboard-user', executionId },
+    (events) => {
+      const ev = events[0]; // { executionId, feature, status, currentStep, output, error }
+      console.log(ev.status, ev.currentStep);
+      if (ev.status === 'completed' || ev.status === 'failed') sub.unsubscribe();
+    },
+  );
+
+AGENT SERVICE
+  const result = await ductape.agents.run({ agent: 'support-bot', input: { message: 'Help!' } });
+  const sub = ductape.agents.subscribe(
+    { agent: 'support-bot', executionId: result.executionId },
+    (events) => console.log('chunk', events[0]),
+  );
+  sub.unsubscribe();
+
+BROKER SERVICE
+  await ductape.brokers.connect({ broker: 'notifications-broker', session: 'user-session:eyJ...' });
+  await ductape.brokers.publish({ topic: 'chat.message', message: { text: 'Hello', userId: 'u_1' } });
+  const sub = ductape.brokers.subscribe(
+    { topic: 'chat.message' },
+    (msgs) => {
+      const m = msgs[0]; // { topic, message, headers?, key?, timestamp, offset?, partition? }
+      console.log('new message', m.message);
+    },
+  );
+  sub.unsubscribe();
+  await ductape.brokers.disconnect();
+
+  Passing session scopes delivery to a specific end-user so the server applies session-level
+  authorization. Without session, messages for the whole product+env are delivered.
+
+GRAPH SERVICE
+  const nodes = await ductape.graphs.findNodes({ labels: ['User'], where: { active: true } });
+  const sub = ductape.graphs.subscribe({ labels: ['Order'] }, (nodes) => console.log(nodes));
+  sub.unsubscribe();
+
+RESILIENCE SERVICE (health subscriptions)
+  const sub = ductape.resilience.subscribe(
+    { tag: 'payment-health' },
+    (events) => console.log('health change', events[0]),
+  );
+  sub.unsubscribe();
+
+SESSIONS SERVICE
+  const { valid } = await ductape.sessions.verify({ token: 'user-session:eyJ...' });
+  await ductape.sessions.revoke({ token: 'user-session:eyJ...' });
+  const { token } = await ductape.sessions.refresh({ refreshToken: '...' });
+
+ANALYTICS SERVICE
+  ductape.analytics.pageview({ page: '/dashboard' });
+  ductape.analytics.track('button_click', { button: 'sign-up' });
+  ductape.analytics.identify({ userId: 'u_123', traits: { plan: 'pro' } });
+
+FRAMEWORK-SPECIFIC PACKAGES
+  For React and Vue projects, use the dedicated packages instead of managing the client manually:
+    @ductape/react — DuctapeProvider + hooks (useDatabaseQuery, useFeatureSubscription, etc.)
+                     See: ductape_docs({ topic: "react" })
+    @ductape/vue   — createDuctape() plugin + composables (useDatabaseQuery, useFeatureSubscription, etc.)
+                     See: ductape_docs({ topic: "vue" })
+
+  Use @ductape/client directly only for vanilla JS, Svelte, Angular, or custom integrations.
+
+IMPORTANT
+  - Call ductape.connect() before any .subscribe() — it throws if not connected.
+  - Always clean up (sub.unsubscribe()) in component teardown to prevent memory leaks.
+  - The client auto-resubscribes after a WebSocket reconnect — no manual retry needed.
+  - publishableKey is safe in browser bundles; it grants only proxy-authorized operations.
+  - For SSR, skip connect() on the server; call it only client-side (useEffect / onMounted).
+  - The client SDK does NOT expose secrets, access keys, or workspace admin operations.
+  - Pass session (format session_tag:jwt) to broker connect/subscribe for per-user scoping.
+`.trim(),
+    react: `
+DUCTAPE REACT (@ductape/react)
+
+React hooks and context provider for Ductape. Wraps @ductape/client.
+Requires react >= 17.
+
+INSTALL
+  npm install @ductape/react
+
+SETUP — wrap your app root with DuctapeProvider
+  import { DuctapeProvider } from '@ductape/react';
+
+  function App() {
+    return (
+      <DuctapeProvider
+        config={{
+          publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
+          baseUrl: import.meta.env.VITE_PROXY_URL,
+          product: 'my-product',
+          env: 'prd',
+        }}
+        autoConnect={false}
+      >
+        <MyApp />
+      </DuctapeProvider>
+    );
+  }
+
+  DuctapeProvider props:
+    config              IDuctapeClientConfig  — publishableKey (or accessKey), baseUrl, product, env
+    autoConnect         boolean (default false) — connect WebSocket automatically on mount
+    onConnected         () => void
+    onDisconnected      () => void
+    onError             (error: Error) => void
+    onConnectionChange  (state: ConnectionState) => void
+
+CORE HOOKS
+  useDuctape()        → { client, isConnected, connectionState, connect, disconnect, isReady }
+  useDuctapeContext()  → same; throws if called outside DuctapeProvider
+
+DATABASE HOOKS
+  useDatabase(database)
+    → { isConnected, isConnecting, error, connect, disconnect }
+    Call connect() in a useEffect to open the database session.
+
+  useDatabaseQuery(key, queryOptions, hookOptions?)
+    → { data: IQueryResult<T>, isLoading, error, refetch }
+    key: string | string[]  — deduplication key
+    queryOptions: { table, where?, select?, limit?, offset?, sort? }
+
+  useDatabaseInsert(hookOptions?)   → { mutate({ table, data }), isLoading, error, data }
+  useDatabaseUpdate(hookOptions?)   → { mutate({ table, where, data }), isLoading, error, data }
+  useDatabaseDelete(hookOptions?)   → { mutate({ table, where }), isLoading, error, data }
+
+  useDatabaseSubscription(subscribeOptions, hookOptions?)
+    → { data: T[] | null, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { table, where?, select? }
+    Requires autoConnect: true (or manual connect()) and databases.connect() before subscribing.
+
+FEATURE HOOKS
+  useFeatureExecute(hookOptions?)
+    → { mutate({ feature, input?, product?, env? }), isLoading, error, data }
+  useFeatureStatus(statusInput, hookOptions?)
+    → { data: FeatureStatus, isLoading, error, refetch }
+    statusInput: { feature, executionId, product?, env? }
+  useFeatureSubscription(subscribeOptions, hookOptions?)
+    → { data: FeatureStatusEvent[], isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { feature, executionId, product?, env? }
+  useFeatureSignal(hookOptions?)   → { mutate({ feature, executionId, signal, data? }), isLoading }
+  useFeatureCancel(hookOptions?)   → { mutate({ feature, executionId, reason? }), isLoading }
+
+AGENT HOOKS
+  useAgentRun(hookOptions?)
+    → { mutate({ tag, input?, sessionId? }), isLoading, error, data: IAgentExecutionResult }
+  useAgentStream(tag, input?, hookOptions?)
+    → { events, content, isStreaming, isComplete, error, start, stop, reset }
+    content: accumulated string from all stream text events
+  useAgentStatus(statusInput, hookOptions?)  → { data, isLoading, error, refetch }
+  useAgentSignal(hookOptions?)               → { mutate, isLoading, error }
+
+BROKER HOOKS
+  useBroker(broker, options?)
+    → { isConnected, isConnecting, error, connect, disconnect }
+  useBrokerPublish(hookOptions?)
+    → { mutate({ topic, message, headers?, key? }), isLoading, error, data }
+  useBrokerSubscription(subscribeOptions, hookOptions?)
+    → { data: BrokerMessage[], isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { topic, group? }
+
+GRAPH HOOKS
+  useGraph(graphTag)  → { isConnected, isConnecting, error, connect, disconnect }
+  useCreateNode(hookOptions?)          → { mutate({ labels, properties }), isLoading, error, data }
+  useUpdateNode(hookOptions?)          → { mutate({ id, properties }), isLoading, error, data }
+  useDeleteNode(hookOptions?)          → { mutate({ id, detach? }), isLoading, error, data }
+  useQueryNodes(key, options, hookOptions?)        → { data, isLoading, error }
+  useCreateRelationship(hookOptions?)  → { mutate, isLoading, error, data }
+  useDeleteRelationship(hookOptions?)  → { mutate, isLoading, error }
+  useQueryRelationships(key, options, hookOptions?) → { data, isLoading, error }
+  useTraverse(key, options, hookOptions?)           → { data, isLoading, error }
+  useShortestPath(key, options, hookOptions?)       → { data, isLoading, error }
+  useGraphSubscription(subscribeOptions, hookOptions?)
+    → { data, isSubscribed, error, unsubscribe, resubscribe }
+
+VECTOR HOOKS
+  useVector(vectorTag)    → { isConnected, isConnecting, error, connect, disconnect }
+  useVectorQuery(key, options, hookOptions?)   → { data, isLoading, error }
+  useVectorSearch(key, options, hookOptions?)  → { data, isLoading, error }
+  useVectorUpsert(hookOptions?)   → { mutate({ id, values, metadata? }), isLoading, error, data }
+  useVectorDelete(hookOptions?)   → { mutate({ ids }), isLoading, error }
+  useVectorFetch(key, options, hookOptions?)   → { data: VectorFetchResult, isLoading, error }
+  useVectorStats(key, options, hookOptions?)   → { data: VectorStatsResult, isLoading, error }
+  useVectorNamespaces(key, options, hookOptions?) → { data, isLoading, error }
+
+STORAGE HOOKS
+  useUpload(hookOptions?)
+    → { upload({ storage, fileName, buffer, mimeType? }), isLoading, progress, error, data }
+    progress: 0–100 number
+  useDownload(hookOptions?)         → { mutate, isLoading, error, data }
+  useStorageDelete(hookOptions?)    → { mutate, isLoading, error }
+  useListFiles(key, options, hookOptions?)    → { data, isLoading, error }
+  useSignedUrl(key, options, hookOptions?)    → { data: string, isLoading, error }
+
+SESSION HOOKS
+  useSessionStart(hookOptions?)     → { mutate, isLoading, error, data: { token, refreshToken } }
+  useSessionVerify(hookOptions?)    → { mutate, isLoading, error, data }
+  useSessionRefresh(hookOptions?)   → { mutate, isLoading, error, data }
+  useSessionRevoke(hookOptions?)    → { mutate, isLoading, error }
+  useSessionRevokeAll(hookOptions?) → { mutate, isLoading, error }
+  useSessionList(key, options, hookOptions?) → { data, isLoading, error }
+  useSessionAutoRefresh(config)
+    → { token, isRefreshing }; auto-refreshes before expiry; no manual call needed
+
+CACHE HOOKS
+  useCacheGet(key, options, hookOptions?)     → { data, isLoading, error }
+  useCacheSet(hookOptions?)                  → { mutate({ key, value, expiry? }), isLoading, error }
+  useCacheDelete(hookOptions?)               → { mutate({ key }), isLoading, error }
+  useCacheExists(key, options, hookOptions?) → { data: boolean, isLoading, error }
+  useCacheGetMany / useCacheSetMany / useCacheDeleteMany
+
+RESILIENCE HOOKS
+  useHealthStatus(key, options, hookOptions?)
+    → { data: HealthStatusResult, isLoading, error, refetch }
+  useHealthSubscription(subscribeOptions, hookOptions?)
+    → { data: HealthChangeEvent[], isSubscribed, error, unsubscribe, resubscribe }
+  useQuotaCheck(hookOptions?)  → { mutate, isLoading, error, data: QuotaCheckResult }
+  useQuotaStatus(key, options, hookOptions?) → { data, isLoading, error }
+  useQuotaSubscription(subscribeOptions, hookOptions?) → { data, isSubscribed, error }
+
+WAREHOUSE HOOKS
+  useWarehouseQuery / useWarehouseSelect / useWarehouseInsert
+  useWarehouseUpdate / useWarehouseDelete / useWarehouseUpsert / useWarehouseTransaction
+
+ACTIONS HOOKS
+  useActions(app) → { isConnected, connect, disconnect }
+  useActionRun(hookOptions?) → { mutate, isLoading, error, data }
+
+ANALYTICS HOOK
+  useAnalytics() → { pageview, track, identify }
+
+hookOptions pattern (applies to all hooks):
+  enabled?    boolean — false skips auto-fetch/subscribe
+  onSuccess?  (data) => void
+  onError?    (error: Error) => void
+  Subscriptions also accept: onData, onSubscribe, onUnsubscribe
+
+EXAMPLE
+  // main.tsx
+  import { DuctapeProvider } from '@ductape/react';
+  root.render(
+    <DuctapeProvider config={{ publishableKey: 'pk_...', baseUrl: '...', product: 'my-app', env: 'prd' }} autoConnect>
+      <App />
+    </DuctapeProvider>
+  );
+
+  // UsersList.tsx
+  import { useDatabaseQuery } from '@ductape/react';
+  function UsersList() {
+    const { data, isLoading } = useDatabaseQuery('users', { table: 'users', limit: 20 });
+    if (isLoading) return <p>Loading...</p>;
+    return <ul>{data?.rows.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
+  }
+
+  // FeatureTracker.tsx
+  import { useFeatureSubscription } from '@ductape/react';
+  function FeatureTracker({ executionId }) {
+    const { data: events } = useFeatureSubscription(
+      { feature: 'onboard-user', executionId },
+      { onData: (evs) => console.log('status:', evs[0].status) },
+    );
+    return <p>{events?.[0]?.status ?? 'waiting'}</p>;
+  }
+
+DEPRECATED ALIASES
+  useWorkflowExecute → useFeatureExecute
+  useWorkflowStatus  → useFeatureStatus
+  useWorkflowSubscription → useFeatureSubscription
+  useWorkflowSignal  → useFeatureSignal
+  useWorkflowCancel  → useFeatureCancel
+`.trim(),
+    vue: `
+DUCTAPE VUE (@ductape/vue)
+
+Vue 3 composables and plugin for Ductape. Wraps @ductape/client.
+Requires vue >= 3.
+
+INSTALL
+  npm install @ductape/vue
+
+SETUP — install the plugin at app root
+  // main.ts
+  import { createApp } from 'vue';
+  import { createDuctape } from '@ductape/vue';
+  import App from './App.vue';
+
+  const app = createApp(App);
+
+  app.use(createDuctape({
+    publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
+    baseUrl: import.meta.env.VITE_PROXY_URL,
+    product: 'my-product',
+    env: 'prd',
+    autoConnect: false,   // true = connect WebSocket when plugin installs
+  }));
+
+  app.mount('#app');
+
+  Plugin options (extends IDuctapeClientConfig):
+    publishableKey / accessKey  — auth
+    baseUrl                     — proxy URL
+    product, env                — defaults for all composables
+    autoConnect                 — boolean (default false)
+
+  The client is provided via inject(DUCTAPE_INJECTION_KEY) and is available on
+  this.$ductape in Options API components.
+
+CORE COMPOSABLE
+  useDuctape()
+    → { client, isReady, isConnected: Ref<boolean>, connectionState: Ref<ConnectionState>,
+        error: Ref<Error|null>, connect, disconnect }
+
+DATABASE COMPOSABLES
+  useDatabase(database)
+    → { isConnected, isConnecting, error, connect, disconnect }  — all Refs
+    Call connect() in onMounted to open the database session.
+
+  useDatabaseQuery(key, queryOptions, composableOptions?)
+    → { data: Ref<IQueryResult<T>|null>, isLoading: Ref<boolean>, error: Ref<Error|null>, refetch }
+
+  useDatabaseInsert(composableOptions?)  → { mutate({ table, data }), isLoading, error, data }
+  useDatabaseUpdate(composableOptions?)  → { mutate({ table, where, data }), isLoading, error, data }
+  useDatabaseDelete(composableOptions?)  → { mutate({ table, where }), isLoading, error, data }
+
+  useDatabaseSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<T[]|null>, isSubscribed: Ref<boolean>, error, unsubscribe, resubscribe }
+    subscribeOptions: { table, where?, select? }
+
+FEATURE COMPOSABLES
+  useFeatureExecute(composableOptions?)
+    → { mutate({ feature, input?, product?, env? }), isLoading, error, data }
+  useFeatureStatus(statusInput, composableOptions?)
+    → { data: Ref<FeatureStatus|null>, isLoading, error, refetch }
+  useFeatureSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<FeatureStatusEvent[]|null>, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { feature, executionId, product?, env? }
+  useFeatureSignal(composableOptions?)  → { mutate, isLoading, error }
+  useFeatureCancel(composableOptions?)  → { mutate, isLoading, error }
+
+AGENT COMPOSABLES
+  useAgentRun(composableOptions?)
+    → { mutate({ tag, input?, sessionId? }), isLoading, error, data }
+  useAgentStream(tag, input?, composableOptions?)
+    → { events, content, isStreaming, isComplete, error, start, stop, reset }
+    content: Ref<string> accumulated from stream text events
+  useAgentStatus(statusInput, composableOptions?) → { data, isLoading, error, refetch }
+  useAgentSignal(composableOptions?)              → { mutate, isLoading, error }
+
+BROKER COMPOSABLES
+  useBroker(broker, options?)
+    → { isConnected, isConnecting, error, connect, disconnect }
+  useBrokerPublish(composableOptions?)
+    → { mutate({ topic, message, headers?, key? }), isLoading, error, data }
+  useBrokerSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<BrokerMessage[]|null>, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { topic, group? }
+
+GRAPH COMPOSABLES
+  useGraph(graphTag)  → { isConnected, isConnecting, error, connect, disconnect }
+  useCreateNode / useUpdateNode / useDeleteNode / useQueryNodes
+  useCreateRelationship / useDeleteRelationship / useQueryRelationships
+  useTraverse / useShortestPath
+  useGraphSubscription(subscribeOptions, composableOptions?)
+    → { data, isSubscribed, error, unsubscribe, resubscribe }
+
+VECTOR COMPOSABLES
+  useVector(vectorTag) → { isConnected, isConnecting, error, connect, disconnect }
+  useVectorQuery / useVectorSearch / useVectorUpsert / useVectorDelete
+  useVectorFetch / useVectorStats / useVectorNamespaces
+
+STORAGE COMPOSABLES
+  useUpload(composableOptions?)
+    → { upload({ storage, fileName, buffer, mimeType? }), isLoading, progress: Ref<number>, error, data }
+  useDownload / useStorageDelete / useListFiles / useSignedUrl
+
+SESSION COMPOSABLES
+  useSessionStart / useSessionVerify / useSessionRefresh
+  useSessionRevoke / useSessionRevokeAll / useSessionList
+  useSessionAutoRefresh(config) → { token: Ref<string|null>, isRefreshing: Ref<boolean> }
+
+CACHE COMPOSABLES
+  useCacheGet / useCacheSet / useCacheDelete / useCacheExists
+  useCacheGetMany / useCacheSetMany / useCacheDeleteMany
+
+RESILIENCE COMPOSABLES
+  useHealthStatus / useHealthSubscription
+  useQuotaRun / useQuotaCheck / useQuotaStatus / useQuotaSubscription
+  useFallbackRun
+
+WAREHOUSE COMPOSABLES
+  useWarehouseQuery / useWarehouseSelect / useWarehouseInsert
+  useWarehouseUpdate / useWarehouseDelete / useWarehouseUpsert / useWarehouseTransaction
+
+ACTIONS COMPOSABLES
+  useActions(app) → { isConnected, connect, disconnect }
+  useActionRun(composableOptions?) → { mutate, isLoading, error, data }
+
+ANALYTICS COMPOSABLE
+  useAnalytics() → { pageview, track, identify }
+
+composableOptions pattern (applies to all composables):
+  enabled?    boolean — false skips auto-fetch/subscribe
+  onSuccess?  (data) => void
+  onError?    (error: Error) => void
+  Subscriptions also accept: onData, onSubscribe, onUnsubscribe
+
+EXAMPLE
+  <!-- UsersList.vue -->
+  <script setup>
+  import { useDatabaseQuery } from '@ductape/vue';
+  const { data, isLoading, error } = useDatabaseQuery('users', { table: 'users', limit: 20 });
+  </script>
+  <template>
+    <div v-if="isLoading">Loading...</div>
+    <div v-else-if="error">{{ error.message }}</div>
+    <ul v-else>
+      <li v-for="user in data?.rows" :key="user.id">{{ user.name }}</li>
+    </ul>
+  </template>
+
+  <!-- FeatureTracker.vue -->
+  <script setup>
+  import { useFeatureSubscription } from '@ductape/vue';
+  const props = defineProps(['executionId']);
+  const { data: events, isSubscribed } = useFeatureSubscription(
+    { feature: 'onboard-user', executionId: props.executionId },
+  );
+  </script>
+  <template>
+    <p>{{ events?.[0]?.status ?? 'waiting' }}</p>
+  </template>
+
+DEPRECATED ALIASES
+  useWorkflowExecute → useFeatureExecute
+  useWorkflowStatus  → useFeatureStatus
+  useWorkflowSubscription → useFeatureSubscription
+  useWorkflowSignal  → useFeatureSignal
+  useWorkflowCancel  → useFeatureCancel
 `.trim(),
 };
 const docsHandler = async (args) => {
@@ -2602,7 +3128,7 @@ async function main() {
                 'index strategy, operation types) that should be confirmed with the user first.\n\n' +
                 'Available topics: transactions, presave, triggers, aggregations, migrations, indexes, performance, actions, ' +
                 'graphs, storage, cloud, vector, warehouse, secrets, apps, products, sessions, caches, ' +
-                'notifications, resilience, features, events, logs',
+                'notifications, resilience, features, events, logs, client, react, vue',
             inputSchema: docsInputSchema,
         }, docsHandler);
         server.registerTool('ductape_cli', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/mcp",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "MCP server that exposes Ductape SDK operations via the backend proxy",
   "type": "module",
   "main": "dist/index.js",

package/src/index.ts

@@ -2412,6 +2412,535 @@ Notes:
   - language defaults to "typescript" so the backend knows which SDK emitted the entry.
   - Logs are batched in memory and sent in a single publish() call per operation.
 `.trim(),
+
+  client: `
+DUCTAPE CLIENT SDK (@ductape/client)
+
+The client SDK is for frontend applications (React, Vue, Svelte, vanilla JS). All HTTP
+operations are routed through the Ductape proxy using a publishableKey. WebSocket subscriptions
+connect to the proxy's /realtime gateway. Never use this package on the server — use @ductape/sdk
+for server-side code.
+
+INSTALL
+  npm install @ductape/client
+
+INITIALIZATION
+  import { createClient } from '@ductape/client';
+  // or: import Ductape from '@ductape/client';
+
+  const ductape = createClient({
+    publishableKey: 'pk_live_...',            // from Workbench → Settings → Publishable Keys
+    baseUrl: 'https://your-proxy.example.com', // your deployed proxy URL
+    product: 'my-product',                    // default product tag (can be overridden per call)
+    env: 'prd',                               // default environment slug
+  });
+
+  When publishableKey is set:
+    - HTTP calls go to baseUrl/proxy/v1/sdk-proxy/execute
+    - WebSocket connects to wss://your-proxy.example.com/realtime?token=pk_live_...
+    - No server secret is exposed to the browser
+
+  Use accessKey only for server-side or trusted environments — never in a browser bundle.
+  Override wsUrl to point to a custom WebSocket endpoint.
+
+REAL-TIME CONNECTION
+  await ductape.connect();        // opens WebSocket; required before any .subscribe() call
+  ductape.disconnect();           // closes WebSocket and clears all subscriptions
+  ductape.isConnected             // boolean
+  ductape.connectionState         // 'disconnected' | 'connecting' | 'connected' | 'reconnecting'
+  ductape.onConnectionChange(cb)  // listen to state changes; returns unsubscribe fn
+
+SERVICES
+  ductape.databases     DatabaseService    — CRUD + real-time query subscriptions
+  ductape.features      FeatureService     — execute features, subscribe to execution status
+  ductape.agents        AgentService       — run AI agents, subscribe to output stream
+  ductape.vectors       VectorService      — vector upsert / search
+  ductape.graphs        GraphService       — graph queries + subscriptions
+  ductape.brokers       BrokerService      — publish / subscribe to message brokers
+  ductape.sessions      SessionService     — verify, refresh, revoke sessions
+  ductape.resilience    ResilienceService  — subscribe to healthcheck status
+  ductape.storage       StorageService     — upload / download files
+  ductape.warehouse     WarehouseService   — cross-store federated queries
+  ductape.cache         CacheService       — key-value cache get / set / clear
+  ductape.api           ApiService         — run app actions with OAuth credential support
+  ductape.notifications NotificationsService — send push / email / SMS / callback
+  ductape.analytics     AnalyticsService   — track pageviews, clicks, custom events
+  ductape.workflows     (deprecated alias → features)
+  ductape.actions       (deprecated alias → api)
+
+DATABASE SERVICE
+  await ductape.databases.connect({ database: 'core-db' });
+  const { data } = await ductape.databases.query({ entity: 'users', where: { active: true } });
+  await ductape.databases.insert({ entity: 'users', data: { name: 'Alice', email: 'a@b.com' } });
+  await ductape.databases.update({ entity: 'users', where: { id: 1 }, data: { name: 'Bob' } });
+  await ductape.databases.delete({ entity: 'users', where: { id: 1 } });
+  await ductape.databases.upsert({ entity: 'users', data: { email: 'a@b.com' }, conflict: ['email'] });
+  const total = await ductape.databases.count({ entity: 'users', where: { active: true } });
+  await ductape.databases.raw({ query: 'SELECT * FROM users WHERE id = $1', params: [1] });
+  await ductape.databases.transaction(async (tx) => {
+    await tx.insert({ entity: 'orders', data: { ... } });
+    await tx.update({ entity: 'inventory', where: { ... }, data: { ... } });
+  });
+  await ductape.databases.disconnect();
+
+  Real-time subscription (ductape.connect() must be called first):
+  const sub = ductape.databases.subscribe(
+    { entity: 'orders', where: { status: 'pending' } },
+    (rows) => console.log('live update', rows),
+  );
+  sub.unsubscribe(); // stop receiving updates
+
+FEATURE SERVICE
+  const { executionId } = await ductape.features.execute({ feature: 'onboard-user', input: { userId: 'u_1' } });
+  const status = await ductape.features.status({ feature: 'onboard-user', executionId });
+  await ductape.features.cancel({ feature: 'onboard-user', executionId, reason: 'user request' });
+  await ductape.features.signal({ feature: 'onboard-user', executionId, signal: 'payment-confirmed' });
+  const history = await ductape.features.history({ feature: 'onboard-user', executionId });
+  const { executions } = await ductape.features.list({ status: 'running', limit: 20 });
+
+  Real-time status subscription:
+  const sub = ductape.features.subscribe(
+    { feature: 'onboard-user', executionId },
+    (events) => {
+      const ev = events[0]; // { executionId, feature, status, currentStep, output, error }
+      console.log(ev.status, ev.currentStep);
+      if (ev.status === 'completed' || ev.status === 'failed') sub.unsubscribe();
+    },
+  );
+
+AGENT SERVICE
+  const result = await ductape.agents.run({ agent: 'support-bot', input: { message: 'Help!' } });
+  const sub = ductape.agents.subscribe(
+    { agent: 'support-bot', executionId: result.executionId },
+    (events) => console.log('chunk', events[0]),
+  );
+  sub.unsubscribe();
+
+BROKER SERVICE
+  await ductape.brokers.connect({ broker: 'notifications-broker', session: 'user-session:eyJ...' });
+  await ductape.brokers.publish({ topic: 'chat.message', message: { text: 'Hello', userId: 'u_1' } });
+  const sub = ductape.brokers.subscribe(
+    { topic: 'chat.message' },
+    (msgs) => {
+      const m = msgs[0]; // { topic, message, headers?, key?, timestamp, offset?, partition? }
+      console.log('new message', m.message);
+    },
+  );
+  sub.unsubscribe();
+  await ductape.brokers.disconnect();
+
+  Passing session scopes delivery to a specific end-user so the server applies session-level
+  authorization. Without session, messages for the whole product+env are delivered.
+
+GRAPH SERVICE
+  const nodes = await ductape.graphs.findNodes({ labels: ['User'], where: { active: true } });
+  const sub = ductape.graphs.subscribe({ labels: ['Order'] }, (nodes) => console.log(nodes));
+  sub.unsubscribe();
+
+RESILIENCE SERVICE (health subscriptions)
+  const sub = ductape.resilience.subscribe(
+    { tag: 'payment-health' },
+    (events) => console.log('health change', events[0]),
+  );
+  sub.unsubscribe();
+
+SESSIONS SERVICE
+  const { valid } = await ductape.sessions.verify({ token: 'user-session:eyJ...' });
+  await ductape.sessions.revoke({ token: 'user-session:eyJ...' });
+  const { token } = await ductape.sessions.refresh({ refreshToken: '...' });
+
+ANALYTICS SERVICE
+  ductape.analytics.pageview({ page: '/dashboard' });
+  ductape.analytics.track('button_click', { button: 'sign-up' });
+  ductape.analytics.identify({ userId: 'u_123', traits: { plan: 'pro' } });
+
+FRAMEWORK-SPECIFIC PACKAGES
+  For React and Vue projects, use the dedicated packages instead of managing the client manually:
+    @ductape/react — DuctapeProvider + hooks (useDatabaseQuery, useFeatureSubscription, etc.)
+                     See: ductape_docs({ topic: "react" })
+    @ductape/vue   — createDuctape() plugin + composables (useDatabaseQuery, useFeatureSubscription, etc.)
+                     See: ductape_docs({ topic: "vue" })
+
+  Use @ductape/client directly only for vanilla JS, Svelte, Angular, or custom integrations.
+
+IMPORTANT
+  - Call ductape.connect() before any .subscribe() — it throws if not connected.
+  - Always clean up (sub.unsubscribe()) in component teardown to prevent memory leaks.
+  - The client auto-resubscribes after a WebSocket reconnect — no manual retry needed.
+  - publishableKey is safe in browser bundles; it grants only proxy-authorized operations.
+  - For SSR, skip connect() on the server; call it only client-side (useEffect / onMounted).
+  - The client SDK does NOT expose secrets, access keys, or workspace admin operations.
+  - Pass session (format session_tag:jwt) to broker connect/subscribe for per-user scoping.
+`.trim(),
+
+  react: `
+DUCTAPE REACT (@ductape/react)
+
+React hooks and context provider for Ductape. Wraps @ductape/client.
+Requires react >= 17.
+
+INSTALL
+  npm install @ductape/react
+
+SETUP — wrap your app root with DuctapeProvider
+  import { DuctapeProvider } from '@ductape/react';
+
+  function App() {
+    return (
+      <DuctapeProvider
+        config={{
+          publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
+          baseUrl: import.meta.env.VITE_PROXY_URL,
+          product: 'my-product',
+          env: 'prd',
+        }}
+        autoConnect={false}
+      >
+        <MyApp />
+      </DuctapeProvider>
+    );
+  }
+
+  DuctapeProvider props:
+    config              IDuctapeClientConfig  — publishableKey (or accessKey), baseUrl, product, env
+    autoConnect         boolean (default false) — connect WebSocket automatically on mount
+    onConnected         () => void
+    onDisconnected      () => void
+    onError             (error: Error) => void
+    onConnectionChange  (state: ConnectionState) => void
+
+CORE HOOKS
+  useDuctape()        → { client, isConnected, connectionState, connect, disconnect, isReady }
+  useDuctapeContext()  → same; throws if called outside DuctapeProvider
+
+DATABASE HOOKS
+  useDatabase(database)
+    → { isConnected, isConnecting, error, connect, disconnect }
+    Call connect() in a useEffect to open the database session.
+
+  useDatabaseQuery(key, queryOptions, hookOptions?)
+    → { data: IQueryResult<T>, isLoading, error, refetch }
+    key: string | string[]  — deduplication key
+    queryOptions: { table, where?, select?, limit?, offset?, sort? }
+
+  useDatabaseInsert(hookOptions?)   → { mutate({ table, data }), isLoading, error, data }
+  useDatabaseUpdate(hookOptions?)   → { mutate({ table, where, data }), isLoading, error, data }
+  useDatabaseDelete(hookOptions?)   → { mutate({ table, where }), isLoading, error, data }
+
+  useDatabaseSubscription(subscribeOptions, hookOptions?)
+    → { data: T[] | null, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { table, where?, select? }
+    Requires autoConnect: true (or manual connect()) and databases.connect() before subscribing.
+
+FEATURE HOOKS
+  useFeatureExecute(hookOptions?)
+    → { mutate({ feature, input?, product?, env? }), isLoading, error, data }
+  useFeatureStatus(statusInput, hookOptions?)
+    → { data: FeatureStatus, isLoading, error, refetch }
+    statusInput: { feature, executionId, product?, env? }
+  useFeatureSubscription(subscribeOptions, hookOptions?)
+    → { data: FeatureStatusEvent[], isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { feature, executionId, product?, env? }
+  useFeatureSignal(hookOptions?)   → { mutate({ feature, executionId, signal, data? }), isLoading }
+  useFeatureCancel(hookOptions?)   → { mutate({ feature, executionId, reason? }), isLoading }
+
+AGENT HOOKS
+  useAgentRun(hookOptions?)
+    → { mutate({ tag, input?, sessionId? }), isLoading, error, data: IAgentExecutionResult }
+  useAgentStream(tag, input?, hookOptions?)
+    → { events, content, isStreaming, isComplete, error, start, stop, reset }
+    content: accumulated string from all stream text events
+  useAgentStatus(statusInput, hookOptions?)  → { data, isLoading, error, refetch }
+  useAgentSignal(hookOptions?)               → { mutate, isLoading, error }
+
+BROKER HOOKS
+  useBroker(broker, options?)
+    → { isConnected, isConnecting, error, connect, disconnect }
+  useBrokerPublish(hookOptions?)
+    → { mutate({ topic, message, headers?, key? }), isLoading, error, data }
+  useBrokerSubscription(subscribeOptions, hookOptions?)
+    → { data: BrokerMessage[], isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { topic, group? }
+
+GRAPH HOOKS
+  useGraph(graphTag)  → { isConnected, isConnecting, error, connect, disconnect }
+  useCreateNode(hookOptions?)          → { mutate({ labels, properties }), isLoading, error, data }
+  useUpdateNode(hookOptions?)          → { mutate({ id, properties }), isLoading, error, data }
+  useDeleteNode(hookOptions?)          → { mutate({ id, detach? }), isLoading, error, data }
+  useQueryNodes(key, options, hookOptions?)        → { data, isLoading, error }
+  useCreateRelationship(hookOptions?)  → { mutate, isLoading, error, data }
+  useDeleteRelationship(hookOptions?)  → { mutate, isLoading, error }
+  useQueryRelationships(key, options, hookOptions?) → { data, isLoading, error }
+  useTraverse(key, options, hookOptions?)           → { data, isLoading, error }
+  useShortestPath(key, options, hookOptions?)       → { data, isLoading, error }
+  useGraphSubscription(subscribeOptions, hookOptions?)
+    → { data, isSubscribed, error, unsubscribe, resubscribe }
+
+VECTOR HOOKS
+  useVector(vectorTag)    → { isConnected, isConnecting, error, connect, disconnect }
+  useVectorQuery(key, options, hookOptions?)   → { data, isLoading, error }
+  useVectorSearch(key, options, hookOptions?)  → { data, isLoading, error }
+  useVectorUpsert(hookOptions?)   → { mutate({ id, values, metadata? }), isLoading, error, data }
+  useVectorDelete(hookOptions?)   → { mutate({ ids }), isLoading, error }
+  useVectorFetch(key, options, hookOptions?)   → { data: VectorFetchResult, isLoading, error }
+  useVectorStats(key, options, hookOptions?)   → { data: VectorStatsResult, isLoading, error }
+  useVectorNamespaces(key, options, hookOptions?) → { data, isLoading, error }
+
+STORAGE HOOKS
+  useUpload(hookOptions?)
+    → { upload({ storage, fileName, buffer, mimeType? }), isLoading, progress, error, data }
+    progress: 0–100 number
+  useDownload(hookOptions?)         → { mutate, isLoading, error, data }
+  useStorageDelete(hookOptions?)    → { mutate, isLoading, error }
+  useListFiles(key, options, hookOptions?)    → { data, isLoading, error }
+  useSignedUrl(key, options, hookOptions?)    → { data: string, isLoading, error }
+
+SESSION HOOKS
+  useSessionStart(hookOptions?)     → { mutate, isLoading, error, data: { token, refreshToken } }
+  useSessionVerify(hookOptions?)    → { mutate, isLoading, error, data }
+  useSessionRefresh(hookOptions?)   → { mutate, isLoading, error, data }
+  useSessionRevoke(hookOptions?)    → { mutate, isLoading, error }
+  useSessionRevokeAll(hookOptions?) → { mutate, isLoading, error }
+  useSessionList(key, options, hookOptions?) → { data, isLoading, error }
+  useSessionAutoRefresh(config)
+    → { token, isRefreshing }; auto-refreshes before expiry; no manual call needed
+
+CACHE HOOKS
+  useCacheGet(key, options, hookOptions?)     → { data, isLoading, error }
+  useCacheSet(hookOptions?)                  → { mutate({ key, value, expiry? }), isLoading, error }
+  useCacheDelete(hookOptions?)               → { mutate({ key }), isLoading, error }
+  useCacheExists(key, options, hookOptions?) → { data: boolean, isLoading, error }
+  useCacheGetMany / useCacheSetMany / useCacheDeleteMany
+
+RESILIENCE HOOKS
+  useHealthStatus(key, options, hookOptions?)
+    → { data: HealthStatusResult, isLoading, error, refetch }
+  useHealthSubscription(subscribeOptions, hookOptions?)
+    → { data: HealthChangeEvent[], isSubscribed, error, unsubscribe, resubscribe }
+  useQuotaCheck(hookOptions?)  → { mutate, isLoading, error, data: QuotaCheckResult }
+  useQuotaStatus(key, options, hookOptions?) → { data, isLoading, error }
+  useQuotaSubscription(subscribeOptions, hookOptions?) → { data, isSubscribed, error }
+
+WAREHOUSE HOOKS
+  useWarehouseQuery / useWarehouseSelect / useWarehouseInsert
+  useWarehouseUpdate / useWarehouseDelete / useWarehouseUpsert / useWarehouseTransaction
+
+ACTIONS HOOKS
+  useActions(app) → { isConnected, connect, disconnect }
+  useActionRun(hookOptions?) → { mutate, isLoading, error, data }
+
+ANALYTICS HOOK
+  useAnalytics() → { pageview, track, identify }
+
+hookOptions pattern (applies to all hooks):
+  enabled?    boolean — false skips auto-fetch/subscribe
+  onSuccess?  (data) => void
+  onError?    (error: Error) => void
+  Subscriptions also accept: onData, onSubscribe, onUnsubscribe
+
+EXAMPLE
+  // main.tsx
+  import { DuctapeProvider } from '@ductape/react';
+  root.render(
+    <DuctapeProvider config={{ publishableKey: 'pk_...', baseUrl: '...', product: 'my-app', env: 'prd' }} autoConnect>
+      <App />
+    </DuctapeProvider>
+  );
+
+  // UsersList.tsx
+  import { useDatabaseQuery } from '@ductape/react';
+  function UsersList() {
+    const { data, isLoading } = useDatabaseQuery('users', { table: 'users', limit: 20 });
+    if (isLoading) return <p>Loading...</p>;
+    return <ul>{data?.rows.map(u => <li key={u.id}>{u.name}</li>)}</ul>;
+  }
+
+  // FeatureTracker.tsx
+  import { useFeatureSubscription } from '@ductape/react';
+  function FeatureTracker({ executionId }) {
+    const { data: events } = useFeatureSubscription(
+      { feature: 'onboard-user', executionId },
+      { onData: (evs) => console.log('status:', evs[0].status) },
+    );
+    return <p>{events?.[0]?.status ?? 'waiting'}</p>;
+  }
+
+DEPRECATED ALIASES
+  useWorkflowExecute → useFeatureExecute
+  useWorkflowStatus  → useFeatureStatus
+  useWorkflowSubscription → useFeatureSubscription
+  useWorkflowSignal  → useFeatureSignal
+  useWorkflowCancel  → useFeatureCancel
+`.trim(),
+
+  vue: `
+DUCTAPE VUE (@ductape/vue)
+
+Vue 3 composables and plugin for Ductape. Wraps @ductape/client.
+Requires vue >= 3.
+
+INSTALL
+  npm install @ductape/vue
+
+SETUP — install the plugin at app root
+  // main.ts
+  import { createApp } from 'vue';
+  import { createDuctape } from '@ductape/vue';
+  import App from './App.vue';
+
+  const app = createApp(App);
+
+  app.use(createDuctape({
+    publishableKey: import.meta.env.VITE_PUBLISHABLE_KEY,
+    baseUrl: import.meta.env.VITE_PROXY_URL,
+    product: 'my-product',
+    env: 'prd',
+    autoConnect: false,   // true = connect WebSocket when plugin installs
+  }));
+
+  app.mount('#app');
+
+  Plugin options (extends IDuctapeClientConfig):
+    publishableKey / accessKey  — auth
+    baseUrl                     — proxy URL
+    product, env                — defaults for all composables
+    autoConnect                 — boolean (default false)
+
+  The client is provided via inject(DUCTAPE_INJECTION_KEY) and is available on
+  this.$ductape in Options API components.
+
+CORE COMPOSABLE
+  useDuctape()
+    → { client, isReady, isConnected: Ref<boolean>, connectionState: Ref<ConnectionState>,
+        error: Ref<Error|null>, connect, disconnect }
+
+DATABASE COMPOSABLES
+  useDatabase(database)
+    → { isConnected, isConnecting, error, connect, disconnect }  — all Refs
+    Call connect() in onMounted to open the database session.
+
+  useDatabaseQuery(key, queryOptions, composableOptions?)
+    → { data: Ref<IQueryResult<T>|null>, isLoading: Ref<boolean>, error: Ref<Error|null>, refetch }
+
+  useDatabaseInsert(composableOptions?)  → { mutate({ table, data }), isLoading, error, data }
+  useDatabaseUpdate(composableOptions?)  → { mutate({ table, where, data }), isLoading, error, data }
+  useDatabaseDelete(composableOptions?)  → { mutate({ table, where }), isLoading, error, data }
+
+  useDatabaseSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<T[]|null>, isSubscribed: Ref<boolean>, error, unsubscribe, resubscribe }
+    subscribeOptions: { table, where?, select? }
+
+FEATURE COMPOSABLES
+  useFeatureExecute(composableOptions?)
+    → { mutate({ feature, input?, product?, env? }), isLoading, error, data }
+  useFeatureStatus(statusInput, composableOptions?)
+    → { data: Ref<FeatureStatus|null>, isLoading, error, refetch }
+  useFeatureSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<FeatureStatusEvent[]|null>, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { feature, executionId, product?, env? }
+  useFeatureSignal(composableOptions?)  → { mutate, isLoading, error }
+  useFeatureCancel(composableOptions?)  → { mutate, isLoading, error }
+
+AGENT COMPOSABLES
+  useAgentRun(composableOptions?)
+    → { mutate({ tag, input?, sessionId? }), isLoading, error, data }
+  useAgentStream(tag, input?, composableOptions?)
+    → { events, content, isStreaming, isComplete, error, start, stop, reset }
+    content: Ref<string> accumulated from stream text events
+  useAgentStatus(statusInput, composableOptions?) → { data, isLoading, error, refetch }
+  useAgentSignal(composableOptions?)              → { mutate, isLoading, error }
+
+BROKER COMPOSABLES
+  useBroker(broker, options?)
+    → { isConnected, isConnecting, error, connect, disconnect }
+  useBrokerPublish(composableOptions?)
+    → { mutate({ topic, message, headers?, key? }), isLoading, error, data }
+  useBrokerSubscription(subscribeOptions, composableOptions?)
+    → { data: Ref<BrokerMessage[]|null>, isSubscribed, error, unsubscribe, resubscribe }
+    subscribeOptions: { topic, group? }
+
+GRAPH COMPOSABLES
+  useGraph(graphTag)  → { isConnected, isConnecting, error, connect, disconnect }
+  useCreateNode / useUpdateNode / useDeleteNode / useQueryNodes
+  useCreateRelationship / useDeleteRelationship / useQueryRelationships
+  useTraverse / useShortestPath
+  useGraphSubscription(subscribeOptions, composableOptions?)
+    → { data, isSubscribed, error, unsubscribe, resubscribe }
+
+VECTOR COMPOSABLES
+  useVector(vectorTag) → { isConnected, isConnecting, error, connect, disconnect }
+  useVectorQuery / useVectorSearch / useVectorUpsert / useVectorDelete
+  useVectorFetch / useVectorStats / useVectorNamespaces
+
+STORAGE COMPOSABLES
+  useUpload(composableOptions?)
+    → { upload({ storage, fileName, buffer, mimeType? }), isLoading, progress: Ref<number>, error, data }
+  useDownload / useStorageDelete / useListFiles / useSignedUrl
+
+SESSION COMPOSABLES
+  useSessionStart / useSessionVerify / useSessionRefresh
+  useSessionRevoke / useSessionRevokeAll / useSessionList
+  useSessionAutoRefresh(config) → { token: Ref<string|null>, isRefreshing: Ref<boolean> }
+
+CACHE COMPOSABLES
+  useCacheGet / useCacheSet / useCacheDelete / useCacheExists
+  useCacheGetMany / useCacheSetMany / useCacheDeleteMany
+
+RESILIENCE COMPOSABLES
+  useHealthStatus / useHealthSubscription
+  useQuotaRun / useQuotaCheck / useQuotaStatus / useQuotaSubscription
+  useFallbackRun
+
+WAREHOUSE COMPOSABLES
+  useWarehouseQuery / useWarehouseSelect / useWarehouseInsert
+  useWarehouseUpdate / useWarehouseDelete / useWarehouseUpsert / useWarehouseTransaction
+
+ACTIONS COMPOSABLES
+  useActions(app) → { isConnected, connect, disconnect }
+  useActionRun(composableOptions?) → { mutate, isLoading, error, data }
+
+ANALYTICS COMPOSABLE
+  useAnalytics() → { pageview, track, identify }
+
+composableOptions pattern (applies to all composables):
+  enabled?    boolean — false skips auto-fetch/subscribe
+  onSuccess?  (data) => void
+  onError?    (error: Error) => void
+  Subscriptions also accept: onData, onSubscribe, onUnsubscribe
+
+EXAMPLE
+  <!-- UsersList.vue -->
+  <script setup>
+  import { useDatabaseQuery } from '@ductape/vue';
+  const { data, isLoading, error } = useDatabaseQuery('users', { table: 'users', limit: 20 });
+  </script>
+  <template>
+    <div v-if="isLoading">Loading...</div>
+    <div v-else-if="error">{{ error.message }}</div>
+    <ul v-else>
+      <li v-for="user in data?.rows" :key="user.id">{{ user.name }}</li>
+    </ul>
+  </template>
+
+  <!-- FeatureTracker.vue -->
+  <script setup>
+  import { useFeatureSubscription } from '@ductape/vue';
+  const props = defineProps(['executionId']);
+  const { data: events, isSubscribed } = useFeatureSubscription(
+    { feature: 'onboard-user', executionId: props.executionId },
+  );
+  </script>
+  <template>
+    <p>{{ events?.[0]?.status ?? 'waiting' }}</p>
+  </template>
+
+DEPRECATED ALIASES
+  useWorkflowExecute → useFeatureExecute
+  useWorkflowStatus  → useFeatureStatus
+  useWorkflowSubscription → useFeatureSubscription
+  useWorkflowSignal  → useFeatureSignal
+  useWorkflowCancel  → useFeatureCancel
+`.trim(),
 };
 
 const docsHandler = async (args: { topic: string }) => {
@@ -2723,7 +3252,7 @@ async function main() {
           'index strategy, operation types) that should be confirmed with the user first.\n\n' +
           'Available topics: transactions, presave, triggers, aggregations, migrations, indexes, performance, actions, ' +
           'graphs, storage, cloud, vector, warehouse, secrets, apps, products, sessions, caches, ' +
-          'notifications, resilience, features, events, logs',
+          'notifications, resilience, features, events, logs, client, react, vue',
         inputSchema: docsInputSchema,
       },
       docsHandler,