@coffer-org/server 7.0.0 → 7.2.0

package/dist/background-scheduler.d.ts

@@ -17,6 +17,7 @@ export interface BackgroundScheduler {
     start(): void;
     stop(): void;
 }
+export declare const DEFAULT_TASK_TIMEOUT_MS = 600000;
 export declare function makeScheduler(opts?: SchedulerOpts): BackgroundScheduler;
 export declare function startScheduler(tasks: BackgroundTask[], opts?: SchedulerOpts): void;
 export declare function stopScheduler(): void;

package/dist/background-scheduler.js

@@ -6,10 +6,11 @@ const defaultSetTimer = (cb, ms) => {
         t.unref();
     return t;
 };
+export const DEFAULT_TASK_TIMEOUT_MS = 600_000;
 export function makeScheduler(opts = {}) {
     const startupDelayMs = opts.startupDelayMs ?? (Number(process.env['BG_STARTUP_DELAY_MS']) || 600_000);
     const gapMs = opts.gapMs ?? (Number(process.env['BG_GAP_MS']) || 30_000);
-    const defaultTimeoutMs = opts.taskTimeoutMs ?? (Number(process.env['BG_TASK_TIMEOUT_MS']) || 600_000);
+    const defaultTimeoutMs = opts.taskTimeoutMs ?? (Number(process.env['BG_TASK_TIMEOUT_MS']) || DEFAULT_TASK_TIMEOUT_MS);
     const setTimer = opts.setTimer ?? defaultSetTimer;
     const clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
     const tasks = [];

package/dist/embed-openai.d.ts

@@ -14,11 +14,11 @@ export declare class OpenAIEmbeddingError extends Error {
     });
 }
 export declare function embeddingFailureMessage(error: unknown): string;
