@stagewhisper/stagewhisper 0.49.0 → 0.52.0

package/src/channel.ts

@@ -1,178 +0,0 @@
-import {
-  createChatChannelPlugin,
-  createChannelPluginBase,
-  DEFAULT_ACCOUNT_ID,
-} from "openclaw/plugin-sdk/core";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-
-export type StageWhisperAccount = {
-  accountId: string | null;
-  apiBaseUrl: string;
-  integrationId: string;
-  relayToken: string;
-  label: string;
-};
-
-function getChannelSection(cfg: OpenClawConfig): Record<string, unknown> {
-  const channels = cfg.channels as
-    | Record<string, Record<string, unknown>>
-    | undefined;
-  return channels?.["stagewhisper"] ?? {};
-}
-
-export function resolveAccount(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): StageWhisperAccount {
-  const section = getChannelSection(cfg);
-  const pluginCfg = (cfg as Record<string, unknown>)?.["plugins"] as
-    | Record<string, unknown>
-    | undefined;
-  const entries = pluginCfg?.["entries"] as
-    | Record<string, Record<string, unknown>>
-    | undefined;
-  const swConfig = entries?.["stagewhisper"]?.["config"] as
-    | Record<string, unknown>
-    | undefined;
-
-  const apiBaseUrl =
-    (section["apiBaseUrl"] as string) ||
-    (swConfig?.["apiBaseUrl"] as string) ||
-    "https://api.stagewhisper.io";
-  const integrationId =
-    (section["integrationId"] as string) ??
-    (swConfig?.["integrationId"] as string) ??
-    "";
-  const relayToken =
-    (section["relayToken"] as string) ??
-    (swConfig?.["relayToken"] as string) ??
-    "";
-  const label =
-    (section["label"] as string) ??
-    (swConfig?.["label"] as string) ??
-    "StageWhisper";
-
-  if (!apiBaseUrl) throw new Error("stagewhisper: apiBaseUrl is required");
-  if (!integrationId)
-    throw new Error("stagewhisper: integrationId is required");
-  if (!relayToken) throw new Error("stagewhisper: relayToken is required");
-
-  return {
-    accountId: accountId ?? null,
-    apiBaseUrl,
-    integrationId,
-    relayToken,
-    label,
-  };
-}
-
-const base = createChannelPluginBase<StageWhisperAccount>({
-  id: "stagewhisper",
-  capabilities: {
-    chatTypes: ["direct"],
-  },
-  config: {
-    listAccountIds: (cfg: OpenClawConfig) => {
-      try {
-        resolveAccount(cfg);
-        return [DEFAULT_ACCOUNT_ID];
-      } catch {
-        return [];
-      }
-    },
-    resolveAccount,
-    inspectAccount(cfg: OpenClawConfig) {
-      try {
-        const account = resolveAccount(cfg);
-        return {
-          enabled: true,
-          configured: true,
-          label: account.label,
-          apiBaseUrl: account.apiBaseUrl,
-        };
-      } catch {
-        return {
-          enabled: false,
-          configured: false,
-          tokenStatus: "missing",
-        };
-      }
-    },
-  },
-  setup: {
-    applyAccountConfig({ cfg, input }) {
-      const channels = (cfg.channels ?? {}) as Record<
-        string,
-        Record<string, unknown>
-      >;
-      const section = { ...(channels["stagewhisper"] ?? {}) };
-      const raw = input as unknown as Record<string, string>;
-
-      if (raw["apiBaseUrl"]) section["apiBaseUrl"] = raw["apiBaseUrl"];
-      if (raw["integrationId"])
-        section["integrationId"] = raw["integrationId"];
-      if (raw["relayToken"]) section["relayToken"] = raw["relayToken"];
-      if (raw["label"]) section["label"] = raw["label"];
-
-      return {
-        ...cfg,
-        channels: { ...channels, stagewhisper: section },
-      } as OpenClawConfig;
-    },
-  },
-});
-
-export const stagewhisperPlugin = createChatChannelPlugin<StageWhisperAccount>(
-  {
-    base: base as unknown as Parameters<typeof createChatChannelPlugin<StageWhisperAccount>>[0]["base"],
-
-    security: {
-      dm: {
-        channelKey: "stagewhisper",
-        resolvePolicy: () => "closed",
-        resolveAllowFrom: () => [],
-        defaultPolicy: "closed",
-      },
-    },
-
-    pairing: {
-      text: {
-        idLabel: "StageWhisper pairing code",
-        message: "Run this command to complete pairing:",
-        notify: async () => {},
-      },
-    },
-
-    threading: { topLevelReplyToMode: "reply" },
-
-    outbound: {
-      base: {
-        deliveryMode: "direct",
-        resolveTarget: (params: {
-          cfg?: OpenClawConfig;
-          to?: string;
-          allowFrom?: string[];
-          accountId?: string | null;
-          mode?: string;
-        }) => {
-          if (!params.to) return { ok: false as const, error: new Error("No delivery target") };
-          return { ok: true as const, to: params.to };
-        },
-      },
-      attachedResults: {
-        channel: "stagewhisper",
-        sendText: async (ctx) => {
-          const target = (ctx as Record<string, unknown>).to as string | undefined ?? "";
-          if (target.startsWith("sw-session-")) {
-            return { messageId: `sw-relay-ack-${Date.now()}`, ok: true };
-          }
-          console.warn(
-            `[stagewhisper] sendText called for unrecognised target "${target}"; ` +
-            `StageWhisper channel is inbound-only — task replies are routed by the relay service`,
-          );
-          return { messageId: `sw-dropped-${Date.now()}`, ok: false };
-        },
-      },
-    },
-  },
-);

