wave-agent-sdk 1.0.4 → 1.0.6

package/src/utils/nameGenerator.ts

@@ -1,99 +0,0 @@
-/**
- * Random name generator for plan files
- */
-
-const adjectives = [
-  "gentle",
-  "swift",
-  "calm",
-  "bold",
-  "bright",
-  "cool",
-  "warm",
-  "quiet",
-  "loud",
-  "fast",
-  "slow",
-  "high",
-  "low",
-  "deep",
-  "shallow",
-  "broad",
-  "narrow",
-  "long",
-  "short",
-  "brave",
-  "wild",
-  "tame",
-  "smart",
-  "clever",
-  "kind",
-  "fair",
-  "just",
-  "wise",
-  "strong",
-  "weak",
-];
-
-const nouns = [
-  "breeze",
-  "river",
-  "mountain",
-  "forest",
-  "ocean",
-  "valley",
-  "peak",
-  "stream",
-  "cloud",
-  "storm",
-  "sun",
-  "moon",
-  "star",
-  "field",
-  "meadow",
-  "desert",
-  "island",
-  "coast",
-  "plain",
-  "glacier",
-  "eagle",
-  "wolf",
-  "bear",
-  "lion",
-  "tiger",
-  "hawk",
-  "owl",
-  "fox",
-  "deer",
-  "elk",
-];
-
-/**
- * Generates a random English name (adjective-adjective-noun)
- */
-export function generateRandomName(seed?: string): string {
-  let adj1Index: number;
-  let adj2Index: number;
-  let nounIndex: number;
-
-  if (seed) {
-    // Simple hash function to derive indices from seed
-    let hash = 0;
-    for (let i = 0; i < seed.length; i++) {
-      hash = (hash << 5) - hash + seed.charCodeAt(i);
-      hash |= 0; // Convert to 32bit integer
-    }
-    adj1Index = Math.abs(hash) % adjectives.length;
-    adj2Index = Math.abs(hash >> 4) % adjectives.length;
-    nounIndex = Math.abs(hash >> 8) % nouns.length;
-  } else {
-    adj1Index = Math.floor(Math.random() * adjectives.length);
-    adj2Index = Math.floor(Math.random() * adjectives.length);
-    nounIndex = Math.floor(Math.random() * nouns.length);
-  }
-
-  const adj1 = adjectives[adj1Index];
-  const adj2 = adjectives[adj2Index];
-  const noun = nouns[nounIndex];
-  return `${adj1}-${adj2}-${noun}`;
-}

package/src/utils/notificationXml.ts

@@ -1,57 +0,0 @@
-import type { TaskNotificationBlock } from "../types/messaging.js";
-
-export function taskNotificationToXml(block: TaskNotificationBlock): string {
-  let xml = `<task-notification>\n`;
-  xml += `<task-id>${block.taskId}</task-id>\n`;
-  xml += `<task-type>${block.taskType}</task-type>\n`;
-  if (block.outputFile) {
-    xml += `<output-file>${block.outputFile}</output-file>\n`;
-  }
-  xml += `<status>${block.status}</status>\n`;
-  xml += `<summary>${block.summary}</summary>\n`;
-  xml += `</task-notification>`;
-  return xml;
-}
-
-function extractTag(xml: string, tag: string): string | null {
-  const regex = new RegExp(`<${tag}>(.*?)</${tag}>`, "s");
-  const match = xml.match(regex);
-  return match ? match[1] : null;
-}
-
-export function parseTaskNotificationXml(
-  xml: string,
-): TaskNotificationBlock | null {
-  try {
-    const taskId = extractTag(xml, "task-id");
-    const taskType = extractTag(xml, "task-type") as
-      | "shell"
-      | "agent"
-      | "workflow"
-      | null;
-    const status = extractTag(xml, "status") as
-      | "completed"
-      | "failed"
-      | "killed"
-      | "aborted"
-      | null;
-    const summary = extractTag(xml, "summary");
-
-    if (!taskId || !taskType || !status || !summary) {
-      return null;
-    }
-
-    const outputFile = extractTag(xml, "output-file") || undefined;
-
-    return {
-      type: "task_notification",
-      taskId,
-      taskType,
-      status,
-      summary,
-      ...(outputFile && { outputFile }),
-    };
-  } catch {
-    return null;
-  }
-}

