@whitewall/blip-sdk 0.0.191 → 0.0.193

package/dist/types/utils/minifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minifier.d.ts","sourceRoot":"","sources":["../../../src/utils/minifier.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAOH,KAAK,IAAI,EAQZ,MAAM,kBAAkB,CAAA;AAqHzB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAA4E,CAAA;AAEtG,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA4E,CAAA;AASrG;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBnB,CAAA;AAEb;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAI7B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CA8CnD;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAwIrF"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@whitewall/blip-sdk",
-    "version": "0.0.191",
+    "version": "0.0.193",
     "description": "Blip API wrapper",
     "exports": {
         "types": "./dist/types/index.d.ts",

package/src/client.ts

@@ -13,6 +13,7 @@ import { TunnelNamespace } from './namespaces/tunnel.ts'
 import { WhatsAppNamespace } from './namespaces/whatsapp.ts'
 import { isClosable } from './sender/closable.ts'
 import { HttpSender } from './sender/http/httpsender.ts'
+import type { NonTransportAuthentication } from './sender/security.ts'
 import type { ConnectionSender, ConnectionSenderConstructor, Sender } from './sender/sender.ts'
 import type { Message, MessageTypes } from './types/message.ts'
 import { type BlipDomain, type Domain, type Identity, Node } from './types/node.ts'
@@ -76,7 +77,7 @@ export class BlipClient<TSender extends Sender = Sender> {
     }
 
     public static async createAccountAndConnect<TSender extends Sender>(
-        sender: ConnectionSenderConstructor<TSender>,
+        sender: ConnectionSenderConstructor<TSender, NonTransportAuthentication>,
         identity: Identity,
         password: string,
         tenantId?: string,

package/src/index.ts

@@ -5,6 +5,8 @@ export * from './sender/index.ts'
 export * from './types/index.ts'
 export * from './utils/builder.ts'
 export * from './utils/desk.ts'
+export * from './utils/flow-rules.ts'
+export * from './utils/minifier.ts'
 export * from './utils/odata.ts'
 export * from './utils/thread.ts'
 export * from './utils/uri.ts'

package/src/types/flow.ts

@@ -44,6 +44,19 @@ const CONDITION_SOURCES = ['input', 'context'] as const
 const LOGICAL_OPERATORS = ['or', 'and'] as const
 const TYPE_OF_STATE_ID = ['state', 'variable'] as const
 
+export const ROOT_STATE_ID = 'onboarding'
+
+export const CUSTOM_ACTION_LISTS = [
+    '$enteringCustomActions',
+    '$leavingCustomActions',
+    '$afterStateChangedActions',
+    '$localCustomActions',
+] as const
+
+/** The state that declares `root`, or the conventional id for a flow that predates it. */
+export const resolveEntryPointId = (flow: Record<string, { root?: boolean }>): string | undefined =>
+    Object.keys(flow).find((stateId) => flow[stateId].root) ?? (ROOT_STATE_ID in flow ? ROOT_STATE_ID : undefined)
+
 const createVariableNameSchema = (description: string) => z.string().describe(description)
 
 const plainTextSchema = z.string()
@@ -142,7 +155,10 @@ const sendMessageActionSettingsSchema = z.object({
 
 const sendRawMessageActionSettingsSchema = z.object({
     $invalid: z.boolean().optional(),
-    type: z.literal('application/json').optional(),
+    // The media type the runtime deserializes the raw content as, so it is not
+    // restricted to application/json: a document assembled at runtime is sent as
+    // its own lime type, which is how a dynamic menu is rendered.
+    type: z.string().optional(),
     // Useful to send raw channel payloads, such as WhatsApp interactive content.
     rawContent: z.string(),
 })
@@ -190,7 +206,7 @@ export const conditionSchema = z.object({
     values: z.array(z.string()),
 })
 
-const baseActionSchema = z.object({
+export const baseActionSchema = z.object({
     $id: z.string(),
     // Should only exist for SendMessage and SendRawMessage actions. When it is
     // omitted, GET responses usually return an empty string.
@@ -206,8 +222,9 @@ const baseActionSchema = z.object({
             position: z.literal('left'),
             document: z.object({
                 id: z.string(),
-                // Must match the type defined in the action settings.
-                type: z.enum(MIME_TYPES).or(z.literal('application/json')),
+                // Must match the type defined in the action settings, which for a
+                // raw message can be any media type.
+                type: z.string(),
                 // Must match the content defined in the action settings.
                 content: flowMessageContentSchema.or(z.string()),
                 textContent: z.string().optional(),
@@ -218,7 +235,7 @@ const baseActionSchema = z.object({
     continueOnError: z.boolean().optional(),
 })
 
-const actionTypeSchema = z.discriminatedUnion('type', [
+export const actionTypeSchema = z.discriminatedUnion('type', [
     z.object({
         type: z.literal('SendMessage'),
         settings: sendMessageActionSettingsSchema,
@@ -361,7 +378,7 @@ export const stateSchema = z.object({
         }),
     ),
     id: z.string().optional(),
-    // Only the special state with id "onboarding" is usually marked as root.
+    // Set on the entry point, which the builder always keys as ROOT_STATE_ID.
     root: z.boolean().optional(),
     $title: z.string(),
     $position: z
@@ -389,6 +406,35 @@ export type State = z.infer<typeof stateSchema>
 export type Flow = z.infer<typeof flowSchema>
 export type BuilderFlow = Flow
 
+/**
+ * Typing indicators are noise in every projection of a flow, so both the digest
+ * and the minifier drop them. The two signals are checked because `$typeOfContent`
+ * is absent from a minified flow and can come back empty from a GET, while the
+ * settings mime type is absent from a hand-written action.
+ */
+export function isChatStateSendMessage(item: {
+    action?: { type: string; $typeOfContent?: string; settings: { type?: string; [key: string]: unknown } }
+}): boolean {
+    if (item.action?.type !== 'SendMessage') {
+        return false
+    }
+
+    return (
+        item.action.$typeOfContent === 'chat-state' ||
+        item.action.settings.type === 'application/vnd.lime.chatstate+json'
+    )
+}
+
+/** The input the runtime will use: the first one in the state, if any. */
+export function inputOf<T>(state: { $contentActions: Array<{ input?: T }> }): T | undefined {
+    return state.$contentActions.find((item) => item.input)?.input
+}
+
+/** The labels of a select's options, which are what a user answers with. */
+export function optionLabels(content: { options?: Array<string | { text?: string }> }): Array<string> {
+    return (content.options ?? []).map((option) => (typeof option === 'string' ? option : (option?.text ?? '')))
+}
+
 export type BuilderConfiguration = {
     'builder:minimumIntentScore'?: string
     'builder:stateTrack'?: string

package/src/utils/builder.ts

@@ -1,54 +1,53 @@
-import type { Action, ContentActionItem, State } from '../types/flow.ts'
-
-export type MinifiedAction = {
+/**
+ * Lossy, read-only projection of a builder flow, meant for presenting a state to
+ * a human or an LLM. It renames the `$`-prefixed keys to readable ones, drops
+ * layout metadata and denormalizes state names, so it cannot be pushed back to
+ * the builder. For the round-trippable format, see `./minifier.ts`.
+ *
+ * Typed over `MinifiedState`, which a full `State` satisfies, so both a pulled
+ * flow and a minified one digest without casts.
+ */
+import { type Condition, isChatStateSendMessage, resolveEntryPointId } from '../types/flow.ts'
+import type { MinifiedAction, MinifiedInput, MinifiedState } from './minifier.ts'
+
+/** A `Condition` with the builder's nullish bookkeeping dropped. */
+export type ConditionDigest = Omit<Condition, 'variable'> & { variable?: string }
+
+export type ActionDigest = {
     type: string
     settings: Record<string, unknown>
-    conditions?: Array<{
-        source: string
-        variable?: string
-        comparison: string
-        operator?: string
-        values: Array<string>
-    }>
+    conditions?: Array<ConditionDigest>
 }
 
-export type MinifiedInput = {
+export type InputDigest = {
     bypass: boolean
     variable?: string
     validation?: { rule: string; regex?: string; type?: string; error: string }
     expiration?: string
-    conditions?: MinifiedAction['conditions']
+    conditions?: Array<ConditionDigest>
 }
 
-export type MinifiedOutput = {
+export type OutputDigest = {
     stateId: string
     stateName?: string
     typeOfStateId?: string
-    conditions?: MinifiedAction['conditions']
+    conditions?: Array<ConditionDigest>
 }
 
-export type MinifiedState = {
+export type StateDigest = {
     id: string
     name: string
     root?: boolean
-    enteringActions?: Array<MinifiedAction>
-    contentActions?: Array<{ action?: MinifiedAction; input?: MinifiedInput }>
-    leavingActions?: Array<MinifiedAction>
-    outputs?: Array<MinifiedOutput>
-    defaultOutput: { stateId: string; stateName?: string; typeOfStateId?: string }
-    afterStateChangedActions?: Array<MinifiedAction>
-    localActions?: Array<MinifiedAction>
+    enteringActions?: Array<ActionDigest>
+    contentActions?: Array<{ action?: ActionDigest; input?: InputDigest }>
+    leavingActions?: Array<ActionDigest>
+    outputs?: Array<OutputDigest>
+    defaultOutput: OutputDigest
+    afterStateChangedActions?: Array<ActionDigest>
+    localActions?: Array<ActionDigest>
 }
 
-function minifyConditions(
-    conditions?: Array<{
-        source: string
-        variable?: string
-        comparison: string
-        operator?: string
-        values: Array<string>
-    }>,
-): MinifiedAction['conditions'] | undefined {
+function digestConditions(conditions?: Array<Condition>): Array<ConditionDigest> | undefined {
     if (!conditions || conditions.length === 0) return undefined
     return conditions.map((c) => ({
         source: c.source,
@@ -59,26 +58,26 @@ function minifyConditions(
     }))
 }
 
-function minifyActionSettings(settings: Record<string, unknown>): Record<string, unknown> {
+function digestActionSettings(settings: Record<string, unknown>): Record<string, unknown> {
     const clone = { ...settings }
     delete clone.$invalid
     delete clone.id
     return clone
 }
 
-export function minifyAction(action: Action): MinifiedAction {
-    const result: MinifiedAction = {
+export function digestAction(action: MinifiedAction): ActionDigest {
+    const result: ActionDigest = {
         type: action.type,
-        settings: minifyActionSettings(action.settings as Record<string, unknown>),
+        settings: digestActionSettings(action.settings as Record<string, unknown>),
     }
-    const conditions = minifyConditions(action.conditions as MinifiedAction['conditions'])
+    const conditions = digestConditions(action.conditions)
     if (conditions) result.conditions = conditions
     return result
 }
 
-function minifyInput(input: ContentActionItem['input']): MinifiedInput | undefined {
+function digestInput(input: MinifiedInput | undefined): InputDigest | undefined {
     if (!input) return undefined
-    const result: MinifiedInput = { bypass: input.bypass }
+    const result: InputDigest = { bypass: input.bypass }
     if (input.variable) result.variable = input.variable
     if (input.validation) {
         result.validation = {
@@ -89,76 +88,65 @@ function minifyInput(input: ContentActionItem['input']): MinifiedInput | undefin
         }
     }
     if (input.expiration) result.expiration = input.expiration
-    const conditions = minifyConditions(input.conditions as MinifiedAction['conditions'])
+    const conditions = digestConditions(input.conditions)
     if (conditions) result.conditions = conditions
     return result
 }
 
-export function isChatStateSendMessage(item: ContentActionItem): boolean {
-    return item.action?.type === 'SendMessage' && item.action.$typeOfContent === 'chat-state'
-}
-
-export function resolveStateName(stateId: string, flow: Record<string, State>): string | undefined {
+export function resolveStateName(stateId: string, flow: Record<string, MinifiedState>): string | undefined {
     const state = flow[stateId]
     return state?.$title
 }
 
-function minifyOutput(
-    output: { stateId: string; typeOfStateId?: string; conditions?: Array<unknown>; $invalid?: boolean },
-    flow: Record<string, State>,
-): MinifiedOutput {
-    const result: MinifiedOutput = {
+function digestOutput(
+    output: { stateId: string; typeOfStateId?: string; conditions?: Array<Condition> },
+    flow: Record<string, MinifiedState>,
+): OutputDigest {
+    const result: OutputDigest = {
         stateId: output.stateId,
     }
     const name = resolveStateName(output.stateId, flow)
     if (name) result.stateName = name
     if (output.typeOfStateId) result.typeOfStateId = output.typeOfStateId
-    if ('conditions' in output && Array.isArray(output.conditions) && output.conditions.length > 0) {
-        result.conditions = minifyConditions(output.conditions as MinifiedAction['conditions'])
-    }
+    const conditions = digestConditions(output.conditions)
+    if (conditions) result.conditions = conditions
     return result
 }
 
-export function minifyState(stateId: string, state: State, flow: Record<string, State>): MinifiedState {
-    const result: MinifiedState = {
+export function digestState(stateId: string, state: MinifiedState, flow: Record<string, MinifiedState>): StateDigest {
+    const result: StateDigest = {
         id: stateId,
         name: state.$title,
-        defaultOutput: {
-            stateId: state.$defaultOutput.stateId,
-            ...(resolveStateName(state.$defaultOutput.stateId, flow)
-                ? { stateName: resolveStateName(state.$defaultOutput.stateId, flow) }
-                : {}),
-            ...(state.$defaultOutput.typeOfStateId ? { typeOfStateId: state.$defaultOutput.typeOfStateId } : {}),
-        },
+        defaultOutput: digestOutput(state.$defaultOutput, flow),
     }
 
-    if (state.root) result.root = true
+    if (resolveEntryPointId(flow) === stateId) result.root = true
 
-    const enteringActions = state.$enteringCustomActions.map(minifyAction)
+    const enteringActions = state.$enteringCustomActions.map(digestAction)
     if (enteringActions.length > 0) result.enteringActions = enteringActions
 
     const contentActions = state.$contentActions
-        .filter((item: ContentActionItem) => !isChatStateSendMessage(item))
-        .map((item: ContentActionItem) => {
-            const entry: { action?: MinifiedAction; input?: MinifiedInput } = {}
-            if (item.action) entry.action = minifyAction(item.action)
-            const input = minifyInput(item.input)
+        .filter((item) => !isChatStateSendMessage(item))
+        .map((item) => {
+            const entry: { action?: ActionDigest; input?: InputDigest } = {}
+            if (item.action) entry.action = digestAction(item.action)
+            const input = digestInput(item.input)
             if (input) entry.input = input
             return entry
         })
-        .filter((entry: { action?: MinifiedAction; input?: MinifiedInput }) => entry.action || entry.input)
+        .filter((entry) => entry.action || entry.input)
     if (contentActions.length > 0) result.contentActions = contentActions
 
-    const leavingActions = state.$leavingCustomActions.map(minifyAction)
+    const leavingActions = state.$leavingCustomActions.map(digestAction)
     if (leavingActions.length > 0) result.leavingActions = leavingActions
 
-    const outputs = state.$conditionOutputs.map((o: State['$conditionOutputs'][number]) => minifyOutput(o, flow))
+    const outputs = state.$conditionOutputs.map((o) => digestOutput(o, flow))
     if (outputs.length > 0) result.outputs = outputs
 
-    const afterStateChangedActions = (state.$afterStateChangedActions ?? []).map(minifyAction)
+    const afterStateChangedActions = (state.$afterStateChangedActions ?? []).map(digestAction)
     if (afterStateChangedActions.length > 0) result.afterStateChangedActions = afterStateChangedActions
 
-    const localActions = (state.$localCustomActions ?? []).map(minifyAction)
+    const localActions = (state.$localCustomActions ?? []).map(digestAction)
     if (localActions.length > 0) result.localActions = localActions
 
     return result