-export declare function embedBatch(texts: string[], apiKey: string, fetchImpl?: typeof fetch): Promise<{
+export declare function embedBatch(texts: string[], apiKey: string, fetchImpl?: typeof fetch, signal?: AbortSignal): Promise<{
     vectors: number[][];
     tokens: number;
 }>;
-export declare function embedOne(text: string, apiKey: string, fetchImpl?: typeof fetch): Promise<{
+export declare function embedOne(text: string, apiKey: string, fetchImpl?: typeof fetch, signal?: AbortSignal): Promise<{
     vector: number[];
     tokens: number;
 }>;

package/dist/embed-openai.js

@@ -54,7 +54,7 @@ export function embeddingFailureMessage(error) {
             return `OpenAI embeddings are unavailable${error.status == null ? '' : ` (HTTP ${error.status})`}. RAG will retry; records are still saved.`;
     }
 }
-export async function embedBatch(texts, apiKey, fetchImpl = fetch) {
+export async function embedBatch(texts, apiKey, fetchImpl = fetch, signal) {
     if (texts.length === 0)
         return { vectors: [], tokens: 0 };
     if (!apiKey)
@@ -65,6 +65,7 @@ export async function embedBatch(texts, apiKey, fetchImpl = fetch) {
             method: 'POST',
             headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
             body: JSON.stringify({ model: EMBED_MODEL, input: texts, dimensions: EMBED_DIM }),
+            ...(signal ? { signal } : {}),
         });
     }
     catch (cause) {
@@ -79,8 +80,8 @@ export async function embedBatch(texts, apiKey, fetchImpl = fetch) {
     const vectors = [...json.data].sort((a, b) => a.index - b.index).map((d) => d.embedding);
     return { vectors, tokens: json.usage?.total_tokens ?? 0 };
 }
-export async function embedOne(text, apiKey, fetchImpl = fetch) {
-    const { vectors, tokens } = await embedBatch([text], apiKey, fetchImpl);
+export async function embedOne(text, apiKey, fetchImpl = fetch, signal) {
+    const { vectors, tokens } = await embedBatch([text], apiKey, fetchImpl, signal);
     const vector = vectors[0];
     if (!vector)
         throw new Error('embeddings: empty response');

package/dist/embeddings.d.ts

@@ -39,3 +39,4 @@ export declare function searchEmbeddings(queryVec: number[], k: number, opts?: {
     shelfKeys?: Set<string>;
 }): Promise<EmbeddingHit[]>;
 export declare function listEventsSince(lastId: number, limit: number): Promise<EventRow[]>;
+export declare function latestEventId(): Promise<number>;

package/dist/embeddings.js

@@ -116,3 +116,11 @@ export async function listEventsSince(lastId, limit) {
     }));
     return rows;
 }
+export async function latestEventId() {
+    const em = getEm().fork();
+    const rows = (await em.find('_Event', {}, {
+        orderBy: { id: 'DESC' },
+        limit: 1,
+    }));
+    return rows[0]?.id ?? 0;
+}

package/dist/mcp-contract/schema.d.ts

@@ -1,4 +1,30 @@
 import type { LocaleResolver } from '../locale-registry.ts';
+import { type AgentMeta } from '@coffer-org/sdk/library';
+import type { Condition } from '@coffer-org/sdk/condition';
+interface ShelfClient {
+    shelf: string;
+    library: string;
+    label: string;
+    agent?: string;
+    standalone?: boolean;
+    fields: unknown[];
+}
+interface ExtendClient {
+    id: string;
+    attachTo: {
+        library: string;
+        shelf?: string;
+    }[];
+    showWhen?: Condition;
+    agent?: AgentMeta | string;
+}
+interface LibraryClient {
+    id: string;
+    label: string;
+    agent?: AgentMeta | string;
+    extends?: ExtendClient[];
+    shelves: ShelfClient[];
+}
 export interface ShelfIndexEntry {
     library: string;
     libraryLabel: string;
@@ -25,13 +51,20 @@ export declare const FILE_WRITE_HINT: string;
 export declare const SOURCE_WRITE_HINT: string;
 export declare const DERIVED_WRITE_HINT: string;
 export declare const serverOwnedPartsHint: (roles: string[]) => string;
+export interface OperatingRule {
+    source: string;
+    when?: string;
+    text: string;
+}
 export interface ShelfDescription {
     library: string;
     shelf: string;
     label: string;
     agent?: string;
+    operatingRules?: OperatingRule[];
     fields: FieldInfo[];
 }
+export declare function collectOperatingRules(lib: LibraryClient, shelf: string): OperatingRule[];
 interface SchemaClient {
     getSchema(): Promise<unknown>;
 }
@@ -46,6 +79,6 @@ export declare class SchemaCache {
     private load;
     index(): Promise<ShelfIndexEntry[]>;
     describeShelf(library: string, shelf: string): Promise<ShelfDescription>;
-    private find;
+    private locate;
 }
 export {};

package/dist/mcp-contract/schema.js

@@ -1,3 +1,6 @@
+import { normalizeAgentMeta } from '@coffer-org/sdk/library';
+import { extendMatches } from '@coffer-org/sdk/extend';
+import { describeCondition } from '@coffer-org/sdk/condition';
 export const FILE_WRITE_HINT = 'Uploaded file only: {"name":"<filename returned by POST /api/upload>"} ' +
     '(or an array of those when the field is multiple). ' +
     'A remote URL is rejected — the server stores files, not links. ' +
@@ -13,6 +16,22 @@ export const DERIVED_WRITE_HINT = 'Read-only — the server recomputes this fiel
 export const serverOwnedPartsHint = (roles) => `Partly read-only — the server owns ${roles.map((r) => `\`${r}\``).join(', ')} in this value and ` +
     `computes ${roles.length > 1 ? 'them' : 'it'} on every write. Send the other roles only; anything ` +
     `sent for these is discarded, and a read returns the server's value.`;
