React SDK Types

interface TamboThread {
  id: string;
  title?: string;
  messages: TamboMessage[];
  status: RunStatus;
  metadata?: Record<string, unknown>;
  createdAt: string;
  updatedAt: string;
  lastRunCancelled: boolean;
}

type RunStatus = "idle" | "waiting" | "streaming" | "complete" | "error";

interface StreamingState {
  status: RunStatus;
  runId?: string;
  messageId?: string;
  startTime?: number;
  error?: {
    message: string;
    code?: string;
  };
}

interface TamboMessage {
  id: string;
  role: MessageRole;
  content: Content[];
  createdAt?: string;
  metadata?: Record<string, unknown>;
  reasoning?: string[];
  reasoningDurationMS?: number;
}

type MessageRole = "user" | "assistant" | "system";

type Content =
  | TextContent
  | ComponentContent
  | ToolUseContent
  | ToolResultContent
  | ResourceContent;

interface TextContent {
  type: "text";
  text: string;
}

interface ComponentContent {
  type: "component";
  id: string;
  name: string;
  props: Record<string, unknown>;
  streamingState?: "started" | "streaming" | "done";
  renderedComponent?: ReactElement | null;
}

interface ToolUseContent {
  type: "tool_use";
  id: string;
  name: string;
  input: Record<string, unknown>;
  hasCompleted?: boolean;
  statusMessage?: string;
  tamboDisplayProps?: TamboToolDisplayProps;
}

interface TamboToolDisplayProps {
  _tambo_displayMessage?: string;
  _tambo_statusMessage?: string;
  _tambo_completionStatusMessage?: string;
}

interface ToolResultContent {
  type: "tool_result";
  tool_use_id: string;
  content: string | ContentPart[];
}

interface ResourceContent {
  type: "resource";
  uri: string;
  name?: string;
  mimeType?: string;
  text?: string;
}

interface TamboComponent {
  name: string;
  description: string;
  component: ComponentType<any>;
  propsSchema: Record<string, unknown>;
  stateSchema?: Record<string, unknown>;
  initialState?: () => Record<string, unknown>;
}

import { z } from "zod";
import { zodToJsonSchema } from "zod-to-json-schema";

const WeatherCardSchema = z.object({
  city: z.string().describe("The city name"),
  temperature: z.number().describe("Temperature in Fahrenheit"),
  condition: z.string().describe("Weather condition"),
});

const components: TamboComponent[] = [
  {
    name: "WeatherCard",
    description: "Displays current weather for a city",
    component: WeatherCard,
    propsSchema: zodToJsonSchema(WeatherCardSchema),
  },
];

interface TamboComponentProps<TProps, TState> {
  props: TProps;
  state?: TState;
  componentId: string;
  isStreaming?: boolean;
}

interface TamboTool {
  name: string;
  description: string;
  tool: (params: Record<string, unknown>) => unknown;
  inputSchema: SupportedSchema;
  outputSchema: SupportedSchema;
  transformToContent?: (result: any) => Promise<ContentPart[]> | ContentPart[];
  maxCalls?: number;
  annotations?: ToolAnnotations;
}

type TamboCustomEvent =
  | ComponentStartEvent
  | ComponentPropsDeltaEvent
  | ComponentStateDeltaEvent
  | ComponentEndEvent
  | RunAwaitingInputEvent;

interface ComponentStartEvent {
  name: "tambo.component.start";
  componentId: string;
  componentName: string;
}

interface ComponentPropsDeltaEvent {
  name: "tambo.component.props_delta";
  componentId: string;
  delta: JsonPatchOperation[];
}

interface ComponentStateDeltaEvent {
  name: "tambo.component.state_delta";
  componentId: string;
  delta: JsonPatchOperation[];
}

interface ComponentEndEvent {
  name: "tambo.component.end";
  componentId: string;
}

interface RunAwaitingInputEvent {
  name: "tambo.run.awaiting_input";
  toolCalls: ToolCall[];
}

function isTamboCustomEvent(event: {
  name?: string;
}): event is TamboCustomEvent;
function asTamboCustomEvent(event: CustomEvent): TamboCustomEvent | undefined;

interface SubmitOptions {
  debug?: boolean;
  toolChoice?: ToolChoice;
}

type ToolChoice = "auto" | "required" | "none" | { name: string };

interface StreamStatus {
  isPending: boolean;
  isStreaming: boolean;
  isSuccess: boolean;
  isError: boolean;
  streamError?: Error;
}

interface PropStatus {
  isPending: boolean;
  isStreaming: boolean;
  isSuccess: boolean;
  error?: Error;
}

type ToolAnnotations = MCPToolAnnotations & {
  tamboStreamableHint?: boolean;
};