@aliou/pi-neuralwatt 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-neuralwatt",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/extensions/provider/index.ts

@@ -8,6 +8,7 @@ import {
   registerNeuralwattSettings,
 } from "../../config";
 import { getNeuralwattApiKey } from "../../lib/env";
+import { fetchModels } from "../../lib/fetch-models";
 import type { NeuralwattQuotas } from "../../types/quota-api";
 import {
   NEURALWATT_QUOTAS_REQUEST_EVENT,
@@ -16,9 +17,24 @@ import {
   parseQuotaHeaders,
 } from "../../types/quota-events";
 import { fetchQuotas } from "../../utils/quotas";
-import { NEURALWATT_MODELS } from "./models";
+import type { NeuralwattModelConfig } from "./models";
+import { NEURALWATT_MODELS_CACHE } from "./models";
 
-export function registerNeuralwattProvider(pi: ExtensionAPI): void {
+function buildModelsPayload(models: NeuralwattModelConfig[]) {
+  return models.map(({ fast: _fast, ...model }) => ({
+    ...model,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+      ...model.compat,
+    },
+  }));
+}
+
+function registerNeuralwattProvider(
+  pi: ExtensionAPI,
+  models: NeuralwattModelConfig[],
+): void {
   pi.registerProvider("neuralwatt", {
     baseUrl: "https://api.neuralwatt.com/v1",
     apiKey: "NEURALWATT_API_KEY",
@@ -28,20 +44,15 @@ export function registerNeuralwattProvider(pi: ExtensionAPI): void {
       Referer: "https://pi.dev",
       "X-Title": "npm:@aliou/pi-neuralwatt",
     },
-    models: NEURALWATT_MODELS.map(({ fast: _fast, ...model }) => ({
-      ...model,
-      compat: {
-        supportsDeveloperRole: false,
-        maxTokensField: "max_tokens",
-        ...model.compat,
-      },
-    })),
+    models: buildModelsPayload(models),
   });
 }
 
 export default async function (pi: ExtensionAPI) {
   await configLoader.load();
-  registerNeuralwattProvider(pi);
+
+  // Register with hardcoded cache immediately so models are available on startup
+  registerNeuralwattProvider(pi, NEURALWATT_MODELS_CACHE);
 
   // Track which feature extensions loaded
   const loadedFeatures = new Set<NeuralwattFeatureId>();
@@ -131,16 +142,35 @@ export default async function (pi: ExtensionAPI) {
     loadedFeatures.add(feature);
   });
 
-  // On session start: request extensions to register, then emit config
+  // On session start: fetch live models, request extensions, emit config, fetch quotas
   pi.on("session_start", async (_event, ctx) => {
     loadedFeatures.clear();
     pi.events.emit(NEURALWATT_EXTENSIONS_REQUEST_EVENT, undefined);
     emitConfigUpdated(pi);
 
+    // Fetch live models from the API and re-register if successful
+    const result = await fetchModels();
+    if (result.success) {
+      const cacheIds = new Set(NEURALWATT_MODELS_CACHE.map((m) => m.id));
+      const liveIds = new Set(result.models.map((m) => m.id));
+      const added = result.models.filter((m) => !cacheIds.has(m.id));
+      const removed = NEURALWATT_MODELS_CACHE.filter((m) => !liveIds.has(m.id));
+      if (added.length > 0 || removed.length > 0) {
+        const parts: string[] = [];
+        if (added.length > 0) parts.push(`${added.length} new`);
+        if (removed.length > 0) parts.push(`${removed.length} removed`);
+        ctx.ui.notify(
+          `Neuralwatt models updated (${parts.join(", ")})`,
+          "info",
+        );
+      }
+      registerNeuralwattProvider(pi, result.models);
+    }
+
     if (ctx.model?.provider !== "neuralwatt") return;
     const apiKey = await getNeuralwattApiKey(ctx.modelRegistry.authStorage);
     if (!apiKey) return;
-    const result = await fetchQuotas(apiKey);
-    if (result.success) emitQuotas(result.data.quotas, "api");
+    const quotaResult = await fetchQuotas(apiKey);
+    if (quotaResult.success) emitQuotas(quotaResult.data.quotas, "api");
   });
 }

