@bikdotai/bik-component-library 0.0.742-beta.10 → 0.0.742-beta.13

package/dist/cjs/components/bik-chatbot/index.d.ts

@@ -0,0 +1,137 @@
+export { BIKChatbot, default as default } from './components/BIKChatbot';
+export { AIChat } from './components/AIChat';
+export { AIProvider, useAIContext } from './contexts/AIContext';
+export { useAIChat } from './services/useAIChat';
+export type { ChatMessage, ChatState, IceBreaker, VideoStarter, SessionRecord, FunctionDefinition, ToolCall, GenericAIResponse, CallbackPayload, SystemConfig, PromptConfig, ToolPrompt, ApiRequestExecutor, GenericChatbotProps, BIKChatbotProps, AIChatProps, ChatWindowProps, AIProviderProps, AIContextState, UseAIChatProps, AIServiceConstructorProps, ErrorWithMessage, } from './types';
+export { createSessionRecord, DEFAULT_RESPONSE_FORMAT, DEFAULT_MAX_TOOL_CALLS, DEFAULT_CONVERSATION_ID, CHAT_MESSAGE_ROLES, RESPONSE_FORMATS, } from './types';
+/**
+ * BIKChatbot - Generic AI Chatbot Component
+ *
+ * This component provides a flexible, generic chatbot interface that can be configured
+ * for any use case through custom prompts, functions, and response handling.
+ *
+ * ## Generic Mode (Custom Functions & Built-in Tools)
+ *
+ * ### Simple Text Chatbot (responseFormat: 'text')
+ *
+ * ```typescript
+ * <BIKChatbot
+ *   systemPrompt="You are a helpful assistant"
+ *   responseFormat="text"
+ *   requestExecutor={myRequestExecutor}
+ *   baseUrl={myBaseUrl}
+ *   onMessageReceived={(text) => handleText(text)}
+ * />
+ * ```
+ *
+ * ### Analytics Advisor with Functions (and built-in tools)
+ *
+ * ```typescript
+ * <BIKChatbot
+ *   systemPrompt="You analyze delivery metrics and suggest improvements. Call getAnalytics() to fetch data, then summarize for the user."
+ *   responseFormat="json"
+ *   tools={["web_search_preview"]}
+ *   requestExecutor={myRequestExecutor}
+ *   baseUrl={myBaseUrl}
+ *   functions={[
+ *     {
+ *       name: "getAnalytics",
+ *       description: "Fetch delivery rate and engagement metrics",
+ *       parameters: { type: "object", properties: {}, required: [] }
+ *     }
+ *   ]}
+ *   functionHandler={async (name, args) => {
+ *     if (name === "getAnalytics") {
+ *       return { deliveryRate: 0.75, engagementRate: 0.12 };
+ *     }
+ *   }}
+ *   onMessageReceived={(payload) => {
+ *     // In json mode, payload is parsed JSON when AI returns JSON text
+ *     // Or TOOL_CALL/TOOL_RESULT when tools are used
+ *   }}
+ * />
+ * ```
+ *
+ * ### Content Idea Generator (Multi-step Tool Calls)
+ *
+ * ```typescript
+ * <BIKChatbot
+ *   systemPrompt="Call getTrends() to fetch social media trends. Generate 5 content ideas. Call updateIdeas() to save them. Then summarize for the user."
+ *   responseFormat="json"
+ *   functions={[
+ *     { name: "getTrends", description: "Get latest social media trends", parameters: { type: "object", properties: {}, required: [] } },
+ *     { name: "updateIdeas", description: "Save content ideas", parameters: { type: "object", properties: { ideas: { type: "array", items: { type: "string" } } }, required: ["ideas"] } }
+ *   ]}
+ *   functionHandler={async (name, args) => {
+ *     if (name === "getTrends") return "AI, short-form video, nostalgia marketing";
+ *     if (name === "updateIdeas") { saveToDatabase(args.ideas); return { success: true }; }
+ *   }}
+ *   onMessageReceived={(payload) => {
+ *     // Handle TOOL_CALL/TOOL_RESULT events or parsed JSON, depending on flow
+ *   }}
+ * />
+ * ```
+ *
+ * ### Silent Background Generation
+ *
+ * ```typescript
+ * <BIKChatbot
+ *   systemPrompt="Generate email templates for the campaign"
+ *   responseFormat="json"
+ *   displayInUI={false}  // Silent mode - no chat bubbles
+ *   onMessageReceived={(payload) => {
+ *     // Receives data (parsed JSON or tool events) without UI display
+ *   }}
+ * />
+ * ```
+ *
+ * ### Built-in Tools & Campaign Flow (Optional)
+ *
+ * ```typescript
+ * <BIKChatbot
+ *   systemPrompt={campaignSystemPrompt}
+ *   tools={["web_search_preview"]}
+ *   requestExecutor={myRequestExecutor}
+ *   baseUrl={myBaseUrl}
+ *   functions={[submitCampaignsFunction]}
+ *   functionHandler={async (name, args) => name === 'submitCampaigns' ? 'submitted' : 'ok'}
+ *   onMessageReceived={(event) => {
+ *     if (event && typeof event === 'object' && 'type' in event && (event as any).type === 'TOOL_CALL') {
+ *       const d = (event as any).data;
+ *       if (d?.name === 'submitCampaigns' && Array.isArray(d?.args?.campaigns)) {
+ *         setCampaigns(d.args.campaigns);
+ *       }
+ *     }
+ *   }}
+ * />
+ * ```
+ *
+ * ## Universal Pattern for ANY Use Case
+ *
+ * 1. Define your custom functions (tools AI can call) and built-in tools (e.g., web_search_preview)
+ * 2. Set `responseFormat`:
+ *    - 'text' for normal chat
+ *    - 'json' to parse assistant JSON and show parsed.response
+ * 3. Implement `functionHandler` for your tools
+ * 4. Handle final output in `onMessageReceived`:
+ *    - text string (when responseFormat='text')
+ *    - parsed JSON object (when responseFormat='json')
+ *    - TOOL_CALL / TOOL_RESULT events (when tools are used)
+ *
+ * **The Universal Flow:**
+ * ```
+ * User input → AI thinking
+ *   ↓
+ * AI calls custom function (getTrends, getAnalytics, etc.)
+ *   ↓
+ * Your functionHandler executes it
+ *   ↓
+ * Result returned to AI
+ *   ↓
+ * AI calls another function (optional, repeat) or returns final reply
+ *   ↓
+ * Component displays response in chat bubble (or stays silent if displayInUI=false)
+ *   ↓
+ * onMessageReceived receives text, parsed JSON, or tool events
+ * ```
+ */

