@kuralle-agents/messaging 0.8.5 → 0.9.0

package/README.md

@@ -19,6 +19,7 @@ Provides the `PlatformClient` interface that every messaging vendor package impl
 - **`MessageDeduplicator`** — LRU cache that prevents duplicate webhook processing.
 - **`WindowTracker`** / **`WindowStore`** — tracks 24-hour messaging windows per thread; used by `createMessagingRouter` to detect expired windows.
 - **`OutboundPipeline`** + **`windowGuard`** — window-safe outbound path (see below).
+- **`createInputCoalescer`** + **`inboundCoalescing`** — optional per-thread burst coalescing before `runtime.run` (WhatsApp text-ins). Default **off**; see [Inbound coalescing](#inbound-coalescing).
 
 ### Window-safe outbound
 
@@ -27,6 +28,31 @@ Every outbound send — default `StreamMapper` text replies, custom `responseMap
 `createMessagingRouter` accepts optional `windowStore` (default `InMemoryWindowStore`) and `outbound` (extra middleware installed **before** `windowGuard`). Custom `responseMapper` closures still return `Promise<SendResult>`; deferred sends resolve to a synthetic result with an empty `messageId` (not delivered).
 
 `WhatsAppClient.sendTextOrTemplate` is **deprecated** — it bypasses this pipeline. Use `OutboundPipeline` / the router instead.
+
+### Inbound coalescing
+
+WhatsApp users often send bursts of short messages (`hi` / `i want to order` / `the blue one`). Without coalescing, each webhook becomes its own serialized turn. Enable burst merging on the router:
+
+```typescript
+const router = createMessagingRouter({
+  runtime,
+  platforms: { whatsapp },
+  inboundCoalescing: {
+    debounceMs: 3000,   // trailing debounce; 0 = off (pass-through)
+    maxWaitMs: 10_000,  // hard cap from first buffered message
+    maxMessages: 10,    // flush when buffer is full
+  },
+});
+```
+
+Defaults when `inboundCoalescing` is set: `debounceMs` **3000**, `maxWaitMs` **10000**, `maxMessages` **10**. Interactive selections (button/list taps) flush immediately — they are complete by construction. Each flushed batch becomes **one** `runtime.run` with a merged `UserInputContent` parts array in arrival order (image-then-caption → `[FilePart, TextPart]`).
+
+Omit `inboundCoalescing` entirely for today's behavior (one message → one turn).
+
+**Durable Objects:** v1 keeps the coalescer buffer in-memory on the router instance. In a DO deployment the DO *is* the thread, so the timer lives with the conversation. Process eviction can lose at most one un-flushed buffer; upgrade to `storage.setAlarm` for eviction-proof debounce (not implemented in v1).
+
+Mid-turn messages queued while a turn is in flight are merged at admission in `@kuralle-agents/core` (`consumeAllPendingUserInput`) — pair both layers for burst UX on WhatsApp.
+
 - Error classes: `MessagingError`, `RateLimitError` (with `retryAfterMs`), `WindowClosedError` (with `suggestedTemplates`), `AuthenticationError`, `PermissionError`, `RecipientError`, `TemplateError`, `MediaError`, `WebhookVerificationError`.
 
 ## Usage

package/dist/adapter/createMessagingRouter.js

@@ -1,9 +1,11 @@
 import { Hono } from 'hono';
+import { mergeUserInputContents } from '@kuralle-agents/core';
 import { MessageDeduplicator } from '../shared/deduplicator.js';
 import { InMemoryWindowStore } from './window-store.js';
 import { defaultSessionResolver } from './session-resolver.js';
 import { InboundResolverChain, defaultInboundChain, } from './input-resolver-chain.js';
 import { attachInboundMedia } from './inbound-media.js';
+import { createInputCoalescer } from './input-coalescer.js';
 import { StreamMapper } from './stream-mapper.js';
 import { OutboundPipeline } from './outbound-pipeline.js';
 import { windowGuard } from './middleware/window-guard.js';
@@ -86,6 +88,16 @@ export function createMessagingRouter(config) {
         : defaultInboundChain();
     const streamMapper = new StreamMapper();
     const fallbackMessage = config.fallbackMessage ?? "Sorry, I'm having trouble right now. Please try again.";
+    const coalescing = config.inboundCoalescing;
+    const coalescer = coalescing
+        ? createInputCoalescer({
+            debounceMs: coalescing.debounceMs,
+            maxWaitMs: coalescing.maxWaitMs,
+            maxMessages: coalescing.maxMessages,
+            timer: coalescing.timer,
+            flushImmediately: coalescing.flushImmediately ?? ((item) => item.selection !== undefined),
+        })
+        : undefined;
     for (const [name, platform] of Object.entries(config.platforms)) {
         const pipeline = new OutboundPipeline(buildOutboundChain(config.outbound), platform);
         platform.onMessage(async (message) => {
@@ -105,44 +117,63 @@ export function createMessagingRouter(config) {
             // Multimodal intake: download any inbound media and attach it as AI SDK file
             // parts so photos / voice notes / documents reach the model (REQ multimodal).
             const input = await attachInboundMedia(message, resolvedInput, platform);
-            try {
-                const handle = config.runtime.run({
-                    input,
-                    sessionId,
-                    userId,
-                    selection,
-                });
-                const parts = await streamMapper.mapStream(handle.events, platform, message.threadId, {
-                    responseMapper: config.responseMapper,
-                    pipeline,
-                    windowStore,
-                    sessionId,
-                    userId,
-                });
-                if (config.ownership &&
-                    parts.some((p) => p.type === 'handoff' && p.targetAgent === 'human')) {
-                    await config.ownership.claim(message.threadId, 'human');
-                }
-            }
-            catch (error) {
+            const runInbound = async (items) => {
+                const mergedInput = mergeUserInputContents(items.map((i) => i.input)) ?? '';
+                const last = items[items.length - 1];
+                const { sessionId, userId } = last;
                 try {
-                    const window = await windowStore.get(message.threadId);
-                    await pipeline.send({
-                        threadId: message.threadId,
-                        platform: name,
-                        payload: { kind: 'text', text: fallbackMessage },
-                        meta: { window, parts: [], sessionId, userId },
+                    const handle = config.runtime.run({
+                        input: mergedInput,
+                        sessionId,
+                        userId,
+                        selection: last.selection,
                     });
+                    const parts = await streamMapper.mapStream(handle.events, platform, message.threadId, {
+                        responseMapper: config.responseMapper,
+                        pipeline,
+                        windowStore,
+                        sessionId,
+                        userId,
+                    });
+                    if (config.ownership &&
+                        parts.some((p) => p.type === 'handoff' && p.targetAgent === 'human')) {
+                        await config.ownership.claim(message.threadId, 'human');
+                    }
                 }
-                catch {
-                    // Cannot even send fallback — nothing more we can do
+                catch (error) {
+                    try {
+                        const window = await windowStore.get(message.threadId);
+                        await pipeline.send({
+                            threadId: message.threadId,
+                            platform: name,
+                            payload: { kind: 'text', text: fallbackMessage },
+                            meta: { window, parts: [], sessionId, userId },
+                        });
+                    }
+                    catch {
+                        // Cannot even send fallback — nothing more we can do
+                    }
+                    const errorContext = {
+                        message: last.message,
+                        platform: name,
+                        error: error,
+                    };
+                    config.onError?.(error, errorContext);
                 }
-                const errorContext = {
-                    message,
-                    platform: name,
-                    error: error,
-                };
-                config.onError?.(error, errorContext);
+            };
+            const item = {
+                input,
+                selection,
+                sessionId,
+                userId,
+                message,
+                platform: name,
+            };
+            if (coalescer) {
+                coalescer.push(message.threadId, item, runInbound);
+            }
+            else {
+                await runInbound([item]);
             }
         });
         platform.onStatus(async (status) => {

package/dist/adapter/input-coalescer.d.ts

@@ -0,0 +1,14 @@
+import type { InjectableTimer } from '@kuralle-agents/core';
+export type InputCoalescerTimer = InjectableTimer;
+export interface InputCoalescerOptions<T> {
+    debounceMs?: number;
+    maxWaitMs?: number;
+    maxMessages?: number;
+    flushImmediately?: (item: T) => boolean;
+    timer?: InputCoalescerTimer;
+}
+export interface InputCoalescer<T> {
+    push(threadId: string, item: T, deliver: (items: T[]) => void | Promise<void>): void;
+    flush(threadId: string): void;
+}
+export declare function createInputCoalescer<T>(opts?: InputCoalescerOptions<T>): InputCoalescer<T>;

package/dist/adapter/input-coalescer.js

@@ -0,0 +1,86 @@
+const defaultTimer = {
+    set: (fn, ms) => setTimeout(fn, ms),
+    clear: (handle) => clearTimeout(handle),
+};
+export function createInputCoalescer(opts = {}) {
+    const debounceMs = opts.debounceMs ?? 3000;
+    const maxWaitMs = opts.maxWaitMs ?? 10000;
+    const maxMessages = opts.maxMessages ?? 10;
+    const flushImmediately = opts.flushImmediately ?? (() => false);
+    const timer = opts.timer ?? defaultTimer;
+    const buffers = new Map();
+    function clearTimers(buf) {
+        if (buf.debounceHandle != null)
+            timer.clear(buf.debounceHandle);
+        if (buf.maxWaitHandle != null)
+            timer.clear(buf.maxWaitHandle);
+        buf.debounceHandle = undefined;
+        buf.maxWaitHandle = undefined;
+    }
+    // Delivery runs a full agent turn — invoke synchronously (tests and router
+    // ordering rely on it) but never let a sync throw or async rejection escape.
+    function safeDeliver(deliver, items) {
+        try {
+            const result = deliver(items);
+            if (result && typeof result.catch === 'function') {
+                void result.catch((error) => {
+                    console.warn('[Kuralle] coalesced inbound delivery failed:', error);
+                });
+            }
+        }
+        catch (error) {
+            console.warn('[Kuralle] coalesced inbound delivery failed:', error);
+        }
+    }
+    function invokeDeliver(buf) {
+        safeDeliver(buf.deliver, buf.items);
+    }
+    function flush(threadId) {
+        const buf = buffers.get(threadId);
+        if (!buf || buf.items.length === 0)
+            return;
+        clearTimers(buf);
+        buffers.delete(threadId);
+        invokeDeliver(buf);
+    }
+    function push(threadId, item, deliver) {
+        if (debounceMs === 0) {
+            safeDeliver(deliver, [item]);
+            return;
+        }
+        if (flushImmediately(item)) {
+            const buf = buffers.get(threadId);
+            const batch = buf ? [...buf.items, item] : [item];
+            if (buf) {
+                clearTimers(buf);
+                buffers.delete(threadId);
+            }
+            safeDeliver(deliver, batch);
+            return;
+        }
+        let buf = buffers.get(threadId);
+        if (!buf) {
+            buf = {
+                items: [],
+                firstAt: Date.now(),
+                debounceHandle: undefined,
+                maxWaitHandle: undefined,
+                deliver,
+            };
+            buffers.set(threadId, buf);
+            buf.maxWaitHandle = timer.set(() => flush(threadId), maxWaitMs);
+        }
+        else {
+            buf.deliver = deliver;
+        }
+        buf.items.push(item);
+        if (buf.items.length >= maxMessages) {
+            flush(threadId);
+            return;
+        }
+        if (buf.debounceHandle != null)
+            timer.clear(buf.debounceHandle);
+        buf.debounceHandle = timer.set(() => flush(threadId), debounceMs);
+    }
+    return { push, flush };
+}

package/dist/adapter/render-choices.d.ts

@@ -0,0 +1,20 @@
+import type { ChoiceOption } from '@kuralle-agents/core';
+import type { InteractiveMessage } from '../types/messages.js';
+/** WhatsApp reply-button title limit (R-11). */
+export declare const BUTTON_TITLE_MAX = 20;
+/** WhatsApp list row title limit (R-11). */
+export declare const LIST_ROW_TITLE_MAX = 24;
+/** WhatsApp reply buttons per message. */
+export declare const BUTTON_COUNT_MAX = 3;
+/** WhatsApp list rows per message. */
+export declare const LIST_ROW_COUNT_MAX = 10;
+/**
+ * Renders author choices to a channel-neutral `InteractiveMessage`, enforcing
+ * WhatsApp limits (R-11). URL options map to a single-button reply shape because
+ * `InteractiveMessage` has no dedicated CTA variant — the sink must interpret
+ * `ChoiceOption.url` when sending platform CTA messages.
+ *
+ * Lives in `@kuralle-agents/messaging` (single source); `@kuralle-agents/engagement`
+ * re-exports it.
+ */
+export declare function renderChoices(options: ChoiceOption[], prompt: string): InteractiveMessage;

package/dist/adapter/render-choices.js

@@ -0,0 +1,105 @@
+/** WhatsApp reply-button title limit (R-11). */
+export const BUTTON_TITLE_MAX = 20;
+/** WhatsApp list row title limit (R-11). */
+export const LIST_ROW_TITLE_MAX = 24;
+/** WhatsApp reply buttons per message. */
+export const BUTTON_COUNT_MAX = 3;
+/** WhatsApp list rows per message. */
+export const LIST_ROW_COUNT_MAX = 10;
+function assertButtonTitle(label, optionId) {
+    if (label.length > BUTTON_TITLE_MAX) {
+        throw new Error(`interactive: button title for "${optionId}" exceeds ${BUTTON_TITLE_MAX} characters (got ${label.length})`);
+    }
+}
+function assertListRowTitle(label, optionId) {
+    if (label.length > LIST_ROW_TITLE_MAX) {
+        throw new Error(`interactive: list row title for "${optionId}" exceeds ${LIST_ROW_TITLE_MAX} characters (got ${label.length})`);
+    }
+}
+/**
+ * Renders author choices to a channel-neutral `InteractiveMessage`, enforcing
+ * WhatsApp limits (R-11). URL options map to a single-button reply shape because
+ * `InteractiveMessage` has no dedicated CTA variant — the sink must interpret
+ * `ChoiceOption.url` when sending platform CTA messages.
+ *
+ * Lives in `@kuralle-agents/messaging` (single source); `@kuralle-agents/engagement`
+ * re-exports it.
+ */
+export function renderChoices(options, prompt) {
+    if (options.length === 0) {
+        throw new Error('interactive: at least one option is required');
+    }
+    const flowOption = options.find((o) => o.flow);
+    if (flowOption) {
+        if (options.length > 1) {
+            throw new Error('interactive: flow messages support exactly one option');
+        }
+        const { flowId } = flowOption.flow;
+        if (!flowOption.flow.cta) {
+            throw new Error('interactive: flow option requires flow.cta');
+        }
+        return {
+            type: 'flow',
+            body: prompt,
+            action: {
+                type: 'flow',
+                flowId,
+                flowToken: flowOption.id,
+            },
+        };
+    }
+    if (options.some((o) => o.url)) {
+        const urlOptions = options.filter((o) => o.url);
+        if (urlOptions.length > BUTTON_COUNT_MAX) {
+            throw new Error(`interactive: too many URL options (max ${BUTTON_COUNT_MAX} reply buttons)`);
+        }
+        for (const o of urlOptions) {
+            assertButtonTitle(o.label, o.id);
+        }
+        return {
+            type: 'buttons',
+            body: prompt,
+            action: {
+                type: 'buttons',
+                buttons: urlOptions.map((o) => ({ id: o.id, title: o.label })),
+            },
+        };
+    }
+    if (options.length > LIST_ROW_COUNT_MAX) {
+        throw new Error(`interactive: too many options (max ${LIST_ROW_COUNT_MAX} list rows)`);
+    }
+    if (options.length <= BUTTON_COUNT_MAX) {
+        for (const o of options) {
+            assertButtonTitle(o.label, o.id);
+        }
+        return {
+            type: 'buttons',
+            body: prompt,
+            action: {
+                type: 'buttons',
+                buttons: options.map((o) => ({ id: o.id, title: o.label })),
+            },
+        };
+    }
+    for (const o of options) {
+        assertListRowTitle(o.label, o.id);
+    }
+    return {
+        type: 'list',
+        body: prompt,
+        action: {
+            type: 'list',
+            button: 'Choose',
+            sections: [
+                {
+                    title: 'Options',
+                    rows: options.map((o) => ({
+                        id: o.id,
+                        title: o.label,
+                        description: o.description,
+                    })),
+                },
+            ],
+        },
+    };
+}

package/dist/adapter/stream-mapper.js

@@ -1,3 +1,4 @@
+import { renderChoices } from './render-choices.js';
 /** Default interval for sending typing indicators during streaming (ms). */
 const DEFAULT_TYPING_INTERVAL_MS = 5_000;
 function outcomeToSendResult(threadId, outcome) {
@@ -48,7 +49,7 @@ export class StreamMapper {
                 });
             }
             else {
-                await this.defaultMapResponse(options.pipeline, platform, threadId, textBuffer, meta);
+                await this.defaultMapResponse(options.pipeline, platform, threadId, textBuffer, meta, parts);
             }
         }
         finally {
@@ -76,7 +77,34 @@ export class StreamMapper {
         }
         return outcomeToSendResult(threadId, outcome);
     }
-    async defaultMapResponse(pipeline, platform, threadId, text, meta) {
+    async defaultMapResponse(pipeline, platform, threadId, text, meta, parts) {
+        // A turn that ends with an `interactive` part (flow choices) renders as a
+        // native interactive message; its prompt IS the user-facing question, so
+        // accumulated text is sent first only when it adds something beyond it.
+        const interactivePart = [...parts]
+            .reverse()
+            .find((part) => part.type === 'interactive');
+        if (interactivePart) {
+            const trimmed = text.trim();
+            if (trimmed.length > 0 && trimmed !== interactivePart.prompt.trim()) {
+                await pipeline.send({
+                    threadId,
+                    platform: platform.platform,
+                    payload: { kind: 'text', text: platform.formatConverter.toPlatformFormat(trimmed) },
+                    meta,
+                });
+            }
+            await pipeline.send({
+                threadId,
+                platform: platform.platform,
+                payload: {
+                    kind: 'interactive',
+                    interactive: renderChoices(interactivePart.options, interactivePart.prompt),
+                },
+                meta,
+            });
+            return;
+        }
         if (text.trim().length === 0)
             return;
         const formatted = platform.formatConverter.toPlatformFormat(text);

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-export type { PlatformClient, InboundMessage, StatusUpdate, SendResult, MediaPayload, MediaHandle, MediaDownload, MediaUploadOptions, MediaReference, InteractiveMessage, InteractiveAction, InteractiveReply, ContactInfo, LocationData, ReactionData, MessageContext, ConversationInfo, PricingInfo, StatusError, FormatConverter, MessageHandler, StatusHandler, ReactionHandler, MessagingRouterConfig, SessionResolver, ResponseMapper, ResponseContext, ErrorContext, StreamMapperOptions, HealthCheckResult, } from './types.js';
+export type { PlatformClient, InboundMessage, StatusUpdate, SendResult, MediaPayload, MediaHandle, MediaDownload, MediaUploadOptions, MediaReference, InteractiveMessage, InteractiveAction, InteractiveReply, ContactInfo, LocationData, ReactionData, MessageContext, ConversationInfo, PricingInfo, StatusError, FormatConverter, MessageHandler, StatusHandler, ReactionHandler, MessagingRouterConfig, InboundCoalescingConfig, CoalescedInboundItem, SessionResolver, ResponseMapper, ResponseContext, ErrorContext, StreamMapperOptions, HealthCheckResult, } from './types.js';
 export { MessagingError, RateLimitError, WindowClosedError, AuthenticationError, PermissionError, RecipientError, TemplateError, MediaError, WebhookVerificationError, } from './errors.js';
 export { createMessagingRouter } from './adapter/createMessagingRouter.js';
+export { createInputCoalescer } from './adapter/input-coalescer.js';
+export type { InputCoalescer, InputCoalescerOptions } from './adapter/input-coalescer.js';
 export { defaultSessionResolver } from './adapter/session-resolver.js';
 export { SessionResolverChain, ThreadIdResolver, PhoneLookupResolver, } from './adapter/session-resolver-chain.js';
 export type { SessionResolverPlugin } from './adapter/session-resolver-chain.js';
@@ -28,3 +30,4 @@ export { OutboundPipeline } from './adapter/outbound-pipeline.js';
 export { windowGuard } from './adapter/middleware/window-guard.js';
 export type { OutboundSink, OutboundTemplate, OutboundTemplateComponent, OutboundMiddleware, OutboundNext, OutboundRequest, OutboundPayload, OutboundMeta, SendOutcome, DeferReason, } from './types/outbound.js';
 export { isTemplateCapable, isTagCapable } from './types/outbound.js';
+export { renderChoices, BUTTON_TITLE_MAX, LIST_ROW_TITLE_MAX, BUTTON_COUNT_MAX, LIST_ROW_COUNT_MAX, } from './adapter/render-choices.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export { MessagingError, RateLimitError, WindowClosedError, AuthenticationError,
 // Adapter
 // ====================================
 export { createMessagingRouter } from './adapter/createMessagingRouter.js';
+export { createInputCoalescer } from './adapter/input-coalescer.js';
 export { defaultSessionResolver } from './adapter/session-resolver.js';
 export { SessionResolverChain, ThreadIdResolver, PhoneLookupResolver, } from './adapter/session-resolver-chain.js';
 export { InboundResolverChain, InteractiveResolver, TextResolver, defaultInboundChain, } from './adapter/input-resolver-chain.js';
@@ -32,3 +33,4 @@ export { filterStreamParts } from './stream-filter.js';
 export { OutboundPipeline } from './adapter/outbound-pipeline.js';
 export { windowGuard } from './adapter/middleware/window-guard.js';
 export { isTemplateCapable, isTagCapable } from './types/outbound.js';
+export { renderChoices, BUTTON_TITLE_MAX, LIST_ROW_TITLE_MAX, BUTTON_COUNT_MAX, LIST_ROW_COUNT_MAX, } from './adapter/render-choices.js';

package/dist/types/adapter.d.ts

@@ -4,7 +4,7 @@
  * Adapter types: session resolution, response mapping, error context,
  * router config, and stream mapper options.
  */
-import type { RuntimeLike, HarnessStreamPart } from '@kuralle-agents/core';
+import type { RuntimeLike, HarnessStreamPart, ResolvedSelection, UserInputContent, InjectableTimer } from '@kuralle-agents/core';
 import type { OutboundPipeline } from '../adapter/outbound-pipeline.js';
 import type { WindowStore } from '../adapter/window-store.js';
 import type { ConsentStore } from '../adapter/consent-store.js';
@@ -65,6 +65,33 @@ export interface MessagingRouterConfig {
     ownership?: OwnershipStore;
     /** When set, STOP inbound opts the customer out; outbound uses `consentGate` (REQ-11). */
     consent?: ConsentStore;
+    /**
+     * Per-thread inbound debounce/coalesce before `runtime.run`. Default off (each
+     * message is its own turn). See README for `debounceMs`, `maxWaitMs`, DO note.
+     */
+    inboundCoalescing?: InboundCoalescingConfig;
+}
+/** Sliding debounce + max-wait cap for burst WhatsApp text-ins. */
+export interface InboundCoalescingConfig {
+    /** Trailing debounce in ms; `0` disables coalescing (pass-through). Default 3000. */
+    debounceMs?: number;
+    /** Hard cap from first buffered message (ms). Default 10000. */
+    maxWaitMs?: number;
+    /** Flush when buffer reaches this count. Default 10. */
+    maxMessages?: number;
+    /** Immediate flush predicate; default: any resolved interactive selection. */
+    flushImmediately?: (item: CoalescedInboundItem) => boolean;
+    /** Injectable timer for deterministic tests. */
+    timer?: InjectableTimer;
+}
+/** One resolved inbound waiting in the coalescer or about to run. */
+export interface CoalescedInboundItem {
+    input: UserInputContent;
+    selection?: ResolvedSelection;
+    sessionId: string;
+    userId?: string;
+    message: InboundMessage;
+    platform: string;
 }
 /** Options for the stream mapper. */
 export interface StreamMapperOptions {

package/dist/types.d.ts

@@ -7,4 +7,4 @@
 export type { ContactInfo, LocationData, MediaPayload, MediaReference, MediaHandle, MediaDownload, MediaUploadOptions, InteractiveMessage, InteractiveAction, InteractiveReply, ReactionData, MessageContext, ConversationInfo, PricingInfo, StatusError, InboundMessage, StatusUpdate, } from './types/messages.js';
 export type { SendResult, FormatConverter } from './types/responses.js';
 export type { MessageHandler, StatusHandler, ReactionHandler, PlatformClient, HealthCheckResult, } from './types/client.js';
-export type { SessionResolver, ResponseContext, ResponseMapper, ErrorContext, MessagingRouterConfig, StreamMapperOptions, } from './types/adapter.js';
+export type { SessionResolver, ResponseContext, ResponseMapper, ErrorContext, MessagingRouterConfig, InboundCoalescingConfig, CoalescedInboundItem, StreamMapperOptions, } from './types/adapter.js';

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/kuralle/kuralle-agents.git",
     "directory": "packages/kuralle-messaging"
   },
-  "version": "0.8.5",
+  "version": "0.9.0",
   "description": "Core interfaces and Kuralle adapter for messaging platforms",
   "type": "module",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
   ],
   "dependencies": {
     "hono": "^4.7.4",
-    "@kuralle-agents/core": "0.8.5"
+    "@kuralle-agents/core": "0.9.0"
   },
   "devDependencies": {
     "typescript": "^5.8.2",