lemma-sdk 0.2.28 → 0.2.31

package/dist/record-form.js

@@ -0,0 +1,199 @@
+import { parseForeignKeyReference } from "./datastore-query.js";
+import { DatastoreDataType } from "./types.js";
+function sentenceCase(value) {
+    return value
+        .replace(/_/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function isBlank(value) {
+    return value === null || typeof value === "undefined" || (typeof value === "string" && value.trim() === "");
+}
+function isIntegerLike(value) {
+    return Number.isInteger(value);
+}
+function getRawColumnDefault(column) {
+    return column.default;
+}
+function shouldUseTextarea(column) {
+    if (typeof column.max_length === "number" && column.max_length >= 240) {
+        return true;
+    }
+    return /(description|content|body|note|instruction|summary|message)/i.test(column.name);
+}
+function toDateInputValue(value) {
+    if (typeof value === "string") {
+        return value.includes("T") ? value.slice(0, 10) : value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString().slice(0, 10);
+    }
+    return String(value);
+}
+function toDateTimeLocalInputValue(value) {
+    if (typeof value === "string") {
+        const timestamp = new Date(value);
+        if (!Number.isNaN(timestamp.getTime())) {
+            const pad = (part) => String(part).padStart(2, "0");
+            return [
+                timestamp.getFullYear(),
+                pad(timestamp.getMonth() + 1),
+                pad(timestamp.getDate()),
+            ].join("-") + `T${pad(timestamp.getHours())}:${pad(timestamp.getMinutes())}`;
+        }
+        return value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        const pad = (part) => String(part).padStart(2, "0");
+        return [
+            value.getFullYear(),
+            pad(value.getMonth() + 1),
+            pad(value.getDate()),
+        ].join("-") + `T${pad(value.getHours())}:${pad(value.getMinutes())}`;
+    }
+    return String(value);
+}
+export function getRecordFieldKind(column) {
+    if (column.foreign_key?.references)
+        return "foreign-key";
+    if (column.type === DatastoreDataType.ENUM)
+        return "select";
+    if (column.type === DatastoreDataType.BOOLEAN)
+        return "boolean";
+    if (column.type === DatastoreDataType.JSON || column.type === DatastoreDataType.VECTOR)
+        return "json";
+    if (column.type === DatastoreDataType.INTEGER
+        || column.type === DatastoreDataType.FLOAT
+        || column.type === DatastoreDataType.SERIAL) {
+        return "number";
+    }
+    if (column.type === DatastoreDataType.DATE)
+        return "date";
+    if (column.type === DatastoreDataType.DATETIME)
+        return "datetime";
+    if (column.type === DatastoreDataType.UUID)
+        return "uuid";
+    if (column.type === DatastoreDataType.TEXT && shouldUseTextarea(column))
+        return "textarea";
+    return "text";
+}
+export function buildRecordSchemaFields(table) {
+    return table.columns.map((column) => {
+        const foreignKey = column.foreign_key?.references
+            ? parseForeignKeyReference(column.foreign_key.references)
+            : null;
+        return {
+            name: column.name,
+            label: sentenceCase(column.name),
+            kind: getRecordFieldKind(column),
+            column,
+            required: column.required === true,
+            readOnly: column.system === true || column.computed === true || column.auto === true,
+            system: column.system === true,
+            computed: column.computed === true,
+            auto: column.auto === true,
+            options: column.options ?? [],
+            foreignKey,
+        };
+    });
+}
+export function getEditableRecordFields(table) {
+    return buildRecordSchemaFields(table).filter((field) => !field.readOnly);
+}
+export function formatRecordValueForForm(column, value) {
+    const kind = getRecordFieldKind(column);
+    if (value === null || typeof value === "undefined") {
+        if (kind === "boolean")
+            return false;
+        return "";
+    }
+    if (kind === "boolean") {
+        return Boolean(value);
+    }
+    if (kind === "json") {
+        if (typeof value === "string")
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    if (kind === "date") {
+        return toDateInputValue(value);
+    }
+    if (kind === "datetime") {
+        return toDateTimeLocalInputValue(value);
+    }
+    if (kind === "number") {
+        return String(value);
+    }
+    return String(value);
+}
+export function buildRecordFormValues(table, values = {}) {
+    const next = {};
+    buildRecordSchemaFields(table).forEach((field) => {
+        const provided = values[field.name];
+        const rawDefault = getRawColumnDefault(field.column);
+        const source = typeof provided !== "undefined" ? provided : rawDefault;
+        next[field.name] = formatRecordValueForForm(field.column, source);
+    });
+    return next;
+}
+function coerceEmptyValue(mode, name, target) {
+    if (mode === "update") {
+        target[name] = null;
+    }
+}
+export function buildRecordPayload(table, values, options = {}) {
+    const mode = options.mode ?? "create";
+    const data = {};
+    const errors = {};
+    getEditableRecordFields(table).forEach((field) => {
+        const rawValue = values[field.name];
+        const value = typeof rawValue === "string" ? rawValue : rawValue;
+        if (field.kind === "boolean") {
+            data[field.name] = Boolean(rawValue);
+            return;
+        }
+        if (isBlank(value)) {
+            if (field.required) {
+                errors[field.name] = `${field.label} is required.`;
+                return;
+            }
+            coerceEmptyValue(mode, field.name, data);
+            return;
+        }
+        if (field.kind === "number") {
+            const parsed = Number(value);
+            if (!Number.isFinite(parsed)) {
+                errors[field.name] = `${field.label} must be a valid number.`;
+                return;
+            }
+            if ((field.column.type === DatastoreDataType.INTEGER || field.column.type === DatastoreDataType.SERIAL)
+                && !isIntegerLike(parsed)) {
+                errors[field.name] = `${field.label} must be a whole number.`;
+                return;
+            }
+            data[field.name] = parsed;
+            return;
+        }
+        if (field.kind === "json") {
+            try {
+                data[field.name] = typeof value === "string" ? JSON.parse(value) : value;
+            }
+            catch {
+                errors[field.name] = `${field.label} must be valid JSON.`;
+            }
+            return;
+        }
+        data[field.name] = typeof value === "string" ? value : String(value);
+    });
+    return {
+        data,
+        errors,
+        isValid: Object.keys(errors).length === 0,
+    };
+}

package/dist/schema-form.d.ts

@@ -0,0 +1,41 @@
+export type JsonSchemaPrimitiveType = "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+export interface JsonSchemaLike {
+    type?: JsonSchemaPrimitiveType | JsonSchemaPrimitiveType[];
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: unknown;
+    enum?: unknown[];
+    properties?: Record<string, JsonSchemaLike>;
+    required?: string[];
+    items?: JsonSchemaLike;
+    anyOf?: JsonSchemaLike[];
+    oneOf?: JsonSchemaLike[];
+    allOf?: JsonSchemaLike[];
+    [key: string]: unknown;
+}
+export type SchemaFormFieldKind = "text" | "textarea" | "number" | "boolean" | "select" | "json" | "date" | "datetime" | "email";
+export interface SchemaFormField {
+    name: string;
+    label: string;
+    description?: string;
+    required: boolean;
+    kind: SchemaFormFieldKind;
+    type: JsonSchemaPrimitiveType | "unknown";
+    format?: string;
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+    defaultValue?: unknown;
+    schema: JsonSchemaLike;
+}
+export interface BuildSchemaFormPayloadResult {
+    data: Record<string, unknown>;
+    errors: Record<string, string>;
+    isValid: boolean;
+}
+export declare function buildSchemaFormFields(schema: JsonSchemaLike | null | undefined, uiSchema?: Record<string, unknown> | null): SchemaFormField[];
+export declare function formatSchemaFieldValueForForm(field: SchemaFormField, value: unknown): unknown;
+export declare function buildSchemaFormValues(schema: JsonSchemaLike | null | undefined, values?: Record<string, unknown>, uiSchema?: Record<string, unknown> | null): Record<string, unknown>;
+export declare function buildSchemaFormPayload(schema: JsonSchemaLike | null | undefined, values: Record<string, unknown>, uiSchema?: Record<string, unknown> | null): BuildSchemaFormPayloadResult;

package/dist/schema-form.js

@@ -0,0 +1,200 @@
+function sentenceCase(value) {
+    return value
+        .replace(/_/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/\b\w/g, (match) => match.toUpperCase());
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isBlank(value) {
+    return value === null || typeof value === "undefined" || (typeof value === "string" && value.trim() === "");
+}
+function normalizeSchemaType(schema) {
+    if (Array.isArray(schema.type)) {
+        const nonNull = schema.type.find((entry) => entry !== "null");
+        return nonNull ?? "unknown";
+    }
+    if (typeof schema.type === "string") {
+        return schema.type;
+    }
+    if (schema.enum?.length) {
+        return "string";
+    }
+    if (schema.properties && isRecord(schema.properties)) {
+        return "object";
+    }
+    if (schema.items) {
+        return "array";
+    }
+    return "unknown";
+}
+function getSchemaFieldKind(schema) {
+    if (schema.enum?.length)
+        return "select";
+    const type = normalizeSchemaType(schema);
+    const format = typeof schema.format === "string" ? schema.format : undefined;
+    if (type === "boolean")
+        return "boolean";
+    if (type === "number" || type === "integer")
+        return "number";
+    if (format === "date")
+        return "date";
+    if (format === "date-time")
+        return "datetime";
+    if (format === "email")
+        return "email";
+    if (type === "object" || type === "array")
+        return "json";
+    if (format === "textarea")
+        return "textarea";
+    const title = `${schema.title ?? ""} ${schema.description ?? ""}`.toLowerCase();
+    if (/(description|body|content|message|note|summary|instructions)/.test(title)) {
+        return "textarea";
+    }
+    return "text";
+}
+function formatDateInputValue(value) {
+    if (typeof value === "string") {
+        return value.includes("T") ? value.slice(0, 10) : value;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString().slice(0, 10);
+    }
+    return String(value);
+}
+function formatDateTimeLocalInputValue(value) {
+    const date = value instanceof Date ? value : new Date(String(value));
+    if (Number.isNaN(date.getTime())) {
+        return String(value);
+    }
+    const pad = (part) => String(part).padStart(2, "0");
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+export function buildSchemaFormFields(schema, uiSchema) {
+    if (!schema || !isRecord(schema.properties))
+        return [];
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    const order = Array.isArray(uiSchema?.["ui:order"])
+        ? (uiSchema?.["ui:order"]).filter((entry) => typeof entry === "string")
+        : [];
+    const orderIndex = new Map(order.map((name, index) => [name, index]));
+    const fields = Object.entries(schema.properties).map(([name, propertySchema]) => {
+        const property = isRecord(propertySchema) ? propertySchema : {};
+        const uiFieldConfig = isRecord(uiSchema?.[name]) ? uiSchema?.[name] : {};
+        const widget = typeof uiFieldConfig["ui:widget"] === "string" ? uiFieldConfig["ui:widget"] : undefined;
+        const kind = widget === "textarea" ? "textarea" : getSchemaFieldKind(property);
+        return {
+            name,
+            label: typeof property.title === "string" && property.title.trim().length > 0
+                ? property.title
+                : sentenceCase(name),
+            description: typeof property.description === "string" ? property.description : undefined,
+            required: required.includes(name),
+            kind,
+            type: normalizeSchemaType(property),
+            format: typeof property.format === "string" ? property.format : undefined,
+            options: (property.enum ?? []).map((value) => ({
+                label: typeof value === "string" ? value : JSON.stringify(value),
+                value: typeof value === "string" ? value : JSON.stringify(value),
+            })),
+            defaultValue: property.default,
+            schema: property,
+        };
+    });
+    return fields.sort((left, right) => {
+        const leftIndex = orderIndex.get(left.name);
+        const rightIndex = orderIndex.get(right.name);
+        if (typeof leftIndex === "number" && typeof rightIndex === "number") {
+            return leftIndex - rightIndex;
+        }
+        if (typeof leftIndex === "number")
+            return -1;
+        if (typeof rightIndex === "number")
+            return 1;
+        return left.label.localeCompare(right.label);
+    });
+}
+export function formatSchemaFieldValueForForm(field, value) {
+    if (value === null || typeof value === "undefined") {
+        if (field.kind === "boolean")
+            return false;
+        return "";
+    }
+    if (field.kind === "boolean")
+        return Boolean(value);
+    if (field.kind === "number")
+        return String(value);
+    if (field.kind === "date")
+        return formatDateInputValue(value);
+    if (field.kind === "datetime")
+        return formatDateTimeLocalInputValue(value);
+    if (field.kind === "json") {
+        if (typeof value === "string")
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    return String(value);
+}
+export function buildSchemaFormValues(schema, values = {}, uiSchema) {
+    const fields = buildSchemaFormFields(schema, uiSchema);
+    const next = {};
+    fields.forEach((field) => {
+        const provided = values[field.name];
+        const source = typeof provided !== "undefined" ? provided : field.defaultValue;
+        next[field.name] = formatSchemaFieldValueForForm(field, source);
+    });
+    return next;
+}
+export function buildSchemaFormPayload(schema, values, uiSchema) {
+    const fields = buildSchemaFormFields(schema, uiSchema);
+    const data = {};
+    const errors = {};
+    fields.forEach((field) => {
+        const rawValue = values[field.name];
+        if (field.kind === "boolean") {
+            data[field.name] = Boolean(rawValue);
+            return;
+        }
+        if (isBlank(rawValue)) {
+            if (field.required) {
+                errors[field.name] = `${field.label} is required.`;
+            }
+            return;
+        }
+        if (field.kind === "number") {
+            const parsed = Number(rawValue);
+            if (!Number.isFinite(parsed)) {
+                errors[field.name] = `${field.label} must be a valid number.`;
+                return;
+            }
+            if (field.type === "integer" && !Number.isInteger(parsed)) {
+                errors[field.name] = `${field.label} must be a whole number.`;
+                return;
+            }
+            data[field.name] = parsed;
+            return;
+        }
+        if (field.kind === "json") {
+            try {
+                data[field.name] = typeof rawValue === "string" ? JSON.parse(rawValue) : rawValue;
+            }
+            catch {
+                errors[field.name] = `${field.label} must be valid JSON.`;
+            }
+            return;
+        }
+        data[field.name] = rawValue;
+    });
+    return {
+        data,
+        errors,
+        isValid: Object.keys(errors).length === 0,
+    };
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AssistantResponse, AvailableModels, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, FlowRunEntity, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -51,6 +51,10 @@ export type Task = TaskResponse;
 export type TaskMessage = TaskMessageResponse;
 export type FunctionRun = FunctionRunResponse;
 export type FlowRun = FlowRunEntity;
+export type Workflow = FlowResponse;
+export type Table = TableResponse;
+export type TableColumn = ColumnSchema;
+export type DatastoreQueryResult = DatastoreQueryResponse;
 export type Pod = PodResponse;
 export type PodConfig = PodConfigResponse;
 export type PodMember = PodMemberResponse;
@@ -65,6 +69,7 @@ export interface CursorPage<T> {
     items: T[];
     limit: number;
     next_page_token?: string | null;
+    total?: number;
 }
 /**
  * Re-export generated OpenAPI models/enums/services from the same module so this

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.28",
+  "version": "0.2.31",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "lemma-sdk": "./bin/lemma-sdk.js"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/gappyai/lemma-typescript.git"
+    "url": "https://github.com/gappyai/lemma-typescript"
   },
   "homepage": "https://github.com/gappyai/lemma-typescript#readme",
   "bugs": {
@@ -29,18 +32,19 @@
       "types": "./dist/react/index.d.ts",
       "default": "./dist/react/index.js"
     },
-    "./react/styles.css": "./dist/react/styles.css",
     "./browser-bundle": "./dist/browser/lemma-client.js"
   },
   "unpkg": "dist/browser/lemma-client.js",
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "generate:client": "./scripts/generate_openapi_client.sh",
-    "build": "npm run clean && tsc -p tsconfig.json && node ./scripts/copy_react_styles.mjs && npm run build:bundle",
+    "build": "npm run clean && tsc -p tsconfig.json && npm run build:bundle",
     "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
-    "clean": "rm -rf dist",
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })\"",
+    "registry:build": "shadcn build ./registry.json -o ./public/r",
     "prepublishOnly": "npm run build",
     "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run"
   },
@@ -53,13 +57,12 @@
     }
   },
   "dependencies": {
-    "react-markdown": "^10.1.0",
-    "remark-gfm": "^4.0.1",
     "supertokens-web-js": "^0.16.0"
   },
   "devDependencies": {
     "@types/react": "^18.3.28",
     "openapi-typescript-codegen": "^0.29.0",
+    "shadcn": "^4.2.0",
     "typescript": "^5.6.3"
   }
 }

package/dist/react/components/AssistantChrome.d.ts

@@ -1,86 +0,0 @@
-import { type ComponentPropsWithoutRef, type ReactNode } from "react";
-import type { AssistantConversationListItem, AssistantConversationRenderArgs } from "./assistant-types.js";
-export type AssistantSurfaceTone = "default" | "subtle" | "flat";
-export type AssistantThemeMode = "auto" | "light" | "dark";
-export interface AssistantThemeScopeProps extends ComponentPropsWithoutRef<"div"> {
-    children: ReactNode;
-    theme?: AssistantThemeMode;
-}
-export declare function AssistantThemeScope({ className, children, theme, ...props }: AssistantThemeScopeProps): import("react/jsx-runtime").JSX.Element;
-export interface AssistantHeaderProps {
-    title: ReactNode;
-    subtitle?: ReactNode;
-    badge?: ReactNode;
-    controls?: ReactNode;
-    tone?: AssistantSurfaceTone;
-    className?: string;
-}
-export interface AssistantMessageViewportProps extends ComponentPropsWithoutRef<"div"> {
-    innerClassName?: string;
-    children: ReactNode;
-}
-export declare const AssistantMessageViewport: import("react").ForwardRefExoticComponent<AssistantMessageViewportProps & import("react").RefAttributes<HTMLDivElement>>;
-export interface AssistantShellLayoutProps {
-    sidebar?: ReactNode;
-    sidebarVisible?: boolean;
-    main: ReactNode;
-    className?: string;
-}
-export declare function AssistantShellLayout({ sidebar, sidebarVisible, main, className, }: AssistantShellLayoutProps): import("react/jsx-runtime").JSX.Element;
-export declare function AssistantHeader({ title, subtitle, badge, controls, tone, className, }: AssistantHeaderProps): import("react/jsx-runtime").JSX.Element;
-export interface AssistantConversationListProps {
-    conversations: AssistantConversationListItem[];
-    activeConversationId: string | null;
-    onSelectConversation: (conversationId: string) => void;
-    onNewConversation?: () => void;
-    renderConversationLabel?: (args: AssistantConversationRenderArgs) => ReactNode;
-    title?: ReactNode;
-    newLabel?: ReactNode;
-    className?: string;
-}
-export declare function AssistantConversationList({ conversations, activeConversationId, onSelectConversation, onNewConversation, renderConversationLabel, title, newLabel, className, }: AssistantConversationListProps): import("react/jsx-runtime").JSX.Element;
-export interface AssistantModelPickerProps<TValue extends string = string> {
-    value: TValue | null;
-    options: TValue[];
-    disabled?: boolean;
-    autoLabel?: ReactNode;
-    getOptionLabel?: (value: TValue) => ReactNode;
-    onChange: (value: TValue | null) => void;
-    className?: string;
-}
-export declare function AssistantModelPicker<TValue extends string = string>({ value, options, disabled, autoLabel, getOptionLabel, onChange, className, }: AssistantModelPickerProps<TValue>): import("react/jsx-runtime").JSX.Element;
-export interface AssistantAskOverlayProps {
-    questionNumber: number;
-    totalQuestions: number;
-    question: ReactNode;
-    options: string[];
-    selectedOptions: string[];
-    canContinue: boolean;
-    continueLabel: ReactNode;
-    onSelectOption: (option: string) => void;
-    onContinue?: () => void;
-    onSkip?: () => void;
-    mode?: "single_select" | "multi_select" | "rank_priorities";
-}
-export declare function AssistantAskOverlay({ questionNumber, totalQuestions, question, options, selectedOptions, canContinue, continueLabel, onSelectOption, onContinue, onSkip, mode, }: AssistantAskOverlayProps): import("react/jsx-runtime").JSX.Element;
-export interface AssistantPendingFileChipProps {
-    label: ReactNode;
-    onRemove?: () => void;
-    className?: string;
-}
-export interface AssistantComposerProps {
-    floating?: ReactNode;
-    status?: ReactNode;
-    pendingFiles?: ReactNode;
-    children: ReactNode;
-    tone?: AssistantSurfaceTone;
-    className?: string;
-}
-export declare function AssistantComposer({ floating, status, pendingFiles, children, tone, className, }: AssistantComposerProps): import("react/jsx-runtime").JSX.Element;
-export declare function AssistantPendingFileChip({ label, onRemove, className, }: AssistantPendingFileChipProps): import("react/jsx-runtime").JSX.Element;
-export interface AssistantStatusPillProps {
-    label: ReactNode;
-    subtle?: boolean;
-    className?: string;
-}
-export declare function AssistantStatusPill({ label, subtle, className, }: AssistantStatusPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/react/components/AssistantChrome.js

@@ -1,48 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { forwardRef } from "react";
-function cx(...values) {
-    return values.filter(Boolean).join(" ");
-}
-export function AssistantThemeScope({ className, children, theme = "auto", ...props }) {
-    return (_jsx("div", { "data-lemma-theme": theme, className: cx("lemma-assistant-theme", className), ...props, children: children }));
-}
-export const AssistantMessageViewport = forwardRef(function AssistantMessageViewport({ className, innerClassName, children, ...props }, ref) {
-    return (_jsx("div", { ref: ref, className: cx("lemma-assistant-viewport", className), ...props, children: _jsx("div", { className: cx("lemma-assistant-viewport-inner", innerClassName), children: children }) }));
-});
-export function AssistantShellLayout({ sidebar, sidebarVisible = false, main, className, }) {
-    const hasSidebar = !!sidebar;
-    return (_jsxs("div", { className: cx("lemma-assistant-shell", hasSidebar && "lemma-assistant-shell--with-sidebar", hasSidebar && sidebarVisible && "lemma-assistant-shell--sidebar-visible", className), children: [sidebar && sidebarVisible ? (_jsx("div", { className: "lemma-assistant-shell-sidebar", children: sidebar })) : null, main] }));
-}
-export function AssistantHeader({ title, subtitle, badge, controls, tone = "subtle", className, }) {
-    return (_jsxs("div", { "data-tone": tone, className: cx("lemma-assistant-header", className), children: [_jsxs("div", { className: "lemma-assistant-header-copy", children: [badge ? (_jsx("div", { className: "lemma-assistant-header-badge", children: badge })) : null, _jsxs("div", { className: "lemma-assistant-header-titles", children: [_jsx("h3", { className: "lemma-assistant-header-title", children: title }), subtitle ? (_jsx("p", { className: "lemma-assistant-header-subtitle", children: subtitle })) : null] })] }), controls ? (_jsx("div", { className: "lemma-assistant-header-controls", children: controls })) : null] }));
-}
-export function AssistantConversationList({ conversations, activeConversationId, onSelectConversation, onNewConversation, renderConversationLabel, title = "Conversations", newLabel = "New", className, }) {
-    return (_jsxs("aside", { className: cx("lemma-assistant-conversation-list", className), children: [_jsx("div", { className: "lemma-assistant-conversation-list-header", children: _jsxs("div", { className: "lemma-assistant-conversation-list-header-row", children: [_jsxs("div", { className: "lemma-assistant-conversation-list-copy", children: [_jsx("div", { className: "lemma-assistant-conversation-list-title", children: title }), _jsxs("div", { className: "lemma-assistant-conversation-list-meta", children: [conversations.length, " total"] })] }), onNewConversation ? (_jsx("button", { type: "button", onClick: onNewConversation, className: "lemma-assistant-conversation-list-new", children: newLabel })) : null] }) }), _jsx("div", { className: "lemma-assistant-conversation-list-items", children: conversations.map((conversation) => {
-                    const isActive = conversation.id === activeConversationId;
-                    return (_jsxs("button", { type: "button", onClick: () => onSelectConversation(conversation.id), className: cx("lemma-assistant-conversation-list-item", isActive && "lemma-assistant-conversation-list-item-active"), children: [_jsx("div", { className: "lemma-assistant-conversation-list-item-title", children: renderConversationLabel
-                                    ? renderConversationLabel({ conversation, isActive })
-                                    : (conversation.title || "Untitled conversation") }), _jsx("div", { className: "lemma-assistant-conversation-list-item-status", children: (conversation.status || "waiting").toLowerCase() })] }, conversation.id));
-                }) })] }));
-}
-export function AssistantModelPicker({ value, options, disabled, autoLabel = "Auto", getOptionLabel, onChange, className, }) {
-    const autoValue = "__AUTO__";
-    return (_jsxs("select", { value: value ?? autoValue, onChange: (event) => onChange(event.target.value === autoValue ? null : event.target.value), disabled: disabled, className: cx("lemma-assistant-model-picker", className), "aria-label": "Conversation model", title: "Conversation model", children: [_jsx("option", { value: autoValue, children: autoLabel }), options.map((option) => (_jsx("option", { value: option, children: getOptionLabel ? getOptionLabel(option) : option }, option)))] }));
-}
-export function AssistantAskOverlay({ questionNumber, totalQuestions, question, options, selectedOptions, canContinue, continueLabel, onSelectOption, onContinue, onSkip, mode = "single_select", }) {
-    return (_jsxs("div", { className: "lemma-assistant-ask-overlay", children: [_jsxs("div", { className: "lemma-assistant-ask-overlay-header", children: [_jsxs("div", { className: "lemma-assistant-ask-overlay-copy", children: [_jsxs("div", { className: "lemma-assistant-ask-overlay-kicker", children: ["Question ", questionNumber, " of ", totalQuestions] }), _jsx("p", { className: "lemma-assistant-ask-overlay-question", children: question })] }), onSkip ? (_jsx("button", { type: "button", onClick: onSkip, className: "lemma-assistant-ask-overlay-skip", children: "Skip" })) : null] }), _jsx("div", { className: "lemma-assistant-ask-overlay-options", children: options.map((option, optionIndex) => {
-                    const isSelected = selectedOptions.includes(option);
-                    const rankLabel = mode === "rank_priorities" && isSelected
-                        ? selectedOptions.indexOf(option) + 1
-                        : null;
-                    return (_jsx("button", { type: "button", onClick: () => onSelectOption(option), className: cx("lemma-assistant-ask-overlay-option", isSelected && "lemma-assistant-ask-overlay-option-selected"), children: _jsxs("span", { className: "lemma-assistant-ask-overlay-option-label", children: [rankLabel ? (_jsx("span", { className: "lemma-assistant-ask-overlay-option-rank", children: rankLabel })) : (_jsx("span", { className: cx("lemma-assistant-ask-overlay-option-indicator", isSelected && "lemma-assistant-ask-overlay-option-indicator-selected") })), option] }) }, `${option}-${optionIndex}`));
-                }) }), onContinue ? (_jsx("div", { className: "lemma-assistant-ask-overlay-actions", children: _jsx("button", { type: "button", onClick: onContinue, disabled: !canContinue, className: cx("lemma-assistant-ask-overlay-continue", canContinue && "lemma-assistant-ask-overlay-continue-enabled"), children: continueLabel }) })) : null] }));
-}
-export function AssistantComposer({ floating, status, pendingFiles, children, tone = "subtle", className, }) {
-    return (_jsxs("div", { "data-tone": tone, "data-has-status": status ? "true" : "false", "data-has-pending-files": pendingFiles ? "true" : "false", "data-has-floating": floating ? "true" : "false", className: cx("lemma-assistant-composer", className), children: [floating ? (_jsx("div", { className: "lemma-assistant-composer-floating", children: floating })) : null, status ? (_jsx("div", { className: "lemma-assistant-composer-status-rail", children: _jsx("div", { className: "lemma-assistant-composer-status", children: status }) })) : null, pendingFiles ? (_jsx("div", { className: "lemma-assistant-composer-pending", children: pendingFiles })) : null, _jsx("div", { className: "lemma-assistant-composer-body", children: children })] }));
-}
-export function AssistantPendingFileChip({ label, onRemove, className, }) {
-    return (_jsxs("span", { className: cx("lemma-assistant-pending-file-chip", className), children: [_jsx("span", { className: "lemma-assistant-pending-file-chip-label", children: label }), onRemove ? (_jsx("button", { type: "button", onClick: onRemove, className: "lemma-assistant-pending-file-chip-remove", title: "Remove file", children: "\u00D7" })) : null] }));
-}
-export function AssistantStatusPill({ label, subtle = false, className, }) {
-    return (_jsxs("div", { className: cx("lemma-assistant-status-pill", subtle && "lemma-assistant-status-pill-subtle", className), children: [_jsxs("span", { className: "lemma-assistant-status-pill-dot", children: [_jsx("span", { className: "lemma-assistant-status-pill-dot-ping" }), _jsx("span", { className: "lemma-assistant-status-pill-dot-core" })] }), _jsx("span", { className: "lemma-assistant-status-pill-label", children: label })] }));
-}