package/src/client.ts

@@ -1,144 +0,0 @@
-export type TaskPayload = {
-  id: string;
-  session_id: string;
-  title: string;
-  request_text: string;
-  action_type: string;
-  status: string;
-  evidence_payload: Record<string, unknown> | null;
-  created_at: string;
-};
-
-export type PairCompleteResponse = {
-  integration_id: string;
-  relay_token: string;
-  label: string;
-};
-
-export type HeartbeatResponse = {
-  ok: boolean;
-};
-
-export class StageWhisperClient {
-  private baseUrl: string;
-  private integrationId: string;
-  private relayToken: string;
-
-  constructor(baseUrl: string, integrationId: string, relayToken: string) {
-    this.baseUrl = baseUrl.replace(/\/+$/, "");
-    this.integrationId = integrationId;
-    this.relayToken = relayToken;
-  }
-
-  private headers(): Record<string, string> {
-    return {
-      Authorization: `Bearer ${this.relayToken}`,
-      "Content-Type": "application/json",
-    };
-  }
-
-  async completePairing(pairingCode: string, hostLabel: string): Promise<PairCompleteResponse> {
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/pair/complete`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        pairing_code: pairingCode,
-        host_label: hostLabel,
-      }),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Pairing failed (${res.status}): ${text}`);
-    }
-    return res.json();
-  }
-
-  async updateTaskStatus(taskId: string, status: string, remoteTaskId?: string): Promise<void> {
-    const body: Record<string, unknown> = { status };
-    if (remoteTaskId) body.remote_task_id = remoteTaskId;
-
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/tasks/${taskId}/status`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Status update failed (${res.status}): ${text}`);
-    }
-  }
-
-  async postReply(taskId: string, content: string, remoteMessageId?: string): Promise<void> {
-    const body: Record<string, unknown> = { content };
-    if (remoteMessageId) body.remote_message_id = remoteMessageId;
-
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/tasks/${taskId}/reply`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Reply failed (${res.status}): ${text}`);
-    }
-  }
-
-  async heartbeat(capabilities?: Record<string, unknown>): Promise<HeartbeatResponse> {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/heartbeat`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: capabilities ? JSON.stringify(capabilities) : undefined,
-      },
-    );
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Heartbeat failed (${res.status}): ${text}`);
-    }
-    return res.json();
-  }
-
-  async postReasoningResult(
-    jobId: string,
-    result: Record<string, unknown>,
-    correlationId?: string,
-  ): Promise<void> {
-    const headers = this.headers();
-    if (correlationId) {
-      headers["X-Correlation-ID"] = correlationId;
-    }
-    const res = await fetch(`${this.baseUrl}/api/v1/openclaw/reasoning-jobs/${jobId}/complete`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(result),
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Reasoning result post failed (${res.status}): ${text}`);
-    }
-  }
-
-  streamUrl(): string {
-    return `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/stream`;
-  }
-
-  streamHeaders(): Record<string, string> {
-    return { Authorization: `Bearer ${this.relayToken}` };
-  }
-
-  async testReply(testId: string, content: string): Promise<void> {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/openclaw/integrations/${this.integrationId}/test-reply`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ test_id: testId, content }),
-      },
-    );
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Test reply failed (${res.status}): ${text}`);
-    }
-  }
-}

package/src/health.test.ts

@@ -1,101 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createHealthTracker } from "./health.js";
-
-describe("createHealthTracker", () => {
-  it("starts unverified", () => {
-    const tracker = createHealthTracker("gpt-4o");
-    const caps = tracker.get();
-    expect(caps.status).toBe("unverified");
-    expect(caps.supportsReasoning).toBe(true);
-    expect(caps.displayModel).toBe("gpt-4o");
-    expect(caps.consecutiveFailures).toBe(0);
-  });
-
-  it("records success and updates lastHealthyAt", () => {
-    const tracker = createHealthTracker(null);
-    tracker.recordFailure("timeout");
-    tracker.recordSuccess();
-    const caps = tracker.get();
-    expect(caps.status).toBe("healthy");
-    expect(caps.consecutiveFailures).toBe(0);
-    expect(caps.lastHealthyAt).toBeInstanceOf(Date);
-  });
-
-  it("degrades after 3 consecutive failures", () => {
-    const tracker = createHealthTracker(null);
-    tracker.recordFailure("err1");
-    tracker.recordFailure("err2");
-    expect(tracker.get().status).toBe("unverified");
-    tracker.recordFailure("err3");
-    expect(tracker.get().status).toBe("degraded");
-    expect(tracker.get().degradedReason).toBe("err3");
-  });
-
-  it("sets auth_required on 401/403 errors", () => {
-    const tracker = createHealthTracker(null);
-    tracker.recordFailure("401 Unauthorized");
-    expect(tracker.get().status).toBe("auth_required");
-  });
-
-  it("setModel updates displayModel", () => {
-    const tracker = createHealthTracker("gpt-4o");
-    tracker.setModel("claude-4");
-    expect(tracker.get().displayModel).toBe("claude-4");
-  });
-
-  it("setDisabled marks disabled", () => {
-    const tracker = createHealthTracker(null);
-    tracker.setDisabled();
-    const caps = tracker.get();
-    expect(caps.status).toBe("disabled");
-    expect(caps.supportsReasoning).toBe(false);
-  });
-
-  it("toHeartbeatPayload serializes snake_case", () => {
-    const tracker = createHealthTracker("gpt-4o");
-    tracker.recordSuccess();
-    const payload = tracker.toHeartbeatPayload();
-    expect(payload).toMatchObject({
-      supports_assistant_tasks: true,
-      supports_reasoning: true,
-      reasoning_transport: "openresponses",
-      display_model: "gpt-4o",
-      provider_ref: "openclaw",
-      status: "healthy",
-      degraded_reason: null,
-    });
-  });
-
-  it("get returns a copy, not the internal state", () => {
-    const tracker = createHealthTracker(null);
-    const caps = tracker.get();
-    caps.status = "disabled";
-    expect(tracker.get().status).toBe("unverified");
-  });
-
-  it("setDisconnected marks disconnected and setConnected restores", () => {
-    const tracker = createHealthTracker(null);
-    tracker.recordSuccess();
-    expect(tracker.get().status).toBe("healthy");
-
-    tracker.setDisconnected();
-    expect(tracker.get().status).toBe("disconnected");
-
-    tracker.setConnected();
-    expect(tracker.get().status).toBe("healthy");
-  });
-
-  it("setDisconnected does not override disabled", () => {
-    const tracker = createHealthTracker(null);
-    tracker.setDisabled();
-    tracker.setDisconnected();
-    expect(tracker.get().status).toBe("disabled");
-  });
-
-  it("setConnected is a no-op when not disconnected", () => {
-    const tracker = createHealthTracker(null);
-    tracker.recordSuccess();
-    tracker.setConnected();
-    expect(tracker.get().status).toBe("healthy");
-  });
-});

package/src/health.ts

@@ -1,94 +0,0 @@
-export type HostHealthStatus =
-  | "healthy"
-  | "degraded"
-  | "disconnected"
-  | "auth_required"
-  | "disabled"
-  | "unverified";
-
-export type HostCapabilities = {
-  supportsAssistantTasks: boolean;
-  supportsReasoning: boolean;
-  reasoningTransport: string | null;
-  displayModel: string | null;
-  providerRef: string;
-  status: HostHealthStatus;
-  degradedReason: string | null;
-  lastHealthyAt: Date | null;
-  consecutiveFailures: number;
-};
-
-const DEGRADED_THRESHOLD = 3;
-
-export function createHealthTracker(initialModel: string | null) {
-  const state: HostCapabilities = {
-    supportsAssistantTasks: true,
-    supportsReasoning: true,
-    reasoningTransport: "openresponses",
-    displayModel: initialModel,
-    providerRef: "openclaw",
-    status: "unverified",
-    degradedReason: null,
-    lastHealthyAt: null,
-    consecutiveFailures: 0,
-  };
-
-  let statusBeforeDisconnect: HostHealthStatus | null = null;
-
-  return {
-    get: (): HostCapabilities => ({ ...state }),
-
-    recordSuccess() {
-      state.consecutiveFailures = 0;
-      state.status = "healthy";
-      state.degradedReason = null;
-      state.lastHealthyAt = new Date();
-      statusBeforeDisconnect = null;
-    },
-
-    recordFailure(reason: string) {
-      state.consecutiveFailures += 1;
-      state.degradedReason = reason;
-      if (reason.includes("401") || reason.includes("403")) {
-        state.status = "auth_required";
-      } else if (state.consecutiveFailures >= DEGRADED_THRESHOLD) {
-        state.status = "degraded";
-      }
-    },
-
-    setModel(model: string) {
-      state.displayModel = model;
-    },
-
-    setDisabled() {
-      state.status = "disabled";
-      state.supportsReasoning = false;
-    },
-
-    setDisconnected() {
-      if (state.status !== "disabled") {
-        statusBeforeDisconnect = state.status;
-        state.status = "disconnected";
-      }
-    },
-
-    setConnected() {
-      if (state.status === "disconnected" && statusBeforeDisconnect !== null) {
-        state.status = statusBeforeDisconnect;
-        statusBeforeDisconnect = null;
-      }
-    },
-
-    toHeartbeatPayload(): Record<string, unknown> {
-      return {
-        supports_assistant_tasks: state.supportsAssistantTasks,
-        supports_reasoning: state.supportsReasoning,
-        reasoning_transport: state.reasoningTransport,
-        display_model: state.displayModel,
-        provider_ref: state.providerRef,
-        status: state.status,
-        degraded_reason: state.degradedReason,
-      };
-    },
-  };
-}

package/src/openresponses.ts

@@ -1,107 +0,0 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-
-type GatewayConfig = { url: string; apiKey: string | null };
-
-function resolveGatewayConfig(api: OpenClawPluginApi): GatewayConfig {
-  const cfg = api.config as Record<string, unknown>;
-  const gw = (cfg?.gateway as Record<string, unknown>) ?? {};
-  const auth = (gw?.auth as Record<string, unknown>) ?? {};
-
-  const port = Number(gw?.port) || 18789;
-  const explicitUrl = typeof gw?.url === "string" ? gw.url : null;
-  const url = (explicitUrl ?? `http://127.0.0.1:${port}`).replace(/\/+$/, "");
-
-  const token = typeof auth?.token === "string" ? auth.token : null;
-
-  return { url, apiKey: token };
-}
-
-export function isResponsesEndpointEnabled(api: OpenClawPluginApi): boolean {
-  const cfg = api.config as Record<string, unknown>;
-  const gw = (cfg?.gateway as Record<string, unknown>) ?? {};
-  const http = (gw?.http as Record<string, unknown>) ?? {};
-  const endpoints = (http?.endpoints as Record<string, unknown>) ?? {};
-  const responses = (endpoints?.responses as Record<string, unknown>) ?? {};
-  return responses?.enabled === true;
-}
-
-export async function callOpenResponses(
-  api: OpenClawPluginApi,
-  requestBody: OpenResponsesCreateResponseRequestBody,
-  signal?: AbortSignal,
-  correlationId?: string,
-): Promise<OpenResponsesResponseResource> {
-  const gw = resolveGatewayConfig(api);
-  const url = `${gw.url}/v1/responses`;
-
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  };
-  if (gw.apiKey) {
-    headers["Authorization"] = `Bearer ${gw.apiKey}`;
-  }
-  if (correlationId) {
-    headers["X-Correlation-ID"] = correlationId;
-  }
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(requestBody),
-    signal,
-  });
-
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    if (response.status === 404) {
-      throw new OpenResponsesError(
-        "POST /v1/responses returned 404 — the OpenResponses HTTP API is most likely disabled. " +
-        'Enable it in OpenClaw config: gateway.http.endpoints.responses.enabled = true, then restart the gateway.',
-        response.status,
-      );
-    }
-    throw new OpenResponsesError(`POST /v1/responses returned ${response.status}: ${body}`, response.status);
-  }
-  return (await response.json()) as OpenResponsesResponseResource;
-}
-
-export class OpenResponsesError extends Error {
-  constructor(
-    message: string,
-    public readonly statusCode: number,
-  ) {
-    super(message);
-    this.name = "OpenResponsesError";
-  }
-
-  get retryable(): boolean {
-    return (
-      this.statusCode === 408 ||
-      this.statusCode === 429 ||
-      (this.statusCode >= 500 && this.statusCode < 600)
-    );
-  }
-}
-
-export type { components, operations, paths, webhooks } from "../openresponses";
-
-export type OpenResponsesCreateResponseOperation =
-  import("../openresponses").operations["createResponse"];
-export type OpenResponsesCreateResponseRequestBody =
-  import("../openresponses").components["schemas"]["CreateResponseBody"];
-export type OpenResponsesResponseResource =
-  import("../openresponses").components["schemas"]["ResponseResource"];
-export type OpenResponsesRequestItem =
-  import("../openresponses").components["schemas"]["ItemParam"];
-export type OpenResponsesResponseItem =
-  import("../openresponses").components["schemas"]["ItemField"];
-export type OpenResponsesTool =
-  import("../openresponses").components["schemas"]["ResponsesToolParam"];
-export type OpenResponsesToolChoice =
-  import("../openresponses").components["schemas"]["ToolChoiceParam"];
-export type OpenResponsesTextFormat =
-  import("../openresponses").components["schemas"]["TextFormatParam"];
-export type OpenResponsesReasoning =
-  import("../openresponses").components["schemas"]["ReasoningParam"];
-export type OpenResponsesStreamEvent =
-  import("../openresponses").operations["createResponse"]["responses"][200]["content"]["text/event-stream"];