@kuralle-agents/messaging 0.2.0 → 0.3.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -17,7 +17,16 @@ Provides the `PlatformClient` interface that every messaging vendor package impl
 - **`SessionResolver`** — maps inbound messages to Kuralle session IDs. Default: `{platform}:{threadId}`. Swap in `ThreadIdResolver`, `PhoneLookupResolver`, or a custom `SessionResolverChain`.
 - **`StreamMapper`** — consumes `AsyncIterable<HarnessStreamPart>`, sends typing indicators during streaming, delegates final output to a `ResponseMapper`.
 - **`MessageDeduplicator`** — LRU cache that prevents duplicate webhook processing.
-- **`WindowTracker`** — tracks 24-hour messaging windows per thread; used by `createMessagingRouter` to detect expired windows.
+- **`WindowTracker`** / **`WindowStore`** — tracks 24-hour messaging windows per thread; used by `createMessagingRouter` to detect expired windows.
+- **`OutboundPipeline`** + **`windowGuard`** — window-safe outbound path (see below).
+
+### Window-safe outbound
+
+Every outbound send — default `StreamMapper` text replies, custom `responseMapper` (`ResponseContext.sendText` / `sendInteractive` / `sendMedia`), and router `fallbackMessage` on runtime errors — traverses an `OutboundPipeline` with a non-removable, terminal `windowGuard` middleware. The driver reads `WindowStore.get(threadId)` once per send and sets `req.meta.window`; when the window is closed, free-form payloads (text, media, interactive) **defer** (`{ kind: 'deferred', reason: 'window-closed' }`) with zero client calls. Templates are window-agnostic and pass through.
+
+`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.
 - Error classes: `MessagingError`, `RateLimitError` (with `retryAfterMs`), `WindowClosedError` (with `suggestedTemplates`), `AuthenticationError`, `PermissionError`, `RecipientError`, `TemplateError`, `MediaError`, `WebhookVerificationError`.
 
 ## Usage

package/dist/adapter/consent-store.d.ts

@@ -0,0 +1,6 @@
+/** Customer consent for outbound messaging (RFC §4.7 / REQ-11, REQ-19). */
+export interface ConsentStore {
+    isOptedIn(customerId: string): Promise<boolean>;
+    optOut(customerId: string): Promise<void>;
+    optIn(customerId: string): Promise<void>;
+}

package/dist/adapter/consent-store.js

@@ -0,0 +1 @@
+export {};

package/dist/adapter/createMessagingRouter.d.ts

@@ -12,7 +12,7 @@ import type { MessagingRouterConfig } from '../types.js';
  *    and dispatches to the registered message handler
  * 2. The handler deduplicates the message, tracks the conversation window,
  *    resolves the session, and streams the runtime response
- * 3. The stream mapper sends the response back through the platform client
+ * 3. The stream mapper sends the response back through the outbound pipeline
  *
  * @param config - Router configuration with runtime, platforms, and optional customizations.
  * @returns A Hono app with webhook routes mounted for each platform.

package/dist/adapter/createMessagingRouter.js

@@ -1,8 +1,47 @@
 import { Hono } from 'hono';
 import { MessageDeduplicator } from '../shared/deduplicator.js';
-import { WindowTracker } from './window-tracker.js';
+import { InMemoryWindowStore } from './window-store.js';
 import { defaultSessionResolver } from './session-resolver.js';
+import { InboundResolverChain, defaultInboundChain, } from './input-resolver-chain.js';
 import { StreamMapper } from './stream-mapper.js';
+import { OutboundPipeline } from './outbound-pipeline.js';
+import { windowGuard } from './middleware/window-guard.js';
+function buildOutboundChain(extra) {
+    return [...(extra ?? []), windowGuard];
+}
+function emptySession(sessionId, userId) {
+    const now = new Date();
+    return {
+        id: sessionId,
+        conversationId: sessionId,
+        channelId: 'api',
+        userId,
+        createdAt: now,
+        updatedAt: now,
+        messages: [],
+        workingMemory: {},
+        currentAgent: 'main',
+        agentStates: {},
+        handoffHistory: [],
+        metadata: {
+            createdAt: now,
+            lastActiveAt: now,
+            totalTokens: 0,
+            totalSteps: 0,
+            handoffHistory: [],
+        },
+    };
+}
+async function recordInboundToHistory(config, sessionId, message, userId) {
+    const store = config.runtime.getSessionStore();
+    let session = await store.get(sessionId);
+    if (!session) {
+        session = emptySession(sessionId, userId);
+    }
+    session.messages.push({ role: 'user', content: message.text ?? '' });
+    session.updatedAt = new Date();
+    await store.save(session);
+}
 /**
  * Create a Hono router that bridges messaging platform webhooks with the Kuralle runtime.
  *
@@ -15,7 +54,7 @@ import { StreamMapper } from './stream-mapper.js';
  *    and dispatches to the registered message handler
  * 2. The handler deduplicates the message, tracks the conversation window,
  *    resolves the session, and streams the runtime response
- * 3. The stream mapper sends the response back through the platform client
+ * 3. The stream mapper sends the response back through the outbound pipeline
  *
  * @param config - Router configuration with runtime, platforms, and optional customizations.
  * @returns A Hono app with webhook routes mounted for each platform.
@@ -39,40 +78,57 @@ import { StreamMapper } from './stream-mapper.js';
 export function createMessagingRouter(config) {
     const app = new Hono();
     const deduplicator = new MessageDeduplicator();
-    const windowTracker = new WindowTracker();
+    const windowStore = config.windowStore ?? new InMemoryWindowStore();
     const sessionResolver = config.sessionResolver ?? defaultSessionResolver;
+    const inboundChain = config.inputResolver
+        ? new InboundResolverChain(config.inputResolver)
+        : defaultInboundChain();
     const streamMapper = new StreamMapper();
     const fallbackMessage = config.fallbackMessage ?? "Sorry, I'm having trouble right now. Please try again.";
     for (const [name, platform] of Object.entries(config.platforms)) {
-        // -------------------------------------------------------
-        // Register message handler
-        // -------------------------------------------------------
+        const pipeline = new OutboundPipeline(buildOutboundChain(config.outbound), platform);
         platform.onMessage(async (message) => {
-            // Deduplicate — webhooks can be retried by the platform
             if (deduplicator.isDuplicate(message.id))
                 return;
-            // Track the messaging window
-            windowTracker.recordInbound(message.threadId, message.timestamp);
-            // Resolve Kuralle session
+            await windowStore.recordInbound(message.threadId, message.timestamp);
+            if (config.consent && message.text?.trim().toUpperCase() === 'STOP') {
+                await config.consent.optOut(message.customerId);
+                return;
+            }
             const { sessionId, userId } = await sessionResolver.resolve(message);
-            // Extract text input — fall back to a type indicator for non-text messages
-            const input = message.text ?? `[${message.type}]`;
+            if (config.ownership && (await config.ownership.owner(message.threadId)) === 'human') {
+                await recordInboundToHistory(config, sessionId, message, userId);
+                return;
+            }
+            const { input, selection } = await inboundChain.resolve(message);
             try {
-                // Stream from the Kuralle runtime
                 const handle = config.runtime.run({
                     input,
                     sessionId,
                     userId,
+                    selection,
                 });
-                // Map the stream output to platform messages
-                await streamMapper.mapStream(handle.events, platform, message.threadId, {
+                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) {
-                // Attempt to send a fallback message
                 try {
-                    await platform.sendText(message.threadId, fallbackMessage);
+                    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
@@ -85,35 +141,19 @@ export function createMessagingRouter(config) {
                 config.onError?.(error, errorContext);
             }
         });
-        // -------------------------------------------------------
-        // Register status handler
-        // -------------------------------------------------------
         platform.onStatus(async (status) => {
-            // Track window expiry from platform-reported conversation info.
-            // Use status.threadId (set by platform clients in the same format as
-            // inbound messages) so the window tracker key matches recordInbound().
             if (status.conversation?.expirationTimestamp && status.threadId) {
-                windowTracker.recordExpiry(status.threadId, status.conversation.expirationTimestamp);
+                await windowStore.recordExpiry(status.threadId, status.conversation.expirationTimestamp);
             }
-            // Forward to user-provided status handler
             config.onStatus?.(status);
         });
-        // -------------------------------------------------------
-        // Mount webhook routes
-        // -------------------------------------------------------
-        // GET — webhook verification (e.g. Meta's hub.verify_token challenge)
         app.get(`/${name}/webhook`, async (c) => {
             return platform.handleWebhook(c.req.raw);
         });
-        // POST — incoming events (messages, statuses, reactions)
         app.post(`/${name}/webhook`, async (c) => {
             return platform.handleWebhook(c.req.raw);
         });
     }
-    // -------------------------------------------------------
-    // /health — aggregated probe. Included when at least one
-    // platform client implements the optional healthCheck().
-    // -------------------------------------------------------
     const hasAnyProbe = Object.values(config.platforms).some((p) => typeof p.healthCheck === 'function');
     if (hasAnyProbe) {
         app.get('/health', async (c) => {

package/dist/adapter/input-resolver-chain.d.ts

@@ -0,0 +1,32 @@
+import type { ResolvedSelection } from '@kuralle-agents/core';
+import type { InboundMessage } from '../types/messages.js';
+export interface InboundResolverPlugin {
+    readonly name: string;
+    tryResolve(m: InboundMessage): Promise<{
+        input: string;
+        selection?: ResolvedSelection;
+    } | undefined>;
+}
+export declare class InteractiveResolver implements InboundResolverPlugin {
+    readonly name = "interactive";
+    tryResolve(m: InboundMessage): Promise<{
+        input: string;
+        selection?: ResolvedSelection;
+    } | undefined>;
+}
+export declare class TextResolver implements InboundResolverPlugin {
+    readonly name = "text";
+    tryResolve(m: InboundMessage): Promise<{
+        input: string;
+        selection?: ResolvedSelection;
+    }>;
+}
+export declare class InboundResolverChain {
+    private readonly plugins;
+    constructor(plugins: InboundResolverPlugin[]);
+    resolve(m: InboundMessage): Promise<{
+        input: string;
+        selection?: ResolvedSelection;
+    }>;
+}
+export declare function defaultInboundChain(): InboundResolverChain;

package/dist/adapter/input-resolver-chain.js

@@ -0,0 +1,45 @@
+export class InteractiveResolver {
+    name = 'interactive';
+    async tryResolve(m) {
+        const interactiveId = m.interactive?.id;
+        if (interactiveId) {
+            return { input: interactiveId, selection: { id: interactiveId } };
+        }
+        if (m.button?.payload) {
+            return { input: m.button.payload, selection: { id: m.button.payload } };
+        }
+        if (m.interactive?.formResponse) {
+            return {
+                input: '__flow__',
+                selection: { formData: m.interactive.formResponse },
+            };
+        }
+        return undefined;
+    }
+}
+export class TextResolver {
+    name = 'text';
+    async tryResolve(m) {
+        return { input: m.text ?? '', selection: undefined };
+    }
+}
+export class InboundResolverChain {
+    plugins;
+    constructor(plugins) {
+        this.plugins = plugins;
+        if (plugins.length === 0) {
+            throw new Error('InboundResolverChain requires at least one plugin');
+        }
+    }
+    async resolve(m) {
+        for (const plugin of this.plugins) {
+            const result = await plugin.tryResolve(m);
+            if (result !== undefined)
+                return result;
+        }
+        throw new Error('no inbound resolver matched');
+    }
+}
+export function defaultInboundChain() {
+    return new InboundResolverChain([new InteractiveResolver(), new TextResolver()]);
+}

package/dist/adapter/middleware/window-guard.d.ts

@@ -0,0 +1,4 @@
+import type { OutboundMiddleware } from '../../types/outbound.js';
+/** Non-removable, terminal middleware: blocks free-form payloads outside the window (REQ-1/REQ-16).
+ *  Templates are window-agnostic and pass. A closed window DEFERS (Sprint 2 adds template conversion). */
+export declare const windowGuard: OutboundMiddleware;

package/dist/adapter/middleware/window-guard.js

@@ -0,0 +1,14 @@
+/** Non-removable, terminal middleware: blocks free-form payloads outside the window (REQ-1/REQ-16).
+ *  Templates are window-agnostic and pass. A closed window DEFERS (Sprint 2 adds template conversion). */
+export const windowGuard = {
+    name: 'window-guard',
+    async send(req, next) {
+        if (req.payload.kind === 'template')
+            return next(req);
+        if (req.payload.kind === 'text' && req.payload.tag)
+            return next(req);
+        if (req.meta.window.open)
+            return next(req);
+        return { kind: 'deferred', reason: 'window-closed' };
+    },
+};

package/dist/adapter/outbound-pipeline.d.ts

@@ -0,0 +1,8 @@
+import type { OutboundMiddleware, OutboundRequest, OutboundSink, SendOutcome } from '../types/outbound.js';
+export declare class OutboundPipeline {
+    private readonly mw;
+    private readonly sink;
+    constructor(mw: OutboundMiddleware[], sink: OutboundSink);
+    send(req: OutboundRequest): Promise<SendOutcome>;
+    private terminal;
+}

package/dist/adapter/outbound-pipeline.js

@@ -0,0 +1,52 @@
+import { isTagCapable } from '../types/outbound.js';
+const WINDOW_GUARD = 'window-guard';
+export class OutboundPipeline {
+    mw;
+    sink;
+    constructor(mw, sink) {
+        this.mw = mw;
+        this.sink = sink;
+        const idx = mw.findIndex((m) => m.name === WINDOW_GUARD);
+        if (idx === -1) {
+            throw new Error('window-guard middleware is required (window safety)');
+        }
+        if (idx !== mw.length - 1) {
+            throw new Error('window-guard must be terminal (the last middleware before the sink)');
+        }
+    }
+    send(req) {
+        const run = (i, r) => i < this.mw.length
+            ? this.mw[i].send(r, (nr) => run(i + 1, nr))
+            : this.terminal(r);
+        return run(0, req);
+    }
+    async terminal(r) {
+        const { payload, threadId } = r;
+        switch (payload.kind) {
+            case 'text':
+                if (payload.tag && isTagCapable(this.sink)) {
+                    return {
+                        kind: 'sent',
+                        result: await this.sink.sendTextWithTag(threadId, payload.text, payload.tag),
+                    };
+                }
+                return { kind: 'sent', result: await this.sink.sendText(threadId, payload.text) };
+            case 'interactive':
+                return {
+                    kind: 'sent',
+                    result: await this.sink.sendInteractive(threadId, payload.interactive),
+                };
+            case 'media':
+                return { kind: 'sent', result: await this.sink.sendMedia(threadId, payload.media) };
+            case 'template': {
+                if (typeof this.sink.sendTemplate !== 'function') {
+                    throw new Error('sink has no template capability');
+                }
+                return {
+                    kind: 'sent',
+                    result: await this.sink.sendTemplate(threadId, payload.template),
+                };
+            }
+        }
+    }
+}

package/dist/adapter/ownership-store.d.ts

@@ -0,0 +1,7 @@
+/** Conversation ownership: bot vs human (RFC §4.7 / REQ-10). */
+export type ConversationOwner = 'bot' | 'human';
+export interface OwnershipStore {
+    owner(threadId: string): Promise<ConversationOwner>;
+    claim(threadId: string, by: string): Promise<void>;
+    release(threadId: string): Promise<void>;
+}

package/dist/adapter/ownership-store.js

@@ -0,0 +1 @@
+export {};

package/dist/adapter/redis-client.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Minimal Redis client surface for durable messaging stores.
+ * Satisfied by ioredis, node-redis, and @upstash/redis — pass the native client
+ * through a thin adapter that maps `set` to PX/NX when `opts` is provided.
+ */
+export interface RedisLikeClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, opts?: {
+        pxMs?: number;
+        nx?: boolean;
+    }): Promise<unknown>;
+    del(key: string): Promise<unknown>;
+}
+export declare function redisSetSucceeded(result: unknown): boolean;

package/dist/adapter/redis-client.js

@@ -0,0 +1,7 @@
+export function redisSetSucceeded(result) {
+    if (result == null)
+        return false;
+    if (result === 'OK' || result === true)
+        return true;
+    return false;
+}

package/dist/adapter/redis-window-store.d.ts

@@ -0,0 +1,5 @@
+import type { RedisLikeClient } from './redis-client.js';
+import type { WindowStore } from './window-store.js';
+export declare function createRedisWindowStore(client: RedisLikeClient, opts?: {
+    keyPrefix?: string;
+}): WindowStore;

package/dist/adapter/redis-window-store.js

@@ -0,0 +1,45 @@
+const DEFAULT_WINDOW_MS = 24 * 60 * 60 * 1000;
+function windowKey(prefix, threadId) {
+    return `${prefix}win:${threadId}`;
+}
+function parseExpiryMs(raw) {
+    const ms = Number(raw);
+    if (!Number.isFinite(ms))
+        return null;
+    return new Date(ms);
+}
+export function createRedisWindowStore(client, opts) {
+    const prefix = opts?.keyPrefix ?? '';
+    return {
+        async get(threadId) {
+            const raw = await client.get(windowKey(prefix, threadId));
+            if (raw === null)
+                return { open: false, expiresAt: null };
+            const expiresAt = parseExpiryMs(raw);
+            if (!expiresAt)
+                return { open: false, expiresAt: null };
+            const now = new Date();
+            return expiresAt > now
+                ? { open: true, expiresAt }
+                : { open: false, expiresAt };
+        },
+        async recordInbound(threadId, ts) {
+            const key = windowKey(prefix, threadId);
+            const candidate = new Date(ts.getTime() + DEFAULT_WINDOW_MS);
+            const raw = await client.get(key);
+            let expiry = candidate;
+            if (raw !== null) {
+                const existing = parseExpiryMs(raw);
+                if (existing && existing > expiry)
+                    expiry = existing;
+            }
+            const pxMs = Math.max(1, expiry.getTime() - Date.now());
+            await client.set(key, String(expiry.getTime()), { pxMs });
+        },
+        async recordExpiry(threadId, at) {
+            const key = windowKey(prefix, threadId);
+            const pxMs = Math.max(1, at.getTime() - Date.now());
+            await client.set(key, String(at.getTime()), { pxMs });
+        },
+    };
+}

package/dist/adapter/session-resolver.d.ts

@@ -2,11 +2,8 @@ import type { SessionResolver } from '../types.js';
 /**
  * Default session resolver that maps inbound messages to Kuralle sessions.
  *
- * Session ID format: `{platform}:{threadId}` — ensures uniqueness across
- * platforms even when thread IDs collide (e.g. phone numbers used as both
- * WhatsApp and SMS thread IDs).
- *
- * User ID is taken from the message sender's contact ID.
+ * `threadId` is already platform-scoped (e.g. `whatsapp:{phoneNumberId}:{from}`).
+ * User ID prefers {@link InboundMessage.customerId} over {@link ContactInfo.id}.
  */
 export declare const defaultSessionResolver: SessionResolver;
 export type { SessionResolver } from '../types.js';

package/dist/adapter/session-resolver.js

@@ -1,17 +1,14 @@
 /**
  * Default session resolver that maps inbound messages to Kuralle sessions.
  *
- * Session ID format: `{platform}:{threadId}` — ensures uniqueness across
- * platforms even when thread IDs collide (e.g. phone numbers used as both
- * WhatsApp and SMS thread IDs).
- *
- * User ID is taken from the message sender's contact ID.
+ * `threadId` is already platform-scoped (e.g. `whatsapp:{phoneNumberId}:{from}`).
+ * User ID prefers {@link InboundMessage.customerId} over {@link ContactInfo.id}.
  */
 export const defaultSessionResolver = {
     async resolve(message) {
         return {
-            sessionId: `${message.platform}:${message.threadId}`,
-            userId: message.from.id,
+            sessionId: message.threadId,
+            userId: message.customerId ?? message.from.id,
         };
     },
 };

package/dist/adapter/stream-mapper.d.ts

@@ -1,32 +1,8 @@
 import type { HarnessStreamPart } from '@kuralle-agents/core';
 import type { PlatformClient, StreamMapperOptions } from '../types.js';
-/**
- * Maps an Kuralle runtime stream to platform messages.
- *
- * The mapper:
- * 1. Starts a typing indicator interval on the platform
- * 2. Buffers all `text-delta` events into a complete response string
- * 3. Collects metadata events (suggested-questions, handoff, flow-end, done)
- * 4. When the stream completes, either delegates to a custom `ResponseMapper`
- *    or uses the default behavior:
- *    - Sends the accumulated text via `platform.sendText()`
- *    - If suggested questions exist, sends them as interactive buttons
- * 5. Clears the typing indicator
- * 6. Returns all collected stream parts
- */
 export declare class StreamMapper {
-    /**
-     * Consume an Kuralle runtime stream and send the response to a platform.
-     *
-     * @param stream - The async iterable from `runtime.stream()`.
-     * @param platform - The platform client to send messages through.
-     * @param threadId - The thread to send responses to.
-     * @param options - Optional configuration for response mapping and typing interval.
-     * @returns All collected stream parts for inspection or logging.
-     */
-    mapStream(stream: AsyncIterable<HarnessStreamPart>, platform: PlatformClient, threadId: string, options?: StreamMapperOptions): Promise<HarnessStreamPart[]>;
-    /**
-     * Default response mapping: send accumulated text and optional suggested questions.
-     */
+    mapStream(stream: AsyncIterable<HarnessStreamPart>, platform: PlatformClient, threadId: string, options: StreamMapperOptions): Promise<HarnessStreamPart[]>;
+    private buildMeta;
+    private sendFreeform;
     private defaultMapResponse;
 }

package/dist/adapter/stream-mapper.js

@@ -1,34 +1,16 @@
 /** Default interval for sending typing indicators during streaming (ms). */
 const DEFAULT_TYPING_INTERVAL_MS = 5_000;
-/**
- * Maps an Kuralle runtime stream to platform messages.
- *
- * The mapper:
- * 1. Starts a typing indicator interval on the platform
- * 2. Buffers all `text-delta` events into a complete response string
- * 3. Collects metadata events (suggested-questions, handoff, flow-end, done)
- * 4. When the stream completes, either delegates to a custom `ResponseMapper`
- *    or uses the default behavior:
- *    - Sends the accumulated text via `platform.sendText()`
- *    - If suggested questions exist, sends them as interactive buttons
- * 5. Clears the typing indicator
- * 6. Returns all collected stream parts
- */
+function outcomeToSendResult(threadId, outcome) {
+    if (outcome.kind === 'sent' || outcome.kind === 'converted') {
+        return outcome.result;
+    }
+    return { messageId: '', threadId, timestamp: new Date() };
+}
 export class StreamMapper {
-    /**
-     * Consume an Kuralle runtime stream and send the response to a platform.
-     *
-     * @param stream - The async iterable from `runtime.stream()`.
-     * @param platform - The platform client to send messages through.
-     * @param threadId - The thread to send responses to.
-     * @param options - Optional configuration for response mapping and typing interval.
-     * @returns All collected stream parts for inspection or logging.
-     */
     async mapStream(stream, platform, threadId, options) {
         const parts = [];
         let textBuffer = '';
-        const typingIntervalMs = options?.typingIntervalMs ?? DEFAULT_TYPING_INTERVAL_MS;
-        // Start typing indicator loop
+        const typingIntervalMs = options.typingIntervalMs ?? DEFAULT_TYPING_INTERVAL_MS;
         let typingActive = true;
         const typingInterval = setInterval(async () => {
             if (!typingActive)
@@ -37,10 +19,9 @@ export class StreamMapper {
                 await platform.sendTypingIndicator(threadId);
             }
             catch {
-                // Typing indicator failures are non-critical — silently ignore
+                // Non-critical
             }
         }, typingIntervalMs);
-        // Send an initial typing indicator immediately
         try {
             await platform.sendTypingIndicator(threadId);
         }
@@ -50,46 +31,66 @@ export class StreamMapper {
         try {
             for await (const part of stream) {
                 parts.push(part);
-                switch (part.type) {
-                    case 'text-delta':
-                        textBuffer += part.text;
-                        break;
-                    // All other event types are collected for the response mapper
-                    // but don't require special handling during streaming
+                if (part.type === 'text-delta') {
+                    textBuffer += part.text;
                 }
             }
-            // Stop typing indicator
             typingActive = false;
             clearInterval(typingInterval);
-            // Delegate to custom response mapper or use default behavior
-            if (options?.responseMapper) {
+            const meta = await this.buildMeta(options.windowStore, threadId, parts, options.sessionId, options.userId);
+            if (options.responseMapper) {
                 await options.responseMapper.mapResponse(parts, {
                     threadId,
                     platform: platform.platform,
-                    sendText: (text) => platform.sendText(threadId, text),
-                    sendInteractive: (msg) => platform.sendInteractive(threadId, msg),
-                    sendMedia: (media) => platform.sendMedia(threadId, media),
+                    sendText: (text) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'text', text }, meta),
+                    sendInteractive: (msg) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'interactive', interactive: msg }, meta),
+                    sendMedia: (media) => this.sendFreeform(options.pipeline, platform, threadId, { kind: 'media', media }, meta),
                 });
             }
             else {
-                await this.defaultMapResponse(platform, threadId, textBuffer, parts);
+                await this.defaultMapResponse(options.pipeline, platform, threadId, textBuffer, meta);
             }
         }
         finally {
-            // Ensure typing indicator is always cleaned up
             typingActive = false;
             clearInterval(typingInterval);
         }
         return parts;
     }
-    /**
-     * Default response mapping: send accumulated text and optional suggested questions.
-     */
-    async defaultMapResponse(platform, threadId, text, parts) {
-        // Send the accumulated text response
-        if (text.trim().length > 0) {
-            const formatted = platform.formatConverter.toPlatformFormat(text);
-            await platform.sendText(threadId, formatted);
+    async buildMeta(windowStore, threadId, parts, sessionId, userId) {
+        const window = await windowStore.get(threadId);
+        return { window, parts, sessionId, userId };
+    }
+    async sendFreeform(pipeline, platform, threadId, payload, meta) {
+        const outcome = await pipeline.send({
+            threadId,
+            platform: platform.platform,
+            payload,
+            meta,
+        });
+        if (outcome.kind === 'deferred' || outcome.kind === 'suppressed') {
+            return outcomeToSendResult(threadId, outcome);
+        }
+        if (outcome.kind === 'sent' || outcome.kind === 'converted') {
+            return outcome.result;
+        }
+        return outcomeToSendResult(threadId, outcome);
+    }
+    async defaultMapResponse(pipeline, platform, threadId, text, meta) {
+        if (text.trim().length === 0)
+            return;
+        const formatted = platform.formatConverter.toPlatformFormat(text);
+        const outcome = await pipeline.send({
+            threadId,
+            platform: platform.platform,
+            payload: { kind: 'text', text: formatted },
+            meta,
+        });
+        if (outcome.kind === 'sent' || outcome.kind === 'converted') {
+            return;
+        }
+        if (outcome.kind === 'deferred' || outcome.kind === 'suppressed') {
+            return;
         }
     }
 }

package/dist/adapter/window-store.d.ts

@@ -0,0 +1,23 @@
+import { WindowTracker } from './window-tracker.js';
+/** Window state value type (RFC §4.1/§4.9). */
+export type WindowState = {
+    open: true;
+    expiresAt: Date;
+} | {
+    open: false;
+    expiresAt: Date | null;
+};
+/** Pluggable messaging-window store (RFC §4.9 / REQ-18). Fail-closed on a miss. */
+export interface WindowStore {
+    get(threadId: string): Promise<WindowState>;
+    recordInbound(threadId: string, ts: Date): Promise<void>;
+    recordExpiry(threadId: string, at: Date): Promise<void>;
+}
+/** In-memory default; wraps WindowTracker. For single-process/dev (REQ-18 — durable adapter is backlog). */
+export declare class InMemoryWindowStore implements WindowStore {
+    private readonly tracker;
+    constructor(tracker?: WindowTracker);
+    get(threadId: string): Promise<WindowState>;
+    recordInbound(threadId: string, ts: Date): Promise<void>;
+    recordExpiry(threadId: string, at: Date): Promise<void>;
+}

package/dist/adapter/window-store.js

@@ -0,0 +1,22 @@
+import { WindowTracker } from './window-tracker.js';
+/** In-memory default; wraps WindowTracker. For single-process/dev (REQ-18 — durable adapter is backlog). */
+export class InMemoryWindowStore {
+    tracker;
+    constructor(tracker) {
+        this.tracker = tracker ?? new WindowTracker();
+    }
+    async get(threadId) {
+        const expiresAt = this.tracker.getExpiry(threadId);
+        if (!expiresAt)
+            return { open: false, expiresAt: null };
+        return expiresAt > new Date()
+            ? { open: true, expiresAt }
+            : { open: false, expiresAt };
+    }
+    async recordInbound(threadId, ts) {
+        this.tracker.recordInbound(threadId, ts);
+    }
+    async recordExpiry(threadId, at) {
+        this.tracker.recordExpiry(threadId, at);
+    }
+}

package/dist/index.d.ts

@@ -4,8 +4,17 @@ export { createMessagingRouter } from './adapter/createMessagingRouter.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';
+export { InboundResolverChain, InteractiveResolver, TextResolver, defaultInboundChain, } from './adapter/input-resolver-chain.js';
+export type { InboundResolverPlugin } from './adapter/input-resolver-chain.js';
 export { StreamMapper } from './adapter/stream-mapper.js';
 export { WindowTracker } from './adapter/window-tracker.js';
+export type { WindowStore, WindowState } from './adapter/window-store.js';
+export { InMemoryWindowStore } from './adapter/window-store.js';
+export type { RedisLikeClient } from './adapter/redis-client.js';
+export { redisSetSucceeded } from './adapter/redis-client.js';
+export { createRedisWindowStore } from './adapter/redis-window-store.js';
+export type { OwnershipStore, ConversationOwner } from './adapter/ownership-store.js';
+export type { ConsentStore } from './adapter/consent-store.js';
 export { MessageDeduplicator } from './shared/deduplicator.js';
 export { passthroughFormatter } from './shared/format-base.js';
 export type { MessageFormatter } from './shared/format-base.js';
@@ -14,3 +23,7 @@ export type { MediaCacheConfig, CachedMedia } from './shared/media-cache.js';
 export { HttpUrlStrategy, UploadStrategy, FileHashDedupStrategy, } from './shared/media-strategy.js';
 export type { MediaStrategy, ResolvedMedia, MediaUploader, UploadHandleStore, } from './shared/media-strategy.js';
 export { filterStreamParts } from './stream-filter.js';
+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';

package/dist/index.js

@@ -8,8 +8,12 @@ export { MessagingError, RateLimitError, WindowClosedError, AuthenticationError,
 export { createMessagingRouter } from './adapter/createMessagingRouter.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';
 export { StreamMapper } from './adapter/stream-mapper.js';
 export { WindowTracker } from './adapter/window-tracker.js';
+export { InMemoryWindowStore } from './adapter/window-store.js';
+export { redisSetSucceeded } from './adapter/redis-client.js';
+export { createRedisWindowStore } from './adapter/redis-window-store.js';
 // ====================================
 // Shared
 // ====================================
@@ -21,3 +25,9 @@ export { HttpUrlStrategy, UploadStrategy, FileHashDedupStrategy, } from './share
 // Stream filter
 // ====================================
 export { filterStreamParts } from './stream-filter.js';
+// ====================================
+// Outbound
+// ====================================
+export { OutboundPipeline } from './adapter/outbound-pipeline.js';
+export { windowGuard } from './adapter/middleware/window-guard.js';
+export { isTemplateCapable, isTagCapable } from './types/outbound.js';

package/dist/types/adapter.d.ts

@@ -5,6 +5,12 @@
  * router config, and stream mapper options.
  */
 import type { RuntimeLike, HarnessStreamPart } 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';
+import type { OwnershipStore } from '../adapter/ownership-store.js';
+import type { InboundResolverPlugin } from '../adapter/input-resolver-chain.js';
+import type { OutboundMiddleware } from './outbound.js';
 import type { InboundMessage, InteractiveMessage, MediaPayload } from './messages.js';
 import type { SendResult } from './responses.js';
 import type { PlatformClient, StatusHandler } from './client.js';
@@ -45,14 +51,28 @@ export interface MessagingRouterConfig {
     runtime: RuntimeLike;
     platforms: Record<string, PlatformClient>;
     sessionResolver?: SessionResolver;
+    /** Custom inbound input resolvers; defaults to `[InteractiveResolver, TextResolver]`. */
+    inputResolver?: InboundResolverPlugin[];
     responseMapper?: ResponseMapper;
     onStatus?: StatusHandler;
     onError?: (error: Error, context: ErrorContext) => void;
     fallbackMessage?: string;
+    /** Extra outbound middleware installed before the non-removable terminal `windowGuard`. */
+    outbound?: OutboundMiddleware[];
+    /** Pluggable window store; defaults to in-memory (fail-closed on miss). */
+    windowStore?: WindowStore;
+    /** When set, human-owned threads skip `runtime.run` on inbound (REQ-21). */
+    ownership?: OwnershipStore;
+    /** When set, STOP inbound opts the customer out; outbound uses `consentGate` (REQ-11). */
+    consent?: ConsentStore;
 }
 /** Options for the stream mapper. */
 export interface StreamMapperOptions {
     responseMapper?: ResponseMapper;
     /** Interval in ms for sending typing indicators during streaming. Default: 5000. */
     typingIntervalMs?: number;
+    pipeline: OutboundPipeline;
+    windowStore: WindowStore;
+    sessionId: string;
+    userId?: string;
 }

package/dist/types/messages.d.ts

@@ -125,6 +125,8 @@ export interface InteractiveReply {
     description?: string;
     /** Raw payload from the platform. */
     payload?: string;
+    /** Parsed Flow submission (`nfm_reply.response_json`). */
+    formResponse?: Record<string, unknown>;
 }
 /** A reaction event on a message. */
 export interface ReactionData {
@@ -177,6 +179,8 @@ export interface InboundMessage {
     platform: string;
     /** Conversation or thread identifier. */
     threadId: string;
+    /** Platform-scoped customer identity (e.g. WhatsApp wa_id), distinct from session/thread. */
+    customerId: string;
     /** Sender information. */
     from: ContactInfo;
     /** When the message was sent. */
@@ -193,6 +197,11 @@ export interface InboundMessage {
     contacts?: ContactInfo[];
     /** Interactive reply data (for interactive responses). */
     interactive?: InteractiveReply;
+    /** Template quick-reply tap (top-level `button`, not `interactive.button_reply`). */
+    button?: {
+        payload: string;
+        text: string;
+    };
     /** Reaction data (for reaction events). */
     reaction?: ReactionData;
     /** Reply context if this message is a reply. */

package/dist/types/outbound.d.ts

@@ -0,0 +1,83 @@
+import type { HarnessStreamPart } from '@kuralle-agents/core';
+import type { WindowState } from '../adapter/window-store.js';
+import type { InteractiveMessage, MediaPayload } from './messages.js';
+import type { SendResult } from './responses.js';
+import type { PlatformClient } from './client.js';
+/** Channel-neutral template component (R-10). Maps to the platform's native shape at the sink. */
+export interface OutboundTemplateComponent {
+    type: 'header' | 'body' | 'button';
+    /** Positional parameter values for this component. */
+    params?: string[];
+    /** Button sub-type (e.g. `quick_reply`, `url`). */
+    subType?: string;
+    /** Zero-based button index. */
+    index?: number;
+}
+/** A channel-neutral template payload (RFC §4.2). */
+export interface OutboundTemplate {
+    name: string;
+    language: string;
+    namedParams?: Record<string, string>;
+    positionalParams?: string[];
+    components?: OutboundTemplateComponent[];
+    raw?: unknown;
+}
+/** The channel-neutral send surface the OutboundPipeline terminates in (RFC §4.2). */
+export interface OutboundSink {
+    sendText(to: string, text: string): Promise<SendResult>;
+    sendTextWithTag?(to: string, text: string, tag: string): Promise<SendResult>;
+    sendInteractive(to: string, msg: InteractiveMessage): Promise<SendResult>;
+    sendMedia(to: string, media: MediaPayload): Promise<SendResult>;
+    sendTemplate?(to: string, t: OutboundTemplate): Promise<SendResult>;
+}
+/** Capability detection — true when the client can send templates (window-agnostic payload). */
+export declare function isTemplateCapable(c: PlatformClient): c is PlatformClient & Required<Pick<OutboundSink, 'sendTemplate'>>;
+/** Capability detection — true when the sink can send tagged text (RFC §4.12 message-tag). */
+export declare function isTagCapable(c: OutboundSink): c is OutboundSink & Required<Pick<OutboundSink, 'sendTextWithTag'>>;
+export type OutboundPayload = {
+    kind: 'text';
+    text: string;
+    tag?: string;
+} | {
+    kind: 'interactive';
+    interactive: InteractiveMessage;
+} | {
+    kind: 'media';
+    media: MediaPayload;
+} | {
+    kind: 'template';
+    template: OutboundTemplate;
+};
+export interface OutboundMeta {
+    window: WindowState;
+    parts: HarnessStreamPart[];
+    sessionId: string;
+    userId?: string;
+}
+export interface OutboundRequest {
+    threadId: string;
+    platform: string;
+    payload: OutboundPayload;
+    meta: OutboundMeta;
+}
+export type DeferReason = 'window-closed' | 'window-closed-no-recovery' | (string & {});
+export type SendOutcome = {
+    kind: 'sent';
+    result: SendResult;
+} | {
+    kind: 'converted';
+    result: SendResult;
+    template: string;
+    from: string;
+} | {
+    kind: 'deferred';
+    reason: DeferReason;
+} | {
+    kind: 'suppressed';
+    reason: string;
+};
+export type OutboundNext = (req: OutboundRequest) => Promise<SendOutcome>;
+export interface OutboundMiddleware {
+    readonly name: string;
+    send(req: OutboundRequest, next: OutboundNext): Promise<SendOutcome>;
+}

package/dist/types/outbound.js

@@ -0,0 +1,8 @@
+/** Capability detection — true when the client can send templates (window-agnostic payload). */
+export function isTemplateCapable(c) {
+    return typeof c.sendTemplate === 'function';
+}
+/** Capability detection — true when the sink can send tagged text (RFC §4.12 message-tag). */
+export function isTagCapable(c) {
+    return typeof c.sendTextWithTag === 'function';
+}

package/package.json

@@ -1,6 +1,12 @@
 {
   "name": "@kuralle-agents/messaging",
-  "version": "0.2.0",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kuralle/kuralle-agents.git",
+    "directory": "packages/kuralle-messaging"
+  },
+  "version": "0.3.1",
   "description": "Core interfaces and Kuralle adapter for messaging platforms",
   "type": "module",
   "main": "dist/index.js",
@@ -20,12 +26,11 @@
   ],
   "dependencies": {
     "hono": "^4.7.4",
-    "@kuralle-agents/core": "0.2.0"
+    "@kuralle-agents/core": "0.3.1"
   },
   "devDependencies": {
     "typescript": "^5.8.2",
-    "@types/node": "^22.13.4",
-    "@kuralle-agents/core": "0.2.0"
+    "@types/node": "^22.13.4"
   },
   "scripts": {
     "prebuild": "rm -rf dist",