@agent-native/core 0.214.0 → 0.217.0

package/dist/data-widgets/index.d.ts

@@ -27,6 +27,9 @@ export interface DataWidgetAction {
     href: string;
     icon?: DataWidgetActionIcon;
 }
+export interface DataWidgetChartAction extends DataWidgetAction {
+    presentation?: "icon";
+}
 export interface DataChartWidget {
     type: "bar" | "line" | "area";
     title?: string;
@@ -46,11 +49,15 @@ export interface DataChartWidget {
     axisTitleFontWeight?: 400 | 500;
     valueLabelFontSize?: number;
     valueLabelFontWeight?: 400 | 500;
+    valueAxisTickInterval?: number;
+    /** Fraction of each horizontal-bar category slot left empty; defaults to the existing spacing. */
+    horizontalCategoryGapRatio?: number;
     xKey: string;
     series: DataChartSeriesDefinition[];
     data: Array<Record<string, unknown>>;
     sampled?: boolean;
-    actions?: DataWidgetAction[];
+    truncated?: boolean;
+    actions?: DataWidgetChartAction[];
 }
 export interface DataWidgetDisplay {
     title?: string;
@@ -70,6 +77,7 @@ export type DataWidgetDisplayAction = {
     label: string;
     href: string;
     icon?: DataWidgetActionIcon;
+    presentation?: "icon";
 } | {
     id?: string;
     type: "copy";
@@ -109,6 +117,7 @@ export type DataInsightsWidgetResult<Input extends DataInsightsWidgetResultInput
     widget: typeof DATA_INSIGHTS_WIDGET;
 };
 export type DataWidgetResult = DataTableWidgetResult | DataChartWidgetResult | DataInsightsWidgetResult;
+export declare const DATA_WIDGET_MAX_CHART_POINTS = 200;
 export declare function normalizeDataWidgetKind(value: unknown): DataWidgetKind | null;
 export declare function isDataTableWidget(value: unknown): value is DataTableWidget;
 export declare function isDataChartWidget(value: unknown): value is DataChartWidget;
@@ -126,7 +135,6 @@ export declare function createDataInsightsWidgetResult<const Input extends DataI
 export declare function normalizeDataWidgetResult(value: unknown): DataWidgetResult | null;
 export declare function isDataWidgetResult(value: unknown): value is DataWidgetResult;
 export declare const DATA_WIDGET_MAX_ROWS = 50;
-export declare const DATA_WIDGET_MAX_CHART_POINTS = 200;
 export declare function clampDataWidgetRows(result: DataWidgetResult): DataWidgetResult;
 export declare const dataTableWidgetSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
@@ -169,6 +177,8 @@ export declare const dataChartWidgetSchema: z.ZodObject<{
     axisTitleFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
     valueLabelFontSize: z.ZodOptional<z.ZodNumber>;
     valueLabelFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
+    valueAxisTickInterval: z.ZodOptional<z.ZodNumber>;
+    horizontalCategoryGapRatio: z.ZodOptional<z.ZodNumber>;
     xKey: z.ZodString;
     series: z.ZodArray<z.ZodObject<{
         key: z.ZodString;
@@ -177,6 +187,7 @@ export declare const dataChartWidgetSchema: z.ZodObject<{
     }, z.core.$loose>>;
     data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     sampled: z.ZodOptional<z.ZodBoolean>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
     actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
         label: z.ZodString;
         href: z.ZodString;
@@ -185,6 +196,7 @@ export declare const dataChartWidgetSchema: z.ZodObject<{
             explore: "explore";
             notebook: "notebook";
         }>>;
+        presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;
 export declare const dataTableWidgetResultSchema: z.ZodObject<{
@@ -218,6 +230,7 @@ export declare const dataTableWidgetResultSchema: z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -273,6 +286,7 @@ export declare const dataChartWidgetResultSchema: z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -307,6 +321,8 @@ export declare const dataChartWidgetResultSchema: z.ZodObject<{
         axisTitleFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
         valueLabelFontSize: z.ZodOptional<z.ZodNumber>;
         valueLabelFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
+        valueAxisTickInterval: z.ZodOptional<z.ZodNumber>;
+        horizontalCategoryGapRatio: z.ZodOptional<z.ZodNumber>;
         xKey: z.ZodString;
         series: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
@@ -315,6 +331,7 @@ export declare const dataChartWidgetResultSchema: z.ZodObject<{
         }, z.core.$loose>>;
         data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         sampled: z.ZodOptional<z.ZodBoolean>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
         actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             label: z.ZodString;
             href: z.ZodString;
@@ -323,6 +340,7 @@ export declare const dataChartWidgetResultSchema: z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>>>;
     }, z.core.$loose>;
 }, z.core.$loose>;
@@ -357,6 +375,7 @@ export declare const dataInsightsWidgetResultSchema: z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -406,6 +425,8 @@ export declare const dataInsightsWidgetResultSchema: z.ZodObject<{
         axisTitleFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
         valueLabelFontSize: z.ZodOptional<z.ZodNumber>;
         valueLabelFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
+        valueAxisTickInterval: z.ZodOptional<z.ZodNumber>;
+        horizontalCategoryGapRatio: z.ZodOptional<z.ZodNumber>;
         xKey: z.ZodString;
         series: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
@@ -414,6 +435,7 @@ export declare const dataInsightsWidgetResultSchema: z.ZodObject<{
         }, z.core.$loose>>;
         data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         sampled: z.ZodOptional<z.ZodBoolean>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
         actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             label: z.ZodString;
             href: z.ZodString;
@@ -422,6 +444,7 @@ export declare const dataInsightsWidgetResultSchema: z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>>>;
     }, z.core.$loose>>;
 }, z.core.$loose>;
@@ -456,6 +479,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -510,6 +534,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -544,6 +569,8 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
         axisTitleFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
         valueLabelFontSize: z.ZodOptional<z.ZodNumber>;
         valueLabelFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
+        valueAxisTickInterval: z.ZodOptional<z.ZodNumber>;
+        horizontalCategoryGapRatio: z.ZodOptional<z.ZodNumber>;
         xKey: z.ZodString;
         series: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
@@ -552,6 +579,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
         }, z.core.$loose>>;
         data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         sampled: z.ZodOptional<z.ZodBoolean>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
         actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             label: z.ZodString;
             href: z.ZodString;
@@ -560,6 +588,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>>>;
     }, z.core.$loose>;
 }, z.core.$loose>, z.ZodObject<{
@@ -593,6 +622,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>, z.ZodObject<{
             id: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"copy">;
@@ -642,6 +672,8 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
         axisTitleFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
         valueLabelFontSize: z.ZodOptional<z.ZodNumber>;
         valueLabelFontWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<400>, z.ZodLiteral<500>]>>;
+        valueAxisTickInterval: z.ZodOptional<z.ZodNumber>;
+        horizontalCategoryGapRatio: z.ZodOptional<z.ZodNumber>;
         xKey: z.ZodString;
         series: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
@@ -650,6 +682,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
         }, z.core.$loose>>;
         data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         sampled: z.ZodOptional<z.ZodBoolean>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
         actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             label: z.ZodString;
             href: z.ZodString;
