@kuralle-agents/cf-agent 0.10.0 → 0.11.0

package/dist/inbound-runtime.d.ts

@@ -0,0 +1,108 @@
+import type { RuntimeLike } from '@kuralle-agents/core';
+import { type ClaimResult, type Clock, type CoalesceScheduler, type ConsentStore, type ConversationKey, type InboundEvent, type InboundLedger, type InboundRuntime, type MediaResolver, type OutboundSender, type OwnershipStore, type TurnResult, type TurnRunner, type WindowState, type WindowStore } from '@kuralle-agents/messaging';
+import { TurnQueue, type MessageConcurrency } from 'agents/chat';
+import type { SqlExecutor } from './types.js';
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare class SqlInboundLedger implements InboundLedger {
+    private readonly sql;
+    private readonly options;
+    private initialized;
+    constructor(sql: SqlExecutor, options?: {
+        inProgressTtlMs?: number;
+    });
+    claim(key: ConversationKey, eventId: string): Promise<ClaimResult>;
+    complete(key: ConversationKey, eventId: string): Promise<void>;
+    append(key: ConversationKey, event: InboundEvent): Promise<{
+        seq: number;
+    }>;
+    readUnprocessed(key: ConversationKey): Promise<InboundEvent[]>;
+    commitCursor(key: ConversationKey, throughSeq: number, expect: number): Promise<boolean>;
+    prune(key: ConversationKey, ttlMs: number): Promise<number>;
+    cursor(key: ConversationKey): number;
+    private ensureTables;
+    private ensureCursor;
+}
+export declare class SqlWindowStore implements WindowStore {
+    private readonly sql;
+    private initialized;
+    constructor(sql: SqlExecutor);
+    get(threadId: string): Promise<WindowState>;
+    recordInbound(threadId: string, ts: Date): Promise<void>;
+    recordExpiry(threadId: string, at: Date): Promise<void>;
+    private ensureTable;
+}
+export declare class SqlConsentStore implements ConsentStore {
+    private readonly sql;
+    private initialized;
+    constructor(sql: SqlExecutor);
+    isOptedIn(customerId: string): Promise<boolean>;
+    optOut(customerId: string): Promise<void>;
+    optIn(customerId: string): Promise<void>;
+    private upsert;
+    private ensureTable;
+}
+export declare class SqlOwnershipStore implements OwnershipStore {
+    private readonly sql;
+    private initialized;
+    constructor(sql: SqlExecutor);
+    owner(threadId: string): Promise<'bot' | 'human'>;
+    claim(threadId: string, by: string): Promise<void>;
+    release(threadId: string): Promise<void>;
+    private ensureTable;
+}
+export interface ScheduleHost {
+    schedule<T = JsonValue>(when: Date | string | number, callback: string, payload?: T, options?: {
+        idempotent?: boolean;
+    }): Promise<{
+        id: string;
+    }>;
+    cancelSchedule(id: string): Promise<void>;
+}
+export declare class AgentScheduleCoalesceScheduler implements CoalesceScheduler {
+    private readonly sql;
+    private readonly host;
+    private readonly callback;
+    private initialized;
+    constructor(sql: SqlExecutor, host: ScheduleHost, callback: string);
+    arm(key: ConversationKey, atMs: number): Promise<void>;
+    cancel(key: ConversationKey): Promise<void>;
+    private ensureTable;
+}
+export declare class RuntimeTurnRunner implements TurnRunner {
+    private readonly runtime;
+    constructor(runtime: RuntimeLike);
+    runTurn(args: Parameters<TurnRunner['runTurn']>[0]): Promise<TurnResult>;
+    deliverSignal(args: Parameters<TurnRunner['deliverSignal']>[0]): Promise<TurnResult>;
+}
+export declare class QueuedTurnRunner implements TurnRunner {
+    private readonly inner;
+    private readonly queue;
+    private readonly messageConcurrency;
+    private debounceTimer;
+    private pendingDebounced;
+    constructor(inner: TurnRunner, queue?: TurnQueue, messageConcurrency?: MessageConcurrency);
+    runTurn(args: Parameters<TurnRunner['runTurn']>[0]): Promise<TurnResult>;
+    deliverSignal(args: Parameters<TurnRunner['deliverSignal']>[0]): Promise<TurnResult>;
+    concurrency(): MessageConcurrency;
+    waitForIdle(): Promise<void>;
+    private runDebounced;
+    private flushDebounced;
+}
+export interface DurableObjectInboundRuntimeOptions {
+    sql: SqlExecutor;
+    runtime: RuntimeLike;
+    media: MediaResolver;
+    sender: OutboundSender;
+    queue?: TurnQueue;
+    messageConcurrency?: MessageConcurrency;
+    scheduler?: CoalesceScheduler;
+    clock?: Clock;
+    window?: WindowStore;
+    consent?: ConsentStore;
+    ownership?: OwnershipStore;
+}
+export declare function createDurableObjectInboundRuntime(options: DurableObjectInboundRuntimeOptions): InboundRuntime;
+export declare function eventSeqFromSql(event: InboundEvent): number | undefined;
+export {};