package/src/utils/openaiClient.ts

@@ -1,251 +0,0 @@
-import {
-  ChatCompletionCreateParamsNonStreaming,
-  ChatCompletionCreateParamsStreaming,
-  ChatCompletionChunk,
-  ChatCompletion,
-} from "openai/resources.js";
-import { GatewayConfig } from "../types/config.js";
-import { logger } from "./globalLogger.js";
-
-const MAX_RETRIES = 10;
-const BASE_DELAY_MS = 500;
-const MAX_DELAY_MS = 32000;
-
-function getRetryDelay(
-  attempt: number,
-  retryAfterHeader: string | null,
-): number {
-  if (retryAfterHeader) {
-    const seconds = parseInt(retryAfterHeader, 10);
-    if (!isNaN(seconds)) {
-      return seconds * 1000;
-    }
-  }
-  const baseDelay = Math.min(
-    BASE_DELAY_MS * Math.pow(2, attempt - 1),
-    MAX_DELAY_MS,
-  );
-  const jitter = Math.random() * 0.25 * baseDelay;
-  return baseDelay + jitter;
-}
-
-type CreateParams =
-  | ChatCompletionCreateParamsNonStreaming
-  | ChatCompletionCreateParamsStreaming;
-
-interface APIResponse<T> {
-  data: T;
-  response: Response;
-}
-
-interface APIPromise<T> extends Promise<T> {
-  withResponse(): Promise<APIResponse<T>>;
-}
-
-export class OpenAIClient {
-  constructor(private config: GatewayConfig) {}
-
-  get chat() {
-    return {
-      completions: {
-        create: <P extends CreateParams>(
-          params: P,
-          options?: { signal?: AbortSignal },
-        ): APIPromise<
-          P extends ChatCompletionCreateParamsStreaming
-            ? AsyncIterable<ChatCompletionChunk>
-            : ChatCompletion
-        > => {
-          const responsePromise = this._create(params, options);
-          const promise = responsePromise.then(
-            (res) => res.data,
-          ) as unknown as APIPromise<
-            P extends ChatCompletionCreateParamsStreaming
-              ? AsyncIterable<ChatCompletionChunk>
-              : ChatCompletion
-          >;
-          promise.withResponse = () =>
-            responsePromise as Promise<
-              APIResponse<
-                P extends ChatCompletionCreateParamsStreaming
-                  ? AsyncIterable<ChatCompletionChunk>
-                  : ChatCompletion
-              >
-            >;
-          // Prevent unhandled rejection if only withResponse() is used
-          promise.catch((e) => {
-            if (!(e instanceof Error && e.name === "AbortError")) {
-              logger.error("Unhandled OpenAI promise rejection:", e);
-            }
-          });
-          return promise;
-        },
-      },
-    };
-  }
-
-  private async _create<P extends CreateParams>(
-    params: P,
-    options?: { signal?: AbortSignal },
-  ): Promise<
-    APIResponse<
-      P extends ChatCompletionCreateParamsStreaming
-        ? AsyncIterable<ChatCompletionChunk>
-        : ChatCompletion
-    >
-  > {
-    const {
-      baseURL,
-      apiKey,
-      sessionId,
-      defaultHeaders,
-      fetchOptions,
-      fetch: customFetch,
-    } = this.config;
-    const url = `${baseURL}/chat/completions`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-      ...(sessionId ? { "x-session-id": sessionId } : {}),
-      ...defaultHeaders,
-    };
-
-    const fetchFn = (customFetch as typeof fetch) || fetch;
-    let lastError: (Error & { status?: number; body?: unknown }) | undefined;
-    let lastRetryAfter: string | null = null;
-
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      if (attempt > 0) {
-        const delay = getRetryDelay(attempt, lastRetryAfter);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-
-      let response: Response;
-      try {
-        response = await fetchFn(url, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(params),
-          signal: options?.signal,
-          ...(fetchOptions as RequestInit),
-        });
-      } catch (e) {
-        if (e instanceof Error && e.name === "AbortError") {
-          throw e;
-        }
-        if (attempt < MAX_RETRIES) {
-          logger.warn("OpenAI API network error, retrying...", {
-            model: params.model,
-            attempt: attempt + 1,
-            error: e,
-          });
-          lastError = e as Error;
-          lastRetryAfter = null;
-          continue;
-        }
-        throw e;
-      }
-
-      if (response.ok) {
-        if (params.stream) {
-          return {
-            data: this.streamChatCompletion(response),
-            response,
-          } as unknown as APIResponse<
-            P extends ChatCompletionCreateParamsStreaming
-              ? AsyncIterable<ChatCompletionChunk>
-              : ChatCompletion
-          >;
-        } else {
-          const data = await response.json();
-          return {
-            data,
-            response,
-          } as unknown as APIResponse<
-            P extends ChatCompletionCreateParamsStreaming
-              ? AsyncIterable<ChatCompletionChunk>
-              : ChatCompletion
-          >;
-        }
-      }
-
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch (e) {
-        logger.error("Failed to read error response text", { error: e });
-      }
-
-      const error = new Error(
-        `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}: ${responseText}`,
-      ) as Error & { status?: number; body?: unknown };
-      error.status = response.status;
-      error.body = responseText;
-
-      const retryableStatus =
-        response.status === 429 ||
-        (response.status >= 500 && response.status !== 501);
-      if (retryableStatus && attempt < MAX_RETRIES) {
-        lastRetryAfter = response.headers.get("retry-after");
-        logger.warn("OpenAI API error, retrying...", {
-          model: params.model,
-          attempt: attempt + 1,
-          status: response.status,
-          retryAfter: lastRetryAfter,
-        });
-        lastError = error;
-        continue;
-      }
-
-      logger.error("OpenAI API Error:", {
-        status: response.status,
-        statusText: response.statusText,
-        body: responseText,
-      });
-      throw error;
-    }
-    throw lastError;
-  }
-
-  private async *streamChatCompletion(
-    response: Response,
-  ): AsyncIterable<ChatCompletionChunk> {
-    const reader = response.body?.getReader();
-    if (!reader) return;
-
-    const decoder = new TextDecoder();
-    let buffer = "";
-
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-
-        for (const line of lines) {
-          const trimmedLine = line.trim();
-          if (!trimmedLine || !trimmedLine.startsWith("data:")) continue;
-
-          const data = trimmedLine.slice(5).trim();
-          if (data === "[DONE]") return;
-          if (!data) continue; // Skip empty data lines (keepalive heartbeats)
-
-          try {
-            const json = JSON.parse(data);
-            yield json as ChatCompletionChunk;
-          } catch (e) {
-            logger.error("Failed to parse stream chunk", {
-              error: e instanceof Error ? e.message : String(e),
-              data,
-            });
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-}

package/src/utils/parseCronExpression.ts

@@ -1,78 +0,0 @@
-// Minimal cron expression validation.
-// Supports the standard 5-field cron subset:
-//   minute hour day-of-month month day-of-week
-//
-// Field syntax: wildcard, N, step (star-slash-N), range (N-M), list (N,M,...).
-// No L, W, ?, or name aliases. Based on Claude Code's parseCronExpression.
-
-type FieldRange = { min: number; max: number };
-
-const FIELD_RANGES: FieldRange[] = [
-  { min: 0, max: 59 }, // minute
-  { min: 0, max: 23 }, // hour
-  { min: 1, max: 31 }, // dayOfMonth
-  { min: 1, max: 12 }, // month
-  { min: 0, max: 6 }, // dayOfWeek (0=Sunday; 7 accepted as Sunday alias)
-];
-
-function expandField(field: string, range: FieldRange): number[] | null {
-  const { min, max } = range;
-  const out = new Set<number>();
-
-  for (const part of field.split(",")) {
-    // wildcard or star-slash-N
-    const stepMatch = part.match(/^\*(?:\/(\d+))?$/);
-    if (stepMatch) {
-      const step = stepMatch[1] ? parseInt(stepMatch[1], 10) : 1;
-      if (step < 1) return null;
-      for (let i = min; i <= max; i += step) out.add(i);
-      continue;
-    }
-
-    // N-M or N-M/S
-    const rangeMatch = part.match(/^(\d+)-(\d+)(?:\/(\d+))?$/);
-    if (rangeMatch) {
-      const lo = parseInt(rangeMatch[1]!, 10);
-      const hi = parseInt(rangeMatch[2]!, 10);
-      const step = rangeMatch[3] ? parseInt(rangeMatch[3], 10) : 1;
-      const isDow = min === 0 && max === 6;
-      const effMax = isDow ? 7 : max;
-      if (lo > hi || step < 1 || lo < min || hi > effMax) return null;
-      for (let i = lo; i <= hi; i += step) {
-        out.add(isDow && i === 7 ? 0 : i);
-      }
-      continue;
-    }
-
-    // plain N
-    const singleMatch = part.match(/^\d+$/);
-    if (singleMatch) {
-      let n = parseInt(part, 10);
-      if (min === 0 && max === 6 && n === 7) n = 0;
-      if (n < min || n > max) return null;
-      out.add(n);
-      continue;
-    }
-
-    return null;
-  }
-
-  if (out.size === 0) return null;
-  return Array.from(out).sort((a, b) => a - b);
-}
-
-/**
- * Validate a 5-field cron expression.
- * Returns true if valid, false otherwise.
- */
-export function parseCronExpression(expr: string): boolean {
-  const parts = expr.trim().split(/\s+/);
-  if (parts.length !== 5) return false;
-
-  for (let i = 0; i < 5; i++) {
-    const result = expandField(parts[i]!, FIELD_RANGES[i]!);
-    if (!result) return false;
-  }
-
-  return true;
-}

package/src/utils/path.ts

@@ -1,72 +0,0 @@
-import { resolve } from "path";
-import { homedir } from "os";
-import { relative } from "path";
-
-/**
- * Handle paths, supporting ~ expansion
- * @param filePath File path
- * @param workdir Working directory
- * @returns Resolved absolute path
- */
-export function resolvePath(filePath: string, workdir: string): string {
-  // If the path starts with ~, replace it with the user's home directory
-  if (filePath.startsWith("~/")) {
-    return resolve(homedir(), filePath.slice(2));
-  }
-
-  // If the path starts with ~ but has no slash, it means it's the home directory
-  if (filePath === "~") {
-    return homedir();
-  }
-
-  // For other paths, resolve using the specified working directory
-  return resolve(workdir, filePath);
-}
-
-/**
- * Get relative path for display, use relative path if shorter and not in parent directory.
- *
- * The returned path is always normalized to forward slashes (posix) regardless of
- * platform. This keeps display output consistent across Windows/Unix so that logs,
- * LLM context, and tests don't need platform-specific branches — `path.relative`
- * and `path.join` produce backslashes on Windows, which we collapse here.
- *
- * @param filePath Absolute path
- * @param workdir Working directory
- * @returns Path for display (relative or absolute), always forward-slash
- */
-export function getDisplayPath(filePath: string, workdir: string): string {
-  if (!filePath) {
-    return filePath;
-  }
-
-  try {
-    const relativePath = relative(workdir, filePath);
-
-    // If the relative path is empty (i.e., the paths are the same), return "."
-    if (relativePath === "") {
-      return ".";
-    }
-
-    // If the relative path is shorter than the absolute path and does not start with .. (not in parent directory), use the relative path
-    if (
-      relativePath.length < filePath.length &&
-      !relativePath.startsWith("..")
-    ) {
-      return toPosixPath(relativePath);
-    }
-  } catch {
-    // If calculating the relative path fails, keep the original path
-  }
-  return toPosixPath(filePath);
-}
-
-/**
- * Convert backslashes to forward slashes for shell compatibility on Windows.
- * On Windows, os.tmpdir() returns paths with backslashes (e.g., C:\Users\foo\Temp),
- * which are treated as escape characters when interpolated into shell command strings.
- * Returns the path as-is on non-Windows platforms.
- */
-export function toPosixPath(p: string): string {
-  return process.platform === "win32" ? p.replace(/\\/g, "/") : p;
-}