@vanira/sdk-react-native 0.0.2

package/src/presets/presetClientAdapter.ts

@@ -0,0 +1,29 @@
+import type {VaniraAI} from '../core/VaniraAI';
+import type {PresetClient} from './types';
+
+/** Map VaniraAI public API → PresetClient (web PresetRenderer contract). */
+export function toPresetClient(ai: VaniraAI | null): PresetClient | null {
+  if (!ai) {
+    return null;
+  }
+
+  return {
+    sendToolResult: (toolCallId, result) => ai.sendToolResult(toolCallId, result),
+    sendToolError: (toolCallId, error) => ai.sendToolError(toolCallId, error),
+    sendContextUpdate: data => ai.updateContext(data),
+    triggerActionInterrupt: () => ai.interruptAudioOnly(),
+    sendActionTrigger: (actionName, data) => {
+      ai.sendEvent('client_action_trigger', {
+        data: {
+          action_name: actionName,
+          data,
+        },
+      });
+    },
+    uploadMedia: (file, reason, message) =>
+      ai.uploadMedia(file, reason, message),
+    sendEvent: (event, payload) => ai.sendEvent(event, payload ?? {}),
+    serverUrl: ai.serverUrl,
+    callId: ai.callId,
+  };
+}

package/src/presets/presetCompletion.ts

@@ -0,0 +1,91 @@
+import type {PresetClient} from './types';
+import type {PresetId} from './types';
+
+/** Web PresetRenderer.tsx onComplete wrapper (calendar uses sendActionTrigger). */
+export function completePreset(
+  client: PresetClient | null,
+  presetId: PresetId,
+  toolCallId: string,
+  clientFields: Record<string, unknown>,
+  payload: Record<string, unknown>,
+  toolName?: string,
+): void {
+  if (!client) {
+    return;
+  }
+
+  if (payload.media_id || payload.url) {
+    return;
+  }
+
+  if (
+    presetId === 'vanira_type_text' ||
+    presetId === 'vanira_erase_text' ||
+    presetId === 'vanira_draw'
+  ) {
+    return;
+  }
+
+  if (presetId === 'vanira_calendar') {
+    client.triggerActionInterrupt?.();
+    const actionName = String(
+      clientFields.action_name || 'calendar_slot_selected',
+    );
+    client.sendActionTrigger?.(actionName, payload);
+    return;
+  }
+
+  if (presetId === 'vanira_form') {
+    client.triggerActionInterrupt?.();
+    const actionName = String(
+      clientFields.action_name ||
+        `user_submitted_${toolName || 'collect_user_data'}`,
+    );
+    client.sendActionTrigger?.(actionName, payload);
+    return;
+  }
+
+  if (presetId === 'vanira_navigate') {
+    client.triggerActionInterrupt?.();
+    const actionName = String(
+      clientFields.action_name ||
+        `user_submitted_${toolName || 'navigate_user'}`,
+    );
+    client.sendActionTrigger?.(actionName, payload);
+    return;
+  }
+
+  if (toolCallId) {
+    client.sendToolResult(toolCallId, payload);
+  }
+}
+
+/** Web PresetRenderer.tsx onCancel wrapper. */
+export function cancelPreset(
+  client: PresetClient | null,
+  presetId: PresetId,
+  toolCallId: string,
+  reason?: string,
+): void {
+  if (!client || !toolCallId) {
+    return;
+  }
+
+  if (
+    presetId === 'vanira_type_text' ||
+    presetId === 'vanira_erase_text' ||
+    presetId === 'vanira_draw'
+  ) {
+    return;
+  }
+
+  const message = reason || 'User cancelled the action';
+  if (client.sendToolError) {
+    client.sendToolError(toolCallId, message);
+  } else {
+    client.sendToolResult(toolCallId, {
+      status: 'cancelled',
+      reason: message,
+    });
+  }
+}

package/src/presets/presetEventHelpers.ts