@@ -658,6 +691,7 @@ export declare const dataWidgetResultSchema: z.ZodUnion<readonly [z.ZodObject<{
                 explore: "explore";
                 notebook: "notebook";
             }>>;
+            presentation: z.ZodOptional<z.ZodLiteral<"icon">>;
         }, z.core.$loose>>>;
     }, z.core.$loose>>;
 }, z.core.$loose>]>;

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;
@@ -81,6 +146,14 @@ export function isDataChartWidget(value) {
         (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) &&
@@ -89,7 +162,7 @@ export function isDataChartWidget(value) {
             (series.color === undefined || typeof series.color === "string")) &&
         (value.actions === undefined ||
             (Array.isArray(value.actions) &&
-                value.actions.every(isDataWidgetAction))) &&
+                value.actions.every(isDataWidgetChartAction))) &&
         Array.isArray(value.data) &&
         value.data.every(isRecord));
 }
@@ -102,6 +175,11 @@ function isDataWidgetAction(value) {
         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;
@@ -126,7 +204,8 @@ function isDataWidgetDisplayAction(value) {
     }
     if (value.type === "link") {
         return (isString(value.href) &&
-            (value.icon === undefined || isDataWidgetActionIcon(value.icon)));
+            (value.icon === undefined || isDataWidgetActionIcon(value.icon)) &&
+            (value.presentation === undefined || value.presentation === "icon"));
     }
     if (value.type === "copy")
         return isString(value.text);
@@ -242,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;
@@ -259,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)
@@ -300,6 +379,7 @@ const dataWidgetActionSchema = z
     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
@@ -318,13 +398,20 @@ export const dataChartWidgetSchema = z
     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),
@@ -347,6 +434,7 @@ const dataWidgetDisplayActionSchema = z.discriminatedUnion("type", [
         label: z.string().min(1),
         href: z.string().min(1),
         icon: z.enum(["explore", "camera", "notebook"]).optional(),
+        presentation: z.literal("icon").optional(),
     })
         .passthrough(),
     z
@@ -384,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.d.ts

@@ -42,8 +42,8 @@ declare const _default: import("../../action.js").ActionDefinition<{
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
     configured?: undefined;
+    error?: undefined;
 } | {
     url?: undefined;
     id?: undefined;

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/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");