package/dist/inbound-runtime.js

@@ -0,0 +1,490 @@
+import { mergeUserInputContents } from '@kuralle-agents/core';
+import { conversationKeyToString, eventSeq, noopCoalesceScheduler, systemClock, } from '@kuralle-agents/messaging';
+import { TurnQueue } from 'agents/chat';
+const ledgerSeq = Symbol.for('@kuralle-agents/messaging/inbound-seq');
+function nowIso() {
+    return new Date().toISOString();
+}
+function claimStatus(value) {
+    return value === 'in_progress' || value === 'complete' ? value : undefined;
+}
+function toNumber(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'bigint')
+        return Number(value);
+    if (typeof value === 'string')
+        return Number(value);
+    return 0;
+}
+function encodeEvent(event) {
+    return JSON.stringify(event);
+}
+function decodeEvent(row) {
+    const event = JSON.parse(row.event_json);
+    if (event.kind === 'message') {
+        event.data.timestamp = new Date(event.data.timestamp);
+    }
+    else if (event.kind === 'status') {
+        event.data.timestamp = new Date(event.data.timestamp);
+        if (event.data.conversation?.expirationTimestamp) {
+            event.data.conversation.expirationTimestamp = new Date(event.data.conversation.expirationTimestamp);
+        }
+    }
+    const sequenced = Object.assign({}, event);
+    Object.defineProperty(sequenced, ledgerSeq, {
+        value: row.seq,
+        enumerable: false,
+    });
+    return sequenced;
+}
+function defaultSessionId(key) {
+    return conversationKeyToString(key);
+}
+async function collectParts(stream) {
+    const parts = [];
+    for await (const part of stream)
+        parts.push(part);
+    return parts;
+}
+function turnResult(parts) {
+    const paused = parts.find((part) => part.type === 'paused');
+    return {
+        parts,
+        suspended: paused ? { signalId: paused.waitingFor } : undefined,
+        handoffToHuman: parts.some((part) => part.type === 'handoff' && part.targetAgent === 'human'),
+    };
+}
+export class SqlInboundLedger {
+    sql;
+    options;
+    initialized = false;
+    constructor(sql, options = {}) {
+        this.sql = sql;
+        this.options = options;
+    }
+    async claim(key, eventId) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        const claimedAt = Date.now();
+        this.sql `
+      INSERT OR IGNORE INTO kuralle_inbound_claims
+        (conv_key, event_id, status, claimed_at)
+      VALUES
+        (${convKey}, ${eventId}, ${'in_progress'}, ${claimedAt})
+    `;
+        const inserted = this.sql `SELECT changes() AS changed`;
+        if (toNumber(inserted[0]?.changed) > 0)
+            return 'claimed';
+        const rows = this.sql `
+      SELECT status, claimed_at FROM kuralle_inbound_claims
+      WHERE conv_key = ${convKey} AND event_id = ${eventId}
+    `;
+        const status = claimStatus(rows[0]?.status);
+        if (status === 'complete')
+            return 'duplicate';
+        const staleAfterMs = this.options.inProgressTtlMs;
+        if (status === 'in_progress' &&
+            staleAfterMs !== undefined &&
+            claimedAt - toNumber(rows[0]?.claimed_at) >= staleAfterMs) {
+            this.sql `
+        UPDATE kuralle_inbound_claims
+        SET claimed_at = ${claimedAt}
+        WHERE conv_key = ${convKey} AND event_id = ${eventId}
+      `;
+            return 'claimed';
+        }
+        return status === 'in_progress' ? 'in_progress' : 'claimed';
+    }
+    async complete(key, eventId) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.sql `
+      UPDATE kuralle_inbound_claims
+      SET status = ${'complete'}, completed_at = ${Date.now()}
+      WHERE conv_key = ${convKey} AND event_id = ${eventId}
+    `;
+    }
+    async append(key, event) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.sql `
+      INSERT OR IGNORE INTO kuralle_inbound_events
+        (conv_key, event_id, ts, event_json, appended_at)
+      VALUES
+        (${convKey}, ${event.id}, ${event.ts}, ${encodeEvent(event)}, ${Date.now()})
+    `;
+        const rows = this.sql `
+      SELECT seq FROM kuralle_inbound_events
+      WHERE conv_key = ${convKey} AND event_id = ${event.id}
+    `;
+        return { seq: toNumber(rows[0]?.seq) };
+    }
+    async readUnprocessed(key) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.ensureCursor(convKey);
+        const rows = this.sql `
+      SELECT e.seq, e.event_json
+      FROM kuralle_inbound_events e
+      JOIN kuralle_inbound_cursors c ON c.conv_key = e.conv_key
+      WHERE e.conv_key = ${convKey} AND e.seq > c.cursor
+      ORDER BY e.ts ASC, e.seq ASC
+    `;
+        return rows.map((row) => decodeEvent({ event_json: row.event_json, seq: toNumber(row.seq) }));
+    }
+    async commitCursor(key, throughSeq, expect) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.ensureCursor(convKey);
+        this.sql `
+      UPDATE kuralle_inbound_cursors
+      SET cursor = ${Math.max(throughSeq, expect)}, updated_at = ${Date.now()}
+      WHERE conv_key = ${convKey} AND cursor = ${expect}
+    `;
+        const rows = this.sql `SELECT changes() AS changed`;
+        return toNumber(rows[0]?.changed) > 0;
+    }
+    async prune(key, ttlMs) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.ensureCursor(convKey);
+        const cutoff = Date.now() - ttlMs;
+        this.sql `
+      DELETE FROM kuralle_inbound_events
+      WHERE conv_key = ${convKey}
+        AND appended_at < ${cutoff}
+        AND seq <= (SELECT cursor FROM kuralle_inbound_cursors WHERE conv_key = ${convKey})
+    `;
+        const rows = this.sql `SELECT changes() AS changed`;
+        return toNumber(rows[0]?.changed);
+    }
+    cursor(key) {
+        this.ensureTables();
+        const convKey = conversationKeyToString(key);
+        this.ensureCursor(convKey);
+        const rows = this.sql `
+      SELECT cursor FROM kuralle_inbound_cursors WHERE conv_key = ${convKey}
+    `;
+        return toNumber(rows[0]?.cursor);
+    }
+    ensureTables() {
+        if (this.initialized)
+            return;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_claims (
+        conv_key TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('in_progress', 'complete')),
+        claimed_at INTEGER NOT NULL,
+        completed_at INTEGER,
+        PRIMARY KEY (conv_key, event_id)
+      )
+    `;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_events (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        conv_key TEXT NOT NULL,
+        event_id TEXT NOT NULL,
+        ts INTEGER NOT NULL,
+        event_json TEXT NOT NULL,
+        appended_at INTEGER NOT NULL,
+        UNIQUE (conv_key, event_id)
+      )
+    `;
+        this.sql `
+      CREATE INDEX IF NOT EXISTS idx_kuralle_inbound_events_read
+      ON kuralle_inbound_events (conv_key, ts, seq)
+    `;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_cursors (
+        conv_key TEXT PRIMARY KEY,
+        cursor INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL
+      )
+    `;
+        this.initialized = true;
+    }
+    ensureCursor(convKey) {
+        this.sql `
+      INSERT OR IGNORE INTO kuralle_inbound_cursors (conv_key, cursor, updated_at)
+      VALUES (${convKey}, ${0}, ${Date.now()})
+    `;
+    }
+}
+export class SqlWindowStore {
+    sql;
+    initialized = false;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    async get(threadId) {
+        this.ensureTable();
+        const rows = this.sql `
+      SELECT expires_at FROM kuralle_inbound_windows WHERE thread_id = ${threadId}
+    `;
+        const expiresAt = rows[0]?.expires_at ? new Date(rows[0].expires_at) : null;
+        if (!expiresAt)
+            return { open: false, expiresAt: null };
+        return expiresAt > new Date() ? { open: true, expiresAt } : { open: false, expiresAt };
+    }
+    async recordInbound(threadId, ts) {
+        const expiresAt = new Date(ts.getTime() + 24 * 60 * 60 * 1000);
+        await this.recordExpiry(threadId, expiresAt);
+    }
+    async recordExpiry(threadId, at) {
+        this.ensureTable();
+        this.sql `
+      INSERT INTO kuralle_inbound_windows (thread_id, expires_at, updated_at)
+      VALUES (${threadId}, ${at.toISOString()}, ${nowIso()})
+      ON CONFLICT(thread_id) DO UPDATE SET
+        expires_at = excluded.expires_at,
+        updated_at = excluded.updated_at
+    `;
+    }
+    ensureTable() {
+        if (this.initialized)
+            return;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_windows (
+        thread_id TEXT PRIMARY KEY,
+        expires_at TEXT,
+        updated_at TEXT NOT NULL
+      )
+    `;
+        this.initialized = true;
+    }
+}
+export class SqlConsentStore {
+    sql;
+    initialized = false;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    async isOptedIn(customerId) {
+        this.ensureTable();
+        const rows = this.sql `
+      SELECT opted_in FROM kuralle_inbound_consent WHERE customer_id = ${customerId}
+    `;
+        return rows.length === 0 || toNumber(rows[0].opted_in) === 1;
+    }
+    async optOut(customerId) {
+        this.ensureTable();
+        this.upsert(customerId, false);
+    }
+    async optIn(customerId) {
+        this.ensureTable();
+        this.upsert(customerId, true);
+    }
+    upsert(customerId, optedIn) {
+        this.sql `
+      INSERT INTO kuralle_inbound_consent (customer_id, opted_in, updated_at)
+      VALUES (${customerId}, ${optedIn ? 1 : 0}, ${nowIso()})
+      ON CONFLICT(customer_id) DO UPDATE SET
+        opted_in = excluded.opted_in,
+        updated_at = excluded.updated_at
+    `;
+    }
+    ensureTable() {
+        if (this.initialized)
+            return;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_consent (
+        customer_id TEXT PRIMARY KEY,
+        opted_in INTEGER NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `;
+        this.initialized = true;
+    }
+}
+export class SqlOwnershipStore {
+    sql;
+    initialized = false;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    async owner(threadId) {
+        this.ensureTable();
+        const rows = this.sql `
+      SELECT owner FROM kuralle_inbound_ownership WHERE thread_id = ${threadId}
+    `;
+        return rows[0]?.owner === 'human' ? 'human' : 'bot';
+    }
+    async claim(threadId, by) {
+        this.ensureTable();
+        const owner = by === 'human' ? 'human' : 'bot';
+        this.sql `
+      INSERT INTO kuralle_inbound_ownership (thread_id, owner, updated_at)
+      VALUES (${threadId}, ${owner}, ${nowIso()})
+      ON CONFLICT(thread_id) DO UPDATE SET
+        owner = excluded.owner,
+        updated_at = excluded.updated_at
+    `;
+    }
+    async release(threadId) {
+        this.ensureTable();
+        this.sql `DELETE FROM kuralle_inbound_ownership WHERE thread_id = ${threadId}`;
+    }
+    ensureTable() {
+        if (this.initialized)
+            return;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_ownership (
+        thread_id TEXT PRIMARY KEY,
+        owner TEXT NOT NULL CHECK(owner IN ('bot', 'human')),
+        updated_at TEXT NOT NULL
+      )
+    `;
+        this.initialized = true;
+    }
+}
+export class AgentScheduleCoalesceScheduler {
+    sql;
+    host;
+    callback;
+    initialized = false;
+    constructor(sql, host, callback) {
+        this.sql = sql;
+        this.host = host;
+        this.callback = callback;
+    }
+    async arm(key, atMs) {
+        this.ensureTable();
+        const convKey = conversationKeyToString(key);
+        const existing = this.sql `
+      SELECT schedule_id FROM kuralle_inbound_schedule_refs WHERE conv_key = ${convKey}
+    `;
+        if (existing[0]?.schedule_id) {
+            await this.host.cancelSchedule(existing[0].schedule_id);
+        }
+        const schedule = await this.host.schedule(new Date(atMs), this.callback, { key }, { idempotent: true });
+        this.sql `
+      INSERT INTO kuralle_inbound_schedule_refs (conv_key, schedule_id, updated_at)
+      VALUES (${convKey}, ${schedule.id}, ${Date.now()})
+      ON CONFLICT(conv_key) DO UPDATE SET
+        schedule_id = excluded.schedule_id,
+        updated_at = excluded.updated_at
+    `;
+    }
+    async cancel(key) {
+        this.ensureTable();
+        const convKey = conversationKeyToString(key);
+        const existing = this.sql `
+      SELECT schedule_id FROM kuralle_inbound_schedule_refs WHERE conv_key = ${convKey}
+    `;
+        if (existing[0]?.schedule_id) {
+            await this.host.cancelSchedule(existing[0].schedule_id);
+        }
+        this.sql `DELETE FROM kuralle_inbound_schedule_refs WHERE conv_key = ${convKey}`;
+    }
+    ensureTable() {
+        if (this.initialized)
+            return;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS kuralle_inbound_schedule_refs (
+        conv_key TEXT PRIMARY KEY,
+        schedule_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `;
+        this.initialized = true;
+    }
+}
+export class RuntimeTurnRunner {
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async runTurn(args) {
+        const handle = this.runtime.run({
+            input: args.input,
+            selection: args.selection,
+            sessionId: args.sessionId ?? defaultSessionId(args.key),
+            userId: args.userId,
+            abortSignal: args.signal,
+        });
+        return turnResult(await collectParts(handle.events));
+    }
+    async deliverSignal(args) {
+        const handle = this.runtime.run({
+            sessionId: args.sessionId ?? defaultSessionId(args.key),
+            signalDelivery: args.signal,
+            abortSignal: args.signal2,
+        });
+        return turnResult(await collectParts(handle.events));
+    }
+}
+export class QueuedTurnRunner {
+    inner;
+    queue;
+    messageConcurrency;
+    debounceTimer;
+    pendingDebounced = [];
+    constructor(inner, queue = new TurnQueue(), messageConcurrency = 'queue') {
+        this.inner = inner;
+        this.queue = queue;
+        this.messageConcurrency = messageConcurrency;
+    }
+    async runTurn(args) {
+        if (typeof this.messageConcurrency === 'object' && this.messageConcurrency.strategy === 'debounce') {
+            return this.runDebounced(args, this.messageConcurrency.debounceMs ?? 750);
+        }
+        const result = await this.queue.enqueue(`${conversationKeyToString(args.key)}:${crypto.randomUUID()}`, async () => this.inner.runTurn(args));
+        return result.status === 'completed' ? result.value : { parts: [] };
+    }
+    async deliverSignal(args) {
+        const result = await this.queue.enqueue(`${conversationKeyToString(args.key)}:${args.signal.signalId}`, async () => this.inner.deliverSignal(args));
+        return result.status === 'completed' ? result.value : { parts: [] };
+    }
+    concurrency() {
+        return this.messageConcurrency;
+    }
+    waitForIdle() {
+        return this.queue.waitForIdle();
+    }
+    runDebounced(args, debounceMs) {
+        return new Promise((resolve, reject) => {
+            this.pendingDebounced.push({ args, resolve, reject });
+            if (this.debounceTimer)
+                clearTimeout(this.debounceTimer);
+            this.debounceTimer = setTimeout(() => {
+                this.debounceTimer = undefined;
+                void this.flushDebounced();
+            }, debounceMs);
+        });
+    }
+    async flushDebounced() {
+        const pending = this.pendingDebounced.splice(0);
+        if (pending.length === 0)
+            return;
+        const latest = pending[pending.length - 1];
+        const input = mergeUserInputContents(pending.map((item) => item.args.input)) ?? latest.args.input;
+        for (const item of pending.slice(0, -1))
+            item.resolve({ parts: [] });
+        try {
+            const result = await this.queue.enqueue(`${conversationKeyToString(latest.args.key)}:${crypto.randomUUID()}`, async () => this.inner.runTurn({ ...latest.args, input }));
+            latest.resolve(result.status === 'completed' ? result.value : { parts: [] });
+        }
+        catch (error) {
+            latest.reject(error);
+        }
+    }
+}
+export function createDurableObjectInboundRuntime(options) {
+    const baseRunner = new RuntimeTurnRunner(options.runtime);
+    return {
+        ledger: new SqlInboundLedger(options.sql),
+        window: options.window ?? new SqlWindowStore(options.sql),
+        consent: options.consent ?? new SqlConsentStore(options.sql),
+        ownership: options.ownership ?? new SqlOwnershipStore(options.sql),
+        media: options.media,
+        sender: options.sender,
+        runtime: new QueuedTurnRunner(baseRunner, options.queue, options.messageConcurrency),
+        scheduler: options.scheduler ?? noopCoalesceScheduler,
+        clock: options.clock ?? systemClock,
+    };
+}
+export function eventSeqFromSql(event) {
+    return eventSeq(event);
+}

package/dist/index.d.ts

@@ -30,6 +30,8 @@ export { SqlPersistentMemoryStore } from './SqlPersistentMemoryStore.js';
 export { createSqlExecutor } from './sqlExecutor.js';
 export { createSSEResponse } from './StreamAdapter.js';
 export { lastUserInputFromMessages } from './cfMessageInput.js';
+export { AgentScheduleCoalesceScheduler, QueuedTurnRunner, RuntimeTurnRunner, SqlConsentStore, SqlInboundLedger, SqlOwnershipStore, SqlWindowStore, createDurableObjectInboundRuntime, eventSeqFromSql, } from './inbound-runtime.js';
 export type { StreamAdapterConfig, OrchestrationState, SqlExecutor, } from './types.js';
+export type { DurableObjectInboundRuntimeOptions, ScheduleHost, } from './inbound-runtime.js';
 export { DEFAULT_STREAM_CONFIG } from './types.js';
 export type { HarnessConfig, HarnessHooks, HarnessStreamPart, Session, } from '@kuralle-agents/core';

package/dist/index.js

@@ -30,4 +30,5 @@ export { SqlPersistentMemoryStore } from './SqlPersistentMemoryStore.js';
 export { createSqlExecutor } from './sqlExecutor.js';
 export { createSSEResponse } from './StreamAdapter.js';
 export { lastUserInputFromMessages } from './cfMessageInput.js';
+export { AgentScheduleCoalesceScheduler, QueuedTurnRunner, RuntimeTurnRunner, SqlConsentStore, SqlInboundLedger, SqlOwnershipStore, SqlWindowStore, createDurableObjectInboundRuntime, eventSeqFromSql, } from './inbound-runtime.js';
 export { DEFAULT_STREAM_CONFIG } from './types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuralle-agents/cf-agent",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Kuralle agent integration for Cloudflare Workers with AIChatAgent",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,20 +21,21 @@
   "dependencies": {
     "@cloudflare/ai-chat": "^0.8.4",
     "ai": "^6.0.90",
-    "@kuralle-agents/core": "0.10.0",
-    "@kuralle-agents/realtime-audio": "0.10.0"
+    "@kuralle-agents/core": "0.11.0",
+    "@kuralle-agents/messaging": "0.11.0",
+    "@kuralle-agents/realtime-audio": "0.11.0"
   },
   "peerDependencies": {
     "agents": ">=0.14.0 <1.0.0",
     "zod": "^4.0.0",
-    "@kuralle-agents/voice-protocol": "0.10.0"
+    "@kuralle-agents/voice-protocol": "0.11.0"
   },
   "devDependencies": {
     "@cloudflare/vitest-pool-workers": "^0.12.7",
     "agents": "^0.15.0",
     "typescript": "^5.7.0",
     "vitest": "^3.2.4",
-    "@kuralle-agents/voice-protocol": "0.10.0"
+    "@kuralle-agents/voice-protocol": "0.11.0"
   },
   "engines": {
     "node": ">=20"