wave-agent-sdk 1.0.8 → 1.0.9

package/builtin/skills/artifact/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: artifact
+description: Publish a local HTML or Markdown file as a shareable web page
+disable-model-invocation: true
+---
+
+# Artifact: Publish a File as a Shareable Web Page
+
+Publish a local `.html` or `.md` file as a default-private, shareable web page.
+
+- If a file path was provided ($ARGUMENTS / $1), use it directly as the `file_path`.
+- Otherwise, infer which file to publish from the conversation context; if it is not clear, ask the user which file to publish.
+
+Call the `Artifact` tool with the resolved `file_path` (and `favicon` if relevant), then report the resulting URL to the user.

package/builtin/skills/settings/ENV.md

@@ -23,7 +23,7 @@ Wave uses several environment variables to control its core functionality. Varia
 | :--- | :--- | :--- |
 | `WAVE_API_KEY` | API key for the AI gateway. | - |
 | `WAVE_BASE_URL` | Base URL for the AI gateway. | - |
-| `WAVE_SERVER_URL` | Server URL for SSO authentication. **OS env only** — set via OS env or `options.serverUrl`; not read from settings.json `env` (avoids a startup 401 race). | `https://codechat.codewave.163.com` |
+| `WAVE_SERVER_URL` | Server URL for SSO authentication. Resolution order: `options.serverUrl` → `process.env.WAVE_SERVER_URL` → default. Unlike other `WAVE_*` vars, a settings.json `env` value is also mirrored to `process.env` so process-level singletons (AuthService) see it without a per-session snapshot. | `https://codechat.codewave.163.com` |
 | `WAVE_CUSTOM_HEADERS` | Custom HTTP headers for the AI gateway. Newline-separated `Key: Value` pairs (e.g., `"X-Foo: bar\nAuthorization: Bearer xxx"`). | - |
 | `WAVE_MODEL` | The primary AI model to use for the agent. | `gemini-3-flash` |
 | `WAVE_FAST_MODEL` | The fast AI model to use for quick tasks. | `gemini-2.5-flash` |

package/builtin/skills/settings/SKILL.md

@@ -104,6 +104,13 @@ For detailed guidance on creating plugins and marketplaces, see [PLUGINS.md](${W
 - `language`: Preferred language for agent communication (e.g., `"en"`, `"zh"`).
 - `autoMemoryEnabled`: Enable or disable auto-memory (default: `true`).
 - `autoMemoryFrequency`: Frequency of auto-memory extraction turns (default: `1`).
+- `enableArtifact`: Enable the Artifact tool, which publishes local `.html`/`.md` files as shareable (default-private) web pages. Defaults to `false` while the frame backend is not live; set to `true` to register the tool and enable WebFetch interception for artifact URLs. Toggling it hot-reloads the tool registry.
+
+```json
+{
+  "enableArtifact": true
+}
+```
 
 ## How to use this skill
 

package/builtin/skills/settings/SUBAGENTS.md

@@ -35,7 +35,7 @@ You are a specialized subagent for a specific task. Your goal is to:
 - `name`: (Required) Unique identifier.
 - `description`: (Required) Explains the subagent's expertise and when to use it.
 - `tools`: (Optional) List of tools the subagent can use.
-- `model`: (Optional) Overrides the default model for this subagent.
+- `model`: (Optional) Overrides the default model for this subagent. The special values `fastModel` and `visionModel` resolve to the `WAVE_FAST_MODEL` / `WAVE_VISION_MODEL` env vars respectively. Built-in subagents declaring `model: visionModel` (e.g. the built-in `vision` agent) are only registered when `WAVE_VISION_MODEL` is set; for user-defined subagents the value simply resolves to the configured vision model.
 
 ## Subagent Locations
 

package/dist/managers/backgroundTaskManager.js

@@ -3,6 +3,7 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 import { stripAnsiColors } from "../utils/stringUtils.js";
+import { WindowsStreamDecoder } from "../utils/encoding.js";
 import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
 export class BackgroundTaskManager {
@@ -116,8 +117,12 @@ export class BackgroundTaskManager {
                 }
             }, timeout);
         }