@@ -0,0 +1,45 @@
+import type {ClientToolCall} from '../core/VaniraAI';
+import {parseToolCall} from './parseToolCall';
+
+type RawToolCall = {
+  name?: string;
+  tool_name?: string;
+  arguments?: Record<string, unknown>;
+  args?: Record<string, unknown>;
+  client_fields?: Record<string, unknown>;
+  tool_call_id?: string;
+  call_id?: string;
+  execution_mode?: string;
+};
+
+function normalizeRawToolCall(raw: unknown): RawToolCall {
+  if (!raw || typeof raw !== 'object') {
+    return {};
+  }
+  let data = (raw as {data?: RawToolCall}).data ?? (raw as RawToolCall);
+  const nested = (data as {tool_call?: RawToolCall}).tool_call;
+  if (nested && typeof nested === 'object') {
+    data = nested;
+  }
+  return data;
+}
+
+export function extractPresetId(toolCall: unknown): string | undefined {
+  return parseToolCall(toolCall)?.presetId;
+}
+
+export function extractToolName(toolCall: unknown): string {
+  const data = normalizeRawToolCall(toolCall);
+  const name = data.name ?? data.tool_name;
+  return typeof name === 'string' ? name : '';
+}
+
+export function toClientToolCallPayload(toolCall: ClientToolCall) {
+  return {
+    name: toolCall.name,
+    arguments: toolCall.arguments,
+    tool_call_id: toolCall.tool_call_id,
+    execution_mode: toolCall.execution_mode,
+    client_fields: toolCall.client_fields,
+  };
+}

package/src/presets/registry.ts

@@ -0,0 +1,128 @@
+/** Single source of truth for built-in client preset IDs (web parity). */
+export const VaniraPresetId = {
+  Form: 'vanira_form',
+  Calendar: 'vanira_calendar',
+  Navigate: 'vanira_navigate',
+  Upload: 'vanira_upload',
+  Camera: 'vanira_camera',
+  HighlightElement: 'vanira_highlight_element',
+  ClickElement: 'vanira_click_element',
+  SelectOption: 'vanira_select_option',
+  SetDate: 'vanira_set_date',
+  TypeText: 'vanira_type_text',
+  EraseText: 'vanira_erase_text',
+  Draw: 'vanira_draw',
+  LiveVision: 'vanira_live_vision',
+  CloseLiveCamera: 'vanira_close_live_camera',
+  LiveScreen: 'vanira_live_screen',
+  CloseLiveScreen: 'vanira_close_live_screen',
+  ClipRegion: 'vanira_clip_region',
+} as const;
+
+export type VaniraPresetIdValue =
+  (typeof VaniraPresetId)[keyof typeof VaniraPresetId];
+
+export const VANIRA_PRESET_IDS: readonly VaniraPresetIdValue[] =
+  Object.values(VaniraPresetId);
+
+const presetIdSet = new Set<string>(VANIRA_PRESET_IDS);
+
+export const FIRE_AND_FORGET_PRESET_IDS = new Set<VaniraPresetIdValue>([
+  VaniraPresetId.Camera,
+  VaniraPresetId.LiveVision,
+  VaniraPresetId.LiveScreen,
+]);
+
+export const NON_INTERACTIVE_PRESET_IDS = new Set<VaniraPresetIdValue>([
+  VaniraPresetId.Navigate,
+  VaniraPresetId.HighlightElement,
+  VaniraPresetId.ClickElement,
+  VaniraPresetId.SelectOption,
+  VaniraPresetId.SetDate,
+  VaniraPresetId.TypeText,
+  VaniraPresetId.EraseText,
+  VaniraPresetId.Draw,
+  VaniraPresetId.LiveVision,
+  VaniraPresetId.CloseLiveCamera,
+  VaniraPresetId.LiveScreen,
+  VaniraPresetId.CloseLiveScreen,
+]);
+
+export const BOARD_QUEUED_PRESET_IDS = new Set<VaniraPresetIdValue>([
+  VaniraPresetId.TypeText,
+  VaniraPresetId.EraseText,
+  VaniraPresetId.Draw,
+]);
+
+export const TOOL_NAME_TO_PRESET_ID: Record<string, VaniraPresetIdValue> = {
+  vanira_calendar: VaniraPresetId.Calendar,
+  display_booking_calendar: VaniraPresetId.Calendar,
+  vanira_form: VaniraPresetId.Form,
+  collect_user_data: VaniraPresetId.Form,
+  open_form_to_collect_user_data: VaniraPresetId.Form,
+  vanira_camera: VaniraPresetId.Camera,
+  open_camera: VaniraPresetId.Camera,
+  vanira_upload: VaniraPresetId.Upload,
+  request_file_upload: VaniraPresetId.Upload,
+  navigate_user: VaniraPresetId.Navigate,
+  highlight_ui_element: VaniraPresetId.HighlightElement,
+  click_element: VaniraPresetId.ClickElement,
+  click_ui_element: VaniraPresetId.ClickElement,
+  select_option: VaniraPresetId.SelectOption,
+  select_dropdown_option: VaniraPresetId.SelectOption,
+  set_date: VaniraPresetId.SetDate,
+  set_input_date: VaniraPresetId.SetDate,
+  type_in_input: VaniraPresetId.TypeText,
+  write_on_white_board: VaniraPresetId.TypeText,
+  erase_text: VaniraPresetId.EraseText,
+  draw_on_board: VaniraPresetId.Draw,
+  draw_shapes: VaniraPresetId.Draw,
+  open_live_camera: VaniraPresetId.LiveVision,
+  close_live_camera: VaniraPresetId.CloseLiveCamera,
+  open_live_screen: VaniraPresetId.LiveScreen,
+  share_screen: VaniraPresetId.LiveScreen,
+  close_live_screen: VaniraPresetId.CloseLiveScreen,
+  clip_region: VaniraPresetId.ClipRegion,
+  clip_page_region: VaniraPresetId.ClipRegion,
+};
+
+export function isVaniraPresetId(
+  value: string | undefined | null,
+): value is VaniraPresetIdValue {
+  return !!value && presetIdSet.has(value);
+}
+
+export function isNonInteractivePreset(value: string | undefined | null): boolean {
+  return isVaniraPresetId(value) && NON_INTERACTIVE_PRESET_IDS.has(value);
+}
+
+export function isBoardQueuedPreset(
+  value: string | undefined | null,
+): value is VaniraPresetIdValue {
+  return isVaniraPresetId(value) && BOARD_QUEUED_PRESET_IDS.has(value);
+}
+
+export function isFireAndForgetPreset(
+  value: string | undefined | null,
+): boolean {
+  return isVaniraPresetId(value) && FIRE_AND_FORGET_PRESET_IDS.has(value);
+}
+
+export function resolvePresetId(
+  clientFields?: Record<string, unknown> | null,
+  args?: Record<string, unknown> | null,
+  toolName?: string,
+): VaniraPresetIdValue | undefined {
+  const fromFields = clientFields?.preset_id;
+  if (typeof fromFields === 'string' && isVaniraPresetId(fromFields)) {
+    return fromFields;
+  }
+  const fromArgs = args?.preset_id;
+  if (typeof fromArgs === 'string' && isVaniraPresetId(fromArgs)) {
+    return fromArgs;
+  }
+  if (toolName && TOOL_NAME_TO_PRESET_ID[toolName]) {
+    return TOOL_NAME_TO_PRESET_ID[toolName];
+  }
+  return undefined;
+}