+export function collectOperatingRules(lib, shelf) {
+    const out = [];
+    const libAgent = normalizeAgentMeta(lib.agent);
+    if (libAgent?.instructions)
+        out.push({ source: lib.id, text: libAgent.instructions });
+    for (const e of lib.extends ?? []) {
+        if (!extendMatches(e, lib.id, shelf))
+            continue;
+        const meta = normalizeAgentMeta(e.agent);
+        if (!meta?.instructions)
+            continue;
+        const when = describeCondition(e.showWhen, (f) => f).join(' and ');
+        out.push({ source: e.id, ...(when ? { when } : {}), text: meta.instructions });
+    }
+    return out;
+}
 function serverOwnedRoles(t) {
     const parts = t.parts ?? [];
     return parts.filter((p) => p.mode === 'computedStored').map((p) => p.role);
@@ -89,20 +108,24 @@ export class SchemaCache {
         })));
     }
     async describeShelf(library, shelf) {
-        let m = this.find(await this.load(), library, shelf);
-        if (!m)
-            m = this.find(await this.load(true), library, shelf);
-        if (!m)
+        let at = this.locate(await this.load(), library, shelf);
+        if (!at)
+            at = this.locate(await this.load(true), library, shelf);
+        if (!at)
             throw new Error(`unknown_shelf ${library}/${shelf}`);
+        const rules = collectOperatingRules(at.lib, shelf);
         return {
             library,
             shelf,
-            label: this.display(m.label, m.shelf),
-            ...(m.agent ? { agent: m.agent } : {}),
-            fields: flattenFields(m.fields),
+            label: this.display(at.m.label, at.m.shelf),
+            ...(at.m.agent ? { agent: at.m.agent } : {}),
+            ...(rules.length ? { operatingRules: rules } : {}),
+            fields: flattenFields(at.m.fields),
         };
     }
-    find(libraries, library, shelf) {
-        return libraries.find((v) => v.id === library)?.shelves.find((m) => m.shelf === shelf);
+    locate(libraries, library, shelf) {
+        const lib = libraries.find((v) => v.id === library);
+        const m = lib?.shelves.find((s) => s.shelf === shelf);
+        return lib && m ? { lib, m } : undefined;
     }
 }

package/dist/mcp-contract/tools.js

