wave-agent-sdk 0.14.0 → 0.14.2

package/src/services/aiService.ts

@@ -23,7 +23,7 @@ import * as fs from "fs";
 import * as path from "path";
 
 import {
-  COMPRESS_MESSAGES_SYSTEM_PROMPT,
+  COMPACT_MESSAGES_SYSTEM_PROMPT,
   WEB_CONTENT_SYSTEM_PROMPT,
   BTW_SYSTEM_PROMPT,
 } from "../prompts/index.js";
@@ -751,7 +751,7 @@ async function processStreamingResponse(
   return result;
 }
 
-export interface CompressMessagesOptions {
+export interface CompactMessagesOptions {
   // Resolved configuration
   gatewayConfig: GatewayConfig;
   modelConfig: ModelConfig;
@@ -762,7 +762,7 @@ export interface CompressMessagesOptions {
   model?: string;
 }
 
-export interface CompressMessagesResult {
+export interface CompactMessagesResult {
   content: string;
   usage?: {
     prompt_tokens: number;
@@ -771,9 +771,9 @@ export interface CompressMessagesResult {
   };
 }
 
-export async function compressMessages(
-  options: CompressMessagesOptions,
-): Promise<CompressMessagesResult> {
+export async function compactMessages(
+  options: CompactMessagesOptions,
+): Promise<CompactMessagesResult> {
   const { gatewayConfig, modelConfig, messages, abortSignal } = options;
 
   // Apply global 1 QPS rate limit
@@ -832,7 +832,7 @@ export async function compressMessages(
         messages: [
           {
             role: "system",
-            content: COMPRESS_MESSAGES_SYSTEM_PROMPT,
+            content: COMPACT_MESSAGES_SYSTEM_PROMPT,
           },
           ...cleanedMessages,
           {
@@ -849,7 +849,7 @@ export async function compressMessages(
     const content = response.choices[0]?.message?.content?.trim();
     if (!content) {
       throw new Error(
-        "Failed to compress conversation history: Empty response from AI",
+        "Failed to compact conversation history: Empty response from AI",
       );
     }
     const usage = response.usage
@@ -866,10 +866,10 @@ export async function compressMessages(
     };
   } catch (error) {
     if ((error as Error).name === "AbortError") {
-      logger.info("Compression request was aborted");
-      throw new Error("Compression request was aborted");
+      logger.info("Compaction request was aborted");
+      throw new Error("Compaction request was aborted");
     }
-    logger.error("Failed to compress messages:", error);
+    logger.error("Failed to compact messages:", error);
     throw error;
   }
 }

package/src/services/configurationService.ts

@@ -15,6 +15,7 @@ import type {
   ConfigurationPaths,
   WaveConfiguration,
   Scope,
+  MarketplaceConfig,
 } from "../types/configuration.js";
 import {
   getAllConfigPaths,
@@ -796,6 +797,124 @@ export class ConfigurationService {
     await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 
+  /**
+   * Get merged marketplaces from all scopes
+   */
+  getMergedMarketplaces(workdir: string): Record<string, MarketplaceConfig> {
+    const mergedConfig = loadMergedWaveConfig(workdir);
+    return mergedConfig?.marketplaces || {};
+  }
+
+  /**
+   * Get marketplaces at a specific scope
+   */
+  getScopedMarketplaces(
+    workdir: string,
+    scope: Scope,
+  ): Record<string, MarketplaceConfig> {
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+    const config = loadWaveConfigFromFile(configPath);
+    return config?.marketplaces || {};
+  }
+
+  /**
+   * Add a marketplace to the specified scope
+   */
+  async addMarketplaceToScope(
+    workdir: string,
+    scope: Scope,
+    name: string,
+    config: MarketplaceConfig,
+  ): Promise<void> {
+    if (scope !== "user" && !existsSync(workdir)) {
+      throw new Error(`Working directory does not exist: ${workdir}`);
+    }
+
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+
+    const configDir = path.dirname(configPath);
+    if (!existsSync(configDir)) {
+      await fs.mkdir(configDir, { recursive: true });
+    }
+
+    let fileConfig: WaveConfiguration = {};
+    if (existsSync(configPath)) {
+      try {
+        const content = await fs.readFile(configPath, "utf-8");
+        fileConfig = JSON.parse(content);
+      } catch {
+        // Start with empty config if file is corrupted
+      }
+    }
+
+    if (!fileConfig.marketplaces) {
+      fileConfig.marketplaces = {};
+    }
+    fileConfig.marketplaces[name] = config;
+
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(fileConfig, null, 2),
+      "utf-8",
+    );
+  }
+
+  /**
+   * Remove a marketplace from the specified scope
+   */
+  async removeMarketplaceFromScope(
+    workdir: string,
+    scope: Scope,
+    name: string,
+  ): Promise<void> {
+    if (scope !== "user" && !existsSync(workdir)) {
+      throw new Error(`Working directory does not exist: ${workdir}`);
+    }
+
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    try {
+      const content = await fs.readFile(configPath, "utf-8");
+      const fileConfig: WaveConfiguration = JSON.parse(content);
+
+      if (fileConfig.marketplaces && name in fileConfig.marketplaces) {
+        delete fileConfig.marketplaces[name];
+        await fs.writeFile(
+          configPath,
+          JSON.stringify(fileConfig, null, 2),
+          "utf-8",
+        );
+      }
+    } catch {
+      // Ignore errors for corrupted or non-existent files
+    }
+  }
+
   /**
    * Remove a plugin from the enabled plugins in the specified scope
    */
@@ -991,6 +1110,7 @@ export function loadWaveConfigFromFile(
           ? config.autoMemoryEnabled
           : undefined,
       models: config.models || undefined,
+      marketplaces: config.marketplaces || undefined,
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1124,6 +1244,12 @@ export function loadMergedWaveConfig(
       mergedConfig.autoMemoryFrequency = config.autoMemoryFrequency;
     }
 
+    // Merge marketplaces (last one wins for same key)
+    if (config.marketplaces) {
+      if (!mergedConfig.marketplaces) mergedConfig.marketplaces = {};
+      Object.assign(mergedConfig.marketplaces, config.marketplaces);
+    }
+
     // Merge models
     if (config.models) {
       if (!mergedConfig.models) mergedConfig.models = {};
@@ -1157,6 +1283,11 @@ export function loadMergedWaveConfig(
         : undefined,
     language: mergedConfig.language,
     autoMemoryEnabled: mergedConfig.autoMemoryEnabled,
+    marketplaces:
+      mergedConfig.marketplaces &&
+      Object.keys(mergedConfig.marketplaces).length > 0
+        ? mergedConfig.marketplaces
+        : undefined,
     models:
       mergedConfig.models && Object.keys(mergedConfig.models).length > 0
         ? mergedConfig.models

package/src/services/hook.ts

@@ -84,6 +84,23 @@ async function buildHookJsonInput(
     }
   }
 
+  // Add SessionStart-specific fields
+  if (context.event === "SessionStart") {
+    if (context.source !== undefined) {
+      jsonInput.source = context.source;
+    }
+    if (context.agentType !== undefined) {
+      jsonInput.agent_type = context.agentType;
+    }
+  }
+
+  // Add SessionEnd-specific fields
+  if (context.event === "SessionEnd") {
+    if (context.endSource !== undefined) {
+      jsonInput.end_source = context.endSource;
+    }
+  }
+
   return jsonInput;
 }
 

package/src/services/initializationService.ts

@@ -178,6 +178,38 @@ export class InitializationService {
       // Don't throw error to prevent app startup failure
     }
 
+    // Execute SessionStart hooks
+    try {
+      const phaseStart = performance.now();
+      const sessionStartResult = await hookManager.executeSessionStartHooks(
+        "startup",
+        messageManager.getSessionId(),
+        messageManager.getTranscriptPath(),
+      );
+
+      // Inject additionalContext as a meta user message (matches Claude Code)
+      if (sessionStartResult.additionalContext) {
+        messageManager.addUserMessage({
+          content: `<system-reminder>\nSessionStart hook additional context: ${sessionStartResult.additionalContext}\n</system-reminder>`,
+          isMeta: true,
+        });
+      }
+
+      // Inject initialUserMessage as a meta user message
+      if (sessionStartResult.initialUserMessage) {
+        messageManager.addUserMessage({
+          content: sessionStartResult.initialUserMessage,
+          isMeta: true,
+        });
+      }
+
+      logger?.debug(
+        `Initialization Phase [SessionStart Hooks] took ${(performance.now() - phaseStart).toFixed(2)}ms`,
+      );
+    } catch (error) {
+      logger?.warn("SessionStart hooks execution failed:", error);
+    }
+
     // Trigger WorktreeCreate hook if this is a new worktree
     if (agentOptions.isNewWorktree && hookManager) {
       try {
@@ -318,7 +350,7 @@ export class InitializationService {
       if (sessionToRestore) {
         messageManager.initializeFromSession(sessionToRestore);
 
-        // Update task manager with the root session ID to ensure continuity across compressions
+        // Update task manager with the root session ID to ensure continuity across compactions
         taskManager.setTaskListId(
           sessionToRestore.rootSessionId || sessionToRestore.id,
         );

package/src/services/interactionService.ts

@@ -183,7 +183,7 @@ export class InteractionService {
     // 6. Initialize session state last
     messageManager.initializeFromSession(sessionData);
 
-    // Update task manager with the root session ID to ensure continuity across compressions
+    // Update task manager with the root session ID to ensure continuity across compactions
     taskManager.setTaskListId(sessionData.rootSessionId || sessionData.id);
 
     // 7. Load tasks for the restored session

package/src/services/pluginLoader.ts

@@ -153,7 +153,13 @@ export class PluginLoader {
     const hooksPath = path.join(pluginPath, "hooks", "hooks.json");
     try {
       const content = await fs.readFile(hooksPath, "utf-8");
-      return JSON.parse(content) as PartialHookConfiguration;
+      const parsed = JSON.parse(content);
+      // Claude Code wrapper format: { "hooks": { "SessionStart": [...] } }
+      // (optional "description" sibling key)
+      if (parsed && typeof parsed === "object" && "hooks" in parsed) {
+        return parsed.hooks as PartialHookConfiguration;
+      }
+      return undefined;
     } catch {
       return undefined;
     }

package/src/services/session.ts

@@ -816,7 +816,7 @@ export async function sessionExistsInJsonl(
 /**
  * Get the content of the first message in a session
  * For user role: get text block content
- * For assistant role: get compress block content
+ * For assistant role: get compact block content
  * @param sessionId - Session ID to get first message from
  * @param workdir - Working directory for session operations
  * @returns Promise that resolves to the first message content or null if not found
@@ -996,18 +996,18 @@ export async function loadFullMessageThread(
 
     sessionIds.unshift(currentId);
     // Add messages from this session to the beginning of the list
-    // But skip the "compress" block if it's not the first session in our traversal (which is the latest)
+    // But skip the "compact" block if it's not the first session in our traversal (which is the latest)
     // Actually, we should probably keep all messages and let the UI/logic handle it.
-    // But wait, if we are concatenating, the "compress" block in session N summarizes session N-1.
-    // So if we have session N-1 and session N, we should probably skip the compress block in session N.
+    // But wait, if we are concatenating, the "compact" block in session N summarizes session N-1.
+    // So if we have session N-1 and session N, we should probably skip the compact block in session N.
 
     const messages = sessionData.messages;
     if (allMessages.length > 0) {
       // If we already have messages (from "later" sessions),
       // we are now adding messages from an "earlier" session.
-      // The later session's first message might be a "compress" block.
-      if (allMessages[0].blocks.some((b) => b.type === "compress")) {
-        // Remove the compress block from the later session's messages
+      // The later session's first message might be a "compact" block.
+      if (allMessages[0].blocks.some((b) => b.type === "compact")) {
+        // Remove the compact block from the later session's messages
         // because we are now providing the actual messages it summarized.
         allMessages.shift();
       }

package/src/services/taskManager.ts

@@ -30,7 +30,7 @@ export class TaskManager extends EventEmitter {
 
   /**
    * Syncs the task list ID with the current session's root session ID.
-   * This is typically called when the session is cleared or compressed.
+   * This is typically called when the session is cleared or compacted.
    */
   public async syncWithSession(): Promise<void> {
     const messageManager = this.container.get<MessageManager>("MessageManager");

package/src/types/configuration.ts

@@ -9,9 +9,15 @@
 import type { HookEvent, HookEventConfig } from "./hooks.js";
 import type { PermissionMode } from "./permissions.js";
 import type { ModelConfig } from "./config.js";
+import type { MarketplaceSource } from "./marketplace.js";
 
 export type Scope = "user" | "project" | "local";
 
+export interface MarketplaceConfig {
+  source: MarketplaceSource;
+  autoUpdate?: boolean;
+}
+
 /**
  * Root configuration structure for all Wave Agent settings including hooks and environment variables
  */
@@ -39,6 +45,8 @@ export interface WaveConfiguration {
   autoMemoryFrequency?: number;
   /** Model-specific configuration overrides */
   models?: Record<string, Partial<ModelConfig>>;
+  /** Scoped marketplace declarations */
+  marketplaces?: Record<string, MarketplaceConfig>;
 }
 
 /**

package/src/types/core.ts

@@ -25,7 +25,7 @@ export interface Usage {
   completion_tokens: number; // Tokens generated in completions
   total_tokens: number; // Sum of prompt + completion tokens
   model?: string; // Model used for the operation (e.g., "gpt-4", "gpt-3.5-turbo")
-  operation_type?: "agent" | "compress"; // Type of operation that generated usage
+  operation_type?: "agent" | "compact"; // Type of operation that generated usage
 
   // Cache-related tokens (Claude models only)
   cache_read_input_tokens?: number; // Tokens read from cache

package/src/types/hooks.ts

@@ -21,7 +21,9 @@ export type HookEvent =
   | "SubagentStop"
   | "PermissionRequest"
   | "WorktreeCreate"
-  | "CwdChanged";
+  | "CwdChanged"
+  | "SessionStart"
+  | "SessionEnd";
 
 // Individual hook command configuration
 export interface HookCommand {
@@ -94,6 +96,10 @@ export class HookConfigurationError extends Error {
   }
 }
 
+export type SessionStartSource = "startup" | "resume" | "compact";
+
+export type SessionEndSource = "exit" | "stop" | "compact";
+
 // Type guards for runtime validation
 export function isValidHookEvent(event: string): event is HookEvent {
   return [
@@ -105,6 +111,8 @@ export function isValidHookEvent(event: string): event is HookEvent {
     "PermissionRequest",
     "WorktreeCreate",
     "CwdChanged",
+    "SessionStart",
+    "SessionEnd",
   ].includes(event);
 }
 
@@ -161,7 +169,7 @@ export interface HookJsonInput {
   session_id: string; // Format: "wave_session_{uuid}_{shortId}"
   transcript_path: string; // Format: "~/.wave/sessions/session_{shortId}.json"
   cwd: string; // Absolute path to current working directory
-  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "CwdChanged"
+  hook_event_name: HookEvent; // "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "CwdChanged" | "SessionStart"
 
   // Optional fields based on event type
   tool_name?: string; // Present for PreToolUse, PostToolUse, PermissionRequest
@@ -172,6 +180,9 @@ export interface HookJsonInput {
   name?: string; // Present for WorktreeCreate events
   old_cwd?: string; // Present for CwdChanged events
   new_cwd?: string; // Present for CwdChanged events
+  source?: SessionStartSource; // Present for SessionStart events
+  agent_type?: string; // Present for SessionStart events
+  end_source?: SessionEndSource; // Present for SessionEnd events
 }
 
 // Extended context interface for passing additional data to hook executor
@@ -187,6 +198,9 @@ export interface ExtendedHookExecutionContext extends HookExecutionContext {
   worktreeName?: string; // Worktree name (WorktreeCreate only)
   oldCwd?: string; // Previous working directory (CwdChanged only)
   newCwd?: string; // New working directory (CwdChanged only)
+  source?: SessionStartSource; // Session start source (SessionStart only)
+  agentType?: string; // Agent type identifier (SessionStart only)
+  endSource?: SessionEndSource; // Session end source (SessionEnd only)
 }
 
 // Environment variables injected into hook processes

package/src/types/marketplace.ts

@@ -48,6 +48,8 @@ export interface KnownMarketplace {
   isBuiltin?: boolean;
   autoUpdate?: boolean;
   lastUpdated?: string;
+  /** The scope where this marketplace was declared (user, project, local, or builtin) */
+  declaredScope?: "user" | "project" | "local" | "builtin";
 }
 
 export interface KnownMarketplacesRegistry {

package/src/types/messaging.ts

@@ -25,7 +25,7 @@ export type MessageBlock =
   | ToolBlock
   | ImageBlock
   | BangBlock
-  | CompressBlock
+  | CompactBlock
   | ReasoningBlock
   | FileHistoryBlock
   | TaskNotificationBlock;
@@ -85,8 +85,8 @@ export interface BangBlock {
   exitCode: number | null;
 }
 
-export interface CompressBlock {
-  type: "compress";
+export interface CompactBlock {
+  type: "compact";
   content: string;
   sessionId: string;
 }

package/src/utils/convertMessagesForAPI.ts

@@ -33,7 +33,7 @@ function safeToolArguments(args: string): string {
 }
 
 /**
- * Convert message format to API call format, stopping when a compressed message is encountered.
+ * Convert message format to API call format, stopping when a compacted message is encountered.
  * Messages with no meaningful content or tool calls are filtered out.
  * @param messages Message list
  * @returns Converted API message format list
@@ -47,19 +47,19 @@ export function convertMessagesForAPI(
   for (let i = startIndex; i >= 0; i--) {
     const message = messages[i];
 
-    // Check if a compression block is encountered, if so, stop iteration
+    // Check if a compaction block is encountered, if so, stop iteration
     if (
       message.role === "assistant" &&
-      message.blocks.some((block) => block.type === "compress")
+      message.blocks.some((block) => block.type === "compact")
     ) {
-      // Add the content of the compression block as an assistant message to the history
-      const compressBlock = message.blocks.find(
-        (block) => block.type === "compress",
+      // Add the content of the compaction block as an assistant message to the history
+      const compactBlock = message.blocks.find(
+        (block) => block.type === "compact",
       );
-      if (compressBlock && compressBlock.type === "compress") {
+      if (compactBlock && compactBlock.type === "compact") {
         recentMessages.unshift({
           role: "user",
-          content: compressBlock.content,
+          content: compactBlock.content,
         });
       }
       break;

package/src/utils/groupMessagesByApiRound.ts

@@ -14,7 +14,7 @@ export interface ApiRound {
  * Boundaries:
  *  - A new `role: "user"` message starts a new round.
  *  - A new `role: "assistant"` message with a different `id` starts a new round.
- *  - A message with a `compress` block is pushed as its own round and starts a
+ *  - A message with a `compact` block is pushed as its own round and starts a
  *    new round after it.
  */
 export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
@@ -28,9 +28,9 @@ export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
     if (msg.role === "user") {
       startNewRound = true;
     } else if (msg.role === "assistant") {
-      // Compress block is always its own round
-      const hasCompress = msg.blocks.some((b) => b.type === "compress");
-      if (hasCompress) {
+      // Compact block is always its own round
+      const hasCompact = msg.blocks.some((b) => b.type === "compact");
+      if (hasCompact) {
         startNewRound = true;
       } else if (msg.id !== lastAssistantId) {
         // New assistant id starts a new round.
@@ -58,10 +58,10 @@ export function groupMessagesByApiRound(messages: Message[]): ApiRound[] {
 
     currentRound.push(msg);
 
-    // After pushing a compress message as its own round, flush immediately
+    // After pushing a compact message as its own round, flush immediately
     if (
       msg.role === "assistant" &&
-      msg.blocks.some((b) => b.type === "compress")
+      msg.blocks.some((b) => b.type === "compact")
     ) {
       rounds.push({
         messages: currentRound,

package/src/utils/messageOperations.ts

@@ -582,11 +582,9 @@ export function getMessageContent(message: Message): string {
     return `!${bangBlock.command}`;
   }
 
-  const compressBlock = message.blocks.find(
-    (block) => block.type === "compress",
-  );
-  if (compressBlock && "content" in compressBlock) {
-    return compressBlock.content;
+  const compactBlock = message.blocks.find((block) => block.type === "compact");
+  if (compactBlock && "content" in compactBlock) {
+    return compactBlock.content;
   }
 
   return "";