package/src/presets/streaming/mediaFrameUpload.ts

@@ -0,0 +1,93 @@
+import type {PresetClient} from '../types';
+
+export function resolveUploadBase(serverUrl: string): string {
+  if (!serverUrl) {
+    return '';
+  }
+  try {
+    return new URL(serverUrl).origin;
+  } catch {
+    return serverUrl.replace(/\/webrtc.*$/, '').replace(/\/$/, '');
+  }
+}
+
+export async function uploadStreamingFrame(
+  client: PresetClient,
+  sessionId: string,
+  frameUri: string,
+  reason: string,
+): Promise<{media_id: string; url: string}> {
+  const uploadBase = resolveUploadBase(client.serverUrl ?? '');
+  const callId = client.callId ?? '';
+  const uploadUrl = `${uploadBase}/media/upload`;
+
+  const form = new FormData();
+  form.append('file', {
+    uri: frameUri,
+    type: 'image/jpeg',
+    name: `frame_${sessionId}.jpg`,
+  } as unknown as Blob);
+  form.append('call_id', callId);
+  form.append('reason', reason);
+
+  const res = await fetch(uploadUrl, {method: 'POST', body: form});
+  if (!res.ok) {
+    throw new Error(`Upload HTTP ${res.status}`);
+  }
+  const data = (await res.json()) as {media_id?: string; url?: string};
+  if (!data.media_id || !data.url) {
+    throw new Error('Upload response missing media_id/url');
+  }
+  return {media_id: data.media_id, url: data.url};
+}
+
+export function sendMediaFrameEvent(
+  client: PresetClient,
+  sessionId: string,
+  frameSeq: number,
+  media_id: string,
+  media_url: string,
+  reason: string,
+  extra?: Record<string, unknown>,
+): void {
+  client.sendEvent?.('client_media_frame', {
+    data: {
+      session_id: sessionId,
+      frame_seq: frameSeq,
+      media_id,
+      media_url,
+      content_type: 'image/jpeg',
+      reason,
+      ...extra,
+    },
+  });
+}
+
+export async function captureAndSendStreamingFrame(
+  client: PresetClient,
+  sessionId: string,
+  frameUri: string,
+  reason: string,
+  frameSeq: number,
+  isSessionActive: () => boolean,
+  extra?: Record<string, unknown>,
+): Promise<number> {
+  if (!isSessionActive()) {
+    return frameSeq;
+  }
+
+  const {media_id, url} = await uploadStreamingFrame(
+    client,
+    sessionId,
+    frameUri,
+    reason,
+  );
+
+  if (!isSessionActive()) {
+    return frameSeq;
+  }
+
+  const nextSeq = frameSeq + 1;
+  sendMediaFrameEvent(client, sessionId, nextSeq, media_id, url, reason, extra);
+  return nextSeq;
+}

