@avallon-labs/mcp 48.0.0-staging.1085 → 48.1.0

package/dist/index.js

@@ -46,5 +46,5 @@ function setupFetch() {
 
 // src/index.ts
 setupFetch();
-await import("./server-N4ND2RVM.js");
+await import("./server-XWEHYT6M.js");
 //# sourceMappingURL=index.js.map

package/dist/{server-N4ND2RVM.js → server-XWEHYT6M.js}

@@ -2815,6 +2815,85 @@ var executeCode = async (id, executeCodeBody, options) => {
     headers: res.headers
   };
 };
+var getListToolVersionsUrl = (id, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        for (const [sk, sv] of Object.entries(value)) {
+          if (sv !== void 0) normalizedParams.append(`${key}[${sk}]`, String(sv));
+        }
+      } else {
+        normalizedParams.append(key, value === null ? "null" : String(value));
+      }
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/tools/${id}/versions?${stringifiedParams}` : `/v1/tools/${id}/versions`;
+};
+var listToolVersions = async (id, params, options) => {
+  const res = await fetch(getListToolVersionsUrl(id, params), {
+    ...options,
+    method: "GET"
+  });
+  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+  const data = body ? JSON.parse(body) : {};
+  return {
+    data,
+    status: res.status,
+    headers: res.headers
+  };
+};
+var getGetToolVersionUrl = (id, version) => {
+  return `/v1/tools/${id}/versions/${version}`;
+};
+var getToolVersion = async (id, version, options) => {
+  const res = await fetch(getGetToolVersionUrl(id, version), {
+    ...options,
+    method: "GET"
+  });
+  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+  const data = body ? JSON.parse(body) : {};
+  return {
+    data,
+    status: res.status,
+    headers: res.headers
+  };
+};
+var getPromoteToolVersionUrl = (id, version) => {
+  return `/v1/tools/${id}/versions/${version}/promote`;
+};
+var promoteToolVersion = async (id, version, promoteToolVersionBody, options) => {
+  const res = await fetch(getPromoteToolVersionUrl(id, version), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(promoteToolVersionBody)
+  });
+  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+  const data = body ? JSON.parse(body) : {};
+  return {
+    data,
+    status: res.status,
+    headers: res.headers
+  };
+};
+var getGetToolVersionChangeSummaryUrl = (id, version) => {
+  return `/v1/tools/${id}/versions/${version}/change-summary`;
+};
+var getToolVersionChangeSummary = async (id, version, options) => {
+  const res = await fetch(getGetToolVersionChangeSummaryUrl(id, version), {
+    ...options,
+    method: "GET"
+  });
+  const body = [204, 205, 304].includes(res.status) ? null : await res.text();
+  const data = body ? JSON.parse(body) : {};
+  return {
+    data,
+    status: res.status,
+    headers: res.headers
+  };
+};
 var getWorkerListToolsUrl = (params) => {
   const normalizedParams = new URLSearchParams();
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -4741,6 +4820,57 @@ var executeCodeHandler = async (args) => {
     ]
   };
 };
+var listToolVersionsHandler = async (args) => {
+  const res = await listToolVersions(args.pathParams.id, args.queryParams);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getToolVersionHandler = async (args) => {
+  const res = await getToolVersion(args.pathParams.id, args.pathParams.version);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var promoteToolVersionHandler = async (args) => {
+  const res = await promoteToolVersion(
+    args.pathParams.id,
+    args.pathParams.version,
+    args.bodyParams
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
+var getToolVersionChangeSummaryHandler = async (args) => {
+  const res = await getToolVersionChangeSummary(
+    args.pathParams.id,
+    args.pathParams.version
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(res)
+      }
+    ]
+  };
+};
 var workerListToolsHandler = async (args) => {
   const res = await workerListTools(args.queryParams);
   return {
@@ -8648,6 +8778,7 @@ var GetProfileResponse = zod.object({
         "voice-agents:promote",
         "tools:write",
         "tools:execute",
+        "tools:promote",
         "extractors:write",
         "inboxes:write",
         "inboxes:send",
@@ -9527,6 +9658,12 @@ var CreateToolBody = zod.object({
   code: zod.string().min(1),
   description: zod.string().min(1)
 });
+var createToolResponseDataToolVersionsLatestMin = -9007199254740991;
+var createToolResponseDataToolVersionsLatestMax = 9007199254740991;
+var createToolResponseDataToolVersionsLiveMin = -9007199254740991;
+var createToolResponseDataToolVersionsLiveMax = 9007199254740991;
+var createToolResponseDataToolVersionsTestMin = -9007199254740991;
+var createToolResponseDataToolVersionsTestMax = 9007199254740991;
 var CreateToolResponse = zod.object({
   data: zod.object({
     tool: zod.object({
@@ -9534,7 +9671,14 @@ var CreateToolResponse = zod.object({
       name: zod.string(),
       schema: zod.record(zod.string(), zod.unknown()).optional(),
       description: zod.string().optional(),
-      code: zod.string().optional()
+      code: zod.string().optional(),
+      versions: zod.object({
+        latest: zod.number().min(createToolResponseDataToolVersionsLatestMin).max(createToolResponseDataToolVersionsLatestMax).describe(
+          "Newest config version. The code, schema and secrets in this response are its snapshot."
+        ),
+        live: zod.number().min(createToolResponseDataToolVersionsLiveMin).max(createToolResponseDataToolVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+        test: zod.number().min(createToolResponseDataToolVersionsTestMin).max(createToolResponseDataToolVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+      })
     })
   }),
   message: zod.string()
@@ -9545,13 +9689,26 @@ var ListToolsQueryParams = zod.object({
   sort_by: zod.enum(["created_at", "updated_at", "name"]).default(listToolsQuerySortByDefault),
   sort_order: zod.enum(["asc", "desc"]).default(listToolsQuerySortOrderDefault)
 });
+var listToolsResponseDataToolsItemVersionsLatestMin = -9007199254740991;
+var listToolsResponseDataToolsItemVersionsLatestMax = 9007199254740991;
+var listToolsResponseDataToolsItemVersionsLiveMin = -9007199254740991;
+var listToolsResponseDataToolsItemVersionsLiveMax = 9007199254740991;
+var listToolsResponseDataToolsItemVersionsTestMin = -9007199254740991;
+var listToolsResponseDataToolsItemVersionsTestMax = 9007199254740991;
 var ListToolsResponse = zod.object({
   data: zod.object({
     tools: zod.array(
       zod.object({
         id: zod.string(),
         name: zod.string(),
-        description: zod.string().optional()
+        description: zod.string().optional(),
+        versions: zod.object({
+          latest: zod.number().min(listToolsResponseDataToolsItemVersionsLatestMin).max(listToolsResponseDataToolsItemVersionsLatestMax).describe(
+            "Newest config version. The code, schema and secrets in this response are its snapshot."
+          ),
+          live: zod.number().min(listToolsResponseDataToolsItemVersionsLiveMin).max(listToolsResponseDataToolsItemVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+          test: zod.number().min(listToolsResponseDataToolsItemVersionsTestMin).max(listToolsResponseDataToolsItemVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+        })
       })
     )
   }),
@@ -9567,6 +9724,12 @@ var DeleteToolResponse = zod.object({
 var GetToolParams = zod.object({
   id: zod.string().uuid()
 });
+var getToolResponseDataToolVersionsLatestMin = -9007199254740991;
+var getToolResponseDataToolVersionsLatestMax = 9007199254740991;
+var getToolResponseDataToolVersionsLiveMin = -9007199254740991;
+var getToolResponseDataToolVersionsLiveMax = 9007199254740991;
+var getToolResponseDataToolVersionsTestMin = -9007199254740991;
+var getToolResponseDataToolVersionsTestMax = 9007199254740991;
 var GetToolResponse = zod.object({
   data: zod.object({
     tool: zod.object({
@@ -9577,7 +9740,14 @@ var GetToolResponse = zod.object({
       schema: zod.record(zod.string(), zod.unknown()),
       secret_ids: zod.array(zod.string()).describe(
         "Secrets attached to the tool. A tool with attached secrets takes its execution environment exclusively from the secret store, each secret arriving under its own env key."
-      )
+      ),
+      versions: zod.object({
+        latest: zod.number().min(getToolResponseDataToolVersionsLatestMin).max(getToolResponseDataToolVersionsLatestMax).describe(
+          "Newest config version. The code, schema and secrets in this response are its snapshot."
+        ),
+        live: zod.number().min(getToolResponseDataToolVersionsLiveMin).max(getToolResponseDataToolVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+        test: zod.number().min(getToolResponseDataToolVersionsTestMin).max(getToolResponseDataToolVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+      })
     })
   }),
   message: zod.string()
@@ -9593,6 +9763,12 @@ var UpdateToolBody = zod.object({
     "Replace the tool's attached secret set. Omit to leave unchanged; pass [] to detach all."
   )
 });
+var updateToolResponseDataToolVersionsLatestMin = -9007199254740991;
+var updateToolResponseDataToolVersionsLatestMax = 9007199254740991;
+var updateToolResponseDataToolVersionsLiveMin = -9007199254740991;
+var updateToolResponseDataToolVersionsLiveMax = 9007199254740991;
+var updateToolResponseDataToolVersionsTestMin = -9007199254740991;
+var updateToolResponseDataToolVersionsTestMax = 9007199254740991;
 var UpdateToolResponse = zod.object({
   data: zod.object({
     tool: zod.object({
@@ -9603,7 +9779,14 @@ var UpdateToolResponse = zod.object({
       schema: zod.record(zod.string(), zod.unknown()),
       secret_ids: zod.array(zod.string()).describe(
         "Secrets attached to the tool. A tool with attached secrets takes its execution environment exclusively from the secret store, each secret arriving under its own env key."
-      )
+      ),
+      versions: zod.object({
+        latest: zod.number().min(updateToolResponseDataToolVersionsLatestMin).max(updateToolResponseDataToolVersionsLatestMax).describe(
+          "Newest config version. The code, schema and secrets in this response are its snapshot."
+        ),
+        live: zod.number().min(updateToolResponseDataToolVersionsLiveMin).max(updateToolResponseDataToolVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+        test: zod.number().min(updateToolResponseDataToolVersionsTestMin).max(updateToolResponseDataToolVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+      })
     })
   }),
   message: zod.string()
@@ -9634,19 +9817,118 @@ var ExecuteCodeResponse = zod.object({
   }),
   message: zod.string()
 });
+var ListToolVersionsParams = zod.object({
+  id: zod.string().uuid()
+});
+var listToolVersionsQueryCountDefault = 50;
+var listToolVersionsQueryCountMax = 100;
+var listToolVersionsQueryOffsetDefault = 0;
+var listToolVersionsQueryOffsetMin = 0;
+var listToolVersionsQuerySortByDefault = `version`;
+var listToolVersionsQuerySortOrderDefault = `desc`;
+var ListToolVersionsQueryParams = zod.object({
+  count: zod.number().min(1).max(listToolVersionsQueryCountMax).default(listToolVersionsQueryCountDefault),
+  offset: zod.number().min(listToolVersionsQueryOffsetMin).default(listToolVersionsQueryOffsetDefault),
+  sort_by: zod.enum(["version", "created_at"]).default(listToolVersionsQuerySortByDefault),
+  sort_order: zod.enum(["asc", "desc"]).default(listToolVersionsQuerySortOrderDefault)
+});
+var listToolVersionsResponseDataItemVersionMin = -9007199254740991;
+var listToolVersionsResponseDataItemVersionMax = 9007199254740991;
+var listToolVersionsResponseMetaTotalMin = -9007199254740991;
+var listToolVersionsResponseMetaTotalMax = 9007199254740991;
+var ListToolVersionsResponse = zod.object({
+  data: zod.array(
+    zod.object({
+      tool_id: zod.string(),
+      version: zod.number().min(listToolVersionsResponseDataItemVersionMin).max(listToolVersionsResponseDataItemVersionMax),
+      actor: zod.string(),
+      created_at: zod.string().datetime({}),
+      changed_fields: zod.array(zod.string())
+    })
+  ),
+  message: zod.string(),
+  meta: zod.object({
+    total: zod.number().min(listToolVersionsResponseMetaTotalMin).max(listToolVersionsResponseMetaTotalMax)
+  })
+});
+var getToolVersionPathVersionMax = 9007199254740991;
+var GetToolVersionParams = zod.object({
+  id: zod.string().uuid(),
+  version: zod.number().min(1).max(getToolVersionPathVersionMax)
+});
+var getToolVersionResponseDataVersionMin = -9007199254740991;
+var getToolVersionResponseDataVersionMax = 9007199254740991;
+var GetToolVersionResponse = zod.object({
+  data: zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    created_at: zod.string().datetime({}),
+    updated_at: zod.string().datetime({}),
+    code: zod.string(),
+    schema: zod.record(zod.string(), zod.unknown()),
+    description: zod.string().optional(),
+    secret_ids: zod.array(zod.string()),
+    version: zod.number().min(getToolVersionResponseDataVersionMin).max(getToolVersionResponseDataVersionMax),
+    version_created_at: zod.string().datetime({}),
+    actor: zod.string(),
+    changed_fields: zod.array(zod.string())
+  }),
+  message: zod.string()
+});
+var promoteToolVersionPathVersionMax = 9007199254740991;
+var PromoteToolVersionParams = zod.object({
+  id: zod.string().uuid(),
+  version: zod.number().min(1).max(promoteToolVersionPathVersionMax)
+});
+var PromoteToolVersionBody = zod.object({
+  environment: zod.enum(["live", "test"])
+});
+var promoteToolVersionResponseDataVersionMin = -9007199254740991;
+var promoteToolVersionResponseDataVersionMax = 9007199254740991;
+var PromoteToolVersionResponse = zod.object({
+  data: zod.object({
+    version: zod.number().min(promoteToolVersionResponseDataVersionMin).max(promoteToolVersionResponseDataVersionMax),
+    environment: zod.enum(["live", "test"])
+  }),
+  message: zod.string()
+});
+var getToolVersionChangeSummaryPathVersionMax = 9007199254740991;
+var GetToolVersionChangeSummaryParams = zod.object({
+  id: zod.string().uuid(),
+  version: zod.number().min(1).max(getToolVersionChangeSummaryPathVersionMax)
+});
+var GetToolVersionChangeSummaryResponse = zod.object({
+  data: zod.object({
+    summary: zod.string()
+  }),
+  message: zod.string()
+});
 var workerListToolsQuerySortByDefault = `created_at`;
 var workerListToolsQuerySortOrderDefault = `desc`;
 var WorkerListToolsQueryParams = zod.object({
   sort_by: zod.enum(["created_at", "updated_at", "name"]).default(workerListToolsQuerySortByDefault),
   sort_order: zod.enum(["asc", "desc"]).default(workerListToolsQuerySortOrderDefault)
 });
+var workerListToolsResponseDataToolsItemVersionsLatestMin = -9007199254740991;
+var workerListToolsResponseDataToolsItemVersionsLatestMax = 9007199254740991;
+var workerListToolsResponseDataToolsItemVersionsLiveMin = -9007199254740991;
+var workerListToolsResponseDataToolsItemVersionsLiveMax = 9007199254740991;
+var workerListToolsResponseDataToolsItemVersionsTestMin = -9007199254740991;
+var workerListToolsResponseDataToolsItemVersionsTestMax = 9007199254740991;
 var WorkerListToolsResponse = zod.object({
   data: zod.object({
     tools: zod.array(
       zod.object({
         id: zod.string(),
         name: zod.string(),
-        description: zod.string().optional()
+        description: zod.string().optional(),
+        versions: zod.object({
+          latest: zod.number().min(workerListToolsResponseDataToolsItemVersionsLatestMin).max(workerListToolsResponseDataToolsItemVersionsLatestMax).describe(
+            "Newest config version. The code, schema and secrets in this response are its snapshot."
+          ),
+          live: zod.number().min(workerListToolsResponseDataToolsItemVersionsLiveMin).max(workerListToolsResponseDataToolsItemVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+          test: zod.number().min(workerListToolsResponseDataToolsItemVersionsTestMin).max(workerListToolsResponseDataToolsItemVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+        })
       })
     )
   }),
@@ -9655,6 +9937,12 @@ var WorkerListToolsResponse = zod.object({
 var WorkerGetToolParams = zod.object({
   id: zod.string().uuid()
 });
+var workerGetToolResponseDataToolVersionsLatestMin = -9007199254740991;
+var workerGetToolResponseDataToolVersionsLatestMax = 9007199254740991;
+var workerGetToolResponseDataToolVersionsLiveMin = -9007199254740991;
+var workerGetToolResponseDataToolVersionsLiveMax = 9007199254740991;
+var workerGetToolResponseDataToolVersionsTestMin = -9007199254740991;
+var workerGetToolResponseDataToolVersionsTestMax = 9007199254740991;
 var WorkerGetToolResponse = zod.object({
   data: zod.object({
     tool: zod.object({
@@ -9665,7 +9953,14 @@ var WorkerGetToolResponse = zod.object({
       schema: zod.record(zod.string(), zod.unknown()),
       secret_ids: zod.array(zod.string()).describe(
         "Secrets attached to the tool. A tool with attached secrets takes its execution environment exclusively from the secret store, each secret arriving under its own env key."
-      )
+      ),
+      versions: zod.object({
+        latest: zod.number().min(workerGetToolResponseDataToolVersionsLatestMin).max(workerGetToolResponseDataToolVersionsLatestMax).describe(
+          "Newest config version. The code, schema and secrets in this response are its snapshot."
+        ),
+        live: zod.number().min(workerGetToolResponseDataToolVersionsLiveMin).max(workerGetToolResponseDataToolVersionsLiveMax).describe("Config version runs in the `live` environment execute."),
+        test: zod.number().min(workerGetToolResponseDataToolVersionsTestMin).max(workerGetToolResponseDataToolVersionsTestMax).describe("Config version runs in the `test` environment execute.")
+      })
     })
   }),
   message: zod.string()
@@ -11235,6 +11530,40 @@ server.tool(
   },
   executeCodeHandler
 );
+server.tool(
+  "listToolVersions",
+  "List tool versions",
+  {
+    pathParams: ListToolVersionsParams,
+    queryParams: ListToolVersionsQueryParams
+  },
+  listToolVersionsHandler
+);
+server.tool(
+  "getToolVersion",
+  "Get tool version",
+  {
+    pathParams: GetToolVersionParams
+  },
+  getToolVersionHandler
+);
+server.tool(
+  "promoteToolVersion",
+  "Promote tool version",
+  {
+    pathParams: PromoteToolVersionParams,
+    bodyParams: PromoteToolVersionBody
+  },
+  promoteToolVersionHandler
+);
+server.tool(
+  "getToolVersionChangeSummary",
+  "Get tool version change summary",
+  {
+    pathParams: GetToolVersionChangeSummaryParams
+  },
+  getToolVersionChangeSummaryHandler
+);
 server.tool(
   "workerListTools",
   "List tools",
@@ -11377,4 +11706,4 @@ var transport = new StdioServerTransport();
 server.connect(transport).then(() => {
   console.error("MCP server running on stdio");
 }).catch(console.error);
-//# sourceMappingURL=server-N4ND2RVM.js.map
+//# sourceMappingURL=server-XWEHYT6M.js.map