agy-acp-map 0.5.0

package/dist/lib/agy-args.d.ts

@@ -0,0 +1,152 @@
+export type SafetyMode = 'safe' | 'autonomous' | 'autonomous-unsandboxed';
+export interface LaunchConfig {
+    model?: string;
+    effort?: string;
+    mode?: string;
+    agent?: string;
+    sandbox?: boolean;
+    jsonSchema?: string;
+    /** Prefer over raw skipPermissions when set. */
+    safety?: SafetyMode;
+    /** When true (default), pass --dangerously-skip-permissions. */
+    skipPermissions?: boolean;
+    /** When true (default), pass --disable-slash-commands. */
+    disableSlashCommands?: boolean;
+    /** Value for --print-timeout (e.g. "0", "30m", "120s"). Default "0". */
+    printTimeout?: string;
+}
+export interface LaunchConfigWithConversation extends LaunchConfig {
+    conversationId?: string;
+}
+export interface SessionLaunchFields extends LaunchConfig {
+    conversationId?: string;
+    [key: string]: unknown;
+}
+export type ApplyConfigResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export interface BuildAgyArgsSession {
+    cwd: string;
+    additionalDirectories?: string[];
+    conversationId?: string;
+    model?: string;
+    effort?: string;
+    mode?: string;
+    agent?: string;
+    sandbox?: boolean;
+    jsonSchema?: string;
+    /** When set, buildAgyArgs may resolve skip/sandbox via resolveSafety unless explicit flags given. */
+    safety?: SafetyMode;
+    skipPermissions?: boolean;
+    disableSlashCommands?: boolean;
+    printTimeout?: string;
+    stagingDirName?: string;
+    stagingOutsideCwd?: string;
+    mapper?: {
+        conversationId?: string;
+    };
+}
+declare const CONFIG_IDS: Set<string>;
+/**
+ * Normalize jsonSchema: object → JSON string; string kept as-is.
+ */
+export declare function normalizeJsonSchema(v: unknown): string | undefined;
+/**
+ * Truthy sandbox from boolean / string / number.
+ * @returns undefined = not set
+ */
+export declare function normalizeSandbox(v: unknown): boolean | undefined;
+/** Canonical safety tier values (also listed on BRIDGE_CAPABILITIES.safetyTiers). */
+export declare const SAFETY_TIERS: readonly ['safe', 'autonomous', 'autonomous-unsandboxed'];
+/**
+ * Normalize safety mode.
+ * Accepts: safe | autonomous | auto | autonomous-unsandboxed | autonomous_unsandboxed | unsandboxed
+ */
+export declare function normalizeSafety(v: unknown): SafetyMode | undefined;
+/**
+ * Normalize boolean-ish with default when unset.
+ */
+export declare function normalizeBool(v: unknown, defaultWhenUnset: boolean): boolean;
+/**
+ * Optional bool: undefined when unset.
+ */
+export declare function normalizeOptionalBool(v: unknown): boolean | undefined;
+/**
+ * Normalize print-timeout string (pass-through; empty → undefined).
+ */
+export declare function normalizePrintTimeout(v: unknown): string | undefined;
+export interface ResolvedSafety {
+    /** Resolved tier used for launch / logging. */
+    safety: SafetyMode;
+    /** Whether to pass --dangerously-skip-permissions. */
+    skipPermissions: boolean;
+    /** Whether to pass --sandbox (false → omit flag). */
+    sandbox: boolean;
+}
+export type SafetyResolveInput = {
+    safety?: SafetyMode | string;
+    sandbox?: boolean;
+    skipPermissions?: boolean;
+};
+/**
+ * Central three-tier safety resolution.
+ *
+ * Tiers:
+ *   safe (default)              — no skip-permissions; sandbox only if explicitly true
+ *   autonomous                  — skip-permissions; default --sandbox unless sandbox:false
+ *   autonomous-unsandboxed      — skip-permissions; NEVER --sandbox
+ *
+ * Inputs:
+ *   session.safety / AGY_ACP_SAFETY
+ *   AGY_ACP_SKIP_PERMISSIONS=1 ≈ autonomous if safety unset; =0 ≈ safe
+ *   explicit session.skipPermissions overrides the skip flag only
+ *   explicit session.sandbox / AGY_ACP_SANDBOX override sandbox except unsandboxed tier
+ */
+export declare function resolveSafety(session?: SafetyResolveInput, env?: NodeJS.ProcessEnv): ResolvedSafety;
+/**
+ * Resolve whether to pass --dangerously-skip-permissions (via resolveSafety).
+ */
+export declare function resolveSkipPermissions(session?: SafetyResolveInput, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve whether to pass --sandbox (via resolveSafety).
+ * Returns true/false; callers that previously treated undefined as omit can use === true.
+ */
+export declare function resolveSandbox(session?: SafetyResolveInput, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve --disable-slash-commands (default true).
+ * Disable via session.disableSlashCommands=false or AGY_ACP_DISABLE_SLASH_COMMANDS=0.
+ */
+export declare function resolveDisableSlashCommands(session: {
+    disableSlashCommands?: boolean;
+}, env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Resolve --print-timeout value (default "0").
+ */
+export declare function resolvePrintTimeout(session: {
+    printTimeout?: string;
+}, env?: NodeJS.ProcessEnv): string;
+/**
+ * Resolve launch flags from session/new (or similar) params + env fallbacks.
+ * Preferred fields: top-level, then _meta, then config, then configOptions, then env.
+ */
+export declare function extractLaunchConfig(params: Record<string, unknown> | null | undefined, env?: NodeJS.ProcessEnv): LaunchConfigWithConversation;
+/**
+ * Apply a single set_config_option onto session launch fields.
+ */
+export declare function applyConfigOption(session: SessionLaunchFields, configId: string, value: unknown): ApplyConfigResult;
+/**
+ * Build argv for `agy` (without the binary name).
+ *
+ * When skipPermissions / sandbox are already resolved by the caller (spawnAgy),
+ * they are used as-is. Otherwise resolveSafety(session) fills them from safety tier.
+ *
+ * Defaults:
+ *   - safety: safe → skipPermissions false, sandbox false
+ *   - disableSlashCommands: true
+ *   - printTimeout: "0"
+ */
+export declare function buildAgyArgs(session: BuildAgyArgsSession, env?: NodeJS.ProcessEnv): string[];
+export { CONFIG_IDS };

package/dist/lib/agy-discovery.d.ts

@@ -0,0 +1,28 @@
+export interface DiscoveryResult {
+    availableModels: string[];
+    availableAgents: string[];
+    modelsError?: string;
+    agentsError?: string;
+}
+/**
+ * Parse `agy models` stdout into model id list.
+ * Skips status lines like "Fetching available models...".
+ * Takes the first whitespace-separated token per non-empty line.
+ */
+export declare function parseAgyModelsStdout(stdout: string): string[];
+/**
+ * Parse `agy agents` / `agy agent` stdout into agent id list.
+ * Accepts "id\\tname", "id name", or plain id-per-line.
+ */
+export declare function parseAgyAgentsStdout(stdout: string): string[];
+/**
+ * Discover models + agents once per process. Failures → empty arrays + error notes.
+ */
+export declare function discoverAgyCatalog(opts?: {
+    bin?: string;
+    timeoutMs?: number;
+    force?: boolean;
+}): Promise<DiscoveryResult>;
+/** Test helper: clear process-lifetime cache. */
+export declare function clearDiscoveryCache(): void;
+export declare function getCachedDiscovery(): DiscoveryResult | null;

package/dist/lib/agy-process.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Cross-platform agy child-process supervision:
+ * generation tokens, graceful→force kill, stale NDJSON ignore, spawn error handling.
+ */
+import { type ChildProcess } from 'node:child_process';
+export declare const DEFAULT_GRACE_MS = 2000;
+export declare const DEFAULT_WAIT_EXIT_MS = 5000;
+export interface AgyProcessCallbacks {
+    /** Parsed NDJSON object from stdout; only invoked when generation is still current. */
+    onEvent: (obj: unknown, generation: number) => void;
+    onStderr?: (chunk: string, generation: number) => void;
+    onExit?: (code: number | null, signal: NodeJS.Signals | null, generation: number) => void;
+    onError?: (err: Error, generation: number) => void;
+    /** Raw bad line (optional logging). */
+    onBadLine?: (line: string, generation: number) => void;
+}
+export interface SpawnAgyOptions extends AgyProcessCallbacks {
+    bin: string;
+    args: string[];
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    /** Optional override; manager increments its own generation when omitted. */
+    generation?: number;
+}
+/**
+ * Per-session process supervisor. Tracks generation so late lines from a killed
+ * child are ignored after a respawn.
+ */
+export declare class AgyProcessManager {
+    private child;
+    private generation;
+    private killInFlight;
+    get currentChild(): ChildProcess | null;
+    get currentGeneration(): number;
+    isAlive(): boolean;
+    isWritable(): boolean;
+    /**
+     * Kill any existing child (await exit), then spawn a new one with a fresh generation.
+     */
+    spawn(opts: SpawnAgyOptions): Promise<{
+        child: ChildProcess;
+        generation: number;
+    }>;
+    /**
+     * Unified kill used by cancel, set_config_option, close, shutdown.
+     * SIGINT → wait → SIGTERM → wait → force (SIGKILL / taskkill on Windows).
+     */
+    kill(opts?: {
+        graceMs?: number;
+        awaitExit?: boolean;
+        waitExitMs?: number;
+    }): Promise<void>;
+    /** Write one NDJSON line to the current child's stdin. */
+    writeLine(line: string): void;
+}
+/**
+ * Soft → hard kill sequence (cross-platform).
+ * Windows: child.kill('SIGINT') may be no-op; we still try SIGTERM then force.
+ */
+export declare function escalateKill(child: ChildProcess, graceMs?: number): Promise<void>;
+/**
+ * Force-terminate. On Windows, prefer taskkill /T /F when pid is known;
+ * fall back to child.kill('SIGKILL') / kill(undefined).
+ */
+export declare function forceKill(child: ChildProcess): void;
+export declare function waitForExit(child: ChildProcess, timeoutMs: number): Promise<boolean>;
+/** Standalone kill helper for callers that only hold a ChildProcess. */
+export declare function killAgyChild(child: ChildProcess | null | undefined, opts?: {
+    graceMs?: number;
+    waitExitMs?: number;
+}): Promise<void>;

package/dist/lib/map-agy-to-acp.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure-ish mapping: agy stream-json NDJSON events → ACP v2 session/update notifications.
+ * Image inlining uses fs via rich-content.ts (best-effort). Offline map.mjs still works.
+ */
+import { type FileToAcpImageOpts } from './rich-content.ts';
+export interface MapperState {
+    conversationId?: string;
+    tools?: string[];
+    permissionMode?: string;
+    agentMessageIds: Map<number, string>;
+    toolSeen: Set<number>;
+    lastStopReason?: string;
+    turnDone?: boolean;
+    emittedImageUris: Set<string>;
+    /** True when at least one agent_response text_delta was emitted this turn. */
+    emittedTextDelta?: boolean;
+    /** Session roots for image allowlist (set by server). */
+    richRoots?: FileToAcpImageOpts;
+}
+export interface AcpNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params: Record<string, unknown>;
+}
+export declare function createMapperState(richRoots?: FileToAcpImageOpts): MapperState;
+/** Reset per-turn tracking (keep conversationId / tools / richRoots). */
+export declare function resetTurnState(state: MapperState): MapperState;
+export declare function guessToolKind(name: unknown): string;
+/**
+ * Map one agy NDJSON event object into zero or more ACP session/update notifications.
+ */
+export declare function mapAgyEvent(sessionId: string, event: unknown, state: MapperState): {
+    notifications: AcpNotification[];
+    state: MapperState;
+};
+/**
+ * Flatten ACP ContentBlock[] into a single user string for agy (text-only, no staging).
+ */
+export declare function promptBlocksToText(blocks: unknown): {
+    text: string;
+    notes: string[];
+};
+/**
+ * Build agy stream-json stdin user message line.
+ */
+export declare function buildAgyUserMessage(text: string): Record<string, unknown>;
+/** Helper for server: build richRoots from session fields. */
+export declare function richRootsFromSession(session: {
+    cwd: string;
+    additionalDirectories?: string[];
+}): FileToAcpImageOpts;

package/dist/lib/path-allowlist.d.ts

@@ -0,0 +1,21 @@
+export interface PathAllowlistRoots {
+    cwd: string;
+    additionalDirectories?: string[];
+    stagingDir?: string;
+}
+/**
+ * Decode file:// URI / percent-encoding into a filesystem path string
+ * suitable for path.resolve (mirrors rich-content decode).
+ */
+export declare function decodeFsPath(value: string): string;
+/**
+ * Resolve candidate path against session cwd (not process.cwd()), then realpath.
+ */
+export declare function resolveAgainstCwd(filePath: string, cwd: string): string | null;
+declare function pathIsInside(candidate: string, root: string): boolean;
+/**
+ * True when resolved realpath of filePath is under cwd, stagingDir, or additionalDirectories.
+ * Missing files return false (caller should not read).
+ */
+export declare function isPathAllowed(filePath: string, roots: PathAllowlistRoots): boolean;
+export { pathIsInside };

package/dist/lib/prompt-normalize.d.ts

@@ -0,0 +1,51 @@
+export interface NormalizeOpts {
+    cwd: string;
+    stagingDir?: string;
+    /** Max decoded bytes for a single blob (default 8MB). */
+    maxBlobBytes?: number;
+    /** Max total decoded bytes staged this call (default 32MB). */
+    maxTotalBytes?: number;
+}
+export interface NormalizeResult {
+    text: string;
+    notes: string[];
+    stagedFiles: string[];
+    /** Total bytes written this normalize call. */
+    stagedBytes: number;
+    /** True when a blob was rejected for size. */
+    sizeRejected: boolean;
+}
+declare const STAGING_DIRNAME = ".agy-acp-staging";
+export declare const DEFAULT_MAX_BLOB_BYTES: number;
+export declare const DEFAULT_MAX_TOTAL_BYTES: number;
+/**
+ * @param {unknown[]} blocks
+ * @param {{ cwd: string, stagingDir?: string }} opts
+ */
+export declare function normalizePromptBlocks(blocks: unknown[], opts: NormalizeOpts): Promise<NormalizeResult>;
+/**
+ * Sync convenience wrapping the same logic.
+ */
+export declare function normalizePromptBlocksSync(blocks: unknown[], opts: NormalizeOpts): NormalizeResult;
+export declare function normalizePromptBlocksAsync(blocks: unknown[], opts: NormalizeOpts): Promise<NormalizeResult>;
+/**
+ * Remove staging files. Honors AGY_ACP_KEEP_STAGING=1 to skip cleanup.
+ * @param filesOrDir list of files to delete, or a staging directory to empty
+ */
+export declare function cleanupStaging(filesOrDir: string[] | string, opts?: {
+    keep?: boolean;
+}): {
+    removed: string[];
+    skipped: boolean;
+};
+/**
+ * Clean `<cwd>/.agy-acp-staging` for a session (all files in that dir).
+ */
+export declare function cleanupSessionStaging(cwd: string, opts?: {
+    keep?: boolean;
+    stagingDir?: string;
+}): {
+    removed: string[];
+    skipped: boolean;
+};
+export { STAGING_DIRNAME, };

package/dist/lib/rich-content.d.ts

@@ -0,0 +1,45 @@
+import { type PathAllowlistRoots } from './path-allowlist.ts';
+export interface AcpImageBlock {
+    type: 'image';
+    mimeType: string;
+    data: string;
+    uri?: string;
+}
+export interface AcpTextBlock {
+    type: 'text';
+    text: string;
+}
+export type AcpContentBlock = AcpImageBlock | AcpTextBlock | Record<string, unknown>;
+export interface ToolContentEntry {
+    type: 'content';
+    content: AcpContentBlock;
+}
+export interface FileToAcpImageOpts extends Partial<PathAllowlistRoots> {
+    maxBytes?: number;
+    /** When true and roots provided, enforce allowlist. Default: enforce when cwd set. */
+    enforceAllowlist?: boolean;
+}
+export interface BuildRichToolContentOpts extends FileToAcpImageOpts {
+    toolName?: string;
+}
+declare const IMAGE_EXT: Set<string>;
+declare const MAX_IMAGE_BYTES: number;
+/**
+ * Collect filesystem-looking image paths from a string or JSON-ish object.
+ */
+export declare function extractImagePaths(textOrObj: unknown): string[];
+/**
+ * Read an image file into an ACP ImageContent block (base64 data).
+ * Skips if missing, oversized, or outside allowlisted roots (when cwd provided).
+ * Relative paths resolve against opts.cwd (session cwd), not process.cwd().
+ */
+export declare function fileToAcpImageBlock(filePath: string, opts?: FileToAcpImageOpts): AcpImageBlock | null;
+/**
+ * Build ACP tool_call_update content entries: text + optional image blocks.
+ */
+export declare function buildRichToolContent(textOut: string, params?: unknown, output?: unknown, opts?: BuildRichToolContentOpts): {
+    content: ToolContentEntry[];
+    imagePaths: string[];
+    emittedImages: number;
+};
+export { MAX_IMAGE_BYTES, IMAGE_EXT };

package/dist/lib/session-store.d.ts

@@ -0,0 +1,82 @@
+/** Launch-config snapshot persisted for resume-after-close/restart. */
+export type SessionRecord = {
+    sessionId: string;
+    conversationId?: string;
+    title?: string;
+    cwd: string;
+    additionalDirectories?: string[];
+    model?: string;
+    effort?: string;
+    mode?: string;
+    agent?: string;
+    safety?: 'safe' | 'autonomous' | 'autonomous-unsandboxed';
+    sandbox?: boolean;
+    jsonSchema?: string;
+    printTimeout?: string;
+    disableSlashCommands?: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type SessionStoreFile = {
+    version: 1;
+    sessions: SessionRecord[];
+};
+/** Resolve store file path from env or default under home. */
+export declare function resolveSessionStorePath(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function deleteOnCloseEnabled(env?: NodeJS.ProcessEnv): boolean;
+/** Build a store record from a live Session-like object. */
+export declare function sessionToRecord(session: {
+    sessionId: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    title?: string;
+    conversationId?: string;
+    additionalDirectories?: string[];
+    model?: string;
+    effort?: string;
+    mode?: string;
+    agent?: string;
+    safety?: SessionRecord['safety'];
+    sandbox?: boolean;
+    jsonSchema?: string;
+    printTimeout?: string;
+    disableSlashCommands?: boolean;
+}): SessionRecord;
+/**
+ * Fields needed to rehydrate an in-memory Session (no child process yet).
+ * Caller attaches proc/mapper/runtime state.
+ */
+export declare function recordLaunchFields(record: SessionRecord): {
+    sessionId: string;
+    cwd: string;
+    additionalDirectories?: string[];
+    createdAt: string;
+    updatedAt: string;
+    title?: string;
+    conversationId?: string;
+    model?: string;
+    effort?: string;
+    mode?: string;
+    agent?: string;
+    safety?: SessionRecord['safety'];
+    sandbox?: boolean;
+    jsonSchema?: string;
+    printTimeout?: string;
+    disableSlashCommands?: boolean;
+};
+export declare class SessionStore {
+    readonly filePath: string;
+    constructor(filePath?: string);
+    /** Read all records; missing/corrupt file → []. */
+    load(): SessionRecord[];
+    /** Atomic write: temp file in same dir + rename. */
+    save(records: SessionRecord[]): void;
+    upsert(record: SessionRecord): void;
+    get(sessionId: string): SessionRecord | undefined;
+    list(filter?: {
+        cwd?: string;
+    }): SessionRecord[];
+    delete(sessionId: string): boolean;
+    remove(sessionId: string): boolean;
+}

package/dist/lib/soft-deny.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Parse agy / jetski soft-deny signals from stderr and stream-json payloads.
+ *
+ * Observed stderr (2026-09):
+ *   jetski: ... a tool required the "command" permission ... auto-denied.
+ *   Add an allow-rule under permissions.allow in settings.json (e.g. command(<target>)).
+ *
+ * Also accepts explicit key=value fragments: tool=, allow-rule=, path=
+ * And stream-json: tool ERROR with permission/denied wording + result.denied_actions
+ *
+ * v0.5.0: do NOT treat generic tool ERROR as soft-deny (tighten parseSoftDenyFromEvent).
+ */
+export interface SoftDenyInfo {
+    tool: string;
+    allowRule: string;
+    path?: string;
+    source?: string;
+}
+/**
+ * @param {string} stderrText
+ * @returns {SoftDenyInfo[]}
+ */
+export declare function parseSoftDeny(stderrText: string): SoftDenyInfo[];
+/**
+ * Extract soft-denies from a single agy NDJSON event (tool ERROR / result.denied_actions).
+ * Generic tool errors without permission wording are ignored (v0.5.0 tighten).
+ */
+export declare function parseSoftDenyFromEvent(event: unknown): SoftDenyInfo[];
+/**
+ * Merge and de-dupe soft-deny lists.
+ */
+export declare function mergeSoftDenies(...lists: (SoftDenyInfo[] | undefined)[]): SoftDenyInfo[];
+/**
+ * Format soft-denies into a short agent-facing note.
+ */
+export declare function formatSoftDenyMessage(denies: SoftDenyInfo[]): string;

package/dist/sdk-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "agy-acp-map",
+  "version": "0.5.0",
+  "description": "Universal ACP v1/v2 bridge for Google Antigravity CLI (agy) supporting Zed, Cursor, and Electron Studio",
+  "type": "module",
+  "bin": {
+    "agy-acp": "dist/bin.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build src/sdk-server.ts --target node --outfile dist/bin.js && bun build src/index.ts --target node --outfile dist/index.js",
+    "build:types": "bunx tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build && bun test src/lib",
+    "start": "bun src/sdk-server.ts",
+    "start:dist": "node dist/bin.js",
+    "start:legacy": "bun archive/legacy-server.ts",
+    "map": "bun src/map.ts",
+    "test": "bun test src/lib",
+    "test:args": "bun tests/test-agy-args.ts",
+    "smoke": "bun tests/smoke/smoke-basic.ts",
+    "smoke:flags": "bun tests/smoke/smoke-flags.ts",
+    "smoke:permissions": "bun tests/smoke/smoke-permissions.ts",
+    "smoke:image-in": "bun tests/smoke/smoke-image-in.ts",
+    "smoke:image-out": "bun tests/smoke/smoke-image-out.ts",
+    "smoke:robustness": "bun tests/smoke/smoke-robustness.ts",
+    "smoke:all": "bun test src/lib && bun tests/test-agy-args.ts && bun tests/smoke/smoke-basic.ts && bun tests/smoke/smoke-flags.ts && bun tests/smoke/smoke-permissions.ts && bun tests/smoke/smoke-image-in.ts && bun tests/smoke/smoke-image-out.ts && bun tests/smoke/smoke-robustness.ts"
+  },
+  "keywords": [
+    "antigravity",
+    "acp",
+    "agent-client-protocol",
+    "google-gemini",
+    "agent",
+    "zed",
+    "cursor"
+  ],
+  "author": "yitom",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yitom486/agy-acp-map.git"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "bun-types": "^1.4.2"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^1.4.0"
+  }
+}