package/src/extensions/provider/models.test.ts

@@ -1,18 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { NEURALWATT_MODELS } from "./models";
-
-interface ApiModel {
-  id: string;
-  object: string;
-  created: number;
-  owned_by: string;
-  max_model_len: number;
-}
-
-interface ApiResponse {
-  object: "list";
-  data: ApiModel[];
-}
+import type {
+  ApiModel as FullApiModel,
+  ApiResponse as FullApiResponse,
+} from "../../lib/fetch-models";
+import { mapApiModel } from "../../lib/fetch-models";
+import { NEURALWATT_MODELS_CACHE } from "./models";
 
 interface Discrepancy {
   model: string;
@@ -21,7 +13,7 @@ interface Discrepancy {
   api: unknown;
 }
 
-async function fetchApiModels(): Promise<ApiModel[]> {
+async function fetchApiModels(): Promise<FullApiModel[]> {
   const apiKey = process.env.NEURALWATT_API_KEY;
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -41,13 +33,13 @@ async function fetchApiModels(): Promise<ApiModel[]> {
     );
   }
 
-  const data: ApiResponse = await response.json();
+  const data: FullApiResponse = await response.json();
   return data.data;
 }
 
 function compareModels(
-  apiModels: ApiModel[],
-  hardcodedModels: typeof NEURALWATT_MODELS,
+  apiModels: FullApiModel[],
+  hardcodedModels: typeof NEURALWATT_MODELS_CACHE,
 ): Discrepancy[] {
   const discrepancies: Discrepancy[] = [];
 
@@ -73,10 +65,55 @@ function compareModels(
         api: apiModel.max_model_len,
       });
     }
