@kynver-app/openclaw-agent-os 0.1.0

package/dist/index.js

@@ -0,0 +1,981 @@
+// src/config.ts
+var pluginConfigSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    agentOsServer: {
+      type: "string",
+      default: "kynver-agent-os",
+      description: "mcporter server name for the Kynver AgentOS MCP server"
+    },
+    timeoutMs: {
+      type: "number",
+      default: 3e4,
+      description: "Timeout in milliseconds for mcporter calls"
+    },
+    mcporterConfigPath: {
+      type: "string",
+      description: "Explicit path to mcporter.json. Defaults to MCPORTER_CONFIG, OPENCLAW_MCPORTER_CONFIG, then ~/.openclaw/workspace/config/mcporter.json."
+    },
+    kynverApiUrl: {
+      type: "string",
+      description: "Kynver API origin for direct HTTP mode, for example https://www.kynver.com. Falls back to KYNVER_API_URL or mcporter env."
+    },
+    kynverApiKey: {
+      type: "string",
+      description: "Kynver API key for direct HTTP mode. Prefer OpenClaw secret references when available."
+    },
+    agentOsSlug: {
+      type: "string",
+      default: "ghost",
+      description: "Default AgentOS slug to use when a tool call does not pass slug."
+    },
+    enableDirectHttp: {
+      type: "boolean",
+      default: true,
+      description: "Use Kynver's AgentOS HTTP API directly when configured; mcporter remains the compatibility fallback."
+    },
+    enableSessionLifecycle: {
+      type: "boolean",
+      default: true,
+      description: "Automatically open and close AgentOS session records from OpenClaw session lifecycle hooks."
+    }
+  }
+};
+function resolvePluginConfig(raw) {
+  return {
+    agentOsServer: typeof raw?.agentOsServer === "string" && raw.agentOsServer.trim() ? raw.agentOsServer.trim() : "kynver-agent-os",
+    timeoutMs: typeof raw?.timeoutMs === "number" && Number.isFinite(raw.timeoutMs) && raw.timeoutMs > 0 ? raw.timeoutMs : 3e4,
+    mcporterConfigPath: typeof raw?.mcporterConfigPath === "string" && raw.mcporterConfigPath.trim() ? raw.mcporterConfigPath.trim() : void 0,
+    kynverApiUrl: typeof raw?.kynverApiUrl === "string" && raw.kynverApiUrl.trim() ? raw.kynverApiUrl.trim().replace(/\/$/, "") : void 0,
+    kynverApiKey: typeof raw?.kynverApiKey === "string" && raw.kynverApiKey.trim() ? raw.kynverApiKey.trim() : void 0,
+    agentOsSlug: typeof raw?.agentOsSlug === "string" && raw.agentOsSlug.trim() ? raw.agentOsSlug.trim() : "ghost",
+    enableDirectHttp: typeof raw?.enableDirectHttp === "boolean" ? raw.enableDirectHttp : true,
+    enableSessionLifecycle: typeof raw?.enableSessionLifecycle === "boolean" ? raw.enableSessionLifecycle : true
+  };
+}
+
+// src/mcporter-client.ts
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+// src/result.ts
+function toolJson(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload
+  };
+}
+function toolError(message, details) {
+  return {
+    content: [{ type: "text", text: message }],
+    details,
+    isError: true
+  };
+}
+
+// src/mcporter-client.ts
+var execFileAsync = promisify(execFile);
+async function callAgentOsTool({
+  serverName,
+  toolName,
+  params,
+  timeoutMs,
+  mcporterConfigPath,
+  kynverApiUrl,
+  kynverApiKey,
+  agentOsSlug,
+  enableDirectHttp = true
+}) {
+  const configPath = resolveMcporterConfigPath(mcporterConfigPath);
+  const directConfig = enableDirectHttp ? resolveDirectAgentOsConfig({ serverName, configPath, kynverApiUrl, kynverApiKey, agentOsSlug }) : void 0;
+  if (directConfig) {
+    try {
+      return toolJson(await callAgentOsApiDirect(toolName, params ?? {}, timeoutMs, directConfig));
+    } catch (error) {
+      if (!isDirectConfigError(error)) {
+        return toolError(`Kynver AgentOS direct call failed for ${toolName}.`, {
+          toolName,
+          serverName,
+          message: redactSecrets(String(error?.message || error))
+        });
+      }
+    }
+  }
+  const selector = `${serverName}.${toolName}`;
+  const args = ["--config", configPath, "call", selector];
+  const hasParams = params && Object.keys(params).length > 0;
+  if (hasParams) {
+    args.push("--args", JSON.stringify(params));
+  }
+  try {
+    const { stdout, stderr } = await execFileAsync("mcporter", args, {
+      timeout: timeoutMs,
+      maxBuffer: 1024 * 1024 * 4
+    });
+    const text = `${stdout || ""}${stderr || ""}`.trim();
+    const parsed = parseMcporterOutput(text);
+    return toolJson(parsed);
+  } catch (error) {
+    const msg = String(error?.message || error);
+    if (msg.includes("timed out")) {
+      return toolError(`Kynver AgentOS call timed out after ${timeoutMs}ms.`, { toolName, serverName });
+    }
+    return toolError(`Kynver AgentOS call failed for ${toolName}.`, {
+      toolName,
+      serverName,
+      message: msg,
+      stdout: error?.stdout,
+      stderr: error?.stderr
+    });
+  }
+}
+async function checkAgentOsHealth({
+  serverName,
+  slug,
+  timeoutMs,
+  mcporterConfigPath,
+  kynverApiUrl,
+  kynverApiKey,
+  agentOsSlug,
+  enableDirectHttp = true
+}) {
+  const startedAt = Date.now();
+  const configPath = resolveMcporterConfigPath(mcporterConfigPath);
+  const directConfig = enableDirectHttp ? resolveDirectAgentOsConfig({ serverName, configPath, kynverApiUrl, kynverApiKey, agentOsSlug }) : void 0;
+  if (directConfig) {
+    try {
+      const parsed = await callAgentOsApiDirect("agent_os_get_context", slug ? { slug } : {}, timeoutMs, directConfig);
+      const summary = summarizeContextPayload(parsed);
+      return toolJson({
+        ok: true,
+        status: "available",
+        transport: "direct-http",
+        serverName,
+        probeTool: "agent_os_get_context",
+        latencyMs: Date.now() - startedAt,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        configPath,
+        ...summary
+      });
+    } catch (error) {
+      return toolJson({
+        ok: false,
+        status: "unavailable",
+        transport: "direct-http",
+        serverName,
+        probeTool: "agent_os_get_context",
+        latencyMs: Date.now() - startedAt,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        configPath,
+        error: sanitizeHealthError(error)
+      });
+    }
+  }
+  const selector = `${serverName}.agent_os_get_context`;
+  const args = ["--config", configPath, "call", selector];
+  if (slug) {
+    args.push("--args", JSON.stringify({ slug }));
+  }
+  try {
+    const { stdout, stderr } = await execFileAsync("mcporter", args, {
+      timeout: timeoutMs,
+      maxBuffer: 1024 * 1024 * 4
+    });
+    const text = `${stdout || ""}${stderr || ""}`.trim();
+    const parsed = parseMcporterOutput(text);
+    const summary = summarizeContextPayload(parsed);
+    return toolJson({
+      ok: true,
+      status: "available",
+      serverName,
+      probeTool: "agent_os_get_context",
+      latencyMs: Date.now() - startedAt,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      configPath,
+      ...summary
+    });
+  } catch (error) {
+    return toolJson({
+      ok: false,
+      status: "unavailable",
+      serverName,
+      probeTool: "agent_os_get_context",
+      latencyMs: Date.now() - startedAt,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      configPath,
+      error: sanitizeHealthError(error)
+    });
+  }
+}
+function resolveDirectAgentOsConfig({
+  serverName,
+  configPath,
+  kynverApiUrl,
+  kynverApiKey,
+  agentOsSlug
+}) {
+  if (kynverApiUrl?.trim()) {
+    return {
+      apiUrl: kynverApiUrl.trim().replace(/\/$/, ""),
+      apiKey: kynverApiKey?.trim() || void 0,
+      defaultSlug: agentOsSlug?.trim() || "ghost"
+    };
+  }
+  const envConfig = directConfigFromEnv(agentOsSlug, kynverApiKey);
+  if (envConfig) return envConfig;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    const server = parsed?.mcpServers?.[serverName];
+    const env = server?.env;
+    const apiUrl = typeof env?.KYNVER_API_URL === "string" ? env.KYNVER_API_URL.trim() : "";
+    if (!apiUrl) return void 0;
+    return {
+      apiUrl: apiUrl.replace(/\/$/, ""),
+      apiKey: typeof env?.KYNVER_API_KEY === "string" ? env.KYNVER_API_KEY.trim() : void 0,
+      defaultSlug: agentOsSlug?.trim() || (typeof env?.KYNVER_AGENT_OS_SLUG === "string" && env.KYNVER_AGENT_OS_SLUG.trim() ? env.KYNVER_AGENT_OS_SLUG.trim() : "ghost")
+    };
+  } catch {
+    return void 0;
+  }
+}
+function directConfigFromEnv(agentOsSlug, kynverApiKey) {
+  const apiUrl = process.env.KYNVER_API_URL?.trim();
+  if (!apiUrl) return void 0;
+  return {
+    apiUrl: apiUrl.replace(/\/$/, ""),
+    apiKey: kynverApiKey?.trim() || process.env.KYNVER_API_KEY?.trim() || void 0,
+    defaultSlug: agentOsSlug?.trim() || process.env.KYNVER_AGENT_OS_SLUG?.trim() || "ghost"
+  };
+}
+function isDirectConfigError(error) {
+  return error?.code === "AGENT_OS_DIRECT_CONFIG";
+}
+async function callAgentOsApiDirect(toolName, params, timeoutMs, config) {
+  const { slug, path: path2, method, body } = directRequestForTool(toolName, params, config.defaultSlug);
+  if (!slug) {
+    const error = new Error("AgentOS slug could not be resolved.");
+    error.code = "AGENT_OS_DIRECT_CONFIG";
+    throw error;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(`${config.apiUrl}/api/agent-os/${encodeURIComponent(slug)}${path2}`, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.apiKey ? { Authorization: `Bearer ${config.apiKey}` } : {}
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) },
+      signal: controller.signal
+    });
+    const text = await res.text();
+    const payload = text ? safeJson(text) ?? text : {};
+    if (!res.ok) {
+      const message = payload && typeof payload === "object" && "error" in payload ? String(payload.error) : `HTTP ${res.status}`;
+      throw new Error(message);
+    }
+    return payload;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function directRequestForTool(toolName, params, defaultSlug) {
+  const slug = stringParam(params.slug) || defaultSlug;
+  const withoutSlug = stripKeys(params, ["slug"]);
+  switch (toolName) {
+    case "agent_os_get_context":
+      return { slug, method: "GET", path: "/stats" };
+    case "agent_os_open_session":
+      return { slug, method: "POST", path: "/sessions", body: withoutSlug };
+    case "agent_os_close_session": {
+      const sessionId = requiredString(params.sessionId, "sessionId");
+      return { slug, method: "PATCH", path: `/sessions/${encodeURIComponent(sessionId)}`, body: stripKeys(params, ["slug", "sessionId"]) };
+    }
+    case "agent_os_log_session": {
+      const topics = arrayParam(params.topicsWorked);
+      const decisions = arrayParam(params.keyDecisions);
+      const lines = [requiredString(params.summary, "summary")];
+      if (topics.length) lines.push(`Topics: ${topics.join(", ")}`);
+      if (decisions.length) lines.push("Key decisions:", ...decisions.map((d) => `- ${d}`));
+      return { slug, method: "POST", path: "/daily-log", body: { entry: lines.join("\n"), ...stringParam(params.date) ? { date: stringParam(params.date) } : {} } };
+    }
+    case "agent_os_list_goals":
+      return { slug, method: "GET", path: `/goals${queryString(params, ["status", "projectId"])}` };
+    case "agent_os_update_goal": {
+      const goalId = stringParam(params.goalId);
+      if (goalId) return { slug, method: "PATCH", path: `/goals/${encodeURIComponent(goalId)}`, body: stripKeys(params, ["slug", "goalId"]) };
+      return { slug, method: "POST", path: "/goals", body: withoutSlug };
+    }
+    case "agent_os_get_projects":
+      return { slug, method: "GET", path: `/projects${queryString(params, ["status"])}` };
+    case "agent_os_create_project":
+      return { slug, method: "POST", path: "/projects", body: withoutSlug };
+    case "agent_os_update_project": {
+      const projectId = requiredString(params.projectId, "projectId");
+      return { slug, method: "PATCH", path: `/projects/${encodeURIComponent(projectId)}`, body: stripKeys(params, ["slug", "projectId"]) };
+    }
+    case "agent_os_search_memory": {
+      const q = requiredString(params.query, "query");
+      return { slug, method: "GET", path: `/memory?${queryStringFromEntries({ q, k: params.k })}` };
+    }
+    case "agent_os_write_memory": {
+      const categoryToSourceId = {
+        long_term: "agent:long-term",
+        project: "agent:project",
+        contact: "agent:long-term",
+        tool_config: "agent:long-term"
+      };
+      const sourceId = stringParam(params.sourceId) || categoryToSourceId[stringParam(params.category) || ""];
+      return {
+        slug,
+        method: "POST",
+        path: "/memory",
+        body: compact({
+          content: requiredString(params.content, "content"),
+          slug: stringParam(params.key),
+          sourceId,
+          metadata: params.metadata
+        })
+      };
+    }
+    case "agent_os_update_memory":
+      return {
+        slug,
+        method: "POST",
+        path: "/memory",
+        body: compact({
+          content: requiredString(params.content, "content"),
+          slug: requiredString(params.key, "key"),
+          sourceId: stringParam(params.sourceId),
+          metadata: params.metadata
+        })
+      };
+    case "agent_os_get_contacts":
+      return { slug, method: "GET", path: "/contacts" };
+    case "agent_os_create_contact":
+      return { slug, method: "POST", path: "/contacts", body: withoutSlug };
+    case "agent_os_update_contact": {
+      const contactId = requiredString(params.contactId, "contactId");
+      return { slug, method: "PATCH", path: `/contacts/${encodeURIComponent(contactId)}`, body: stripKeys(params, ["slug", "contactId"]) };
+    }
+    case "agent_os_consolidate_memory":
+      return { slug, method: "POST", path: "/consolidate", body: {} };
+    default:
+      throw new Error(`Unsupported AgentOS direct tool: ${toolName}`);
+  }
+}
+function requiredString(value, name) {
+  const stringValue = stringParam(value);
+  if (!stringValue) throw new Error(`${name} is required`);
+  return stringValue;
+}
+function stringParam(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function arrayParam(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string" && !!item.trim()).map((item) => item.trim()) : [];
+}
+function stripKeys(source, keys) {
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (!keys.includes(key) && value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function compact(source) {
+  const out = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function queryString(params, keys) {
+  return queryStringFromEntries(Object.fromEntries(keys.map((key) => [key, params[key]])));
+}
+function queryStringFromEntries(entries) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(entries)) {
+    if (typeof value === "string" && value.trim()) params.set(key, value.trim());
+    else if (typeof value === "number" && Number.isFinite(value)) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+function parseMcporterOutput(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return { ok: true, empty: true };
+  const codeFenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (codeFenceMatch) {
+    const inner = codeFenceMatch[1].trim();
+    return safeJson(inner) ?? { raw: trimmed };
+  }
+  const firstBrace = trimmed.indexOf("{");
+  const firstBracket = trimmed.indexOf("[");
+  let start = -1;
+  if (firstBrace >= 0 && firstBracket >= 0) start = Math.min(firstBrace, firstBracket);
+  else start = Math.max(firstBrace, firstBracket);
+  if (start >= 0) {
+    const candidate = trimmed.slice(start);
+    return safeJson(candidate) ?? { raw: trimmed };
+  }
+  return { raw: trimmed };
+}
+function safeJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function resolveMcporterConfigPath(configuredPath) {
+  const here = fileURLToPath(new URL(".", import.meta.url));
+  const candidates = [
+    configuredPath,
+    process.env.MCPORTER_CONFIG,
+    process.env.OPENCLAW_MCPORTER_CONFIG,
+    process.env.HOME ? path.resolve(process.env.HOME, ".openclaw/workspace/config/mcporter.json") : void 0,
+    path.resolve(here, "../../config/mcporter.json"),
+    path.resolve(here, "../../../config/mcporter.json"),
+    path.resolve(process.cwd(), "config/mcporter.json")
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return path.resolve(process.cwd(), "config/mcporter.json");
+}
+function summarizeContextPayload(payload) {
+  if (!payload || typeof payload !== "object") return {};
+  const record = payload;
+  const identity = record.identity && typeof record.identity === "object" ? record.identity : void 0;
+  return {
+    slug: typeof identity?.slug === "string" ? identity.slug : void 0,
+    openGoalCount: typeof record.openGoalCount === "number" ? record.openGoalCount : void 0,
+    projectCount: Array.isArray(record.projects) ? record.projects.length : void 0,
+    contactCount: Array.isArray(record.contacts) ? record.contacts.length : void 0,
+    memoryStats: record.memoryStats && typeof record.memoryStats === "object" ? record.memoryStats : void 0
+  };
+}
+function sanitizeHealthError(error) {
+  const message = String(error?.message || error).replace(/kynver_[A-Za-z0-9_]+/g, "kynver_[REDACTED]");
+  return {
+    message,
+    code: typeof error?.code === "string" ? error.code : void 0,
+    signal: typeof error?.signal === "string" ? error.signal : void 0,
+    stdout: typeof error?.stdout === "string" ? redactSecrets(error.stdout).slice(0, 2e3) : void 0,
+    stderr: typeof error?.stderr === "string" ? redactSecrets(error.stderr).slice(0, 2e3) : void 0
+  };
+}
+function redactSecrets(value) {
+  return value.replace(/kynver_[A-Za-z0-9_]+/g, "kynver_[REDACTED]");
+}
+
+// src/schemas/common.ts
+var stringArray = {
+  type: "array",
+  items: { type: "string" }
+};
+var looseObject = {
+  type: "object",
+  additionalProperties: {}
+};
+
+// src/schemas/contacts.ts
+var getContactsSchema = {
+  type: "object",
+  properties: {
+    slug: { type: "string" }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var createContactSchema = {
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    relationship: { type: "string" },
+    context: { type: "string" },
+    preferences: looseObject,
+    notes: { type: "string" },
+    slug: { type: "string" }
+  },
+  required: ["name"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var updateContactSchema = {
+  type: "object",
+  properties: {
+    contactId: { type: "string" },
+    name: { type: "string" },
+    relationship: { type: "string" },
+    context: { type: "string" },
+    preferences: looseObject,
+    notes: { type: "string" },
+    slug: { type: "string" }
+  },
+  required: ["contactId"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/contacts.ts
+function createContactTools(config) {
+  const mk = (name, description, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: (_toolCallId, params) => callAgentOsTool({
+      serverName: config.agentOsServer,
+      toolName: name,
+      params,
+      timeoutMs: config.timeoutMs,
+      mcporterConfigPath: config.mcporterConfigPath,
+      kynverApiUrl: config.kynverApiUrl,
+      kynverApiKey: config.kynverApiKey,
+      agentOsSlug: config.agentOsSlug,
+      enableDirectHttp: config.enableDirectHttp
+    })
+  });
+  return [
+    mk("agent_os_get_contacts", "Get all AgentOS contacts.", getContactsSchema),
+    mk("agent_os_create_contact", "Create or upsert an AgentOS contact.", createContactSchema),
+    mk("agent_os_update_contact", "Update an existing AgentOS contact.", updateContactSchema)
+  ];
+}
+
+// src/schemas/context.ts
+var getContextSchema = {
+  type: "object",
+  properties: {
+    slug: {
+      type: "string",
+      description: "AgentOS slug. Defaults to KYNVER_AGENT_OS_SLUG, then 'ghost'."
+    }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/context.ts
+function createContextTools(config) {
+  return [
+    {
+      name: "agent_os_get_context",
+      label: "AgentOS Get Context",
+      description: "Get the agent's full AgentOS state in one call: identity, goals, projects, contacts, sessions, and memory stats.",
+      parameters: getContextSchema,
+      execute: (_toolCallId, params) => callAgentOsTool({
+        serverName: config.agentOsServer,
+        toolName: "agent_os_get_context",
+        params,
+        timeoutMs: config.timeoutMs,
+        mcporterConfigPath: config.mcporterConfigPath,
+        kynverApiUrl: config.kynverApiUrl,
+        kynverApiKey: config.kynverApiKey,
+        agentOsSlug: config.agentOsSlug,
+        enableDirectHttp: config.enableDirectHttp
+      })
+    }
+  ];
+}
+
+// src/schemas/goals.ts
+var listGoalsSchema = {
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["open", "in_progress", "blocked", "complete", "cancelled"] },
+    projectId: { type: "string" },
+    slug: { type: "string" }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var updateGoalSchema = {
+  type: "object",
+  properties: {
+    title: { type: "string", description: "Goal title. Required when creating." },
+    description: { type: "string" },
+    status: { type: "string", enum: ["open", "in_progress", "blocked", "complete", "cancelled"] },
+    priority: { type: "string", enum: ["low", "normal", "high", "critical"] },
+    projectId: { type: "string" },
+    analystHypothesisId: { type: "string" },
+    outcome: { type: "string" },
+    goalId: { type: "string" },
+    slug: { type: "string" }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/goals.ts
+function createGoalTools(config) {
+  const mk = (name, description, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: (_toolCallId, params) => callAgentOsTool({
+      serverName: config.agentOsServer,
+      toolName: name,
+      params,
+      timeoutMs: config.timeoutMs,
+      mcporterConfigPath: config.mcporterConfigPath,
+      kynverApiUrl: config.kynverApiUrl,
+      kynverApiKey: config.kynverApiKey,
+      agentOsSlug: config.agentOsSlug,
+      enableDirectHttp: config.enableDirectHttp
+    })
+  });
+  return [
+    mk("agent_os_list_goals", "List AgentOS goals, optionally filtered by status or project.", listGoalsSchema),
+    mk("agent_os_update_goal", "Create a goal or update an existing AgentOS goal.", updateGoalSchema)
+  ];
+}
+
+// src/schemas/health.ts
+var healthCheckSchema = {
+  type: "object",
+  properties: {
+    slug: {
+      type: "string",
+      description: "AgentOS slug to probe. Defaults to the AgentOS server default."
+    }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/health.ts
+function createHealthTools(config) {
+  return [
+    {
+      name: "agent_os_health_check",
+      label: "AgentOS Health Check",
+      description: "Check whether Kynver AgentOS is reachable through the configured first-class tool bridge.",
+      parameters: healthCheckSchema,
+      execute: (_toolCallId, params) => checkAgentOsHealth({
+        serverName: config.agentOsServer,
+        slug: typeof params.slug === "string" && params.slug.trim() ? params.slug.trim() : void 0,
+        timeoutMs: config.timeoutMs,
+        mcporterConfigPath: config.mcporterConfigPath,
+        kynverApiUrl: config.kynverApiUrl,
+        kynverApiKey: config.kynverApiKey,
+        agentOsSlug: config.agentOsSlug,
+        enableDirectHttp: config.enableDirectHttp
+      })
+    }
+  ];
+}
+
+// src/schemas/memory.ts
+var searchMemorySchema = {
+  type: "object",
+  properties: {
+    query: { type: "string" },
+    k: { type: "number" },
+    slug: { type: "string" }
+  },
+  required: ["query"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var writeMemorySchema = {
+  type: "object",
+  properties: {
+    content: { type: "string" },
+    key: { type: "string" },
+    category: { type: "string", enum: ["long_term", "project", "contact", "tool_config"] },
+    sourceId: { type: "string" },
+    metadata: looseObject,
+    slug: { type: "string" }
+  },
+  required: ["content"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var updateMemorySchema = {
+  type: "object",
+  properties: {
+    key: { type: "string" },
+    content: { type: "string" },
+    sourceId: { type: "string" },
+    metadata: looseObject,
+    slug: { type: "string" }
+  },
+  required: ["key", "content"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var consolidateMemorySchema = {
+  type: "object",
+  properties: {
+    slug: { type: "string" }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/memory.ts
+function createMemoryTools(config) {
+  const mk = (name, description, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: (_toolCallId, params) => callAgentOsTool({
+      serverName: config.agentOsServer,
+      toolName: name,
+      params,
+      timeoutMs: config.timeoutMs,
+      mcporterConfigPath: config.mcporterConfigPath,
+      kynverApiUrl: config.kynverApiUrl,
+      kynverApiKey: config.kynverApiKey,
+      agentOsSlug: config.agentOsSlug,
+      enableDirectHttp: config.enableDirectHttp
+    })
+  });
+  return [
+    mk("agent_os_search_memory", "Search AgentOS memory using semantic + keyword hybrid recall.", searchMemorySchema),
+    mk("agent_os_write_memory", "Write a durable memory entry to AgentOS.", writeMemorySchema),
+    mk("agent_os_update_memory", "Update an existing AgentOS memory entry by key.", updateMemorySchema),
+    mk("agent_os_consolidate_memory", "Trigger an AgentOS memory consolidation pass.", consolidateMemorySchema)
+  ];
+}
+
+// src/schemas/projects.ts
+var getProjectsSchema = {
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["active", "on_hold", "shipped", "archived"] },
+    slug: { type: "string" }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var createProjectSchema = {
+  type: "object",
+  properties: {
+    name: { type: "string" },
+    description: { type: "string" },
+    status: { type: "string", enum: ["active", "on_hold", "shipped", "archived"], default: "active" },
+    currentFocus: { type: "string" },
+    nextActions: stringArray,
+    blockers: stringArray,
+    repoUrl: { type: "string" },
+    deployUrl: { type: "string" },
+    slug: { type: "string" }
+  },
+  required: ["name"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var updateProjectSchema = {
+  type: "object",
+  properties: {
+    projectId: { type: "string" },
+    name: { type: "string" },
+    description: { type: "string" },
+    status: { type: "string", enum: ["active", "on_hold", "shipped", "archived"] },
+    currentFocus: { type: "string" },
+    nextActions: stringArray,
+    blockers: stringArray,
+    repoUrl: { type: "string" },
+    deployUrl: { type: "string" },
+    slug: { type: "string" }
+  },
+  required: ["projectId"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/projects.ts
+function createProjectTools(config) {
+  const mk = (name, description, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: (_toolCallId, params) => callAgentOsTool({
+      serverName: config.agentOsServer,
+      toolName: name,
+      params,
+      timeoutMs: config.timeoutMs,
+      mcporterConfigPath: config.mcporterConfigPath,
+      kynverApiUrl: config.kynverApiUrl,
+      kynverApiKey: config.kynverApiKey,
+      agentOsSlug: config.agentOsSlug,
+      enableDirectHttp: config.enableDirectHttp
+    })
+  });
+  return [
+    mk("agent_os_get_projects", "Get all tracked AgentOS projects.", getProjectsSchema),
+    mk("agent_os_create_project", "Create a new AgentOS project.", createProjectSchema),
+    mk("agent_os_update_project", "Update an existing AgentOS project.", updateProjectSchema)
+  ];
+}
+
+// src/schemas/sessions.ts
+var openSessionSchema = {
+  type: "object",
+  properties: {
+    channel: { type: "string", description: "Runtime channel: 'webchat' | 'telegram' | 'discord' | \u2026" },
+    model: { type: "string", description: "Model used for the session." },
+    slug: { type: "string", description: "AgentOS slug. Defaults to KYNVER_AGENT_OS_SLUG, then 'ghost'." }
+  },
+  required: ["channel"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var closeSessionSchema = {
+  type: "object",
+  properties: {
+    sessionId: { type: "string" },
+    summary: { type: "string" },
+    topicsWorked: stringArray,
+    decisionsLog: {},
+    goalIds: stringArray,
+    projectIds: stringArray,
+    slug: { type: "string" }
+  },
+  required: ["sessionId", "summary"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+var logSessionSchema = {
+  type: "object",
+  properties: {
+    summary: { type: "string", description: "2-4 sentence summary of what was worked on." },
+    topicsWorked: stringArray,
+    keyDecisions: stringArray,
+    date: { type: "string", description: "Date to log against (YYYY-MM-DD, defaults to today UTC)." },
+    slug: { type: "string" }
+  },
+  required: ["summary"],
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
+
+// src/tools/sessions.ts
+function createSessionTools(config) {
+  const mk = (name, description, parameters) => ({
+    name,
+    label: name,
+    description,
+    parameters,
+    execute: (_toolCallId, params) => callAgentOsTool({
+      serverName: config.agentOsServer,
+      toolName: name,
+      params,
+      timeoutMs: config.timeoutMs,
+      mcporterConfigPath: config.mcporterConfigPath,
+      kynverApiUrl: config.kynverApiUrl,
+      kynverApiKey: config.kynverApiKey,
+      agentOsSlug: config.agentOsSlug,
+      enableDirectHttp: config.enableDirectHttp
+    })
+  });
+  return [
+    mk("agent_os_open_session", "Open an AgentOS session record at the start of a session.", openSessionSchema),
+    mk("agent_os_close_session", "Close an AgentOS session record with summary, decisions, and linked goals/projects.", closeSessionSchema),
+    mk("agent_os_log_session", "Append a structured session log entry to AgentOS daily notes.", logSessionSchema)
+  ];
+}
+
+// src/tools/index.ts
+function createAllTools(config) {
+  return [
+    ...createHealthTools(config),
+    ...createContextTools(config),
+    ...createSessionTools(config),
+    ...createGoalTools(config),
+    ...createProjectTools(config),
+    ...createMemoryTools(config),
+    ...createContactTools(config)
+  ];
+}
+
+// index.ts
+var plugin = {
+  id: "kynver-agent-os-tools",
+  name: "Kynver AgentOS Tools",
+  description: "First-class OpenClaw tools for Kynver AgentOS, using direct Kynver HTTP with mcporter fallback.",
+  configSchema: pluginConfigSchema,
+  register(api) {
+    const config = resolvePluginConfig(api?.config);
+    const tools = createAllTools(config);
+    for (const tool of tools) {
+      api.registerTool(tool);
+    }
+    if (config.enableSessionLifecycle && typeof api.on === "function") {
+      const sessionIds = /* @__PURE__ */ new Map();
+      const keyFor = (event, ctx) => String(event?.sessionKey || ctx?.sessionKey || event?.sessionId || ctx?.sessionId || "");
+      const shouldTrack = (key) => key && !key.includes("subagent") && !key.includes("acp") && !key.includes("isolated");
+      const channelFor = (key) => {
+        if (key.includes("telegram")) return "telegram";
+        if (key.includes("discord")) return "discord";
+        if (key.includes("webchat")) return "webchat";
+        return "openclaw";
+      };
+      api.on(
+        "session_start",
+        async (event, ctx) => {
+          const key = keyFor(event, ctx);
+          if (!shouldTrack(key) || sessionIds.has(key)) return;
+          const result = await callAgentOsTool({
+            serverName: config.agentOsServer,
+            toolName: "agent_os_open_session",
+            params: { channel: channelFor(key), model: "openclaw" },
+            timeoutMs: Math.min(config.timeoutMs, 1e4),
+            mcporterConfigPath: config.mcporterConfigPath,
+            kynverApiUrl: config.kynverApiUrl,
+            kynverApiKey: config.kynverApiKey,
+            agentOsSlug: config.agentOsSlug,
+            enableDirectHttp: config.enableDirectHttp
+          });
+          const id = result?.details?.id;
+          if (typeof id === "string") sessionIds.set(key, id);
+        },
+        { priority: 10, timeoutMs: 12e3 }
+      );
+      api.on(
+        "session_end",
+        async (event, ctx) => {
+          const key = keyFor(event, ctx);
+          const sessionId = sessionIds.get(key);
+          if (!sessionId) return;
+          sessionIds.delete(key);
+          const reason = typeof event?.reason === "string" ? event.reason : "unknown";
+          const messageCount = typeof event?.messageCount === "number" ? event.messageCount : void 0;
+          const durationMs = typeof event?.durationMs === "number" ? event.durationMs : void 0;
+          await callAgentOsTool({
+            serverName: config.agentOsServer,
+            toolName: "agent_os_close_session",
+            params: {
+              sessionId,
+              summary: `OpenClaw session ended automatically (reason: ${reason}; messages: ${messageCount ?? "unknown"}; durationMs: ${durationMs ?? "unknown"}).`,
+              topicsWorked: ["OpenClaw session lifecycle"]
+            },
+            timeoutMs: Math.min(config.timeoutMs, 1e4),
+            mcporterConfigPath: config.mcporterConfigPath,
+            kynverApiUrl: config.kynverApiUrl,
+            kynverApiKey: config.kynverApiKey,
+            agentOsSlug: config.agentOsSlug,
+            enableDirectHttp: config.enableDirectHttp
+          });
+        },
+        { priority: 10, timeoutMs: 12e3 }
+      );
+    }
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};
+//# sourceMappingURL=index.js.map