package/dist/cjs/components/bik-chatbot/services/aiService.d.ts

@@ -0,0 +1,32 @@
+import { AIServiceConstructorProps, ChatMessage, FunctionDefinition, SystemConfig } from '../types';
+import { APIAdapter } from '../types/ai';
+import type { ResponseFormat } from '../types/ai';
+export declare class AIService {
+    system: SystemConfig;
+    dispatchMessage: (m: ChatMessage) => void;
+    customFunctions?: FunctionDefinition[];
+    functionHandler?: (name: string, args: unknown) => Promise<unknown>;
+    onMessageReceived?: (message: string | object) => void;
+    displayInUI?: boolean;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    apiAdapter: APIAdapter;
+    responseFormat?: ResponseFormat;
+    useCase?: string;
+    storeId?: string;
+    constructor(opts: AIServiceConstructorProps);
+    private sanitizeToolOutput;
+    private tryParseAssistantJson;
+    private dispatchParsedResponses;
+    private makeSystemMessage;
+    generate(messages: {
+        role: string;
+        content: string;
+    }[], conversationId: string, intent?: string, lastResponseId?: string): Promise<{
+        responseId?: string;
+    }>;
+    /**
+     * Recursive tool call engine for all AI interactions
+     */
+    private generateWithRecursiveToolCalls;
+}

