@whitewall/blip-sdk 0.0.190 → 0.0.192

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,EAMH,KAAK,IAAI,EAOZ,MAAM,kBAAkB,CAAA;AAgKzB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBnB,CAAA;AAEb;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAuC7B,CAAA;AAEF,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,CA0CnD;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,IAAI,GAAG,IAAI,CAmIrF"}

package/dist/types/utils/whatsapp.d.ts

@@ -1,4 +1,6 @@
+import { type PossiblyNode } from '../types/node.ts';
 import type { MessageTemplate, MessageTemplatePreview, MessageTemplateVariable } from '../types/whatsapp.ts';
+export declare function isWhatsAppGuidIdentity(identity: PossiblyNode): boolean;
 type TemplateHeaderFormat = NonNullable<MessageTemplatePreview['headerFormat']>;
 type TemplateHeaderComponent = {
     type: 'HEADER';

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

@@ -1 +1 @@
-{"version":3,"file":"whatsapp.d.ts","sourceRoot":"","sources":["../../../src/utils/whatsapp.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"whatsapp.d.ts","sourceRoot":"","sources":["../../../src/utils/whatsapp.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@whitewall/blip-sdk",
-    "version": "0.0.190",
+    "version": "0.0.192",
     "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,7 @@ export * from './sender/index.ts'
 export * from './types/index.ts'
 export * from './utils/builder.ts'
 export * from './utils/desk.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,8 @@ 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'
+
 const createVariableNameSchema = (description: string) => z.string().describe(description)
 
 const plainTextSchema = z.string()
@@ -142,7 +144,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 +195,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 +211,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 +224,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 +367,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

package/src/utils/builder.ts

@@ -1,6 +1,12 @@
-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`.
+ */
+import { type Action, type ContentActionItem, ROOT_STATE_ID, type State } from '../types/flow.ts'
+
+export type ActionDigest = {
     type: string
     settings: Record<string, unknown>
     conditions?: Array<{
@@ -12,35 +18,35 @@ export type MinifiedAction = {
     }>
 }
 
-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?: ActionDigest['conditions']
 }
 
-export type MinifiedOutput = {
+export type OutputDigest = {
     stateId: string
     stateName?: string
     typeOfStateId?: string
-    conditions?: MinifiedAction['conditions']
+    conditions?: ActionDigest['conditions']
 }
 
-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>
+    enteringActions?: Array<ActionDigest>
+    contentActions?: Array<{ action?: ActionDigest; input?: InputDigest }>
+    leavingActions?: Array<ActionDigest>
+    outputs?: Array<OutputDigest>
     defaultOutput: { stateId: string; stateName?: string; typeOfStateId?: string }
-    afterStateChangedActions?: Array<MinifiedAction>
-    localActions?: Array<MinifiedAction>
+    afterStateChangedActions?: Array<ActionDigest>
+    localActions?: Array<ActionDigest>
 }
 
-function minifyConditions(
+function digestConditions(
     conditions?: Array<{
         source: string
         variable?: string
@@ -48,7 +54,7 @@ function minifyConditions(
         operator?: string
         values: Array<string>
     }>,
-): MinifiedAction['conditions'] | undefined {
+): ActionDigest['conditions'] | undefined {
     if (!conditions || conditions.length === 0) return undefined
     return conditions.map((c) => ({
         source: c.source,
@@ -59,26 +65,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: Action): 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 as ActionDigest['conditions'])
     if (conditions) result.conditions = conditions
     return result
 }
 
-function minifyInput(input: ContentActionItem['input']): MinifiedInput | undefined {
+function digestInput(input: ContentActionItem['input']): 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,13 +95,26 @@ 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 as ActionDigest['conditions'])
     if (conditions) result.conditions = conditions
     return result
 }
 
+/**
+ * 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: ContentActionItem): boolean {
-    return item.action?.type === 'SendMessage' && item.action.$typeOfContent === 'chat-state'
+    if (item.action?.type !== 'SendMessage') {
+        return false
+    }
+
+    return (
+        item.action.$typeOfContent === 'chat-state' ||
+        item.action.settings.type === 'application/vnd.lime.chatstate+json'
+    )
 }
 
 export function resolveStateName(stateId: string, flow: Record<string, State>): string | undefined {
@@ -103,24 +122,24 @@ export function resolveStateName(stateId: string, flow: Record<string, State>):
     return state?.$title
 }
 
-function minifyOutput(
+function digestOutput(
     output: { stateId: string; typeOfStateId?: string; conditions?: Array<unknown>; $invalid?: boolean },
     flow: Record<string, State>,
-): MinifiedOutput {
-    const result: MinifiedOutput = {
+): 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'])
+        result.conditions = digestConditions(output.conditions as ActionDigest['conditions'])
     }
     return result
 }
 
-export function minifyState(stateId: string, state: State, flow: Record<string, State>): MinifiedState {
-    const result: MinifiedState = {
+export function digestState(stateId: string, state: State, flow: Record<string, State>): StateDigest {
+    const result: StateDigest = {
         id: stateId,
         name: state.$title,
         defaultOutput: {
@@ -132,33 +151,35 @@ export function minifyState(stateId: string, state: State, flow: Record<string,
         },
     }
 
-    if (state.root) result.root = true
+    // Derived from the id so the digest reads the same whether it is handed a
+    // full flow or a minified one, which no longer carries `root`.
+    if (state.root || stateId === ROOT_STATE_ID) 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)
+            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: { action?: ActionDigest; input?: InputDigest }) => 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: State['$conditionOutputs'][number]) => 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