@agent-native/core 0.214.0 → 0.216.0

package/dist/review/actions/set-review-thread-muted.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadId: z.string().min(1),
         muted: z.boolean(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "viewer");
         const root = await getReviewThreadRoot(args.threadId, { resourceType: args.resourceType, resourceId: args.resourceId }, { userEmail: ctx?.userEmail, orgId: ctx?.orgId }, { bypassScope: true });

package/dist/review/actions/set-review-thread-unread.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadId: z.string().min(1),
         unread: z.boolean(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "viewer");
         const root = await getReviewThreadRoot(args.threadId, { resourceType: args.resourceType, resourceId: args.resourceId }, { userEmail: ctx?.userEmail, orgId: ctx?.orgId }, { bypassScope: true });

package/dist/review/actions/set-review-threads-unread.js

@@ -10,6 +10,11 @@ export default defineAction({
         threadIds: z.array(z.string().min(1)).min(1).max(500),
         unread: z.boolean(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "viewer");
         const userEmail = ctx?.userEmail;

package/dist/review/actions/update-review-comment-anchor.js

@@ -13,6 +13,11 @@ const schema = z.object({
 export default defineAction({
     description: "Move an anchored review comment to a new canvas position.",
     schema,
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const actionCtx = ctx;
         const userEmail = actionCtx?.userEmail?.trim().toLowerCase();

package/dist/review/actions/update-review-comment.js

@@ -25,6 +25,11 @@ const schema = z
 export default defineAction({
     description: "Update an authored review comment body or canvas anchor.",
     schema,
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     run: async (args, ctx) => {
         const actionCtx = ctx;
         const scope = {

package/dist/review/suggestions/actions.js

@@ -6,7 +6,7 @@ import { assertReviewableResourceAccess } from "../registry.js";
 import { ensureReviewTables, insertReviewCommentWithClient, resolveReviewThreadWithClient, } from "../store.js";
 import { suggestionActorKind, suggestionActorKindMatchesReceipt, } from "./actor-kind.js";
 import { getSuggestionAdapter } from "./registry.js";
-import { getSuggestion, ensureSuggestionTables, insertSuggestion, listSuggestions, recordDecision, getDecision, getSuggestionByCreationKey, recordSuggestionCreation, updateSuggestionStatus, getSuggestionAmendment, amendSuggestion, deleteUnclaimedSuggestion, getSuggestionProposal, insertSuggestionProposal, getProposalCreation, recordProposalCreation, getProposalDecision, recordProposalDecision, } from "./store.js";
+import { getSuggestion, getSuggestions, ensureSuggestionTables, insertSuggestion, listSuggestions, recordDecision, getDecision, getSuggestionByCreationKey, recordSuggestionCreation, updateSuggestionStatus, getSuggestionAmendment, amendSuggestion, deleteUnclaimedSuggestion, getSuggestionProposal, insertSuggestionProposal, getProposalCreation, recordProposalCreation, getProposalDecision, recordProposalDecision, } from "./store.js";
 const base = { resourceType: z.string().min(1), resourceId: z.string().min(1) };
 const operation = z.object({
     ordinal: z.number().int().nonnegative(),
@@ -123,6 +123,12 @@ export const createResourceSuggestion = defineAction({
         const url = getSuggestionAdapter(args.adapterKind)?.buildUrl?.(args.resourceId, suggestion.id);
         return url ? { url, label: "Open suggestion" } : null;
     },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: true,
+        idempotentHint: true,
+    },
     run: async (args, ctx) => {
         const access = await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "commenter");
         const adapter = getSuggestionAdapter(args.adapterKind);
@@ -239,6 +245,12 @@ export const updateResourceSuggestion = defineAction({
             .optional()
             .describe("Optional replacement summary; omission preserves the existing summary."),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+        idempotentHint: true,
+    },
     run: async (args, ctx) => {
         const initial = await getSuggestion(args.id);
         if (!initial)
@@ -387,6 +399,12 @@ export const decideResourceSuggestion = defineAction({
         observedBase: z.string().min(1),
         observedRevision: z.number().int().positive().optional(),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+        idempotentHint: true,
+    },
     run: async (args, ctx) => {
         const suggestion = await getSuggestion(args.id);
         if (!suggestion)
@@ -577,6 +595,12 @@ export const getResourceSuggestionProposalByCreationKey = defineAction({
 export const createResourceSuggestionProposal = defineAction({
     description: "Create or append independently reviewable suggestions under one durable proposal. Pass supersedes to replace your own earlier pending suggestions on the same resource in the same step.",
     schema: proposalCreationSchema,
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        openWorldHint: true,
+        idempotentHint: true,
+    },
     run: async (args, ctx) => {
         await assertReviewableResourceAccess(args.resourceType, args.resourceId, ctx, "commenter");
         const adapter = getSuggestionAdapter(args.adapterKind);
@@ -759,6 +783,12 @@ export const decideResourceSuggestionProposal = defineAction({
         }))
             .min(1),
     }),
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+        idempotentHint: true,
+    },
     run: async (args, ctx) => {
         await ensureSuggestionTables();
         const db = getDbExec();
@@ -804,7 +834,7 @@ export const decideResourceSuggestionProposal = defineAction({
             const currentProposal = await getSuggestionProposal(tx, args.proposalId);
             if (!currentProposal)
                 throw new Error("Proposal decision receipt references a missing proposal");
-            const suggestions = await Promise.all(prior.suggestionIds.map((id) => getSuggestion(id, tx)));
+            const suggestions = await getSuggestions(prior.suggestionIds, tx);
             if (suggestions.some((suggestion) => !suggestion))
                 throw new Error("Proposal decision receipt references a missing suggestion");
             return {
@@ -824,8 +854,9 @@ export const decideResourceSuggestionProposal = defineAction({
             if (prior)
                 return replayDecision(tx, prior);
             const suggestions = [];
-            for (const observed of members) {
-                const current = await getSuggestion(observed.id, tx);
+            const loaded = await getSuggestions(members.map((member) => member.id), tx);
+            for (const [index, observed] of members.entries()) {
+                const current = loaded[index];
                 if (!current ||
                     current.proposalId !== proposal.id ||
                     current.resourceType !== proposal.resourceType ||
@@ -842,6 +873,15 @@ export const decideResourceSuggestionProposal = defineAction({
                 }
                 suggestions.push(current);
             }
+            const staleProposal = (error) => {
+                if (error instanceof Error && error.name === "SuggestionStaleError") {
+                    fail("A proposal member is stale; no proposal edits were applied", {
+                        statusCode: 409,
+                        errorCode: "suggestion_stale",
+                    });
+                }
+                throw error;
+            };
             for (const suggestion of suggestions) {
                 const updated = await updateSuggestionStatus(tx, suggestion.id, args.decision, suggestion.revision);
                 if (!updated)
@@ -867,11 +907,7 @@ export const decideResourceSuggestionProposal = defineAction({
                         });
                     }
                     catch (error) {
-                        if (error instanceof Error &&
-                            error.name === "SuggestionStaleError") {
-                            fail("A proposal member is stale; no proposal edits were applied", { statusCode: 409, errorCode: "suggestion_stale" });
-                        }
-                        throw error;
+                        staleProposal(error);
                     }
                 }
                 await resolveReviewThreadWithClient(tx, suggestion.threadId, reviewer, {
@@ -880,22 +916,25 @@ export const decideResourceSuggestionProposal = defineAction({
                 }, args.decision);
             }
             if (args.decision === "accepted") {
-                await adapter.finalizeProposalDecision?.({
-                    resourceType: proposal.resourceType,
-                    resourceId: proposal.resourceId,
-                    transaction: tx,
-                    coordination,
-                });
+                try {
+                    await adapter.finalizeProposalDecision?.({
+                        resourceType: proposal.resourceType,
+                        resourceId: proposal.resourceId,
+                        transaction: tx,
+                        coordination,
+                    });
+                }
+                catch (error) {
+                    staleProposal(error);
+                }
             }
             await recordProposalDecision(tx, args.idempotencyKey, proposal.id, reviewer, args.decision, request, suggestions.map((suggestion) => suggestion.id));
+            const decided = await getSuggestions(suggestions.map((suggestion) => suggestion.id), tx);
+            if (decided.some((suggestion) => !suggestion))
+                throw new Error("Decided suggestion disappeared");
             return {
                 proposal: currentProposal,
-                suggestions: await Promise.all(suggestions.map(async (suggestion) => {
-                    const latest = await getSuggestion(suggestion.id, tx);
-                    if (!latest)
-                        throw new Error("Decided suggestion disappeared");
-                    return latest;
-                })),
+                suggestions: decided,
             };
         }).catch(async (error) => {
             const prior = await getProposalDecision(db, args.idempotencyKey);

package/dist/review/suggestions/store.d.ts

@@ -22,6 +22,8 @@ export declare function getSuggestionAmendment(client: DbExec, key: string): Pro
 }>;
 export declare function amendSuggestion(client: DbExec, before: ResourceSuggestion, operations: SuggestionOperation[], summary: string, idempotencyKey: string, request: string): Promise<ResourceSuggestion | null>;
 export declare function getSuggestion(suggestionId: string, client?: DbExec): Promise<ResourceSuggestion | null>;
+/** Loads several suggestions in two queries; missing ids come back as null. */
+export declare function getSuggestions(suggestionIds: readonly string[], client?: DbExec): Promise<(ResourceSuggestion | null)[]>;
 export declare function listSuggestions(resourceType: string, resourceId: string, statuses?: readonly SuggestionStatus[], client?: DbExec): Promise<ResourceSuggestion[]>;
 export interface SuggestionDecisionRecord {
     id: string;

package/dist/review/suggestions/store.js

@@ -253,6 +253,34 @@ export async function getSuggestion(suggestionId, client = getDbExec()) {
     })).rows;
     return suggestionFromRows(row, rows);
 }
+/** Loads several suggestions in two queries; missing ids come back as null. */
+export async function getSuggestions(suggestionIds, client = getDbExec()) {
+    await ensureSuggestionTables(client);
+    if (suggestionIds.length === 0)
+        return [];
+    const placeholders = suggestionIds.map(() => "?").join(",");
+    const rows = (await client.execute({
+        sql: `SELECT s.*,p.summary AS proposal_summary FROM agent_review_suggestions s LEFT JOIN agent_review_suggestion_proposals p ON p.id = s.proposal_id WHERE s.id IN (${placeholders})`,
+        args: [...suggestionIds],
+    })).rows;
+    const operations = new Map();
+    for (const operation of (await client.execute({
+        sql: `SELECT * FROM agent_review_suggestion_operations WHERE suggestion_id IN (${placeholders}) ORDER BY suggestion_id,ordinal`,
+        args: [...suggestionIds],
+    })).rows) {
+        const id = String(operation.suggestion_id);
+        const list = operations.get(id);
+        if (list)
+            list.push(operation);
+        else
+            operations.set(id, [operation]);
+    }
+    const byId = new Map(rows.map((row) => [
+        String(row.id),
+        suggestionFromRows(row, operations.get(String(row.id)) ?? []),
+    ]));
+    return suggestionIds.map((id) => byId.get(id) ?? null);
+}
 function suggestionFromRows(row, operationRows) {
     return {
         id: String(row.id),

package/dist/secrets/actions/delete-api-key.js

@@ -29,6 +29,11 @@ export default defineAction({
             ? `Deleted organization key ${args.name}`
             : `Deleted personal key ${args.name}`,
     },
+    mcpAnnotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+    },
     // It creates, changes, or revokes a credential or who may use one: every
     // call needs the user's approval, and "always allow" is not offered.
     needsApproval: true,

package/dist/secrets/routes.d.ts

@@ -65,31 +65,31 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
     status?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     errorCode?: undefined;
     ok: boolean;
     status: string;
+    error?: undefined;
 } | {
     error: string;
     removed?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     note?: undefined;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -117,11 +117,11 @@ export declare function createAdHocSecretHandler(): import("h3").EventHandlerWit
 } | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-chat/context-tools.js

@@ -498,7 +498,41 @@ export function createDataWidgetActionEntries() {
                         },
                         display: {
                             type: "object",
-                            description: "Optional display metadata: title, description, primaryAction.",
+                            description: "Optional display metadata: title, description, primaryAction, sources, and actions.",
+                            properties: {
+                                actions: {
+                                    type: "array",
+                                    items: {
+                                        oneOf: [
+                                            {
+                                                type: "object",
+                                                properties: {
+                                                    id: { type: "string" },
+                                                    type: { type: "string", enum: ["link"] },
+                                                    label: { type: "string" },
+                                                    href: { type: "string" },
+                                                    icon: {
+                                                        type: "string",
+                                                        enum: ["explore", "camera", "notebook"],
+                                                    },
+                                                    presentation: { type: "string", enum: ["icon"] },
+                                                },
+                                                required: ["type", "label", "href"],
+                                            },
+                                            {
+                                                type: "object",
+                                                properties: {
+                                                    id: { type: "string" },
+                                                    type: { type: "string", enum: ["copy"] },
+                                                    label: { type: "string" },
+                                                    text: { type: "string" },
+                                                },
+                                                required: ["type", "label", "text"],
+                                            },
+                                        ],
+                                    },
+                                },
+                            },
                         },
                         table: {
                             type: "object",
@@ -506,7 +540,7 @@ export function createDataWidgetActionEntries() {
                         },
                         chartSeries: {
                             type: "object",
-                            description: "For data-chart/data-insights: { type: 'bar'|'line'|'area', title?, xKey, series: [{ key, label, color? }], data, sampled? }. Optional display controls include contentHeight from 1 to 1200 px, contentPadding from 0 to 64 px, labelFontFamily (sans, serif, mono), and label font sizes and weights; these apply only to chart rendering.",
+                            description: "For data-chart/data-insights: { type: 'bar'|'line'|'area', title?, xKey, series: [{ key, label, color? }], data, sampled? }. Optional display controls include contentHeight from 1 to 1200 px, contentPadding from 0 to 64 px, labelFontFamily (sans, serif, mono), label font sizes and weights, valueAxisTickInterval, and horizontalCategoryGapRatio; these apply only to chart rendering.",
                             properties: {
                                 contentHeight: {
                                     type: "number",
@@ -548,6 +582,33 @@ export function createDataWidgetActionEntries() {
                                     type: "number",
                                     enum: [400, 500],
                                 },
+                                valueAxisTickInterval: {
+                                    type: "number",
+                                    minimum: 1e-12,
+                                    description: "Optional positive step for numeric value-axis labels and grid lines; it must produce between 1 and 100 ticks for the chart's value range.",
+                                },
+                                horizontalCategoryGapRatio: {
+                                    type: "number",
+                                    minimum: 0,
+                                    maximum: 0.9,
+                                    description: "Optional fraction of each horizontal-bar category slot left empty. Defaults to the existing spacing; use 0.08 for an 8% gap.",
+                                },
+                                actions: {
+                                    type: "array",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            label: { type: "string" },
+                                            href: { type: "string" },
+                                            icon: {
+                                                type: "string",
+                                                enum: ["explore", "camera", "notebook"],
+                                            },
+                                            presentation: { type: "string", enum: ["icon"] },
+                                        },
+                                        required: ["label", "href"],
+                                    },
+                                },
                             },
                         },
                     },

package/dist/server/agent-chat-plugin.d.ts

@@ -54,6 +54,8 @@ export declare function runPostAgentRunComplete(callback: AgentChatPluginOptions
 }): Promise<void>;
 export declare function runPreAgentTurnAutosave(callback: AgentChatPluginOptions["onAgentTurnStart"] | undefined, scope: AgentChatScope | null | undefined, run: Pick<ActiveRun, "threadId" | "runId">): Promise<void>;
 export { foldAgentChatRunCompletion };
+export declare function assertAgentChatRunProjectionUpdated(updated: boolean, threadId: string, runId: string): void;
+export declare function runAgentChatRunCompletionHooksAfterProjection(persistProjection: () => Promise<void>, runCompletionHooks: () => Promise<void>): Promise<void>;
 /**
  * The model this mount runs with, when the caller does not pass one per request.
  *