package/dist/cjs/components/bik-chatbot/services/aiService.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../_virtual/_tslib.js"),t=require("../utils/guardrails.js"),s=require("./callToChatbot.js");exports.AIService=class{constructor(e){if(Object.defineProperty(this,"system",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"dispatchMessage",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"customFunctions",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"functionHandler",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"onMessageReceived",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"displayInUI",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maxToolCalls",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"maxTokens",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"apiAdapter",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"responseFormat",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"useCase",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),Object.defineProperty(this,"storeId",{enumerable:!0,configurable:!0,writable:!0,value:void 0}),this.system=e.system,this.dispatchMessage=e.dispatchMessage,this.customFunctions=e.customFunctions,this.functionHandler=e.functionHandler,this.onMessageReceived=e.onMessageReceived,this.displayInUI=!1!==e.displayInUI,this.maxToolCalls=e.maxToolCalls||10,this.maxTokens=e.maxTokens,this.apiAdapter=e.apiAdapter,this.responseFormat=e.responseFormat,this.useCase=e.useCase,this.storeId=e.storeId,!this.apiAdapter)throw new Error("Chatbot authentication not configured: RequestExecutor is required")}sanitizeToolOutput(t,s){try{if(null!==s&&"object"==typeof s){const t=s,{success:i}=t,a=e.__rest(t,["success"]);return JSON.stringify(a)}return"string"==typeof s?s:String(s)}catch(e){return"string"==typeof s?s:String(s)}}tryParseAssistantJson(e){if(!e)return null;let t=e.trim();t=t.replace(/^```json\s*/i,"").replace(/^```\s*/i,"").replace(/\s*```$/g,"").trim();try{return JSON.parse(t)}catch(s){try{const e=`[${t.replace(/}\s*{/g,"},{")}]`;return JSON.parse(e)}catch(t){return e}}}dispatchParsedResponses(e){if(!this.displayInUI)return;const t=Date.now();e.forEach(((e,s)=>{let i="",a="assistant";if(e&&"object"==typeof e){const t=e;"string"==typeof t.response?i=t.response:"string"==typeof t.content&&(i=t.content),"system"===t.role&&(a="system")}else"string"==typeof e&&(i=e);i&&this.dispatchMessage({id:`m-${t}-${s}`,role:a,content:i,timestamp:t+s})}))}makeSystemMessage(){return{role:"system",content:t.injectSafetyPrompt(this.system.systemPrompt)}}generate(s,i){let a=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"default",o=arguments.length>3?arguments[3]:void 0;return e.__awaiter(this,void 0,void 0,(function*(){const e=s.map((e=>({role:e.role,text:t.sanitizeUserInput(e.content)}))),n=[{role:"system",text:this.makeSystemMessage().content},...e];return this.generateWithRecursiveToolCalls(n,i,a,o)}))}generateWithRecursiveToolCalls(t,i,a,o){var n,r,l,c,d,u,h,p,m,y;return e.__awaiter(this,void 0,void 0,(function*(){const e=t.map((e=>({role:e.role,text:e.text})));let f,g=o,v=0;for(;v<this.maxToolCalls;){let t;v++;try{if(f)t=f,f=void 0;else{let o;if(1===v&&g){const t=[...e].reverse().find((e=>"user"===e.role));t&&(o=[{role:"user",content:t.text}])}t=yield s.callToChatbot(e,a,i,this.system.id,this.apiAdapter,g,this.system.functions,this.system.model,o,this.system.tools,this.maxTokens,this.useCase,this.storeId)}}catch(e){return this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"system",content:`AI error: ${String((null==e?void 0:e.message)||e)}`,timestamp:Date.now()}),{}}if(g=t.responseId,!t.toolCall){if(t.assistantText)if("json"===this.responseFormat){const e=null!==(n=t.parsed)&&void 0!==n?n:this.tryParseAssistantJson(t.assistantText);if(null!=e){const t=Array.isArray(e)?e:[e];this.displayInUI&&this.dispatchParsedResponses(t),null===(r=this.onMessageReceived)||void 0===r||r.call(this,e)}else{const e=t.assistantText.trim();this.displayInUI&&e&&this.dispatchMessage({id:`m-${Date.now()}`,role:"assistant",content:e,timestamp:Date.now()}),null===(l=this.onMessageReceived)||void 0===l||l.call(this,t.assistantText)}}else this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"assistant",content:t.assistantText,timestamp:Date.now()}),null===(c=this.onMessageReceived)||void 0===c||c.call(this,t.assistantText);return{responseId:g}}const{name:o,args:b,toolCallId:I,callId:x}=t.toolCall;I&&e.push({role:"assistant",text:"",toolCallId:I,toolName:o,toolArgs:JSON.stringify(b)});try{const t="string"==typeof b?(()=>{try{return JSON.parse(b)}catch(e){return b}})():b;null===(d=this.onMessageReceived)||void 0===d||d.call(this,{type:"TOOL_CALL",data:{name:o,args:t}});const n=yield this.functionHandler(o,t);if(I?e.push({role:"tool",text:JSON.stringify(n),toolCallId:I}):e.push({role:"tool",text:JSON.stringify(n)}),x){const t="object"==typeof n&&null!==n?n:String(n),r=this.sanitizeToolOutput(o,t);try{const e="string"==typeof t?t:JSON.stringify(t);null===(u=this.onMessageReceived)||void 0===u||u.call(this,{type:"TOOL_RESULT",data:{name:o,preview:e.slice(0,1e3)}})}catch(e){}const l=[{type:"function_call_output",call_id:x,output:r}],c=yield s.callToChatbot(e,a,i,this.system.id,this.apiAdapter,g,this.system.functions,this.system.model,l,this.system.tools,this.maxTokens,this.useCase,this.storeId);if(g=c.responseId,!c.toolCall){if(c.assistantText)if("json"===this.responseFormat){const e=null!==(h=c.parsed)&&void 0!==h?h:this.tryParseAssistantJson(c.assistantText);if(null!=e){const t=Array.isArray(e)?e:[e];this.displayInUI&&this.dispatchParsedResponses(t),null===(p=this.onMessageReceived)||void 0===p||p.call(this,e)}else this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"assistant",content:c.assistantText,timestamp:Date.now()}),null===(m=this.onMessageReceived)||void 0===m||m.call(this,c.assistantText)}else this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"assistant",content:c.assistantText,timestamp:Date.now()}),null===(y=this.onMessageReceived)||void 0===y||y.call(this,c.assistantText);return{responseId:g}}f=c}else;}catch(e){return this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"system",content:`Tool error: ${String((null==e?void 0:e.message)||e)}`,timestamp:Date.now()}),{responseId:g}}}return this.displayInUI&&this.dispatchMessage({id:`m-${Date.now()}`,role:"system",content:`Maximum tool call iterations (${this.maxToolCalls}) reached.`,timestamp:Date.now()}),{responseId:g}}))}};

package/dist/cjs/components/bik-chatbot/services/callToChatbot.d.ts

@@ -0,0 +1,6 @@
+import { APIAdapter, ApiRequestExecutor, ChatMessageItem, FunctionCallOutputItem, FunctionDefinition, GenericAIResponse } from '../types';
+export declare function createExecutorApiAdapter(executor: ApiRequestExecutor, baseUrl: string, endpointPath?: string): APIAdapter;
+export declare function callToChatbot(history: {
+    role: string;
+    text: string;
+}[], intent: string | undefined, conversationId: string | undefined, systemId: string | undefined, apiAdapter: APIAdapter, previousResponseId?: string, customFunctions?: FunctionDefinition[], model?: string, nextInput?: Array<ChatMessageItem | FunctionCallOutputItem>, builtinTools?: string[], maxTokens?: number, useCase?: string, storeId?: string): Promise<GenericAIResponse>;

package/dist/cjs/components/bik-chatbot/services/callToChatbot.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../_virtual/_tslib.js"),t=require("../types/ai.js");exports.callToChatbot=function(o){let n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"default",s=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"default-session",r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:"generic",i=arguments.length>4?arguments[4]:void 0,l=arguments.length>5?arguments[5]:void 0,a=arguments.length>6?arguments[6]:void 0,d=arguments.length>7&&void 0!==arguments[7]?arguments[7]:t.DEFAULT_MODEL,u=arguments.length>8?arguments[8]:void 0,c=arguments.length>9?arguments[9]:void 0,p=arguments.length>10?arguments[10]:void 0,v=arguments.length>11?arguments[11]:void 0,h=arguments.length>12?arguments[12]:void 0;return e.__awaiter(this,void 0,void 0,(function*(){if(!i)throw new Error("Chatbot authentication not configured: RequestExecutor is required");const e=u&&u.length>0?u:function(e){return e.map((e=>{let{role:t,text:o}=e;return{role:t,content:o}}))}(o),t={input:e,intent:n,conversationId:s,systemId:r,previousResponseId:l,customFunctions:a,builtinTools:c,model:d,maxTokens:null!=p?p:4e3,useCase:v,storeId:h};return yield i(t)}))},exports.createExecutorApiAdapter=function(t,o){let n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:"/bik-ai/call-chatbot";return s=>e.__awaiter(this,void 0,void 0,(function*(){var e,r;const{input:i,model:l,maxTokens:a=4e3,previousResponseId:d,customFunctions:u,builtinTools:c,storeId:p}=s,v={input:i,tools:[...(c||[]).map((e=>({type:e}))),...(h=u,h&&0!==h.length?h.map((e=>({type:"function",name:e.name,description:e.description,parameters:e.parameters}))):[])],model:l,max_output_tokens:a,previous_response_id:d,output_parser:"bik_chatbot_parser",use_case:s.useCase,store_id:p};var h;const g=`${o.replace(/\/$/,"")}${n}`,{status:m,data:_,error:f}=yield t.sendData({apiPath:g,apiMethod:"POST",requestBody:v});if(200!==m||!(null==_?void 0:_.success)){const t=(null===(r=null===(e=null==_?void 0:_.errors)||void 0===e?void 0:e[0])||void 0===r?void 0:r.message)||f;throw new Error("Backend error: "+(t?` - ${String(t)}`:""))}return function(e){const t={assistantText:e.assistantText,parsed:e.parsed,lastResponseId:e.lastResponseId,responseId:e.responseId};return e.toolCall&&(t.toolCall={name:e.toolCall.name,args:e.toolCall.args,toolCallId:e.toolCall.id,callId:e.toolCall.call_id}),t}(_.data)}))};

package/dist/cjs/components/bik-chatbot/services/db.d.ts

@@ -0,0 +1,6 @@
+import { SessionRecord } from '../types';
+/** Save session record to IndexedDB */
+export declare function saveSession(sessionId: string, record: SessionRecord): Promise<void>;
+export declare function loadSession(sessionId: string): Promise<SessionRecord | null>;
+export declare function deleteSession(sessionId: string): Promise<void>;
+export declare function listSessions(): Promise<string[]>;

package/dist/cjs/components/bik-chatbot/services/db.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../_virtual/_tslib.js"),i=require("idb-keyval");const t="ai-session:";exports.loadSession=function(r){return e.__awaiter(this,void 0,void 0,(function*(){return(yield i.get(`${t}${r}`))||null}))},exports.saveSession=function(r,s){return e.__awaiter(this,void 0,void 0,(function*(){yield i.set(`${t}${r}`,s)}))};

package/dist/cjs/components/bik-chatbot/services/useAIChat.d.ts

@@ -0,0 +1,7 @@
+import { ChatMessage, SessionRecord, UseAIChatProps } from '../types';
+export declare function useAIChat({ system, conversationId, skipInitialization, customFunctions, functionHandler, responseFormat, onMessageReceived, displayInUI, maxToolCalls, maxTokens, apiAdapter, useCase, storeId, }: Omit<UseAIChatProps, 'updateUI'>): {
+    messages: ChatMessage[];
+    conversation: SessionRecord;
+    sendMessage: (content: string, intent?: string) => Promise<void>;
+    isApiCallInProgress: boolean;
+};

package/dist/cjs/components/bik-chatbot/services/useAIChat.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../../_virtual/_tslib.js"),s=require("react"),t=require("../types/chat.js"),a=require("./aiService.js"),n=require("./db.js");exports.useAIChat=function(i){var o=this;let{system:r,conversationId:c,skipInitialization:d=!1,customFunctions:l,functionHandler:u,responseFormat:g,onMessageReceived:m,displayInUI:b,maxToolCalls:j,maxTokens:p,apiAdapter:O,useCase:v,storeId:I}=i;const[S,f]=s.useState((()=>t.createSessionRecord(c))),[w,y]=s.useState([]),[h,A]=s.useState(),[C,R]=s.useState(!1);s.useEffect((()=>{n.loadSession(c).then((e=>{var s;e&&(f(e),y(e.messages),A(null===(s=e.metadata)||void 0===s?void 0:s.lastResponseId))}))}),[c]);const D=s.useMemo((()=>d?null:new a.AIService({system:Object.assign(Object.assign({},r),{handleCallback:(e,s)=>{var t;null===(t=r.handleCallback)||void 0===t||t.call(r,e,s)}}),dispatchMessage:e=>{y((s=>[...s,e])),f((s=>{const t=Object.assign(Object.assign({},s),{updatedAt:Date.now(),messages:[...s.messages,e]});return n.saveSession(t.sessionId,Object.assign(Object.assign({},t),{metadata:Object.assign(Object.assign({},t.metadata||{}),{lastResponseId:h})})),t}))},customFunctions:l,functionHandler:u,responseFormat:g,onMessageReceived:m,displayInUI:b,maxToolCalls:j,maxTokens:p,apiAdapter:O,useCase:v,storeId:I})),[r.id,d,p]);return{messages:w,conversation:S,sendMessage:function(s){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"default";return e.__awaiter(o,void 0,void 0,(function*(){if(!D)return;const e={id:`u-${Date.now()}`,role:"user",content:s,timestamp:Date.now()};y((s=>[...s,e])),f((s=>{const t=Object.assign(Object.assign({},s),{updatedAt:Date.now(),messages:[...s.messages,e]});return n.saveSession(t.sessionId,Object.assign(Object.assign({},t),{metadata:Object.assign(Object.assign({},t.metadata||{}),{lastResponseId:h})})),t})),R(!0);try{const s=yield D.generate([...w,e].map((e=>({role:e.role,content:e.content}))),c,t,h);(null==s?void 0:s.responseId)&&(A(s.responseId),f((e=>{const t=Object.assign(Object.assign({},e),{metadata:Object.assign(Object.assign({},e.metadata||{}),{lastResponseId:s.responseId})});return n.saveSession(t.sessionId,t),t})))}catch(e){const s=(null==e?void 0:e.message)||"Something went wrong. Please try again.",t={id:`err-${Date.now()}`,role:"system",content:s,timestamp:Date.now()};y((e=>[...e,t])),f((e=>{const s=Object.assign(Object.assign({},e),{updatedAt:Date.now(),messages:[...e.messages,t]});return n.saveSession(s.sessionId,Object.assign(Object.assign({},s),{metadata:Object.assign(Object.assign({},s.metadata||{}),{lastResponseId:h})})),s}))}finally{R(!1)}}))},isApiCallInProgress:C}};

package/dist/cjs/components/bik-chatbot/types/ai.d.ts

@@ -0,0 +1,163 @@
+/**
+ * AI Service Types
+ *
+ * Types for AI service functionality, function definitions, and responses.
+ */
+export declare const ALLOWED_MODELS: string[];
+export declare const DEFAULT_MODEL = "gpt-4.1-mini";
+export interface FunctionDefinition {
+    name: string;
+    description: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+export interface ToolCall {
+    name: string;
+    args: unknown;
+    toolCallId?: string;
+    callId?: string;
+}
+export type GenericAIResponse = {
+    assistantText: string;
+    parsed?: unknown;
+    toolCall?: ToolCall;
+    lastResponseId: string;
+    responseId?: string;
+};
+export interface ChatMessageItem {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface FunctionCallOutputItem {
+    type: 'function_call_output';
+    call_id: string;
+    output: string | object;
+}
+export type CallbackPayload = {
+    type: 'UI_UPDATE';
+    data: unknown;
+} | {
+    type: 'UI_SIGNAL';
+    data: unknown;
+} | {
+    type: 'AI_RESPONSE';
+    data: {
+        text: string;
+        responseId?: string;
+        timestamp: number;
+    };
+} | {
+    type: 'TOOL_CALL';
+    data: {
+        name: string;
+        args: unknown;
+    };
+};
+export interface SystemConfig {
+    id: string;
+    name: string;
+    model: string;
+    systemPrompt: string;
+    functions?: FunctionDefinition[];
+    tools?: string[];
+    handleCallback?: (payload: CallbackPayload, ctx: {
+        dispatchMessage: (m: any) => void;
+        updatePageState: (updater: (s: any) => any) => void;
+        updateUI?: (signal: any) => void;
+    }) => void;
+}
+export interface PromptConfig {
+    goal_prompt?: string;
+    use_case_prompt?: string;
+    response_instructions?: string;
+    store_instructions?: string;
+    exit_prompt?: string;
+    output_prompt?: string;
+    custom_prompt?: string;
+    extra_content?: {
+        contextual_info?: string;
+        brand_info?: string;
+    };
+}
+export interface ToolPrompt {
+    tool: string;
+    whenToUse: string;
+    outputFormat?: string;
+}
+export interface ErrorWithMessage {
+    message: string;
+}
+export declare const DEFAULT_RESPONSE_FORMAT: 'text' | 'json';
+export declare const DEFAULT_MAX_TOOL_CALLS = 5;
+export declare const RESPONSE_FORMATS: readonly ["text", "json"];
+export declare const BUILTIN_TOOL_TYPES: readonly ["web_search_preview"];
+export type BuiltinToolType = (typeof BUILTIN_TOOL_TYPES)[number];
+export type BackendTool = {
+    type: BuiltinToolType;
+} | {
+    type: 'function';
+    name: string;
+    description: string;
+    parameters: object;
+} | ({
+    type: string;
+} & Record<string, unknown>);
+export interface BackendApiRequest {
+    input: Array<ChatMessageItem | FunctionCallOutputItem>;
+    tools: BackendTool[];
+    model: string;
+    max_output_tokens: number;
+    previous_response_id?: string;
+    output_parser?: string;
+    use_case?: string;
+    store_id?: string;
+}
+export interface BackendApiResponse {
+    status: number;
+    success: boolean;
+    data: {
+        assistantText: string;
+        parsed: unknown;
+        toolCall?: {
+            name: string;
+            args: object | string;
+            id: string;
+            call_id?: string;
+        };
+        responseId: string;
+        lastResponseId: string;
+        requiresFunctionCall: boolean;
+    };
+}
+export type ResponseFormat = 'text' | 'json';
+export interface ApiRequestExecutor {
+    sendData<T>(opts: {
+        apiPath: string;
+        apiMethod?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+        requestBody?: unknown;
+        requestHeader?: Record<string, string>;
+        skipStoreId?: boolean;
+        abortController?: AbortController;
+    }): Promise<{
+        status: number;
+        data?: T;
+        error?: unknown;
+    }>;
+}
+export type APIAdapter = (request: CallToChatbotRequest) => Promise<GenericAIResponse>;
+export type CallToChatbotRequest = {
+    input: Array<ChatMessageItem | FunctionCallOutputItem>;
+    intent: string;
+    conversationId: string;
+    systemId: string;
+    previousResponseId?: string;
+    customFunctions?: FunctionDefinition[];
+    builtinTools?: string[];
+    model: string;
+    maxTokens?: number;
+    useCase?: string;
+    storeId?: string;
+};

package/dist/cjs/components/bik-chatbot/types/ai.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.ALLOWED_MODELS=["gpt-4.1-nano","gpt-4.1-mini"],exports.DEFAULT_MAX_TOOL_CALLS=5,exports.DEFAULT_MODEL="gpt-4.1-mini",exports.DEFAULT_RESPONSE_FORMAT="text",exports.RESPONSE_FORMATS=["text","json"];

package/dist/cjs/components/bik-chatbot/types/chat.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Core Chat Types
+ *
+ * Basic types for chat functionality, messages, and conversation state.
+ */
+export interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+}
+export type ChatState = 'conversation-starter' | 'default' | 'typing' | 'thinking' | 'conversation';
+export interface IceBreaker {
+    id: string;
+    text: string;
+    category?: string;
+}
+export interface VideoStarter {
+    title: string;
+    description: string;
+    onPlay?: () => void;
+}
+export interface SessionRecord {
+    sessionId: string;
+    createdAt: number;
+    updatedAt: number;
+    messages: ChatMessage[];
+    metadata?: {
+        lastResponseId?: string;
+    };
+}
+export declare function createSessionRecord(sessionId: string): SessionRecord;
+export declare const CHAT_MESSAGE_ROLES: readonly ["user", "assistant", "system"];
+export declare const DEFAULT_CONVERSATION_ID = "default-session";

package/dist/cjs/components/bik-chatbot/types/chat.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.CHAT_MESSAGE_ROLES=["user","assistant","system"],exports.DEFAULT_CONVERSATION_ID="default-session",exports.createSessionRecord=function(e){return{sessionId:e,createdAt:Date.now(),updatedAt:Date.now(),messages:[],metadata:{}}};

package/dist/cjs/components/bik-chatbot/types/components.d.ts

@@ -0,0 +1,136 @@
+/// <reference types="react" />
+/**
+ * Component Props Types
+ *
+ * Type definitions for all component props in the bik-chatbot system.
+ */
+import { APIAdapter } from './ai';
+import { ApiRequestExecutor, FunctionDefinition, SystemConfig } from './ai';
+import type { ResponseFormat } from './ai';
+import { ChatMessage, ChatState, IceBreaker, VideoStarter } from './chat';
+export interface GenericChatbotProps {
+    systemPrompt: string;
+    systemId?: string;
+    functions?: FunctionDefinition[];
+    tools?: string[];
+    functionHandler?: (name: string, args: any) => Promise<any>;
+    onMessageReceived?: (message: string | object) => void;
+    displayInUI?: boolean;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    requestExecutor: ApiRequestExecutor;
+    baseUrl: string;
+    endpointPath?: string;
+    responseFormat?: ResponseFormat;
+    responseSchema?: unknown;
+    conversationId?: string;
+    className?: string;
+    height?: string;
+    showHeader?: boolean;
+    placeholder?: string;
+    iceBreakers?: IceBreaker[];
+    videoStarter?: VideoStarter;
+    onUIUpdate?: (signal: unknown) => void;
+    onMessageSent?: (message: string) => void;
+    onIceBreakerClick?: (iceBreaker: IceBreaker) => void;
+    chatState?: ChatState;
+    inputDisabled?: boolean;
+}
+export interface BIKChatbotProps extends GenericChatbotProps {
+    /** AI model to use (optional, defaults to gpt-4o-mini) */
+    model?: string;
+}
+export interface AIChatProps {
+    className?: string;
+    style?: React.CSSProperties;
+    header?: string;
+    showHeader?: boolean;
+    placeholder?: string;
+    suggestions?: string[];
+    disabled?: boolean;
+    isThinking?: boolean;
+    height?: string;
+    iceBreakers?: IceBreaker[];
+    videoStarter?: VideoStarter;
+    onMessageSent?: (message: string) => void;
+    onIceBreakerClick?: (iceBreaker: IceBreaker) => void;
+    chatState?: ChatState;
+    inputDisabled?: boolean;
+}
+export interface ChatWindowProps {
+    messages: ChatMessage[];
+    onSend: (content: string) => void;
+    header?: string;
+    placeholder?: string;
+    suggestions?: string[];
+    iceBreakers?: IceBreaker[];
+    videoStarter?: VideoStarter;
+    disabled?: boolean;
+    isThinking?: boolean;
+    onIceBreakerClick?: (iceBreaker: IceBreaker) => void;
+    chatState?: ChatState;
+    inputDisabled?: boolean;
+}
+export interface AIProviderProps {
+    children: React.ReactNode;
+    systemPrompt: string;
+    systemId?: string;
+    functions?: FunctionDefinition[];
+    tools?: string[];
+    functionHandler?: (name: string, args: any) => Promise<any>;
+    onMessageReceived?: (message: string | object) => void;
+    displayInUI?: boolean;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    requestExecutor: ApiRequestExecutor;
+    baseUrl: string;
+    endpointPath?: string;
+    responseFormat?: ResponseFormat;
+    responseSchema?: unknown;
+    conversationId?: string;
+    onUIUpdate?: (signal: unknown) => void;
+    customModel?: string;
+    onSystemReady?: (system: SystemConfig) => void;
+    useCase?: string;
+    storeId?: string;
+}
+export interface AIContextState {
+    isReady: boolean;
+    isLoading: boolean;
+    isApiCallInProgress: boolean;
+    system: SystemConfig | null;
+    messages: ChatMessage[];
+    conversation: unknown;
+    sendMessage: (content: string, intent?: string) => Promise<void>;
+    error: string | null;
+}
+export interface UseAIChatProps {
+    system: SystemConfig;
+    conversationId: string;
+    updateUI?: (signal: unknown) => void;
+    skipInitialization?: boolean;
+    customFunctions?: FunctionDefinition[];
+    functionHandler?: (name: string, args: any) => Promise<any>;
+    onMessageReceived?: (message: string | object) => void;
+    displayInUI?: boolean;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    apiAdapter: APIAdapter;
+    responseFormat?: ResponseFormat;
+    useCase?: string;
+    storeId?: string;
+}
+export interface AIServiceConstructorProps {
+    system: SystemConfig;
+    dispatchMessage: (m: ChatMessage) => void;
+    customFunctions?: FunctionDefinition[];
+    functionHandler?: (name: string, args: any) => Promise<any>;
+    onMessageReceived?: (message: string | object) => void;
+    displayInUI?: boolean;
+    maxToolCalls?: number;
+    maxTokens?: number;
+    apiAdapter: APIAdapter;
+    responseFormat?: 'text' | 'json';
+    useCase?: string;
+    storeId?: string;
+}

package/dist/cjs/components/bik-chatbot/types/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Comprehensive Type System for BIK Chatbot
+ */
+export * from './chat';
+export * from './ai';
+export * from './components';

package/dist/cjs/components/bik-chatbot/utils/guardrails.d.ts

@@ -0,0 +1,6 @@
+export declare function sanitizeUserInput(text: string): string;
+export declare function injectSafetyPrompt(prompt: string): string;
+export declare function validateOutput(msg: unknown): boolean;
+export declare function validateFunctionCall(fnCall: unknown, allowedFunctions?: Array<{
+    name: string;
+}>): boolean;

package/dist/cjs/components/bik-chatbot/utils/guardrails.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.injectSafetyPrompt=function(e){return`${e}\n\nFollow company safety rules: do not provide PII, do not encourage illegal activity, avoid disallowed content.`},exports.sanitizeUserInput=function(e){return e?e.replace(/[\u0000-\u001F\u007F]/g,"").trim():""};

package/dist/cjs/components/bik-chatbot/utils/markdown.d.ts

@@ -0,0 +1 @@
+export declare function renderMarkdownLite(text: string): string;

package/dist/cjs/components/bik-chatbot/utils/markdown.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.renderMarkdownLite=function(e){if(!e)return"";let r=e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;");return r=r.replace(/```([\s\S]*?)```/g,((e,r)=>`<pre><code>${r.replace(/\n/g,"\n")}</code></pre>`)),r=r.replace(/^####\s+(.+)$/gm,"<h4>$1</h4>"),r=r.replace(/^###\s+(.+)$/gm,"<h3>$1</h3>"),r=r.replace(/^##\s+(.+)$/gm,"<h2>$1</h2>"),r=r.replace(/^#\s+(.+)$/gm,"<h1>$1</h1>"),r=r.replace(/\*\*(.+?)\*\*/g,"<strong>$1</strong>"),r=r.replace(/(^|\s)\*(.+?)\*(?=\s|$)/g,"$1<em>$2</em>"),r=r.replace(/(^|\s)_(.+?)_(?=\s|$)/g,"$1<em>$2</em>"),r=r.replace(/\n\n/g,"<br/><br/>"),r=r.replace(/\n/g,"<br/>"),r};

package/dist/cjs/components/bik-chatbot-examples/AnalyticsAdvisor.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface AnalyticsAdvisorProps {
+    storeId?: string;
+    height?: string;
+    fullHeight?: boolean;
+}
+export declare const AnalyticsAdvisor: React.FC<AnalyticsAdvisorProps>;
+export default AnalyticsAdvisor;

package/dist/cjs/components/bik-chatbot-examples/ContentIdeasDemo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Content Ideas Demo - Multi-step tool flow
+ * getTrends() -> generate 5 ideas -> updateIdeas({ ideas }) -> final JSON reply
+ */
+import React from 'react';
+export interface ContentIdeasDemoProps {
+    height?: string;
+    className?: string;
+    conversationId?: string;
+}
+export declare const ContentIdeasDemo: React.FC<ContentIdeasDemoProps>;
+export default ContentIdeasDemo;

package/dist/cjs/components/bik-chatbot-examples/SilentModeDemo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Silent Function Calls Demo - Testing that custom function calls don't show in chat
+ *
+ * This demonstrates:
+ * - Function calls execute silently (no chat bubbles for function execution)
+ * - Only final JSON data is displayed (not in chat)
+ * - Follows workflow: User Input → Function Call (SILENT) → Handler → Display Data
+ * - Perfect for testing the silent function call behavior
+ */
+import React from 'react';
+export interface SilentModeDemoProps {
+    height?: string;
+    className?: string;
+    conversationId?: string;
+}
+export declare const SilentModeDemo: React.FC<SilentModeDemoProps>;
+export default SilentModeDemo;

package/dist/cjs/components/bik-chatbot-examples/SimpleChatbotDemo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Simple Chatbot Demo - Basic text conversation without functions
+ *
+ * This demonstrates:
+ * - Plain text chatbot
+ * - No functions or structured data
+ * - Basic AI interaction
+ * - Web search capability (via Responses API)
+ */
+import React from 'react';
+export interface SimpleChatbotDemoProps {
+    height?: string;
+    className?: string;
+    conversationId?: string;
+}
+export declare const SimpleChatbotDemo: React.FC<SimpleChatbotDemoProps>;
+export default SimpleChatbotDemo;