+
+    // Check metadata-driven fields if available
+    const meta = apiModel.metadata;
+    if (meta) {
+      // Check reasoning
+      if (meta.capabilities.reasoning !== hardcoded.reasoning) {
+        discrepancies.push({
+          model: hardcoded.id,
+          field: "reasoning",
+          hardcoded: hardcoded.reasoning,
+          api: meta.capabilities.reasoning,
+        });
+      }
+
+      // Check pricing
+      if (meta.pricing.input_per_million !== hardcoded.cost.input) {
+        discrepancies.push({
+          model: hardcoded.id,
+          field: "cost.input",
+          hardcoded: hardcoded.cost.input,
+          api: meta.pricing.input_per_million,
+        });
+      }
+      if (meta.pricing.output_per_million !== hardcoded.cost.output) {
+        discrepancies.push({
+          model: hardcoded.id,
+          field: "cost.output",
+          hardcoded: hardcoded.cost.output,
+          api: meta.pricing.output_per_million,
+        });
+      }
+
+      // Check vision
+      const hasVision = hardcoded.input.includes("image");
+      if (meta.capabilities.vision !== hasVision) {
+        discrepancies.push({
+          model: hardcoded.id,
+          field: "input (vision)",
+          hardcoded: hasVision,
+          api: meta.capabilities.vision,
+        });
+      }
+    }
   }
 
   // Check for API models not in hardcoded list
   for (const apiModel of apiModels) {
+    if (apiModel.metadata?.deprecated || apiModel.metadata?.pricing.pricing_tbd)
+      continue;
     const hardcoded = hardcodedModels.find((m) => m.id === apiModel.id);
     if (!hardcoded) {
       discrepancies.push({
@@ -94,7 +131,7 @@ function compareModels(
 describe("Neuralwatt models", () => {
   it("should match API model definitions", { timeout: 30000 }, async () => {
     const apiModels = await fetchApiModels();
-    const discrepancies = compareModels(apiModels, NEURALWATT_MODELS);
+    const discrepancies = compareModels(apiModels, NEURALWATT_MODELS_CACHE);
 
     if (discrepancies.length > 0) {
       console.error("\nModel discrepancies found:");
@@ -117,4 +154,186 @@ describe("Neuralwatt models", () => {
 
     expect(discrepancies).toHaveLength(0);
   });
+
+  it("should map API models with metadata correctly", () => {
+    // Simulate a reasoning model with reasoning_effort support (like gpt-oss-20b)
+    const apiModelWithEffort: FullApiModel = {
+      id: "openai/gpt-oss-20b",
+      object: "model",
+      created: 1777467968,
+      owned_by: "vllm",
+      root: "openai/gpt-oss-20b",
+      parent: null,
+      max_model_len: 16384,
+      metadata: {
+        display_name: "GPT-OSS 20B",
+        description: "OpenAI GPT-OSS 20B",
+        provider: "OpenAI",
+        huggingface_id: null,
+        pricing: {
+          input_per_million: 0.03,
+          output_per_million: 0.16,
+          cached_input_per_million: null,
+          cached_output_per_million: null,
+          currency: "USD",
+          pricing_tbd: false,
+        },
+        capabilities: {
+          tools: true,
+          json_mode: true,
+          vision: false,
+          reasoning: true,
+          reasoning_effort: true,
+          streaming: true,
+          system_role: true,
+          developer_role: false,
+        },
+        limits: {
+          max_context_length: 16384,
+          max_output_tokens: 4096,
+          max_images: null,
+        },
+        deprecated: false,
+        deprecated_message: null,
+      },
+    };
+
+    const result = mapApiModel(apiModelWithEffort);
+    expect(result.id).toBe("openai/gpt-oss-20b");
+    expect(result.name).toBe("GPT-OSS 20B");
+    expect(result.reasoning).toBe(true);
+    expect(result.contextWindow).toBe(16384);
+    expect(result.maxTokens).toBe(4096);
+    expect(result.input).toEqual(["text"]);
+    expect(result.cost.input).toBe(0.03);
+    expect(result.cost.output).toBe(0.16);
+    expect(
+      (result.compat as Record<string, unknown>)?.supportsReasoningEffort,
+    ).toBe(true);
+    expect(result.fast).toBeUndefined();
+  });
+
+  it("should map fast variants correctly", () => {
+    // Simulate a fast variant (owned by "neuralwatt")
+    const fastModel: FullApiModel = {
+      id: "qwen3.6-35b-fast",
+      object: "model",
+      created: 0,
+      owned_by: "neuralwatt",
+      max_model_len: 131072,
+      metadata: {
+        display_name: "Qwen3.6 35B Fast",
+        description: "Fast variant",
+        provider: "Qwen",
+        huggingface_id: null,
+        pricing: {
+          input_per_million: 0.05,
+          output_per_million: 0.1,
+          cached_input_per_million: null,
+          cached_output_per_million: null,
+          currency: "USD",
+          pricing_tbd: false,
+        },
+        capabilities: {
+          tools: true,
+          json_mode: true,
+          vision: false,
+          reasoning: false,
+          reasoning_effort: false,
+          streaming: true,
+          system_role: true,
+          developer_role: false,
+        },
+        limits: {
+          max_context_length: 131072,
+          max_output_tokens: null,
+          max_images: null,
+        },
+        deprecated: false,
+        deprecated_message: null,
+      },
+    };
+
+    const result = mapApiModel(fastModel);
+    expect(result.id).toBe("qwen3.6-35b-fast");
+    expect(result.fast).toBe(true);
+    expect(result.reasoning).toBe(false);
+    expect(
+      (result.compat as Record<string, unknown>)?.supportsReasoningEffort,
+    ).toBeUndefined();
+  });
+
+  it("should map vision models correctly", () => {
+    const visionModel: FullApiModel = {
+      id: "moonshotai/Kimi-K2.6",
+      object: "model",
+      created: 1777467965,
+      owned_by: "vllm",
+      root: "moonshotai/Kimi-K2.6",
+      parent: null,
+      max_model_len: 262144,
+      metadata: {
+        display_name: "Kimi K2.6",
+        description: "Moonshot Kimi K2.6",
+        provider: "MoonshotAI",
+        huggingface_id: null,
+        pricing: {
+          input_per_million: 0.69,
+          output_per_million: 3.22,
+          cached_input_per_million: null,
+          cached_output_per_million: null,
+          currency: "USD",
+          pricing_tbd: false,
+        },
+        capabilities: {
+          tools: true,
+          json_mode: true,
+          vision: true,
+          reasoning: true,
+          reasoning_effort: false,
+          streaming: true,
+          system_role: true,
+          developer_role: false,
+        },
+        limits: {
+          max_context_length: 262144,
+          max_output_tokens: null,
+          max_images: 20,
+        },
+        deprecated: false,
+        deprecated_message: null,
+      },
+    };
+
+    const result = mapApiModel(visionModel);
+    expect(result.input).toEqual(["text", "image"]);
+    expect(result.reasoning).toBe(true);
+    expect(
+      (result.compat as Record<string, unknown>)?.supportsReasoningEffort,
+    ).toBeUndefined();
+  });
+
+  it("should use defaults when metadata is missing", () => {
+    const bareModel: FullApiModel = {
+      id: "test/model",
+      object: "model",
+      created: 0,
+      owned_by: "vllm",
+      max_model_len: 8192,
+    };
+
+    const result = mapApiModel(bareModel);
+    expect(result.id).toBe("test/model");
+    expect(result.name).toBe("test/model");
+    expect(result.reasoning).toBe(false);
+    expect(result.contextWindow).toBe(8192);
+    expect(result.maxTokens).toBe(65536);
+    expect(result.input).toEqual(["text"]);
+    expect(result.cost.input).toBe(0);
+    expect(result.cost.output).toBe(0);
+    expect(result.fast).toBeUndefined();
+    expect(
+      (result.compat as Record<string, unknown>)?.supportsReasoningEffort,
+    ).toBeUndefined();
+  });
 });

package/src/extensions/provider/models.ts

@@ -18,7 +18,10 @@ const NEURALWATT_REASONING_EFFORT_MAP = {
   xhigh: "high",
 } as const;
 
-export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
+/** Hardcoded model cache. Used as a fallback on startup before live models are fetched.
+ * Updated from https://api.neuralwatt.com/v1/models and https://portal.neuralwatt.com/pricing
+ */
+export const NEURALWATT_MODELS_CACHE: NeuralwattModelConfig[] = [
   // Devstral Small 2 - Mistral
   {
     id: "mistralai/Devstral-Small-2-24B-Instruct-2512",
@@ -74,8 +77,6 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     maxTokens: 32768,
     compat: {
       supportsDeveloperRole: false,
-      supportsReasoningEffort: true,
-      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
       maxTokensField: "max_tokens",
     },
   },
@@ -103,7 +104,7 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
   {
     id: "openai/gpt-oss-20b",
     name: "GPT-OSS 20B",
-    reasoning: false,
+    reasoning: true,
     input: ["text"],
     cost: {
       input: 0.03,
@@ -115,6 +116,8 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     maxTokens: 4096,
     compat: {
       supportsDeveloperRole: false,
+      supportsReasoningEffort: true,
+      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
       maxTokensField: "max_tokens",
     },
   },
@@ -134,8 +137,6 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     maxTokens: 65536,
     compat: {
       supportsDeveloperRole: false,
-      supportsReasoningEffort: true,
-      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
       maxTokensField: "max_tokens",
     },
   },
@@ -159,6 +160,45 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
       maxTokensField: "max_tokens",
     },
   },
+  // Kimi K2.6 - MoonshotAI
+  {
+    id: "moonshotai/Kimi-K2.6",
+    name: "Kimi K2.6",
+    reasoning: true,
+    input: ["text", "image"],
+    cost: {
+      input: 0.69,
+      output: 3.22,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 65536,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  },
+  // Kimi K2.6 Fast - MoonshotAI
+  {
+    id: "kimi-k2.6-fast",
+    name: "Kimi K2.6 Fast",
+    reasoning: false,
+    fast: true,
+    input: ["text", "image"],
+    cost: {
+      input: 0.69,
+      output: 3.22,
+      cacheRead: 0,
+      cacheWrite: 0,
+    },
+    contextWindow: 262144,
+    maxTokens: 65536,
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  },
   // MiniMax M2.5 - MiniMax
   {
     id: "MiniMaxAI/MiniMax-M2.5",
@@ -175,8 +215,6 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     maxTokens: 65536,
     compat: {
       supportsDeveloperRole: false,
-      supportsReasoningEffort: true,
-      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
       maxTokensField: "max_tokens",
     },
   },
@@ -196,8 +234,6 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     maxTokens: 65536,
     compat: {
       supportsDeveloperRole: false,
-      supportsReasoningEffort: true,
-      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
       maxTokensField: "max_tokens",
     },
   },
@@ -235,28 +271,6 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
     },
     contextWindow: 131072,
     maxTokens: 32768,
-    compat: {
-      supportsDeveloperRole: false,
-      supportsReasoningEffort: true,
-      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
-      maxTokensField: "max_tokens",
-    },
-  },
-  // Qwen3.6 35B Fast (qwen3.5-35b-fast) - Qwen
-  {
-    id: "qwen3.5-35b-fast",
-    name: "Qwen3.6 35B Fast",
-    reasoning: false,
-    fast: true,
-    input: ["text"],
-    cost: {
-      input: 0.05,
-      output: 0.1,
-      cacheRead: 0,
-      cacheWrite: 0,
-    },
-    contextWindow: 131072,
-    maxTokens: 32768,
     compat: {
       supportsDeveloperRole: false,
       maxTokensField: "max_tokens",
@@ -265,7 +279,7 @@ export const NEURALWATT_MODELS: NeuralwattModelConfig[] = [
   // Qwen3.6 35B Fast (qwen3.6-35b-fast) - Qwen
   {
     id: "qwen3.6-35b-fast",
-    name: "Qwen3.6 35B Fast (alt)",
+    name: "Qwen3.6 35B Fast",
     reasoning: false,
     fast: true,
     input: ["text"],

package/src/lib/fetch-models.ts

@@ -0,0 +1,181 @@
+import type { NeuralwattModelConfig } from "../extensions/provider/models";
+
+const FETCH_TIMEOUT_MS = 15_000;
+
+export interface ApiModelMetadata {
+  display_name: string;
+  description: string | null;
+  provider: string;
+  huggingface_id: string | null;
+  pricing: {
+    input_per_million: number;
+    output_per_million: number;
+    cached_input_per_million: number | null;
+    cached_output_per_million: number | null;
+    currency: string;
+    pricing_tbd: boolean;
+  };
+  capabilities: {
+    tools: boolean;
+    json_mode: boolean;
+    vision: boolean;
+    reasoning: boolean;
+    reasoning_effort: boolean;
+    streaming: boolean;
+    system_role: boolean;
+    developer_role: boolean;
+  };
+  limits: {
+    max_context_length: number;
+    max_output_tokens: number | null;
+    max_images: number | null;
+  };
+  deprecated: boolean;
+  deprecated_message: string | null;
+}
+
+export interface ApiModel {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+  root?: string;
+  parent?: string | null;
+  max_model_len: number;
+  metadata?: ApiModelMetadata;
+}
+
+export interface ApiResponse {
+  object: "list";
+  data: ApiModel[];
+}
+
+const NEURALWATT_REASONING_EFFORT_MAP = {
+  minimal: "low",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "high",
+} as const;
+
+/** Identify fast variants by their owned_by field or naming convention. */
+function isFastModel(model: ApiModel): boolean {
+  if (model.owned_by === "neuralwatt") return true;
+  return model.id.endsWith("-fast");
+}
+
+/** Map API model data to NeuralwattModelConfig. */
+export function mapApiModel(model: ApiModel): NeuralwattModelConfig {
+  const meta = model.metadata;
+  const fast = isFastModel(model);
+
+  // Base fields from top-level API data
+  const result: NeuralwattModelConfig = {
+    id: model.id,
+    name: meta?.display_name ?? model.id,
+    reasoning: meta?.capabilities.reasoning ?? false,
+    contextWindow: model.max_model_len,
+    maxTokens: 65536, // sensible default
+    cost: {
+      input: meta?.pricing.input_per_million ?? 0,
+      output: meta?.pricing.output_per_million ?? 0,
+      cacheRead: meta?.pricing.cached_input_per_million ?? 0,
+      cacheWrite: meta?.pricing.cached_output_per_million ?? 0,
+    },
+    input: meta?.capabilities.vision ? ["text", "image"] : ["text"],
+    compat: {
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+    },
+  };
+
+  if (fast) {
+    result.fast = true;
+  }
+
+  // Override maxTokens from limits if available
+  if (meta?.limits.max_output_tokens) {
+    result.maxTokens = meta.limits.max_output_tokens;
+  }
+
+  // Reasoning effort support
+  if (meta?.capabilities.reasoning_effort) {
+    result.compat = {
+      ...result.compat,
+      supportsReasoningEffort: true,
+      reasoningEffortMap: NEURALWATT_REASONING_EFFORT_MAP,
+    };
+  }
+
+  return result;
+}
+
+export type FetchModelsResult =
+  | { success: true; models: NeuralwattModelConfig[] }
+  | {
+      success: false;
+      error: { message: string; kind: "timeout" | "network" | "cancelled" };
+    };
+
+/**
+ * Fetch live model definitions from the Neuralwatt /v1/models endpoint.
+ *
+ * When the API returns metadata (pricing, capabilities, limits), those values
+ * are used directly. Fields not exposed by the API fall back to sensible
+ * defaults.
+ */
+export async function fetchModels(
+  signal?: AbortSignal,
+): Promise<FetchModelsResult> {
+  const signals: AbortSignal[] = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+  if (signal) signals.push(signal);
+  const combined = AbortSignal.any(signals);
+
+  try {
+    const response = await fetch("https://api.neuralwatt.com/v1/models", {
+      headers: {
+        Referer: "https://pi.dev",
+        "X-Title": "npm:@aliou/pi-neuralwatt",
+      },
+      signal: combined,
+    });
+
+    if (!response.ok) {
+      return {
+        success: false,
+        error: {
+          message: `Failed to fetch models: ${response.status} ${response.statusText}`,
+          kind: "network",
+        },
+      };
+    }
+
+    const data: ApiResponse = await response.json();
+
+    // Filter out deprecated models
+    const active = data.data.filter(
+      (m) => !m.metadata?.deprecated && !m.metadata?.pricing.pricing_tbd,
+    );
+
+    const models = active.map(mapApiModel);
+    return { success: true, models };
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === "AbortError") {
+      if (
+        combined.reason instanceof DOMException &&
+        combined.reason.name === "TimeoutError"
+      ) {
+        return {
+          success: false,
+          error: { message: "Fetch models timed out", kind: "timeout" },
+        };
+      }
+      return {
+        success: false,
+        error: { message: "Fetch models cancelled", kind: "cancelled" },
+      };
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error: { message, kind: "network" } };
+  }
+}