@keemakr/agent-sdk 0.19.0-dev-20261014201650 → 0.19.0-dev-20261014211203

package/dist/channel-testkit.d.ts

@@ -85,6 +85,7 @@ export interface FakeCore {
         };
         channel?: ChannelDelivery['channel'];
         setup?: ChannelDelivery['setup'];
+        continuity?: ChannelDelivery['continuity'];
         contract?: number;
         timeoutMs?: number;
     }): Promise<Delivered>;

package/dist/channel-testkit.js

@@ -192,11 +192,19 @@ export async function startFakeCore(options = {}) {
             req.on('end', () => {
                 const action = JSON.parse(raw || '{}');
                 // Checked as core checks it: a reach ref counts only if THIS turn was served it.
-                const cited = Array.isArray(action.grounded_on) ? action.grounded_on : [];
+                const effects = action.effects;
+                const cited = action.action === 'turn'
+                    ? (effects?.replies?.flatMap((r) => r.groundedOn ?? []) ?? [])
+                    : Array.isArray(action.grounded_on)
+                        ? action.grounded_on
+                        : [];
                 unverified.set(String(action.delivery_id), cited.filter((g) => typeof g === 'string' &&
                     (!(served.get(trace)?.has(/^(record|op|hold|kb|workflow):/.test(g) ? g : `kb:${g}`) ??
                         false) ||
-                        (g.startsWith('workflow:') && workflowText.get(`${trace}:${g}`) !== action.text))));
+                        (g.startsWith('workflow:') &&
+                            (action.action === 'turn'
+                                ? (effects?.replies?.some((r) => r.groundedOn?.includes(g) && workflowText.get(`${trace}:${g}`) !== r.text) ?? false)
+                                : workflowText.get(`${trace}:${g}`) !== action.text)))));
                 const resolve = waiting.get(String(action.delivery_id));
                 if (resolve) {
                     waiting.delete(String(action.delivery_id));
@@ -276,6 +284,7 @@ export async function startFakeCore(options = {}) {
                     ...(input.language ? { language: input.language } : {}),
                     ...(input.channel ? { channel: input.channel } : {}),
                     ...(input.setup ? { setup: input.setup } : {}),
+                    ...(input.continuity ? { continuity: input.continuity } : {}),
                 }),
             });
             const action = (await answered);

package/dist/channel.d.ts

@@ -14,8 +14,53 @@ export interface ChannelPresentation {
     format: 'chat' | 'email' | 'sms';
     maxTextChars?: number;
 }