package/src/presets/types.ts

@@ -0,0 +1,74 @@
+/**
+ * Shared preset types for RN native UI layer.
+ * Payload shapes mirror WidgetPresetRenderer PresetContext + web tool_call normalization.
+ */
+
+import {
+  VaniraPresetId,
+  type VaniraPresetIdValue,
+  VANIRA_PRESET_IDS,
+} from './registry';
+
+export type PresetId = VaniraPresetIdValue;
+
+export const KNOWN_PRESET_IDS: PresetId[] = [...VANIRA_PRESET_IDS];
+
+/** Mirrors WidgetPresetRenderer knownPresets in PresetRenderer.tsx (interactive popup subset). */
+export const PRESET_RENDERER_KNOWN_PRESETS = [
+  VaniraPresetId.Form,
+  VaniraPresetId.Calendar,
+  VaniraPresetId.Navigate,
+  VaniraPresetId.Upload,
+  VaniraPresetId.Camera,
+  VaniraPresetId.HighlightElement,
+  VaniraPresetId.ClickElement,
+  VaniraPresetId.SelectOption,
+  VaniraPresetId.SetDate,
+  VaniraPresetId.TypeText,
+  VaniraPresetId.EraseText,
+  VaniraPresetId.Draw,
+  VaniraPresetId.ClipRegion,
+] as const;
+
+export type ParsedToolCall = {
+  raw: unknown;
+  name: string;
+  toolCallId: string;
+  arguments: Record<string, unknown>;
+  clientFields: Record<string, unknown>;
+  presetId?: string;
+};
+
+export type PresetContext = {
+  toolCallId: string;
+  presetId: PresetId;
+  clientFields: Record<string, unknown>;
+  args: Record<string, unknown>;
+  toolCall: unknown;
+};
+
+export type PresetClient = {
+  sendToolResult: (toolCallId: string, result: Record<string, unknown>) => void;
+  sendToolError: (toolCallId: string, error: string) => void;
+  sendContextUpdate?: (data: Record<string, unknown>) => void;
+  triggerActionInterrupt?: () => void;
+  sendActionTrigger?: (actionName: string, data: Record<string, unknown>) => void;
+  uploadMedia?: (
+    file: Blob | {uri: string; type: string; name: string},
+    reason?: string,
+    message?: string,
+  ) => Promise<{media_id: string; url: string}>;
+  sendEvent?: (event: string, payload?: Record<string, unknown>) => void;
+  serverUrl?: string;
+  callId?: string;
+};
+
+export type NativePresetRendererProps = {
+  client: PresetClient | null;
+  toolCall: unknown | null;
+  onCustomTool?: (toolCall: unknown) => void;
+  /** Full teardown — stops live vision, board, etc. */
+  onDismiss?: () => void;
+  /** Clear active tool UI only (live vision session keeps running). */
+  onReleaseToolCall?: () => void;
+};