@@ -53,7 +53,9 @@ export function buildTools(client, cache, locales) {
         },
         {
             name: 'describe_shelf',
-            description: 'Detailed shelf schema: the shelf note (agent), then fields with kind/prim/required, relation/options, and ' +
+            description: 'Detailed shelf schema: the shelf note (agent), the operating rules that govern writing here ' +
+                '(operatingRules — from the library and from any extra field-set attached to this shelf, each ' +
+                'with the condition it applies under), then fields with kind/prim/required, relation/options, and ' +
                 'a per-field note (agent) saying what that field means. A collection is one entry with multiple:true and its ' +
                 'row shape in fields[]. A field with derived:true is computed by the server and rejects writes — omit it when ' +
                 'writing. Call BEFORE create_record/update_record.',

package/dist/mcp-tools.d.ts

@@ -4,6 +4,7 @@ import { type ToolResult } from './mcp-contract/tools.ts';
 import { type LocaleResolver } from './locale-registry.ts';
 import { type AuthRole, type PluginHooks } from './plugin-hooks.ts';
 import { type Condition } from '@coffer-org/sdk/condition';
+import { type AgentMeta } from '@coffer-org/sdk/library';
 import { type RagHit } from './rag-search.ts';
 export interface McpToolDef {
     server: string;
@@ -58,12 +59,12 @@ export declare function collectLibraryPurposes(reg?: {
         meta: {
             id: string;
             label?: string;
-            agent?: string;
+            agent?: AgentMeta | string;
         };
     }[];
     extends_: {
         id: string;
-        agent?: string;
+        agent?: AgentMeta | string;
         showWhen?: Condition;
         attachTo: {
             library: string;

package/dist/mcp-tools.js

@@ -10,6 +10,7 @@ import { pluginHooks, pluginCtx } from "./plugin-hooks.js";
 import { getActiveRegistry } from "./registry-context.js";
 import { countTargetsFor, recordCounts } from "./counts.js";
 import { describeCondition } from '@coffer-org/sdk/condition';
+import { normalizeAgentMeta } from '@coffer-org/sdk/library';
 import { getEm } from "./db.js";
 import { getPluginSettings } from "./plugin-runtime.js";
 import { configuredPublicUrl } from "./public-url.js";
@@ -130,9 +131,9 @@ export async function collectMcpTools(opts = {}) {
                 inputSchema: t.inputSchema,
                 scope: 'plugin',
                 role: t.role ?? 'member',
-                handler: async (args) => {
+                handler: async (args, signal) => {
                     try {
-                        const data = await t.handler(args, pluginCtx(id, getEm().fork()));
+                        const data = await t.handler(args, pluginCtx(id, getEm().fork(), signal));
                         return ok(data);
                     }
                     catch (e) {
@@ -162,7 +163,7 @@ export async function collectMcpTools(opts = {}) {
             },
             scope: 'rag',
             role: 'member',
-            handler: async (args) => {
+            handler: async (args, signal) => {
                 const library = args.library;
                 const shelf = args.shelf;
                 if (shelf && !library) {
@@ -180,7 +181,7 @@ export async function collectMcpTools(opts = {}) {
                 }
                 let vector = null;
                 try {
-                    vector = (await embedOne(args.query, embeddingApiKey)).vector;
+                    vector = (await embedOne(args.query, embeddingApiKey, undefined, signal)).vector;
                 }
                 catch (e) {
                     log.warn(`embedding failed, text-only search — ${embeddingFailureMessage(e)}`);
@@ -296,16 +297,19 @@ export function collectLibraryPurposes(reg, locales) {
     if (!registry)
         return [];
     return registry.libraries
-        .filter((v) => v.meta.agent)
+        .filter((v) => normalizeAgentMeta(v.meta.agent)?.description)
         .map((v) => ({
         id: v.meta.id,
         name: (v.meta.label ? locales?.resolve(v.meta.label) : undefined) ?? v.meta.id,
-        agent: v.meta.agent,
-        extends: registry.extends_.flatMap((e) => e.agent
-            ? e.attachTo
-                .filter((a) => a.library === v.meta.id)
-                .map((a) => ({ id: e.id, shelf: a.shelf, agent: e.agent, showWhen: e.showWhen }))
-            : []),
+        agent: normalizeAgentMeta(v.meta.agent).description,
+        extends: registry.extends_.flatMap((e) => {
+            const meta = normalizeAgentMeta(e.agent);
+            return meta?.description
+                ? e.attachTo
+                    .filter((a) => a.library === v.meta.id)
+                    .map((a) => ({ id: e.id, shelf: a.shelf, agent: meta.description, showWhen: e.showWhen }))
+                : [];
+        }),
     }));
 }
 export async function siteSection(siteUrl) {

package/dist/orchestrator/index.d.ts

@@ -17,6 +17,7 @@ export { isSenderAllowed } from './allow.ts';
 export { makeLiveChannel, plainRender } from './live-message.ts';
 export type { LiveChannelOps, LiveChannelOpts, RenderFn } from './live-message.ts';
 export { chunk } from './format.ts';
+export { DEFAULT_TASK_TIMEOUT_MS } from '../background-scheduler.ts';
 export type { Connector, IncomingConversation, GatePolicy, ReplyContext, ReplyPayload, ReplyChannel, AttachmentRef, AttachmentMaterializer, AgentToolDefinition, AgentToolProvider, ConvMessage, AgentRequest, AgentResult, AgentRuntime, AgentCapabilities, AgentPreset, AgentDescriptor, ConnectorRegistration, AgentToolContentBlock, AgentToolContentResult, } from './types.ts';
 export declare function startOrchestrator(): void;
 export declare function stopOrchestrator(): void;

package/dist/orchestrator/index.js

@@ -20,6 +20,7 @@ export { isSenderAllowed } from "./allow.js";
 import { carryLegacyState } from "./allow.js";
 export { makeLiveChannel, plainRender } from "./live-message.js";
 export { chunk } from "./format.js";
+export { DEFAULT_TASK_TIMEOUT_MS } from "../background-scheduler.js";
 let db;
 const STARTERS_CHECK_INTERVAL_MS = 10 * 60_000;
 function runStartersRefresh() {

package/dist/orchestrator/starter-sources.d.ts

@@ -0,0 +1,2 @@
+export declare function shelfSources(slug: string, getShelfOwner: (library: string, shelf: string) => string | undefined): string[];
+export declare function defaultShelfSources(slug: string): string[];

package/dist/orchestrator/starter-sources.js

@@ -0,0 +1,22 @@
+import { getActiveRegistry } from "../registry-context.js";
+export function shelfSources(slug, getShelfOwner) {
+    const parts = slug.split('/');
+    if (parts.length !== 2)
+        return [];
+    const [library, shelf] = parts;
+    if (!library || !shelf)
+        return [];
+    const out = [`library:${library}`];
+    const owner = getShelfOwner(library, shelf);
+    if (owner)
+        out.push(`plugin:${owner}`);
+    return out;
+}
+export function defaultShelfSources(slug) {
+    try {
+        return shelfSources(slug, getActiveRegistry().getShelfOwner);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/orchestrator/starters.d.ts

@@ -3,6 +3,7 @@ import { getPluginState, setPluginState } from '../plugin-state.ts';
 import { collectStarterHints } from '../mcp-tools.ts';
 import { loadAgentId } from './config.ts';
 import { getDefaultAgentId } from './registry.ts';
+import { listEventsSince, latestEventId } from '../embeddings.ts';
 import type { AgentRuntime } from './types.ts';
 export interface StartersDeps {
     getPluginSettings: typeof getPluginSettings;
@@ -14,6 +15,9 @@ export interface StartersDeps {
     getDefaultAgentId: typeof getDefaultAgentId;
     now: () => number;
     shuffle: <T>(xs: T[]) => T[];
+    listEventsSince: typeof listEventsSince;
+    latestEventId: typeof latestEventId;
+    shelfSources: (slug: string) => string[];
 }
 export declare function refreshSystemStarters(deps?: StartersDeps): Promise<void>;
 export declare function getConversationStarters(deps?: StartersDeps): Promise<string[]>;

package/dist/orchestrator/starters.js

@@ -5,14 +5,20 @@ import { collectStarterHints } from "../mcp-tools.js";
 import { getLogger } from '@coffer-org/sdk/logger';
 import { loadAgentId } from "./config.js";
 import { resolveAgent, getDefaultAgentId } from "./registry.js";
+import { listEventsSince, latestEventId } from "../embeddings.js";
+import { defaultShelfSources } from "./starter-sources.js";
 const log = getLogger('orchestrator');
 const PLUGIN = 'orchestrator';
 const STATE_KEY = 'system_starters';
 const POOL_VERSION = 2;
 const ENTRY_TTL_MS = 24 * 60 * 60_000;
+const EARLY_DEBOUNCE_MS = 60 * 60_000;
+const EARLY_COOLDOWN_MS = 6 * 60 * 60_000;
+const EARLY_BUDGET_PER_DAY = 10;
 const SAMPLE_MIN = 4;
 const SAMPLE_MAX = 5;
 const PER_SOURCE_SOFT_CAP = 2;
+const EVENT_BATCH = 5000;
 function shuffled(xs) {
     const out = [...xs];
     for (let i = out.length - 1; i > 0; i--) {
@@ -31,6 +37,9 @@ const defaultDeps = {
     getDefaultAgentId,
     now: () => Date.now(),
     shuffle: shuffled,
+    listEventsSince,
+    latestEventId,
+    shelfSources: defaultShelfSources,
 };
 async function currentLanguage(deps) {
     const system = await deps.getPluginSettings(SYSTEM_SETTINGS_ID);
@@ -58,6 +67,33 @@ async function readPool(deps) {
 function fresh(entry, nowMs) {
     return nowMs - Date.parse(entry.generatedAt) < ENTRY_TTL_MS;
 }
+function dayKey(nowMs) {
+    return new Date(nowMs).toISOString().slice(0, 10);
+}
+function earlyBudgetLeft(pool, nowMs) {
+    const spent = pool.earlyRuns;
+    if (!spent || spent.date !== dayKey(nowMs))
+        return true;
+    return spent.count < EARLY_BUDGET_PER_DAY;
+}
+function countEarlyRun(pool, nowMs) {
+    const key = dayKey(nowMs);
+    pool.earlyRuns =
+        pool.earlyRuns?.date === key ? { date: key, count: pool.earlyRuns.count + 1 } : { date: key, count: 1 };
+}
+function pickEarly(pool, hints, nowMs) {
+    const at = (h) => Date.parse(pool.sources[h.id].generatedAt);
+    return hints
+        .filter((h) => {
+        const e = pool.sources[h.id];
+        if (!e?.dirtySince)
+            return false;
+        if (nowMs - Date.parse(e.dirtySince) < EARLY_DEBOUNCE_MS)
+            return false;
+        return nowMs - Date.parse(e.generatedAt) >= EARLY_COOLDOWN_MS;
+    })
+        .sort((a, b) => at(a) - at(b))[0];
+}
 function tryResolve(deps, agentId) {
     try {
         return deps.resolveAgent(agentId);
@@ -66,6 +102,27 @@ function tryResolve(deps, agentId) {
         return undefined;
     }
 }
+async function markChangedSources(deps, pool, declared, nowMs) {
+    if (pool.eventCursor == null) {
+        pool.eventCursor = await deps.latestEventId();
+        return true;
+    }
+    const rows = await deps.listEventsSince(pool.eventCursor, EVENT_BATCH);
+    if (!rows.length)
+        return false;
+    for (const row of rows) {
+        for (const id of deps.shelfSources(String(row.type ?? ''))) {
+            if (!declared.has(id))
+                continue;
+            const entry = pool.sources[id];
+            if (!entry || entry.dirtySince)
+                continue;
+            entry.dirtySince = new Date(nowMs).toISOString();
+        }
+    }
+    pool.eventCursor = rows[rows.length - 1].id;
+    return true;
+}
 export async function refreshSystemStarters(deps = defaultDeps) {
     const [language, hints] = await Promise.all([currentLanguage(deps), deps.collectStarterHints()]);
     const agentId = (await deps.loadAgentId()) ?? deps.getDefaultAgentId();
@@ -82,6 +139,8 @@ export async function refreshSystemStarters(deps = defaultDeps) {
         }
     }
     const nowMs = deps.now();
+    if (await markChangedSources(deps, pool, declared, nowMs))
+        dirty = true;
     const stale = hints.find((h) => {
         const e = pool.sources[h.id];
         if (!e)
@@ -90,21 +149,25 @@ export async function refreshSystemStarters(deps = defaultDeps) {
             return true;
         return !fresh(e, nowMs);
     });
-    if (stale) {
+    const early = stale || !earlyBudgetLeft(pool, nowMs) ? undefined : pickEarly(pool, hints, nowMs);
+    const target = stale ?? early;
+    if (target) {
         const runtime = tryResolve(deps, agentId);
         if (runtime?.starters) {
             try {
-                const messages = await runtime.starters(stale.text);
-                pool.sources[stale.id] = {
+                const messages = await runtime.starters(target.text);
+                pool.sources[target.id] = {
                     messages,
                     generatedAt: new Date(nowMs).toISOString(),
-                    hintHash: stale.hash,
+                    hintHash: target.hash,
                     agentId,
                 };
+                if (target === early)
+                    countEarlyRun(pool, nowMs);
                 dirty = true;
             }
             catch (err) {
-                log.warn(`starters for ${stale.id} failed: ${err instanceof Error ? err.message : String(err)}`);
+                log.warn(`starters for ${target.id} failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }

package/dist/orchestrator/types.d.ts

@@ -60,11 +60,16 @@ export interface AgentDescriptor {
     title: string;
     presets: AgentPreset[];
 }
+export interface AgentBudget {
+    responseTimeout?: number;
+    toolRounds?: number;
+}
 export interface AgentRequest {
     system: string;
     messages: ConvMessage[];
     toolProvider?: AgentToolProvider;
     presetId?: string;
+    budget?: AgentBudget;
     onDelta?: (accumulated: string) => void;
     onReasoning?: (accumulated: string) => void;
     onSegment?: () => void;

package/dist/plugin-hooks.d.ts

@@ -25,8 +25,9 @@ export interface Migration {
 export interface PluginCtx {
     em: EntityManager;
     log: Logger;
+    signal?: AbortSignal;
 }
-export declare function pluginCtx(id: string, em: EntityManager): PluginCtx;
+export declare function pluginCtx(id: string, em: EntityManager, signal?: AbortSignal): PluginCtx;
 export interface Seed {
     name: string;
     run(ctx: PluginCtx): Promise<void> | void;

package/dist/plugin-hooks.js

@@ -1,6 +1,6 @@
 import { getLogger } from '@coffer-org/sdk/logger';
-export function pluginCtx(id, em) {
-    return { em, log: getLogger(id) };
+export function pluginCtx(id, em, signal) {
+    return { em, log: getLogger(id), ...(signal ? { signal } : {}) };
 }
 export class HttpError extends Error {
     status;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coffer-org/server",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -36,7 +36,7 @@
     "postpack": "node ../../scripts/swap-exports.mjs src"
   },
   "dependencies": {
-    "@coffer-org/sdk": "^7.0.0",
+    "@coffer-org/sdk": "^7.2.0",
     "@extractus/oembed-extractor": "^4.1.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/multipart": "^10.0.0",