+export interface ChannelQuestion {
+    id: string;
+    revision: number;
+    text: string;
+    sourcePosition: number;
+    state: 'open' | 'partitioned' | 'answered' | 'cancelled';
+    attempts: number;
+}
+export interface QuestionRef {
+    id: string;
+    revision: number;
+}
+export interface ChannelTurnEffects {
+    protocol: 'scoped-v1';
+    withdrawals?: Array<{
+        question: QuestionRef;
+        request: QuestionRef;
+    }>;
+    partitions?: Array<{
+        question: QuestionRef;
+        parts: Array<{
+            key: string;
+            text: string;
+        }>;
+    }>;
+    replies: Array<{
+        key: string;
+        text: string;
+        kind: 'answer' | 'conversation' | 'workflow';
+        confidence?: number;
+        coverage: 'answered' | 'clarification' | 'limitation';
+        groundedOn: string[];
+        questions: QuestionRef[];
+    }>;
+    assistance: Array<{
+        key: string;
+        questions: QuestionRef[];
+        reason: 'customer_requested' | 'clinical' | 'repeated_gap' | 'urgent' | 'operation_uncertain';
+        stopAgent?: boolean;
+    }>;
+}
 /** The envelope core POSTs. Loose by rule — core adds fields without asking packs first. */
 export interface ChannelDelivery {
+    continuity?: {
+        protocol: 'scoped-v1';
+        questions: ChannelQuestion[];
+    };
     event: string;
     delivery_id: string;
     conversation: {
@@ -46,6 +91,10 @@ export interface ChannelDelivery {
 }
 /** What a pack proposes. Core decides what happens to it. */
 export type ChannelAction = {
+    action: 'turn';
+    effects: ChannelTurnEffects;
+    usage: Usage;
+} | {
     action: 'reply';
     text: string;
     confidence?: number;
@@ -208,6 +257,10 @@ export declare class ChannelReplyNotDeliverable extends Error {
     constructor();
 }
 export interface ChannelContext {
+    continuity?: ChannelDelivery['continuity'];
+    turn(effects: ChannelTurnEffects, opts?: {
+        usage?: Usage;
+    }): ChannelAction;
     tenantId: string;
     conversationId: string;
     deliveryId: string;

package/dist/channel.js

@@ -224,6 +224,8 @@ export function createChannelAgent(options) {
         // A CONTRACT THIS SDK DOES NOT SPEAK IS A REFUSAL, NOT A GUESS. Absent means a core
         // that predates the field. Anything else means core has changed the envelope's SHAPE,
         // and answering it with v1 assumptions is how a pack confidently misreads a customer.
+        if (body.continuity && body.continuity.protocol !== 'scoped-v1')
+            return refuse(400, 'turn_effects_unsupported');
         if (body.contract !== undefined && body.contract !== SUPPORTED_CONTRACT) {
             return refuse(400, 'contract_unsupported');
         }
@@ -310,6 +312,7 @@ export function createChannelAgent(options) {
             contact: body.contact,
             channel: body.channel,
             setup: body.setup,
+            continuity: body.continuity,
             booking: {
                 async requestVerification(appointmentId) {
                     return (await readOrRefuse(await authed('/api/capability/booking/verification/request', {
@@ -521,6 +524,15 @@ export function createChannelAgent(options) {
             // PURE BUILDERS. They return an action and touch nothing — so a pack's `answer` can
             // be tested by calling it and inspecting what came back, with no core, no fake and no
             // network.
+            turn(effects, opts) {
+                if (body.continuity?.protocol !== 'scoped-v1' || effects.protocol !== 'scoped-v1')
+                    throw new Error('turn_effects_not_negotiated');
+                return {
+                    action: 'turn',
+                    effects,
+                    usage: opts?.usage ?? { input_tokens: 0, output_tokens: 0 },
+                };
+            },
             reply(text, opts) {
                 const run = body.unanswered_messages ?? [];
                 if (run.length > 0 && run.every((m) => m.email && !m.email.replyable)) {
@@ -598,6 +610,8 @@ export function createChannelAgent(options) {
         // ANSWERED on the preview path — so the owner is shown, under v1 assumptions, something
         // no customer of theirs would ever receive. A preview that lies is worse than no
         // preview, because it is trusted.
+        if (body.continuity && body.continuity.protocol !== 'scoped-v1')
+            return refuse(400, 'turn_effects_unsupported');
         if (body.contract !== undefined && body.contract !== SUPPORTED_CONTRACT) {
             return refuse(400, 'contract_unsupported');
         }

package/dist/index.d.ts

@@ -6,4 +6,4 @@ export { useKee, MemoryConflictError, RecordConflictError, RecordValidationError
 export { keemakrToolDirectory } from './tool-directory.js';
 export { refreshGrant, REFRESH_THRESHOLD_SECONDS } from './refresh.js';
 export { audioCanvas, imageCanvas, type AudioCanvas, type Canvas, type ImageCanvas, type ReportCanvas, } from './canvases.js';
-export { createChannelAgent, assertTrustworthyCore, ChannelReachError, ChannelReplyNotDeliverable, isApprovalRequired, isHoldSettled, isOutcomeUnknown, isWriteDone, type ChannelWriteDone, type ChannelWriteResult, type ChannelWriteOptions, type ChannelApprovalRequired, type ChannelHoldSettled, type ChannelOutcomeUnknown, type HeldActionStatus, type ChannelReach, type ChannelRecord, type ChannelAction, type ChannelAgent, type ChannelAgentOptions, type ChannelContext, type ChannelDelivery, type ChannelEmail, type ChannelMessage, type HandoffReason, type Usage, } from './channel.js';
+export { createChannelAgent, assertTrustworthyCore, ChannelReachError, ChannelReplyNotDeliverable, isApprovalRequired, isHoldSettled, isOutcomeUnknown, isWriteDone, type ChannelWriteDone, type ChannelWriteResult, type ChannelWriteOptions, type ChannelApprovalRequired, type ChannelHoldSettled, type ChannelOutcomeUnknown, type HeldActionStatus, type ChannelReach, type ChannelRecord, type ChannelAction, type ChannelAgent, type ChannelAgentOptions, type ChannelContext, type ChannelDelivery, type ChannelTurnEffects, type ChannelQuestion, type QuestionRef, type ChannelEmail, type ChannelMessage, type HandoffReason, type Usage, } from './channel.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keemakr/agent-sdk",
-  "version": "0.19.0-dev-20261014201650",
+  "version": "0.19.0-dev-20261014211203",
   "description": "The floor for keemakr marketplace agents: verify the capability grant and reach tenant connections, memory, and shared platform tools through keemakr-core — without holding raw secrets or resolving the tenant yourself.",
   "license": "MIT",
   "type": "module",