@agent-native/core 0.213.1 → 0.216.0

package/dist/data-widgets/index.js

@@ -13,6 +13,71 @@ function isRecord(value) {
 function isString(value) {
     return typeof value === "string" && value.length > 0;
 }
+const MAX_DATA_CHART_AXIS_TICKS = 100;
+export const DATA_WIDGET_MAX_CHART_POINTS = 200;
+function chartRowsForRender(rows) {
+    return rows.slice(0, DATA_WIDGET_MAX_CHART_POINTS);
+}
+function numericWidgetValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value !== "string" || !value.trim())
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function hasBoundedValueAxisTicks(chart) {
+    const interval = chart.valueAxisTickInterval;
+    if (interval === undefined)
+        return true;
+    if (typeof interval !== "number" ||
+        !Number.isFinite(interval) ||
+        interval < 1e-12) {
+        return false;
+    }
+    const series = Array.isArray(chart.series) ? chart.series : [];
+    const rows = Array.isArray(chart.data) ? chartRowsForRender(chart.data) : [];
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        for (const item of series) {
+            if (!isRecord(item) || !isString(item.key))
+                continue;
+            const value = numericWidgetValue(row[item.key]);
+            if (value === null)
+                continue;
+            min = Math.min(min, value);
+            max = Math.max(max, value);
+        }
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        min = 0;
+        max = 1;
+    }
+    else {
+        if (chart.type === "bar" || chart.type === "area") {
+            min = Math.min(0, min);
+            max = Math.max(0, max);
+        }
+        if (min === max) {
+            const padding = Math.abs(max || 1) * 0.2;
+            min -= padding;
+            max += padding;
+        }
+    }
+    if (!Number.isFinite(max - min))
+        return false;
+    const firstTick = Math.ceil(min / interval - 1e-9);
+    const lastTick = Math.floor(max / interval + 1e-9);
+    const tickCount = lastTick - firstTick + 1;
+    return (Number.isSafeInteger(firstTick) &&
+        Number.isSafeInteger(lastTick) &&
+        Number.isSafeInteger(tickCount) &&
+        tickCount > 0 &&
+        tickCount <= MAX_DATA_CHART_AXIS_TICKS);
+}
 export function normalizeDataWidgetKind(value) {
     if (value === DATA_TABLE_WIDGET)
         return DATA_TABLE_WIDGET;
@@ -39,27 +104,132 @@ export function isDataChartWidget(value) {
     if (!isRecord(value))
         return false;
     return ((value.type === "bar" || value.type === "line" || value.type === "area") &&
+        (value.layout === undefined ||
+            value.layout === "horizontal" ||
+            value.layout === "vertical") &&
+        (value.xAxisTitle === undefined || typeof value.xAxisTitle === "string") &&
+        (value.yAxisTitle === undefined || typeof value.yAxisTitle === "string") &&
+        (value.showValueLabels === undefined ||
+            typeof value.showValueLabels === "boolean") &&
+        (value.contentHeight === undefined ||
+            (typeof value.contentHeight === "number" &&
+                Number.isFinite(value.contentHeight) &&
+                value.contentHeight > 0 &&
+                value.contentHeight <= 1200)) &&
+        (value.contentPadding === undefined ||
+            (typeof value.contentPadding === "number" &&
+                Number.isFinite(value.contentPadding) &&
+                value.contentPadding >= 0 &&
+                value.contentPadding <= 64)) &&
+        (value.labelFontFamily === undefined ||
+            value.labelFontFamily === "sans" ||
+            value.labelFontFamily === "serif" ||
+            value.labelFontFamily === "mono") &&
+        (value.labelFontSize === undefined ||
+            (typeof value.labelFontSize === "number" &&
+                Number.isInteger(value.labelFontSize) &&
+                value.labelFontSize >= 8 &&
+                value.labelFontSize <= 24)) &&
+        (value.axisTitleFontSize === undefined ||
+            (typeof value.axisTitleFontSize === "number" &&
+                Number.isInteger(value.axisTitleFontSize) &&
+                value.axisTitleFontSize >= 8 &&
+                value.axisTitleFontSize <= 24)) &&
+        (value.axisTitleFontWeight === undefined ||
+            value.axisTitleFontWeight === 400 ||
+            value.axisTitleFontWeight === 500) &&
+        (value.valueLabelFontSize === undefined ||
+            (typeof value.valueLabelFontSize === "number" &&
+                Number.isInteger(value.valueLabelFontSize) &&
+                value.valueLabelFontSize >= 8 &&
+                value.valueLabelFontSize <= 24)) &&
+        (value.valueLabelFontWeight === undefined ||
+            value.valueLabelFontWeight === 400 ||
+            value.valueLabelFontWeight === 500) &&
+        (value.horizontalCategoryGapRatio === undefined ||
+            (typeof value.horizontalCategoryGapRatio === "number" &&
+                Number.isFinite(value.horizontalCategoryGapRatio) &&
+                value.horizontalCategoryGapRatio >= 0 &&
+                value.horizontalCategoryGapRatio <= 0.9)) &&
+        (value.sampled === undefined || typeof value.sampled === "boolean") &&
+        (value.truncated === undefined || typeof value.truncated === "boolean") &&
+        hasBoundedValueAxisTicks(value) &&
         isString(value.xKey) &&
         Array.isArray(value.series) &&
         value.series.every((series) => isRecord(series) &&
             isString(series.key) &&
             isString(series.label) &&
             (series.color === undefined || typeof series.color === "string")) &&
+        (value.actions === undefined ||
+            (Array.isArray(value.actions) &&
+                value.actions.every(isDataWidgetChartAction))) &&
         Array.isArray(value.data) &&
         value.data.every(isRecord));
 }
-function isPrimaryAction(value) {
-    return isRecord(value) && isString(value.label) && isString(value.href);
+function isDataWidgetActionIcon(value) {
+    return value === "explore" || value === "camera" || value === "notebook";
+}
+function isDataWidgetAction(value) {
+    return (isRecord(value) &&
+        isString(value.label) &&
+        isString(value.href) &&
+        (value.icon === undefined || isDataWidgetActionIcon(value.icon)));
+}
+function isDataWidgetChartAction(value) {
+    const presentation = isRecord(value) ? value.presentation : undefined;
+    return (isDataWidgetAction(value) &&
+        (presentation === undefined || presentation === "icon"));
+}
+function normalizePrimaryAction(value) {
+    if (!isRecord(value) || !isString(value.label) || !isString(value.href)) {
+        return undefined;
+    }
+    return {
+        label: value.label,
+        href: value.href,
+        ...(isDataWidgetActionIcon(value.icon) ? { icon: value.icon } : {}),
+    };
+}
+function isDataWidgetDataSource(value) {
+    return (isRecord(value) &&
+        isString(value.label) &&
+        (value.id === undefined || typeof value.id === "string") &&
+        (value.href === undefined || isString(value.href)));
+}
+function isDataWidgetDisplayAction(value) {
+    if (!isRecord(value) ||
+        !isString(value.label) ||
+        (value.id !== undefined && typeof value.id !== "string")) {
+        return false;
+    }
+    if (value.type === "link") {
+        return (isString(value.href) &&
+            (value.icon === undefined || isDataWidgetActionIcon(value.icon)) &&
+            (value.presentation === undefined || value.presentation === "icon"));
+    }
+    if (value.type === "copy")
+        return isString(value.text);
+    return false;
 }
 function normalizeDisplay(value) {
-    if (!isRecord(value))
+    if (value === undefined)
         return undefined;
+    if (!isRecord(value))
+        return null;
+    if ((value.sources !== undefined &&
+        (!Array.isArray(value.sources) ||
+            !value.sources.every(isDataWidgetDataSource))) ||
+        (value.actions !== undefined &&
+            (!Array.isArray(value.actions) ||
+                !value.actions.every(isDataWidgetDisplayAction)))) {
+        return null;
+    }
     return {
         title: typeof value.title === "string" ? value.title : undefined,
         description: typeof value.description === "string" ? value.description : undefined,
-        primaryAction: isPrimaryAction(value.primaryAction)
-            ? value.primaryAction
-            : undefined,
+        primaryAction: normalizePrimaryAction(value.primaryAction),
+        sources: value.sources,
+        actions: value.actions,
     };
 }
 function assertDataTableWidget(table) {
@@ -107,6 +277,9 @@ export function normalizeDataWidgetResult(value) {
     const widget = normalizeDataWidgetKind(value.widget);
     if (!widget)
         return null;
+    const display = normalizeDisplay(value.display);
+    if (display === null)
+        return null;
     const table = isDataTableWidget(value.table) ? value.table : undefined;
     const chartSeries = isDataChartWidget(value.chartSeries)
         ? value.chartSeries
@@ -115,7 +288,7 @@ export function normalizeDataWidgetResult(value) {
         widgetId: typeof value.widgetId === "string" ? value.widgetId : undefined,
         title: typeof value.title === "string" ? value.title : undefined,
         summary: isRecord(value.summary) ? value.summary : undefined,
-        display: normalizeDisplay(value.display),
+        display,
     };
     if (widget === DATA_TABLE_WIDGET) {
         if (!table)
@@ -148,7 +321,6 @@ export function isDataWidgetResult(value) {
     return normalizeDataWidgetResult(value) !== null;
 }
 export const DATA_WIDGET_MAX_ROWS = 50;
-export const DATA_WIDGET_MAX_CHART_POINTS = 200;
 export function clampDataWidgetRows(result) {
     const source = result;
     const table = source.table;
@@ -165,8 +337,9 @@ export function clampDataWidgetRows(result) {
     const clampedChart = chartSeries && chartSeries.data.length > DATA_WIDGET_MAX_CHART_POINTS
         ? {
             ...chartSeries,
-            data: chartSeries.data.slice(0, DATA_WIDGET_MAX_CHART_POINTS),
+            data: chartRowsForRender(chartSeries.data),
             sampled: true,
+            truncated: true,
         }
         : chartSeries;
     if (clampedTable === table && clampedChart === chartSeries)
@@ -201,27 +374,85 @@ const dataChartSeriesDefinitionSchema = z
     color: z.string().optional(),
 })
     .passthrough();
+const dataWidgetActionSchema = z
+    .object({
+    label: z.string().min(1),
+    href: z.string().min(1),
+    icon: z.enum(["explore", "camera", "notebook"]).optional(),
+    presentation: z.literal("icon").optional(),
+})
+    .passthrough();
 export const dataChartWidgetSchema = z
     .object({
     type: z.enum(["bar", "line", "area"]),
     title: z.string().optional(),
+    layout: z.enum(["horizontal", "vertical"]).optional(),
+    xAxisTitle: z.string().optional(),
+    yAxisTitle: z.string().optional(),
+    showValueLabels: z.boolean().optional(),
+    contentHeight: z.number().positive().max(1200).optional(),
+    contentPadding: z.number().min(0).max(64).optional(),
+    labelFontFamily: z.enum(["sans", "serif", "mono"]).optional(),
+    labelFontSize: z.number().int().min(8).max(24).optional(),
+    axisTitleFontSize: z.number().int().min(8).max(24).optional(),
+    axisTitleFontWeight: z.union([z.literal(400), z.literal(500)]).optional(),
+    valueLabelFontSize: z.number().int().min(8).max(24).optional(),
+    valueLabelFontWeight: z.union([z.literal(400), z.literal(500)]).optional(),
+    valueAxisTickInterval: z.number().finite().min(1e-12).optional(),
+    horizontalCategoryGapRatio: z.number().finite().min(0).max(0.9).optional(),
     xKey: z.string().min(1),
     series: z.array(dataChartSeriesDefinitionSchema).min(1),
     data: z.array(z.record(z.string(), z.unknown())),
     sampled: z.boolean().optional(),
+    truncated: z.boolean().optional(),
+    actions: z.array(dataWidgetActionSchema).optional(),
 })
     .passthrough();
+const boundedDataChartWidgetSchema = dataChartWidgetSchema.refine(hasBoundedValueAxisTicks, {
+    path: ["valueAxisTickInterval"],
+    message: `valueAxisTickInterval must produce between 1 and ${MAX_DATA_CHART_AXIS_TICKS} ticks.`,
+});
 const primaryActionSchema = z
     .object({
     label: z.string().min(1),
     href: z.string().min(1),
+    icon: z.enum(["explore", "camera", "notebook"]).optional(),
 })
     .passthrough();
+const dataWidgetDataSourceSchema = z
+    .object({
+    id: z.string().optional(),
+    label: z.string().min(1),
+    href: z.string().min(1).optional(),
+})
+    .passthrough();
+const dataWidgetDisplayActionSchema = z.discriminatedUnion("type", [
+    z
+        .object({
+        id: z.string().optional(),
+        type: z.literal("link"),
+        label: z.string().min(1),
+        href: z.string().min(1),
+        icon: z.enum(["explore", "camera", "notebook"]).optional(),
+        presentation: z.literal("icon").optional(),
+    })
+        .passthrough(),
+    z
+        .object({
+        id: z.string().optional(),
+        type: z.literal("copy"),
+        label: z.string().min(1),
+        text: z.string().min(1),
+    })
+        .passthrough(),
+]);
 const dataWidgetDisplaySchema = z
     .object({
     title: z.string().optional(),
     description: z.string().optional(),
     primaryAction: primaryActionSchema.optional(),
+    sources: z.array(dataWidgetDataSourceSchema).optional(),
+    actions: z.array(dataWidgetDisplayActionSchema).optional(),
 })
     .passthrough();
 const dataWidgetBaseSchema = z
@@ -241,14 +472,14 @@ export const dataTableWidgetResultSchema = dataWidgetBaseSchema
 export const dataChartWidgetResultSchema = dataWidgetBaseSchema
     .extend({
     widget: z.literal(DATA_CHART_WIDGET),
-    chartSeries: dataChartWidgetSchema,
+    chartSeries: boundedDataChartWidgetSchema,
 })
     .passthrough();
 export const dataInsightsWidgetResultSchema = dataWidgetBaseSchema
     .extend({
     widget: z.literal(DATA_INSIGHTS_WIDGET),
     table: dataTableWidgetSchema.optional(),
-    chartSeries: dataChartWidgetSchema.optional(),
+    chartSeries: boundedDataChartWidgetSchema.optional(),
 })
     .passthrough()
     .refine((value) => value.table || value.chartSeries, {

package/dist/db/migrations.js

@@ -251,8 +251,11 @@ export function runMigrations(migrationSource, options) {
                             args: [migration.version],
                         });
                     }
+                    // Callbacks are idempotent by contract (store-registry retries them
+                    // the same way), so a concurrent CREATE TABLE losing a pg_type race
+                    // retries instead of escaping and exiting the server.
                     const runResult = migration.run
-                        ? await migration.run(exec)
+                        ? await retryOnDdlRace(() => migration.run(exec))
                         : undefined;
                     if (runResult === MIGRATION_DEFERRED) {
                         console.info(`[db] Deferred migration ${label}; it remains pending for a later boot`);

package/dist/db/schema-snapshot.generated.js

@@ -17,7 +17,7 @@ export const SCHEMA_SNAPSHOT = {
         'CREATE TABLE "a2a_tasks" (\n  "id" text NOT NULL,\n  "context_id" text,\n  "status_state" text DEFAULT \'submitted\'::text NOT NULL,\n  "status_message" text,\n  "status_timestamp" text NOT NULL,\n  "history" text DEFAULT \'[]\'::text NOT NULL,\n  "artifacts" text DEFAULT \'[]\'::text NOT NULL,\n  "metadata" text,\n  "owner_email" text,\n  "owner_scope" text DEFAULT \'\'::text NOT NULL,\n  "idempotency_key" text,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL\n);',
         'CREATE TABLE "account" (\n  "id" text NOT NULL,\n  "account_id" text NOT NULL,\n  "provider_id" text NOT NULL,\n  "user_id" text NOT NULL,\n  "access_token" text,\n  "refresh_token" text,\n  "id_token" text,\n  "access_token_expires_at" timestamp with time zone,\n  "refresh_token_expires_at" timestamp with time zone,\n  "scope" text,\n  "password" text,\n  "created_at" timestamp with time zone NOT NULL,\n  "updated_at" timestamp with time zone NOT NULL\n);',
         'CREATE TABLE "agent_audit_log" (\n  "id" text NOT NULL,\n  "created_at" bigint NOT NULL,\n  "action" text NOT NULL,\n  "caller" text NOT NULL,\n  "actor_kind" text NOT NULL,\n  "actor_email" text,\n  "org_id" text,\n  "thread_id" text,\n  "turn_id" text,\n  "target_type" text,\n  "target_id" text,\n  "status" text DEFAULT \'success\'::text NOT NULL,\n  "summary" text,\n  "input" text,\n  "error_code" text,\n  "owner_email" text,\n  "visibility" text DEFAULT \'private\'::text NOT NULL,\n  "run_id" text,\n  "task_id" text,\n  "parent_task_id" text,\n  "source_kind" text,\n  "source_platform" text,\n  "source_id" text,\n  "source_url" text,\n  "network_protocol" text,\n  "network_id" text,\n  "network_peer" text,\n  "app" text,\n  "reported_client_name" text,\n  "reported_client_version" text,\n  "oauth_client_id" text,\n  "approval" text,\n  "identity_assurance" text\n);',
-        'CREATE TABLE "agent_chat_submission_inbox" (\n  "thread_id" text NOT NULL,\n  "message_id" text NOT NULL,\n  "state" text NOT NULL,\n  "actor_email" text NOT NULL,\n  "actor_auth_user_id" text,\n  "actor_identity_authenticated_at_ms" bigint,\n  "actor_name" text,\n  "actor_org_id" text,\n  "actor_org_scope" text,\n  "actor_anonymous" boolean DEFAULT false NOT NULL,\n  "payload_hash" text NOT NULL,\n  "payload_json" text NOT NULL,\n  "interrupt_active_run" boolean DEFAULT false NOT NULL,\n  "submitted_run_id" text,\n  "queue_order" bigint DEFAULT nextval(\'agent_chat_submission_inbox_queue_order_seq\'::regclass) NOT NULL,\n  "move_to_top_at" bigint,\n  "retry_after" bigint,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "interrupt_run_id" text\n);',
+        'CREATE TABLE "agent_chat_submission_inbox" (\n  "thread_id" text NOT NULL,\n  "message_id" text NOT NULL,\n  "state" text NOT NULL,\n  "actor_email" text NOT NULL,\n  "actor_auth_user_id" text,\n  "actor_identity_authenticated_at_ms" bigint,\n  "actor_name" text,\n  "actor_org_id" text,\n  "actor_org_scope" text,\n  "actor_anonymous" boolean DEFAULT false NOT NULL,\n  "payload_hash" text NOT NULL,\n  "payload_json" text NOT NULL,\n  "interrupt_active_run" boolean DEFAULT false NOT NULL,\n  "submitted_run_id" text,\n  "queue_order" bigint DEFAULT nextval(\'agent_chat_submission_inbox_queue_order_seq\'::regclass) NOT NULL,\n  "move_to_top_at" bigint,\n  "retry_after" bigint,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "interrupt_run_id" text,\n  "retry_count" integer DEFAULT 0 NOT NULL\n);',
         'CREATE TABLE "agent_checkpoints" (\n  "id" text NOT NULL,\n  "thread_id" text NOT NULL,\n  "run_id" text,\n  "commit_sha" text NOT NULL,\n  "message" text DEFAULT \'\'::text NOT NULL,\n  "created_at" bigint NOT NULL\n);',
         'CREATE TABLE "agent_eval_datasets" (\n  "id" text NOT NULL,\n  "name" text NOT NULL,\n  "description" text DEFAULT \'\'::text NOT NULL,\n  "entries" text DEFAULT \'[]\'::text NOT NULL,\n  "created_at" bigint NOT NULL,\n  "updated_at" bigint NOT NULL,\n  "user_id" text,\n  "idempotency_key" text\n);',
         'CREATE TABLE "agent_evals" (\n  "id" text NOT NULL,\n  "run_id" text NOT NULL,\n  "thread_id" text,\n  "user_id" text,\n  "eval_type" text NOT NULL,\n  "criteria" text NOT NULL,\n  "score" real DEFAULT 0 NOT NULL,\n  "reasoning" text,\n  "metadata" text,\n  "created_at" bigint NOT NULL\n);',
@@ -389,6 +389,7 @@ export const SCHEMA_SNAPSHOT = {
         "CREATE INDEX idx_audit_target ON public.agent_audit_log USING btree (target_type, target_id, created_at);",
         "CREATE INDEX idx_audit_turn ON public.agent_audit_log USING btree (turn_id);",
         "CREATE INDEX agent_chat_submission_inbox_pending_idx ON public.agent_chat_submission_inbox USING btree (state, retry_after, interrupt_active_run DESC, move_to_top_at DESC, queue_order);",
+        "CREATE INDEX agent_chat_submission_inbox_thread_pending_idx ON public.agent_chat_submission_inbox USING btree (thread_id, interrupt_active_run DESC, move_to_top_at DESC, queue_order) WHERE (state = 'queued'::text);",
         "CREATE INDEX agent_checkpoints_run_idx ON public.agent_checkpoints USING btree (run_id);",
         "CREATE INDEX agent_checkpoints_thread_created_idx ON public.agent_checkpoints USING btree (thread_id, created_at);",
         "CREATE UNIQUE INDEX idx_eval_datasets_idempotency ON public.agent_eval_datasets USING btree (idempotency_key);",
@@ -959,6 +960,12 @@ export const SCHEMA_SNAPSHOT = {
             "953882e24b68e4fb",
         ],
         ["chat_threads", "chat-thread-inbox-interrupt-replay", "904890f43aebd9fe"],
+        ["chat_threads", "chat-thread-inbox-retry-count", "b25ff25b6a61ccc9"],
+        [
+            "chat_threads",
+            "chat-thread-inbox-thread-order-index",
+            "78d46649cafade48",
+        ],
         ["chat_threads", "chat-thread-shares-notified-at", "f2a3dce63fe66310"],
         ["chat_threads", "chat-threads-base-tables", "bfeaaa8ca4af1288"],
         [

package/dist/feature-flags/actions/set-feature-flag.js

@@ -41,6 +41,11 @@ export default defineAction({
         }),
         summary: (args) => `Feature flag ${args.key}: ${args.operation}`,
     },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const manager = await requireFeatureFlagManager(ctx ?? {});
         if (!getFeatureFlagDefinition(args.key)) {

package/dist/feature-flags/index.d.ts

@@ -1,2 +1,2 @@
 export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, SETTINGS_REDESIGN_FLAG, type FeatureFlagDefinition, } from "./registry.js";
-export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./store.js";
+export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, FeatureFlagRulesError, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, getFeatureFlagRulesStrict, normalizeFeatureFlagRules, type FeatureFlagMode, type FeatureFlagRules, type FeatureFlagScope, } from "./store.js";

package/dist/feature-flags/index.js

@@ -1,2 +1,2 @@
 export { BUILDER_CREDIT_USAGE_REPORTING_FLAG, CONNECT_APPS_FLAG, defineFeatureFlag, defineFeatureFlags, getFeatureFlagDefinition, listFeatureFlags, registerFeatureFlags, SETTINGS_REDESIGN_FLAG, } from "./registry.js";
-export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, normalizeFeatureFlagRules, } from "./store.js";
+export { defaultFeatureFlagRules, evaluateFeatureFlag, evaluateFeatureFlagRules, FeatureFlagRulesError, hasActiveFeatureFlagRollout, isFeatureFlagEnabled, getFeatureFlagRules, getFeatureFlagRulesStrict, normalizeFeatureFlagRules, } from "./store.js";

package/dist/feature-flags/store.d.ts

@@ -20,6 +20,18 @@ export declare const FEATURE_FLAG_SETTINGS_PREFIX = "feature-flag:";
 export declare function defaultFeatureFlagRules(): FeatureFlagRules;
 export declare function normalizeFeatureFlagRules(value: unknown): FeatureFlagRules;
 export declare function getFeatureFlagRules(key: string, scope: Pick<FeatureFlagScope, "orgId" | "transaction">): Promise<FeatureFlagRules>;
+export declare class FeatureFlagRulesError extends Error {
+    readonly code: "unregistered" | "malformed";
+    readonly key: string;
+    constructor(code: "unregistered" | "malformed", key: string, detail: string);
+}
+/**
+ * Reads a flag's rules for callers that route data on it. Unconfigured reads
+ * as off, like `getFeatureFlagRules`, but an unregistered key or malformed
+ * stored rules throw `FeatureFlagRulesError` instead of normalizing to off:
+ * for a routing flag, "off" and "unreadable" choose different write paths.
+ */
+export declare function getFeatureFlagRulesStrict(key: string, scope: Pick<FeatureFlagScope, "orgId" | "transaction">): Promise<FeatureFlagRules>;
 export declare function getFeatureFlagRulesForKeys(keys: readonly string[], scope: Pick<FeatureFlagScope, "orgId" | "transaction">): Promise<Map<string, FeatureFlagRules>>;
 /**
  * Anonymous discovery hint for a rollout that may be scoped to an org.

package/dist/feature-flags/store.js

@@ -1,6 +1,6 @@
 import { getDbExec } from "../db/client.js";
-import { getOrgSetting, mutateOrgSetting } from "../settings/org-settings.js";
-import { getSetting, getSettings, mutateSetting } from "../settings/store.js";
+import { getOrgSetting, getOrgSettingEntry, mutateOrgSetting, } from "../settings/org-settings.js";
+import { getSetting, getSettingEntry, getSettings, mutateSetting, } from "../settings/store.js";
 import { getFeatureFlagDefinition, } from "./registry.js";
 export const FEATURE_FLAG_SETTINGS_PREFIX = "feature-flag:";
 const FEATURE_FLAG_ROLLOUT_INDEX_PREFIX = "feature-flag-rollout-index:";
@@ -113,17 +113,89 @@ export function normalizeFeatureFlagRules(value) {
             : null,
     };
 }
-export async function getFeatureFlagRules(key, scope) {
-    if (!getFeatureFlagDefinition(key))
-        return defaultFeatureFlagRules();
+async function readStoredFeatureFlagRules(key, scope) {
     const orgId = scope.orgId?.trim();
     if (!orgId)
-        return normalizeFeatureFlagRules(await getSetting(settingKey(key), { transaction: scope.transaction }));
+        return getSetting(settingKey(key), { transaction: scope.transaction });
     const [orgStored, globalStored] = await Promise.all([
         getOrgSetting(orgId, settingKey(key), { transaction: scope.transaction }),
         getSetting(settingKey(key), { transaction: scope.transaction }),
     ]);
-    return normalizeFeatureFlagRules(orgStored ?? globalStored);
+    return orgStored ?? globalStored;
+}
+export async function getFeatureFlagRules(key, scope) {
+    if (!getFeatureFlagDefinition(key))
+        return defaultFeatureFlagRules();
+    return normalizeFeatureFlagRules(await readStoredFeatureFlagRules(key, scope));
+}
+export class FeatureFlagRulesError extends Error {
+    code;
+    key;
+    constructor(code, key, detail) {
+        super(`Feature flag ${key}: ${detail}`);
+        this.code = code;
+        this.key = key;
+        this.name = "FeatureFlagRulesError";
+    }
+}
+async function readStoredFeatureFlagRulesEntry(key, scope) {
+    const orgId = scope.orgId?.trim();
+    const options = { transaction: scope.transaction };
+    if (!orgId)
+        return getSettingEntry(settingKey(key), options);
+    const [orgEntry, globalEntry] = await Promise.all([
+        getOrgSettingEntry(orgId, settingKey(key), options),
+        getSettingEntry(settingKey(key), options),
+    ]);
+    return orgEntry.found ? orgEntry : globalEntry;
+}
+function storedRulesProblem(stored) {
+    if (!stored || typeof stored !== "object" || Array.isArray(stored))
+        return `stored rules are ${stored === null ? "null" : Array.isArray(stored) ? "a list" : typeof stored}, not an object`;
+    const value = stored;
+    if (value.version !== 1)
+        return `stored version ${JSON.stringify(value.version) ?? "undefined"} is not 1`;
+    if (value.mode !== "off" && value.mode !== "on" && value.mode !== "rules")
+        return `stored mode ${JSON.stringify(value.mode)} is not off, on, or rules`;
+    for (const field of ["emails", "orgIds"]) {
+        const list = value[field];
+        if (list !== undefined &&
+            !(Array.isArray(list) && list.every((item) => typeof item === "string")))
+            return `stored ${field} is not a list of strings`;
+    }
+    const percentage = value.percentage;
+    if (percentage !== undefined &&
+        !(typeof percentage === "number" &&
+            Number.isInteger(percentage) &&
+            percentage >= 0 &&
+            percentage <= 100))
+        return "stored percentage is not a whole number from 0 to 100";
+    return null;
+}
+/**
+ * Reads a flag's rules for callers that route data on it. Unconfigured reads
+ * as off, like `getFeatureFlagRules`, but an unregistered key or malformed
+ * stored rules throw `FeatureFlagRulesError` instead of normalizing to off:
+ * for a routing flag, "off" and "unreadable" choose different write paths.
+ */
+export async function getFeatureFlagRulesStrict(key, scope) {
+    if (!getFeatureFlagDefinition(key))
+        throw new FeatureFlagRulesError("unregistered", key, "not registered");
+    let stored;
+    try {
+        stored = await readStoredFeatureFlagRulesEntry(key, scope);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            throw new FeatureFlagRulesError("malformed", key, "stored rules are not JSON");
+        throw error;
+    }
+    if (!stored.found)
+        return defaultFeatureFlagRules();
+    const problem = storedRulesProblem(stored.value);
+    if (problem)
+        throw new FeatureFlagRulesError("malformed", key, problem);
+    return normalizeFeatureFlagRules(stored.value);
 }
 export async function getFeatureFlagRulesForKeys(keys, scope) {
     const uniqueKeys = [...new Set(keys)].filter((key) => getFeatureFlagDefinition(key));

package/dist/file-upload/actions/manage-file-storage.js

@@ -27,6 +27,11 @@ export default defineAction({
             ? "Cleared file storage credentials"
             : "Saved file storage settings",
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     run: async ({ operation, ...values }, ctx) => operation === "clear"
         ? clearFileStorage(ctx)
         : { removedKeys: [], status: await saveFileStorage(ctx, values) },

package/dist/file-upload/actions/upload-image.js

@@ -442,6 +442,11 @@ export default defineAction({
         .refine((args) => args.cleanup ? !!args.idempotencyKey : !!args.data || !!args.url, {
         message: "Either a data/url upload or an idempotencyKey cleanup is required.",
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: true,
+    },
     run: async (args) => {
         const idempotencyKey = args.idempotencyKey?.trim();
         if (args.cleanup && idempotencyKey) {

package/dist/framework-tools.js

@@ -165,6 +165,8 @@ export const CORE_ACTION_GROUPS = {
     "change-password": "userProfile",
     "request-privacy-right": "userProfile",
     "change-appearance": "userProfile",
+    "get-theme-family": "userProfile",
+    "set-theme-family": "userProfile",
     "list-audit-events": "audit",
     "get-audit-event": "audit",
     "export-audit-events": "audit",

package/dist/history/actions/create-resource-version.js

@@ -13,6 +13,11 @@ const schema = z.object({
 export default defineAction({
     description: "Create a reusable version-history snapshot for a resource.",
     schema,
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const actionCtx = ctx;
         const access = await assertVersionedResourceAccess(args.resourceType, args.resourceId, actionCtx, "editor");

package/dist/history/actions/restore-resource-version.js

@@ -16,6 +16,11 @@ const schema = z
 export default defineAction({
     description: "Restore a resource from a reusable version-history snapshot.",
     schema,
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const actionCtx = ctx;
         const scope = {

package/dist/ingestion/index.d.ts

@@ -1,7 +1,7 @@
 export { acquireIngestionLease, assertInventoryComplete, consumeIngestionBudget, createIngestionBudgetState, createIngestionCheckpoint, ingestionBudgetStopReason, releaseIngestionLease, renewIngestionLease, type AcquireIngestionLeaseInput, type AcquireIngestionLeaseResult, type IngestionBudgetLimits, type IngestionBudgetState, type IngestionBudgetStopReason, type IngestionCheckpoint, type IngestionLease, type IngestionPhase, } from "./orchestration.js";
 export { detectOfficeDocumentType, normalizeDocumentText, parseOfficeDocument, type OfficeDocumentAst, type OfficeDocumentParser, type OfficeDocumentPart, type OfficeDocumentType, type ParsedOfficeDocument, type ParseOfficeDocumentInput, } from "./office.js";
 export { detectSpreadsheetDocumentType, isSpreadsheetDocument, parseSpreadsheetDocument, type ParsedSpreadsheetDocument, type ParsedSpreadsheetSheet, type ParseSpreadsheetDocumentInput, type SpreadsheetDocumentType, } from "./spreadsheet.js";
-export { parsePptxPresentation, type ParsedPptxImage, type ParsedPptxElement, type ParsedPptxGrid, type ParsedPptxParagraph, type ParsedPptxPresentation, type ParsedPptxSlide, type ParsedPptxTextRun, } from "./pptx.js";
+export { DEFAULT_PPTX_IMAGE_BYTE_LIMITS, PptxImageByteLimitError, parsePptxPresentation, type ParsedPptxImage, type ParsedPptxElement, type ParsedPptxGrid, type ParsedPptxParagraph, type ParsedPptxPresentation, type ParsedPptxSlide, type ParsedPptxTextRun, type PptxImageByteLimits, } from "./pptx.js";
 export { extractDocxSections, parseDocxDocument, sanitizeInertDocumentHtml, type ParsedDocxDocument, type ParsedDocxSection, } from "./docx.js";
 export { compositeFigmaColors, extractFigmaTopLevelFrames, figmaColorToHex, figmaContrastRatio, summarizeFigmaFrame, summarizeFigmaNode, type FigmaContextNode, type FigmaFrameSummary, type FigmaRgba, type SummarizeFigmaNodeResult, } from "./figma.js";
 export { cssBlendMode, gradientAngleDegreesFromHandles, gradientGeometryFromTransform, gradientRayAngleDegreesFromHandles, handlePositionsFromArrayTransform, handlePositionsFromObjectTransform, invert2x3, mat2x3FromArray, remapLinearStopPosition, resolveGradientHandles, vectorLength, type BlendModeResult, type BlendVerdict, type GradientGeometry, type GradientHandles, type GradientKind, type Mat2x3Array, type Mat2x3Object, type Vec2, } from "./figma-paint-math.js";

package/dist/ingestion/index.js

@@ -1,7 +1,7 @@
 export { acquireIngestionLease, assertInventoryComplete, consumeIngestionBudget, createIngestionBudgetState, createIngestionCheckpoint, ingestionBudgetStopReason, releaseIngestionLease, renewIngestionLease, } from "./orchestration.js";
 export { detectOfficeDocumentType, normalizeDocumentText, parseOfficeDocument, } from "./office.js";
 export { detectSpreadsheetDocumentType, isSpreadsheetDocument, parseSpreadsheetDocument, } from "./spreadsheet.js";
-export { parsePptxPresentation, } from "./pptx.js";
+export { DEFAULT_PPTX_IMAGE_BYTE_LIMITS, PptxImageByteLimitError, parsePptxPresentation, } from "./pptx.js";
 export { extractDocxSections, parseDocxDocument, sanitizeInertDocumentHtml, } from "./docx.js";
 export { compositeFigmaColors, extractFigmaTopLevelFrames, figmaColorToHex, figmaContrastRatio, summarizeFigmaFrame, summarizeFigmaNode, } from "./figma.js";
 export { cssBlendMode, gradientAngleDegreesFromHandles, gradientGeometryFromTransform, gradientRayAngleDegreesFromHandles, handlePositionsFromArrayTransform, handlePositionsFromObjectTransform, invert2x3, mat2x3FromArray, remapLinearStopPosition, resolveGradientHandles, vectorLength, } from "./figma-paint-math.js";

package/dist/ingestion/pptx.d.ts

@@ -155,7 +155,18 @@ export interface ParsedPptxPresentation {
     };
     hiddenSlideCount?: number;
 }
+export interface PptxImageByteLimits {
+    maxImageBytes: number;
+    maxTotalImageBytes: number;
+}
+export declare const DEFAULT_PPTX_IMAGE_BYTE_LIMITS: Readonly<PptxImageByteLimits>;
+export declare class PptxImageByteLimitError extends Error {
+    readonly limit: "per-image" | "aggregate";
+    readonly maxBytes: number;
+    constructor(limit: "per-image" | "aggregate", maxBytes: number);
+}
 export declare function parsePptxPresentation(fileBuffer: Uint8Array, options?: {
     includeHiddenSlides?: boolean;
+    imageByteLimits?: Readonly<PptxImageByteLimits>;
 }): Promise<ParsedPptxPresentation>;
 export declare function parsePptxSlideMetadata(value: unknown): ParsedPptxSlideMetadata;