@agent-native/core 0.204.0-nightly-20261008011018 → 0.204.0

package/dist/action.d.ts

@@ -230,6 +230,7 @@ export interface ActionMcpToolAnnotations {
     readOnlyHint: boolean;
     destructiveHint: boolean;
     openWorldHint: boolean;
+    idempotentHint?: boolean;
 }
 interface DefineActionWithSchema<TSchema extends StandardSchemaV1, TReturn = any, TOutputSchema extends StandardSchemaV1 | undefined = undefined> {
     title?: string;

package/dist/action.js

@@ -150,10 +150,12 @@ export function defineAction(options) {
             !Array.isArray(options.mcpAnnotations) &&
             typeof options.mcpAnnotations.readOnlyHint === "boolean" &&
             typeof options.mcpAnnotations.destructiveHint === "boolean" &&
-            typeof options.mcpAnnotations.openWorldHint === "boolean"
+            typeof options.mcpAnnotations.openWorldHint === "boolean" &&
+            (options.mcpAnnotations.idempotentHint === undefined ||
+                typeof options.mcpAnnotations.idempotentHint === "boolean")
             ? options.mcpAnnotations
             : (() => {
-                throw new TypeError("mcpAnnotations must define boolean readOnlyHint, destructiveHint, and openWorldHint values.");
+                throw new TypeError("mcpAnnotations must define boolean readOnlyHint, destructiveHint, and openWorldHint values; idempotentHint is an optional boolean.");
             })();
     const deferLoading = typeof options.deferLoading === "boolean"
         ? options.deferLoading

package/dist/cli/agent.js

@@ -8,7 +8,7 @@ import { getAppConfig } from "../app-config/index.js";
 import { createGitHubRepoToolEntries } from "../provider-api/github-repo.js";
 import { loadCliBootstrap } from "../scripts/cli-bootstrap.js";
 import { resolveDevUserEmail } from "../scripts/dev-session.js";
-import { loadEnv } from "../scripts/utils.js";
+import { loadEnv, serializeCliArgs } from "../scripts/utils.js";
 import { autoDiscoverActions } from "../server/action-discovery.js";
 import { captureCliOutput } from "../server/cli-capture.js";
 import { getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
@@ -213,16 +213,7 @@ function buildHeadlessSystemPrompt(actionNames) {
         .join("\n\n");
 }
 function cliArgsFromToolArgs(args) {
-    const cliArgs = [];
-    for (const [key, value] of Object.entries(args)) {
-        if (value === undefined)
-            continue;
-        const normalized = value != null && typeof value === "object"
-            ? JSON.stringify(value)
-            : String(value);
-        cliArgs.push(`--${key}`, normalized);
-    }
-    return cliArgs;
+    return serializeCliArgs(Object.fromEntries(Object.entries(args).filter(([, value]) => value !== undefined)));
 }
 export async function createHeadlessBuiltinActions() {
     const docsSearch = await import("../scripts/docs/search.js");

package/dist/client/use-db-sync.d.ts

@@ -21,6 +21,19 @@ export declare function registerCollabActivityResource(resource: {
     resourceType: string;
     resourceId: string;
 }): () => void;
+type CollabActivityEvent = {
+    source?: string;
+    resourceType?: string;
+    resourceId?: string;
+    requestSource?: string;
+};
+/**
+ * For a collab connection's own ~12 s poll. A viewer on a screen nobody else
+ * is on has no presence to notice, but that poll still carries the design's
+ * resource-scoped events from the other screens, and the shared transport is
+ * asleep on the 1-5 minute idle cadence until something wakes it.
+ */
+export declare function noteCollabPollActivity(events: readonly CollabActivityEvent[]): void;
 /**
  * Declare that another person is working on the same resource as this tab.
  * While any lease is held, the shared transport polls every 2.5 s whenever no

package/dist/client/use-db-sync.js

@@ -72,11 +72,20 @@ function collabBoostWanted() {
     }
     return ((collabBoostLeases > 0 && collabBoostFresh()) || hasRecentResourceActivity);
 }
+// The server mirrors every saved file into its Yjs doc under the "agent"
+// source, so a lone editor's own save comes back as a collab event that is not
+// from anyone else. Only a Yjs update a browser tab posted names its sender.
+function isHumanCollabUpdate(event) {
+    return (event.source === "collab" &&
+        typeof event.requestSource === "string" &&
+        event.requestSource !== "" &&
+        event.requestSource !== "agent");
+}
 function noteCollaboratorActivity(events) {
     const ownSource = getBrowserTabId();
     const until = Date.now() + COLLAB_ACTIVITY_WINDOW_MS;
     for (const event of events) {
-        if (event.source !== "action" ||
+        if ((event.source !== "action" && !isHumanCollabUpdate(event)) ||
             typeof event.resourceType !== "string" ||
             event.resourceType === "" ||
             typeof event.resourceId !== "string" ||
@@ -89,6 +98,18 @@ function noteCollaboratorActivity(events) {
         }
     }
 }
+/**
+ * For a collab connection's own ~12 s poll. A viewer on a screen nobody else
+ * is on has no presence to notice, but that poll still carries the design's
+ * resource-scoped events from the other screens, and the shared transport is
+ * asleep on the 1-5 minute idle cadence until something wakes it.
+ */
+export function noteCollabPollActivity(events) {
+    const wasWanted = collabBoostWanted();
+    noteCollaboratorActivity(events);
+    if (!wasWanted && collabBoostWanted())
+        notifyCollabBoostChange();
+}
 function collabBoostFresh() {
     return Date.now() - collabBoostActivityAt <= COLLAB_BOOST_IDLE_CEILING_MS;
 }

package/dist/collab/client.js

@@ -3,7 +3,7 @@ import { Awareness } from "y-protocols/awareness";
 import * as Y from "yjs";
 import { agentNativePath } from "../client/api-path.js";
 import { useAvatarUrl } from "../client/use-avatar.js";
-import { acquireCollabPollBoost, registerCollabActivityResource, subscribeSyncEvents, } from "../client/use-db-sync.js";
+import { acquireCollabPollBoost, noteCollabPollActivity, registerCollabActivityResource, subscribeSyncEvents, } from "../client/use-db-sync.js";
 import { REALTIME_CAP_NO_AWARENESS, REALTIME_CAP_POLL_LIVE, } from "../realtime-protocol.js";
 import { dedupeCollabUsersByEmail } from "./types.js";
 export { dedupeCollabUsersByEmail, emailToColor, emailToName, } from "./types.js";
@@ -151,6 +151,8 @@ class CollabDocConnection {
     pollCycleCount = 0;
     pollVersion = 0;
     lastPolledVersion = 0;
+    pollCursor = null;
+    pollActivityBaselineReady = false;
     stateVectorFetch = null;
     stateVectorAbortControllers = new Set();
     sseActive = false;
@@ -415,7 +417,9 @@ class CollabDocConnection {
         });
     }
     fetchInitialState() {
-        fetch(`${this.baseUrl}/${this.docId}/state`).then(async (res) => {
+        fetch(`${this.baseUrl}/${this.docId}/state`, {
+            headers: { "X-Agent-Native-Poll-Baseline": "1" },
+        }).then(async (res) => {
             if (this.disposed)
                 return;
             if (res.status === 404 || res.status === 403) {
@@ -433,6 +437,17 @@ class CollabDocConnection {
                 this.markInitializationFailed("invalid-payload");
                 return;
             }
+            const baseline = data.activityBaseline;
+            if (baseline?.status === "ready" &&
+                Number.isSafeInteger(baseline.version) &&
+                baseline.version >= 0 &&
+                typeof baseline.cursor === "string" &&
+                baseline.cursor.length > 0) {
+                this.pollVersion = baseline.version;
+                this.lastPolledVersion = baseline.version;
+                this.pollCursor = baseline.cursor;
+                this.pollActivityBaselineReady = true;
+            }
             if (data.state) {
                 try {
                     const binary = base64ToUint8Array(data.state);
@@ -807,12 +822,16 @@ class CollabDocConnection {
             return;
         this.flushPendingUpdates();
         try {
-            const res = await fetch(agentNativePath(`/_agent-native/poll?since=${this.pollVersion}`));
+            const pollUrl = this.pollCursor
+                ? `/_agent-native/poll?cursor=${encodeURIComponent(this.pollCursor)}`
+                : `/_agent-native/poll?since=${this.pollVersion}`;
+            const res = await fetch(agentNativePath(pollUrl));
             if (!res.ok)
                 throw new Error("HTTP " + res.status);
             const data = await res.json();
             if (!this.syncActive || this.disposed)
                 return;
+            const hadActivityBaseline = this.pollActivityBaselineReady;
             const { version, events } = data;
             const versionGap = version - this.lastPolledVersion;
             const hadGap = versionGap > POLL_RING_BUFFER_SIZE;
@@ -832,6 +851,20 @@ class CollabDocConnection {
                     }
                 }
             }
+            if (hadActivityBaseline) {
+                noteCollabPollActivity(events);
+            }
+            else {
+                const reconciliation = await this.fetchStateVector();
+                if (reconciliation.status !== "synced") {
+                    throw reconciliation.status === "failed"
+                        ? reconciliation.error
+                        : new Error("Could not reconcile state without an activity baseline");
+                }
+            }
+            this.pollActivityBaselineReady = true;
+            if (typeof data.cursor === "string")
+                this.pollCursor = data.cursor;
             this.pollVersion = version;
             this.lastPolledVersion = version;
             this.pollCycleCount++;

package/dist/collab/routes.d.ts

@@ -1,11 +1,16 @@
 export declare const getCollabState: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    docId?: undefined;
-    state?: undefined;
 } | {
     error?: undefined;
     docId: string;
     state: string;
+    activityBaseline?: {
+        status: "ready";
+        version: number;
+        cursor: string;
+    } | {
+        status: "unavailable";
+    };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     ok?: undefined;

package/dist/collab/routes.js

@@ -1,4 +1,4 @@
-import { defineEventHandler, setResponseStatus, setResponseHeader, getRouterParam, getQuery, } from "h3";
+import { defineEventHandler, setResponseStatus, setResponseHeader, getRouterParam, getQuery, getRequestHeader, } from "h3";
 import { readBody } from "../server/h3-helpers.js";
 import { uint8ArrayToBase64, base64ToUint8Array } from "./storage.js";
 import * as manager from "./ydoc-manager.js";
@@ -25,6 +25,19 @@ export const getCollabState = defineEventHandler(async (event) => {
     }
     const query = getQuery(event);
     const encodedStateVector = typeof query.stateVector === "string" ? query.stateVector : null;
+    let activityBaseline;
+    if (getRequestHeader(event, "x-agent-native-poll-baseline") === "1") {
+        try {
+            const { getCurrentPollBaseline } = await import("../server/poll.js");
+            activityBaseline = {
+                status: "ready",
+                ...(await getCurrentPollBaseline()),
+            };
+        }
+        catch {
+            activityBaseline = { status: "unavailable" };
+        }
+    }
     let state;
     if (encodedStateVector) {
         try {
@@ -41,6 +54,7 @@ export const getCollabState = defineEventHandler(async (event) => {
     return {
         docId,
         state: uint8ArrayToBase64(state),
+        ...(activityBaseline ? { activityBaseline } : {}),
     };
 });
 export const postCollabUpdate = defineEventHandler(async (event) => {

package/dist/collab/struct-routes.d.ts

@@ -1,6 +1,6 @@
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.js

@@ -984,6 +984,18 @@ export function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = []
         { status: 405, headers: { "Content-Type": "application/json" } }
       );
     }
+    const actionSession = ${varName}.requiresAuth === true
+      ? await getGeneratedSession(event)
+      : undefined;
+    const actionContext = uiActionContext ?? (actionSession?.email
+      ? { userEmail: actionSession.email, orgId: actionSession.orgId ?? null }
+      : undefined);
+    if (${varName}.requiresAuth === true && !actionContext?.userEmail) {
+      return new Response(
+        JSON.stringify({ error: "Unauthorized" }),
+        { status: 401, headers: { "Content-Type": "application/json" } },
+      );
+    }
     const params = ${a.method === "get" ? "parseActionSearchParams(event.url.searchParams)" : "(await readBody(event)) ?? {}"};
     try {
       const caller =
@@ -994,16 +1006,11 @@ export function generateWorkerEntry(routes, pluginPaths, defaultPluginStems = []
         caller,
         requestHeaders: event.req.headers,
         actionName: ${JSON.stringify(a.name)},
-        ...(uiActionContext
-          ? {
-              userEmail: uiActionContext.userEmail,
-              orgId: uiActionContext.orgId ?? null,
-            }
-          : {}),
+        ...(actionContext ?? {}),
       };
       const runAction = () => ${varName}.run(params, actionRunContext);
-      const result = actionIsUiOnly
-        ? await runWithGeneratedRequestContext(uiActionContext, runAction)
+      const result = actionContext
+        ? await runWithGeneratedRequestContext(actionContext, runAction)
         : await runAction();
       if (typeof result === "string") { try { return JSON.parse(result); } catch { return result; } }
       return result;

package/dist/deploy/workspace-deploy.js

@@ -64,19 +64,97 @@ function builtinAgentsEnvSnippet() {
 `;
 }
 function workspaceDirectoryEnvSnippet(workspaceApps) {
-    const orgDirectoryUrl = getAppConfig().workspace.orgDirectoryUrl?.trim();
-    if (!orgDirectoryUrl && !workspaceApps.some((app) => app.isDispatch)) {
+    const configuredOrgDirectoryUrl = getAppConfig().workspace.orgDirectoryUrl?.trim();
+    const dispatchApp = workspaceApps.find((app) => app.isDispatch);
+    if (!configuredOrgDirectoryUrl && !dispatchApp) {
         return builtinAgentsEnvSnippet();
     }
+    const runtimeDirectoryResolver = dispatchApp
+        ? `
+  function logInvalidDirectoryBase() {
+    const logKey = Symbol.for("agent-native.workspace.invalid-directory-base");
+    if (globalThis[logKey]) return;
+    globalThis[logKey] = true;
+    console.error("[workspace] Invalid organization directory base URL");
+  }
+
+  function resolveRuntimeDirectoryUrl() {
+    const isVercelProduction =
+      processRef.env.VERCEL_ENV?.trim().toLowerCase() === "production";
+    const vercelCandidates = processRef.env.VERCEL
+      ? (isVercelProduction
+          ? [
+              processRef.env.VERCEL_PROJECT_PRODUCTION_URL,
+              processRef.env.VERCEL_URL,
+              processRef.env.VERCEL_BRANCH_URL,
+            ]
+          : [processRef.env.VERCEL_URL, processRef.env.VERCEL_BRANCH_URL]
+        )
+          .filter(Boolean)
+          .map((candidate) =>
+            /^https?:\\/\\//i.test(candidate)
+              ? candidate
+              : "https://" + candidate,
+          )
+      : [];
+    const candidates = [
+      processRef.env.APP_URL,
+      processRef.env.URL,
+      processRef.env.DEPLOY_URL,
+      processRef.env.BETTER_AUTH_URL,
+      ...vercelCandidates,
+      processRef.env.WORKSPACE_GATEWAY_URL,
+      processRef.env.VITE_WORKSPACE_GATEWAY_URL,
+    ].filter(Boolean);
+    let loopbackUrl;
+    for (const candidate of candidates) {
+      let baseUrl;
+      try {
+        baseUrl = new URL(candidate);
+      } catch {
+        logInvalidDirectoryBase();
+        continue;
+      }
+      if (baseUrl.protocol !== "http:" && baseUrl.protocol !== "https:") {
+        logInvalidDirectoryBase();
+        continue;
+      }
+      const directoryUrl = new URL(${JSON.stringify(dispatchApp.path)}, baseUrl)
+      .toString()
+      .replace(/\\/$/, "");
+      const hostname = baseUrl.hostname.toLowerCase().replace(/\\.$/, "");
+      const mappedIpv4 = hostname.match(
+        /^\\[::ffff:([0-9a-f]{1,4}):[0-9a-f]{1,4}\\]$/,
+      );
+      const isMappedIpv4Loopback =
+        mappedIpv4 !== null &&
+        (Number.parseInt(mappedIpv4[1], 16) >> 8) === 0x7f;
+      if (
+        hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        /^127(?:\\.\\d{1,3}){3}$/.test(hostname) ||
+        /^0(?:\\.\\d{1,3}){3}$/.test(hostname) ||
+        hostname === "[::1]" ||
+        hostname === "::1" ||
+        hostname === "[::]" ||
+        hostname === "::" ||
+        isMappedIpv4Loopback
+      ) {
+        loopbackUrl ??= directoryUrl;
+        continue;
+      }
+      return directoryUrl;
+    }
+    return loopbackUrl ?? null;
+  }
+`
+        : "";
     return `${builtinAgentsEnvSnippet()}
+${runtimeDirectoryResolver}
   const directoryOrigin =
     processRef.env.AGENT_NATIVE_ORG_DIRECTORY_URL ||
-    ${JSON.stringify(orgDirectoryUrl ?? null)} ||
-    processRef.env.WORKSPACE_GATEWAY_URL ||
-    processRef.env.APP_URL ||
-    processRef.env.URL ||
-    processRef.env.DEPLOY_URL ||
-    processRef.env.BETTER_AUTH_URL;
+    ${JSON.stringify(configuredOrgDirectoryUrl ?? null)} ||
+    ${dispatchApp ? "resolveRuntimeDirectoryUrl()" : "null"};
   if (directoryOrigin) {
     processRef.env.AGENT_NATIVE_ORG_DIRECTORY_URL = directoryOrigin;
   }
@@ -167,11 +245,8 @@ function buildOneApp(workspaceRoot, appsDir, app, preset, execFile, workspaceApp
     const appDir = path.join(appsDir, app);
     const workspaceAppAudience = workspaceAppAudienceForApp(workspaceApps, app);
     const workspaceAppRouteAccess = workspaceAppRouteAccessForApp(workspaceApps, app);
-    const workspaceGatewayUrl = process.env.VITE_WORKSPACE_GATEWAY_URL || workspaceBaseUrl();
-    const orgDirectoryUrl = getAppConfig().workspace.orgDirectoryUrl?.trim() ||
-        (workspaceApps.some((entry) => entry.isDispatch)
-            ? workspaceGatewayUrl
-            : null);
+    const workspaceGatewayUrl = workspaceBaseUrl();
+    const orgDirectoryUrl = getAppConfig().workspace.orgDirectoryUrl?.trim();
     const workspaceOAuthUrl = workspaceOAuthOrigin(workspaceGatewayUrl);
     const frameworkRoutePrefix = workspaceFrameworkRoutePrefixEnv();
     const env = {

package/dist/jobs/actions/manage-recurring-job.d.ts

@@ -11,9 +11,9 @@ declare const _default: import("../../action.js").ActionDefinition<{
     enabled?: undefined;
     nextRun?: undefined;
 } | {
+    deleted?: undefined;
     name: string;
     enabled: boolean;
     nextRun: string;
-    deleted?: undefined;
 }>;
 export default _default;

package/dist/mcp/actions/create-org-service-token.js

@@ -54,6 +54,7 @@ export default defineAction({
         purpose: purposeSchema.optional(),
         allowedActions: allowedActionsSchema.nullable().optional(),
     }),
+    requiresAuth: true,
     toolCallable: false,
     audit: orgAdminAudit({
         targetType: "service-principal",

package/dist/mcp/build-server.js

@@ -1937,15 +1937,18 @@ export async function createMCPServerForRequest(config, identity, requestMeta) {
                     entry.tool.description ??
                     name;
                 const title = agentNativeToolTitle(name, entry.tool.title);
-                const annotations = directoryCatalog
-                    ? { title, ...entry.mcpAnnotations }
-                    : {
-                        title,
-                        readOnlyHint: entry.readOnly === true,
-                        destructiveHint: entry.publicAgent?.isConsequential === true ||
-                            entry.needsApproval !== undefined,
-                        openWorldHint: false,
-                    };
+                const annotations = {
+                    title,
+                    ...(entry.mcpAnnotations ??
+                        (directoryCatalog
+                            ? undefined
+                            : {
+                                readOnlyHint: entry.readOnly === true,
+                                destructiveHint: entry.publicAgent?.isConsequential === true ||
+                                    entry.needsApproval !== undefined,
+                                openWorldHint: false,
+                            })),
+                };
                 if (directoryCatalog) {
                     delete annotations["agent-native/producesOpenLink"];
                 }

package/dist/mcp-client/oauth-routes.js

@@ -5,6 +5,7 @@ import { CredentialStoreUnavailableError, resolveSecretPairs, } from "../server/
 import { getH3App } from "../server/framework-request-handler.js";
 import { canonicalFrameworkPathname } from "../server/framework-route-prefix.js";
 import { getAppBasePath, getAppUrl, encodeOAuthState, oauthErrorPage, resolveOAuthRedirectUri, } from "../server/google-oauth.js";
+import { queryEchoSafeRedirect } from "../server/query-echo-safe-redirect.js";
 import { runWithRequestContext } from "../server/request-context.js";
 import { isWorkspaceOAuthCallbackRelayEnabled } from "../server/workspace-oauth.js";
 import { MCP_OAUTH_FLOW_TTL_SECONDS } from "../shared/mcp-oauth-flow-ttl.js";
@@ -491,7 +492,7 @@ async function handleMcpOAuthCallback(event, options) {
         console.warn("[mcp-client/oauth] saved server did not reconnect:", error);
     }
     const returnPath = resolveMcpOAuthReturnPath(connected, flow);
-    return redirectWithStagedCookies(event, getAppUrl(event, stripMcpOAuthAppBasePath(returnPath, getAppBasePath())));
+    return queryEchoSafeRedirect(event, redirectWithStagedCookies(event, getAppUrl(event, stripMcpOAuthAppBasePath(returnPath, getAppBasePath()))));
 }
 export function setMcpOAuthFlowCookie(event, flow, secure) {
     const encrypted = encryptSecretValue(JSON.stringify(flow));

package/dist/notifications/routes.d.ts

@@ -16,6 +16,6 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
 } | {
     count?: undefined;
     updated?: undefined;
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -27,38 +27,38 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    ok?: undefined;
     error: string;
     message: string;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
-} | {
-    error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     message?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/progress/routes.d.ts

@@ -2,6 +2,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;

package/dist/provider-api/actions/custom-provider-registration.d.ts

@@ -75,8 +75,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
         user: "user";
     }>>;
 }, z.core.$strip>>, {
-    message?: undefined;
     deleted?: undefined;
+    message?: undefined;
     found?: undefined;
     providers: {
         id: string;
@@ -93,8 +93,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id?: undefined;
     label?: undefined;
 } | {
-    message?: undefined;
     deleted?: undefined;
+    message?: undefined;
     providers?: undefined;
     count?: undefined;
     found: boolean;
@@ -103,8 +103,8 @@ export declare function createCustomProviderRegistrationAction<TSchema extends Z
     id?: undefined;
     label?: undefined;
 } | {
-    message?: undefined;
     deleted?: undefined;
+    message?: undefined;
     providers?: undefined;
     count?: undefined;
     provider?: undefined;

package/dist/scripts/dev/index.js

@@ -2,6 +2,7 @@ import { createCodingToolRegistry } from "../../coding-tools/index.js";
 import { getRequestRunContext } from "../../server/request-context.js";
 import { normalizeDatabaseToolsMode, } from "../db/tool-mode.js";
 import { dbExecToolParameters } from "../db/tool-schemas.js";
+import { serializeCliArgs } from "../parse-args.js";
 import { tool as listFilesTool, run as listFilesRun } from "./list-files.js";
 import { tool as readFileTool, run as readFileRun } from "./read-file.js";
 import { tool as searchFilesTool, run as searchFilesRun, } from "./search-files.js";
@@ -12,14 +13,7 @@ function wrapCliScript(tool, cliDefault, opts) {
         tool,
         ...(opts?.readOnly ? { readOnly: true } : {}),
         run: async (args) => {
-            const cliArgs = [];
-            for (const [k, v] of Object.entries(args)) {
-                const raw = v;
-                const value = raw != null && typeof raw === "object"
-                    ? JSON.stringify(raw)
-                    : String(raw);
-                cliArgs.push(`--${k}`, value);
-            }
+            const cliArgs = serializeCliArgs(args);
             const logs = [];
             const origLog = console.log;
             console.log = (...a) => {

package/dist/scripts/parse-args.d.ts

@@ -1,2 +1,9 @@
 export declare function parseArgs(args: string[]): Record<string, string>;
+export declare function serializeCliArgs(args: Record<string, unknown>): string[];
+type NormalizeShellArgsOptions = {
+    backslashEscapes?: boolean;
+    splitAllWhitespace?: boolean;
+};
+export declare function normalizeShellArgs(input: string, options?: NormalizeShellArgsOptions): string[];
 export declare function camelCaseArgs(args: Record<string, string>): Record<string, string>;
+export {};