+        // On Windows, native tools (taskkill, powershell, ...) write GBK (cp936)
+        // instead of UTF-8; decode their byte streams accordingly (issue #1753).
+        const stdoutDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
+        const stderrDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
         const onStdout = (data) => {
-            const stripped = stripAnsiColors(data.toString());
+            const stripped = stripAnsiColors(stdoutDecoder ? stdoutDecoder.push(data) : data.toString());
             shell.stdout += stripped;
             if (logStream.writable) {
                 logStream.write(stripped);
@@ -125,7 +130,7 @@ export class BackgroundTaskManager {
             this.notifyTasksChange();
         };
         const onStderr = (data) => {
-            const stripped = stripAnsiColors(data.toString());
+            const stripped = stripAnsiColors(stderrDecoder ? stderrDecoder.push(data) : data.toString());
             shell.stderr += stripped;
             if (logStream.writable) {
                 logStream.write(stripped);
@@ -136,6 +141,26 @@ export class BackgroundTaskManager {
             if (timeoutHandle) {
                 clearTimeout(timeoutHandle);
             }
+            // Decode any bytes still held at stream end (e.g. a trailing UTF-8
+            // character split across the last chunk).
+            if (stdoutDecoder) {
+                const rest = stdoutDecoder.flush();
+                if (rest) {
+                    shell.stdout += rest;
+                    if (logStream.writable) {
+                        logStream.write(rest);
+                    }
+                }
+            }
+            if (stderrDecoder) {
+                const rest = stderrDecoder.flush();
+                if (rest) {
+                    shell.stderr += rest;
+                    if (logStream.writable) {
+                        logStream.write(rest);
+                    }
+                }
+            }
             if (logStream.writable) {
                 logStream.end();
             }
@@ -256,8 +281,12 @@ export class BackgroundTaskManager {
         };
         this.tasks.set(id, shell);
         this.notifyTasksChange();
+        // On Windows, native tools write GBK (cp936) instead of UTF-8; decode
+        // their byte streams accordingly (issue #1753).
+        const stdoutDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
+        const stderrDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
         child.stdout?.on("data", (data) => {
-            const stripped = stripAnsiColors(data.toString());
+            const stripped = stripAnsiColors(stdoutDecoder ? stdoutDecoder.push(data) : data.toString());
             shell.stdout += stripped;
             if (logStream.writable) {
                 logStream.write(stripped);
@@ -265,7 +294,7 @@ export class BackgroundTaskManager {
             this.notifyTasksChange();
         });
         child.stderr?.on("data", (data) => {
-            const stripped = stripAnsiColors(data.toString());
+            const stripped = stripAnsiColors(stderrDecoder ? stderrDecoder.push(data) : data.toString());
             shell.stderr += stripped;
             if (logStream.writable) {
                 logStream.write(stripped);
@@ -273,6 +302,25 @@ export class BackgroundTaskManager {
             this.notifyTasksChange();
         });
         child.on("exit", (code) => {
+            // Decode any bytes still held at stream end
+            if (stdoutDecoder) {
+                const rest = stdoutDecoder.flush();
+                if (rest) {
+                    shell.stdout += rest;
+                    if (logStream.writable) {
+                        logStream.write(rest);
+                    }
+                }
+            }
+            if (stderrDecoder) {
+                const rest = stderrDecoder.flush();
+                if (rest) {
+                    shell.stderr += rest;
+                    if (logStream.writable) {
+                        logStream.write(rest);
+                    }
+                }
+            }
             if (logStream.writable) {
                 logStream.end();
             }

package/dist/managers/skillManager.d.ts

@@ -66,6 +66,19 @@ export declare class SkillManager extends EventEmitter {
      * Find all directories that could contain skills
      */
     private findSkillDirectories;
+    /**
+     * Whether a discovered skill is a feature-gated builtin skill whose gate
+     * is currently off. Mirrors ToolManager's gate for the Artifact tool so
+     * the /artifact skill command stays in sync with enableArtifact.
+     */
+    private isSkillGatedOff;
+    /**
+     * Re-evaluate feature-gated builtin skills after a live configuration
+     * reload (same hook as ToolManager.reloadFeatureGatedTools). Re-scans
+     * skill directories and emits "refreshed" so slash-command registration
+     * follows the gate.
+     */
+    reloadFeatureGatedSkills(): Promise<void>;
     /**
      * Execute a skill by name
      */

package/dist/managers/skillManager.js

@@ -7,6 +7,7 @@ import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
 import { substituteCommandParameters } from "../utils/commandArgumentParser.js";
 import { parseBashCommands, replaceBashCommandsWithOutput, executeBashCommands, } from "../utils/markdownParser.js";
 import { getBuiltinSkillsDir } from "../utils/configPaths.js";
+import { isArtifactEnabled } from "../services/artifactAvailability.js";
 import { logger } from "../utils/globalLogger.js";
 /**
  * Manages skill discovery and loading
@@ -247,6 +248,12 @@ export class SkillManager extends EventEmitter {
                         ...parsed.skillMetadata,
                         type: collection.type,
                     };
+                    // Feature-gated builtin skills (e.g. artifact behind
+                    // enableArtifact) are skipped while the gate is off, mirroring
+                    // ToolManager's registration gate for the Artifact tool.
+                    if (this.isSkillGatedOff(skillMetadata)) {
+                        continue;
+                    }
                     // Create full skill object with content
                     const skill = {
                         ...skillMetadata,
@@ -304,6 +311,29 @@ export class SkillManager extends EventEmitter {
         }
         return directories;
     }
+    /**
+     * Whether a discovered skill is a feature-gated builtin skill whose gate
+     * is currently off. Mirrors ToolManager's gate for the Artifact tool so
+     * the /artifact skill command stays in sync with enableArtifact.
+     */
+    isSkillGatedOff(metadata) {
+        if (metadata.type !== "builtin") {
+            return false;
+        }
+        if (metadata.name === "artifact") {
+            return !isArtifactEnabled(this.workdir);
+        }
+        return false;
+    }
+    /**
+     * Re-evaluate feature-gated builtin skills after a live configuration
+     * reload (same hook as ToolManager.reloadFeatureGatedTools). Re-scans
+     * skill directories and emits "refreshed" so slash-command registration
+     * follows the gate.
+     */
+    async reloadFeatureGatedSkills() {
+        await this.refreshSkills();
+    }
     /**
      * Execute a skill by name
      */

package/dist/managers/toolManager.d.ts

@@ -53,6 +53,14 @@ declare class ToolManager {
      * ```
      */
     initializeBuiltInTools(): void;
+    /**
+     * Re-evaluate feature-gated built-in tools after a live configuration
+     * reload. Currently gates the Artifact tool on settings.json
+     * `enableArtifact`. Safe to call multiple times: gated tools are removed
+     * from the registry first, then initializeBuiltInTools() re-registers them
+     * only if still enabled (so toggling the flag off actually unregisters).
+     */
+    reloadFeatureGatedTools(): void;
     /**
      * Check if a tool should be enabled based on tools configuration and permission rules
      */

package/dist/managers/toolManager.js

@@ -114,6 +114,17 @@ class ToolManager {
             }
         }
     }
+    /**
+     * Re-evaluate feature-gated built-in tools after a live configuration
+     * reload. Currently gates the Artifact tool on settings.json
+     * `enableArtifact`. Safe to call multiple times: gated tools are removed
+     * from the registry first, then initializeBuiltInTools() re-registers them
+     * only if still enabled (so toggling the flag off actually unregisters).
+     */
+    reloadFeatureGatedTools() {
+        this.toolsRegistry.delete(artifactTool.name);
+        this.initializeBuiltInTools();
+    }
     /**
      * Check if a tool should be enabled based on tools configuration and permission rules
      */

package/dist/services/artifactAvailability.d.ts

@@ -2,6 +2,8 @@
 export declare const ARTIFACT_DEFAULT_ENABLED = false;
 /**
  * Whether the Artifact tool should be registered / usable for the given workdir.
- * Explicit `enableArtifact` in merged settings wins over the code default.
+ * Resolution order: remote managed settings (`enableArtifact` from
+ * `GET /api/wave/settings`, admin override) → explicit `enableArtifact` in local
+ * merged settings → code default.
  */
 export declare function isArtifactEnabled(workdir?: string): boolean;

package/dist/services/artifactAvailability.js

@@ -9,13 +9,21 @@
  * "unset follows feature availability" semantics).
  */
 import { loadMergedWaveConfig } from "./configurationService.js";
+import { getRemoteSettingsSync } from "./remoteSettingsService.js";
 /** Code default for Artifact availability. Flip to true after the frame backend goes live. */
 export const ARTIFACT_DEFAULT_ENABLED = false;
 /**
  * Whether the Artifact tool should be registered / usable for the given workdir.
- * Explicit `enableArtifact` in merged settings wins over the code default.
+ * Resolution order: remote managed settings (`enableArtifact` from
+ * `GET /api/wave/settings`, admin override) → explicit `enableArtifact` in local
+ * merged settings → code default.
  */
 export function isArtifactEnabled(workdir) {
+    // Remote managed settings win (same last-write-wins semantics as `model`).
+    const remote = getRemoteSettingsSync();
+    if (remote?.enableArtifact !== undefined) {
+        return remote.enableArtifact;
+    }
     if (workdir) {
         const config = loadMergedWaveConfig(workdir);
         if (config?.enableArtifact !== undefined) {

package/dist/services/remoteSettingsService.js

@@ -307,6 +307,8 @@ export function mergeRemoteSettings(localMerged, remote) {
         result.marketplaces = remote.marketplaces;
     if (remote.enabledPlugins !== undefined)
         result.enabledPlugins = remote.enabledPlugins;
+    if (remote.enableArtifact !== undefined)
+        result.enableArtifact = remote.enableArtifact;
     return result;
 }
 /**

package/dist/tools/bashTool.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/globalLogger.js";
 import { resolveShellPath } from "../utils/shellResolver.js";
 import { toPosixPath } from "../utils/path.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
+import { WindowsStreamDecoder } from "../utils/encoding.js";
 import { processToolResult } from "../utils/toolResultStorage.js";
 import { BASH_MAX_OUTPUT_CHARS } from "../constants/toolLimits.js";
 import { BASH_TOOL_NAME, GLOB_TOOL_NAME, GREP_TOOL_NAME, READ_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, } from "../constants/tools.js";
@@ -250,6 +251,10 @@ The working directory persists between commands. Try to maintain your current wo
             let isAborted = false;
             let isBackgrounded = false;
             let isFinished = false;
+            // On Windows, native tools (taskkill, powershell, ...) write GBK (cp936)
+            // instead of UTF-8; decode their byte streams accordingly (issue #1753).
+            const stdoutDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
+            const stderrDecoder = process.platform === "win32" ? new WindowsStreamDecoder() : null;
             // Best-effort cleanup of the temp CWD file — used by abort/error/exit paths
             const cleanupTempFile = () => {
                 try {
@@ -416,14 +421,14 @@ The working directory persists between commands. Try to maintain your current wo
             }
             child.stdout?.on("data", (data) => {
                 if (!isAborted && !isBackgrounded && !runInBackground) {
-                    const chunk = stripAnsiColors(data.toString());
+                    const chunk = stripAnsiColors(stdoutDecoder ? stdoutDecoder.push(data) : data.toString());
                     outputBuffer += chunk;
                     updateRealtimeResults();
                 }
             });
             child.stderr?.on("data", (data) => {
                 if (!isAborted && !isBackgrounded && !runInBackground) {
-                    const chunk = stripAnsiColors(data.toString());
+                    const chunk = stripAnsiColors(stderrDecoder ? stderrDecoder.push(data) : data.toString());
                     errorBuffer += chunk;
                     updateRealtimeResults();
                 }
@@ -467,6 +472,12 @@ The working directory persists between commands. Try to maintain your current wo
                         }
                     }
                     const exitCode = code ?? 0;
+                    // Decode any bytes still held at stream end (e.g. a trailing UTF-8
+                    // character split across the last chunk).
+                    if (stdoutDecoder)
+                        outputBuffer += stdoutDecoder.flush();
+                    if (stderrDecoder)
+                        errorBuffer += stderrDecoder.flush();
                     const combinedOutput = outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
                     // Prepend CWD change message to output if present
                     const finalOutput = recoveryNotice +

package/dist/tools/editTool.js

@@ -168,7 +168,11 @@ Usage:
             if (replaceAll) {
                 // Replace all matches
                 const regex = new RegExp(escapeRegExp(matchedOldString), "g");
-                newContent = normalizedContent.replace(regex, newString);
+                // Function replacer (claude-code's applyEditToFile approach): newString
+                // is inserted literally, never parsed as a $ replacement template. A
+                // string replacer would expand $& to the matched text, $$ to a single
+                // $, and `$` could even truncate and duplicate the file (issue #1752).
+                newContent = normalizedContent.replace(regex, () => newString);
                 replacementCount = (normalizedContent.match(regex) || []).length;
             }
             else {
@@ -181,7 +185,8 @@ Usage:
                         error: `old_string appears ${matches} times in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all=true to change every instance.`,
                     };
                 }
-                newContent = normalizedContent.replace(matchedOldString, newString);
+                // Function replacer: see note above — $ in newString stays literal
+                newContent = normalizedContent.replace(matchedOldString, () => newString);
                 replacementCount = 1;
             }
             // Permission check after validation but before real operation

package/dist/utils/containerSetup.js

@@ -219,6 +219,14 @@ export function setupAgentContainer(setupOptions) {
         onReload: () => {
             const models = configurationService.getConfiguredModels();
             callbacks.onConfiguredModelsChange?.(models);
+            // Re-evaluate feature-gated tools (e.g. Artifact behind
+            // enableArtifact) so toggling the flag applies without a restart.
+            toolManager.reloadFeatureGatedTools();
+            // Same gate for the builtin /artifact skill: refresh emits "refreshed"
+            // so slash-command registration follows enableArtifact.
+            void skillManager.reloadFeatureGatedSkills().catch((error) => {
+                logger.error("Failed to reload feature-gated skills:", error);
+            });
         },
     });
     container.register("LiveConfigManager", liveConfigManager);

package/dist/utils/encoding.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Streaming byte-to-text decoder for bash tool output on Windows.
+ *
+ * Git Bash (MSYS) tools emit UTF-8, but native Windows programs (taskkill,
+ * powershell, ping, ...) write the system OEM code page — GBK (cp936) on
+ * zh-CN systems. Node's default `data.toString()` decodes every stream as
+ * UTF-8, so GBK bytes turn into U+FFFD mojibake (issue #1753).
+ *
+ * Strategy (per-chunk buffering, decide-once):
+ * - Accumulate raw bytes; try strict UTF-8 (`fatal: true`) over everything
+ *   buffered so far. If it decodes cleanly, emit the text.
+ * - If strict UTF-8 fails, hold back up to 3 trailing bytes (a UTF-8
+ *   character split across chunk boundaries) and retry on the next chunk.
+ * - Once even the head is not valid UTF-8, the stream is GBK: re-decode all
+ *   buffered bytes with GBK and switch to GBK for every subsequent chunk.
+ * - `flush()` decodes any leftover buffered bytes (leniently) at stream end.
+ */
+export declare class WindowsStreamDecoder {
+    private pending;
+    private gbkDecoder;
+    /** Longest possible incomplete UTF-8 tail at a chunk boundary is 3 bytes. */
+    private static readonly MAX_UTF8_TRAIL_BYTES;
+    push(data: Buffer): string;
+    /** Decode any bytes still held at stream end (lenient UTF-8, else GBK). */
+    flush(): string;
+}
+/** Decode a single complete byte sequence (used for non-streaming reads). */
+export declare function decodeBytes(buf: Buffer): string;

package/dist/utils/encoding.js

@@ -0,0 +1,99 @@
+/**
+ * Streaming byte-to-text decoder for bash tool output on Windows.
+ *
+ * Git Bash (MSYS) tools emit UTF-8, but native Windows programs (taskkill,
+ * powershell, ping, ...) write the system OEM code page — GBK (cp936) on
+ * zh-CN systems. Node's default `data.toString()` decodes every stream as
+ * UTF-8, so GBK bytes turn into U+FFFD mojibake (issue #1753).
+ *
+ * Strategy (per-chunk buffering, decide-once):
+ * - Accumulate raw bytes; try strict UTF-8 (`fatal: true`) over everything
+ *   buffered so far. If it decodes cleanly, emit the text.
+ * - If strict UTF-8 fails, hold back up to 3 trailing bytes (a UTF-8
+ *   character split across chunk boundaries) and retry on the next chunk.
+ * - Once even the head is not valid UTF-8, the stream is GBK: re-decode all
+ *   buffered bytes with GBK and switch to GBK for every subsequent chunk.
+ * - `flush()` decodes any leftover buffered bytes (leniently) at stream end.
+ */
+export class WindowsStreamDecoder {
+    constructor() {
+        this.pending = Buffer.alloc(0);
+        this.gbkDecoder = null;
+    }
+    push(data) {
+        // Already determined GBK: decode each chunk as it arrives.
+        if (this.gbkDecoder) {
+            return this.gbkDecoder.decode(data);
+        }
+        this.pending = Buffer.concat([this.pending, data]);
+        try {
+            const text = new TextDecoder("utf-8", { fatal: true }).decode(this.pending);
+            this.pending = Buffer.alloc(0);
+            return text;
+        }
+        catch {
+            // Strict UTF-8 failed. The trailing bytes may be a UTF-8 sequence split
+            // across chunks: hold only the trailing run of non-ASCII bytes (max 3,
+            // the longest incomplete UTF-8 tail). Everything before it is already
+            // decodable and is emitted immediately.
+            const n = this.pending.length;
+            let keep = 0;
+            while (keep < WindowsStreamDecoder.MAX_UTF8_TRAIL_BYTES &&
+                keep < n &&
+                this.pending[n - 1 - keep] >= 0x80) {
+                keep++;
+            }
+            const head = this.pending.subarray(0, n - keep);
+            if (head.length > 0) {
+                try {
+                    const text = new TextDecoder("utf-8", { fatal: true }).decode(head);
+                    this.pending = Buffer.from(this.pending.subarray(n - keep));
+                    return text;
+                }
+                catch {
+                    // Head is not valid UTF-8 → the whole stream is GBK. Re-decode
+                    // everything accumulated so far and commit to GBK.
+                    this.gbkDecoder = new TextDecoder("gbk");
+                    const text = this.gbkDecoder.decode(this.pending);
+                    this.pending = Buffer.alloc(0);
+                    return text;
+                }
+            }
+            // Only the trailing bytes are suspect: hold them for the next chunk.
+            return "";
+        }
+    }
+    /** Decode any bytes still held at stream end (lenient UTF-8, else GBK). */
+    flush() {
+        if (this.pending.length === 0)
+            return "";
+        const rest = this.pending;
+        this.pending = Buffer.alloc(0);
+        if (this.gbkDecoder) {
+            return this.gbkDecoder.decode(rest);
+        }
+        const utf8 = rest.toString("utf-8");
+        if (!utf8.includes("\uFFFD"))
+            return utf8;
+        try {
+            return new TextDecoder("gbk").decode(rest);
+        }
+        catch {
+            return utf8;
+        }
+    }
+}
+/** Longest possible incomplete UTF-8 tail at a chunk boundary is 3 bytes. */
+WindowsStreamDecoder.MAX_UTF8_TRAIL_BYTES = 3;
+/** Decode a single complete byte sequence (used for non-streaming reads). */
+export function decodeBytes(buf) {
+    const utf8 = buf.toString("utf-8");
+    if (!utf8.includes("\uFFFD"))
+        return utf8;
+    try {
+        return new TextDecoder("gbk").decode(buf);
+    }
+    catch {
+        return utf8;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",